1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2022 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
, BUILT_IN_FRONTEND
))
454 switch (DECL_FE_FUNCTION_CODE (decl
))
456 case CP_BUILT_IN_IS_CONSTANT_EVALUATED
:
457 case CP_BUILT_IN_SOURCE_LOCATION
:
458 case CP_BUILT_IN_IS_CORRESPONDING_MEMBER
:
459 case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS
:
464 /* Not a built-in. */
467 switch (DECL_FUNCTION_CODE (decl
))
469 /* These always have constant results like the corresponding
472 case BUILT_IN_FUNCTION
:
475 /* The following built-ins are valid in constant expressions
476 when their arguments are. */
477 case BUILT_IN_ADD_OVERFLOW_P
:
478 case BUILT_IN_SUB_OVERFLOW_P
:
479 case BUILT_IN_MUL_OVERFLOW_P
:
481 /* These have constant results even if their operands are
483 case BUILT_IN_CONSTANT_P
:
484 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
491 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
494 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
497 tree type
= TREE_TYPE (decl
);
499 value
= mark_rvalue_use (value
);
501 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
502 || TREE_TYPE (decl
) == TREE_TYPE (value
)
503 /* On ARM ctors return 'this'. */
504 || (TYPE_PTR_P (TREE_TYPE (value
))
505 && TREE_CODE (value
) == CALL_EXPR
)
506 || useless_type_conversion_p (TREE_TYPE (decl
),
509 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
510 moving a constant aggregate into .rodata. */
511 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
512 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
513 && !VOID_TYPE_P (TREE_TYPE (value
))
514 && reduced_constant_expression_p (value
))
515 TREE_READONLY (decl
) = true;
517 if (complain
& tf_no_cleanup
)
518 /* The caller is building a new-expr and does not need a cleanup. */
522 t
= cxx_maybe_build_cleanup (decl
, complain
);
523 if (t
== error_mark_node
)
524 return error_mark_node
;
526 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
527 if (location_t eloc
= cp_expr_location (value
))
528 SET_EXPR_LOCATION (t
, eloc
);
529 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
530 ignore the TARGET_EXPR. If there really turn out to be no
531 side-effects, then the optimizer should be able to get rid of
532 whatever code is generated anyhow. */
533 TREE_SIDE_EFFECTS (t
) = 1;
538 /* Return an undeclared local temporary of type TYPE for use in building a
542 build_local_temp (tree type
)
544 tree slot
= build_decl (input_location
,
545 VAR_DECL
, NULL_TREE
, type
);
546 DECL_ARTIFICIAL (slot
) = 1;
547 DECL_IGNORED_P (slot
) = 1;
548 DECL_CONTEXT (slot
) = current_function_decl
;
549 layout_decl (slot
, 0);
553 /* Return whether DECL is such a local temporary (or one from
554 create_tmp_var_raw). */
557 is_local_temp (tree decl
)
559 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
560 && !TREE_STATIC (decl
)
561 && DECL_FUNCTION_SCOPE_P (decl
));
564 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
567 process_aggr_init_operands (tree t
)
571 side_effects
= TREE_SIDE_EFFECTS (t
);
575 n
= TREE_OPERAND_LENGTH (t
);
576 for (i
= 1; i
< n
; i
++)
578 tree op
= TREE_OPERAND (t
, i
);
579 if (op
&& TREE_SIDE_EFFECTS (op
))
586 TREE_SIDE_EFFECTS (t
) = side_effects
;
589 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
590 FN, and SLOT. NARGS is the number of call arguments which are specified
591 as a tree array ARGS. */
594 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
600 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
601 TREE_TYPE (t
) = return_type
;
602 AGGR_INIT_EXPR_FN (t
) = fn
;
603 AGGR_INIT_EXPR_SLOT (t
) = slot
;
604 for (i
= 0; i
< nargs
; i
++)
605 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
606 process_aggr_init_operands (t
);
610 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
611 target. TYPE is the type to be initialized.
613 Build an AGGR_INIT_EXPR to represent the initialization. This function
614 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
615 to initialize another object, whereas a TARGET_EXPR can either
616 initialize another object or create its own temporary object, and as a
617 result building up a TARGET_EXPR requires that the type's destructor be
621 build_aggr_init_expr (tree type
, tree init
)
628 gcc_assert (!VOID_TYPE_P (type
));
630 /* Don't build AGGR_INIT_EXPR in a template. */
631 if (processing_template_decl
)
634 fn
= cp_get_callee (init
);
636 return convert (type
, init
);
638 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
639 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
640 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
642 /* We split the CALL_EXPR into its function and its arguments here.
643 Then, in expand_expr, we put them back together. The reason for
644 this is that this expression might be a default argument
645 expression. In that case, we need a new temporary every time the
646 expression is used. That's what break_out_target_exprs does; it
647 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
648 temporary slot. Then, expand_expr builds up a call-expression
649 using the new slot. */
651 /* If we don't need to use a constructor to create an object of this
652 type, don't mess with AGGR_INIT_EXPR. */
653 if (is_ctor
|| TREE_ADDRESSABLE (type
))
655 slot
= build_local_temp (type
);
657 if (TREE_CODE (init
) == CALL_EXPR
)
659 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
660 call_expr_nargs (init
),
661 CALL_EXPR_ARGP (init
));
662 AGGR_INIT_FROM_THUNK_P (rval
)
663 = CALL_FROM_THUNK_P (init
);
667 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
668 aggr_init_expr_nargs (init
),
669 AGGR_INIT_EXPR_ARGP (init
));
670 AGGR_INIT_FROM_THUNK_P (rval
)
671 = AGGR_INIT_FROM_THUNK_P (init
);
673 TREE_SIDE_EFFECTS (rval
) = 1;
674 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
675 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
676 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
677 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
678 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
686 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
687 target. TYPE is the type that this initialization should appear to
690 Build an encapsulation of the initialization to perform
691 and return it so that it can be processed by language-independent
692 and language-specific expression expanders. */
695 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
697 /* This function should cope with what build_special_member_call
698 can produce. When performing parenthesized aggregate initialization,
699 it can produce a { }. */
700 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
702 gcc_assert (cxx_dialect
>= cxx20
);
703 return finish_compound_literal (type
, init
, complain
);
706 tree rval
= build_aggr_init_expr (type
, init
);
709 if (init
== error_mark_node
)
710 return error_mark_node
;
712 if (!complete_type_or_maybe_complain (type
, init
, complain
))
713 return error_mark_node
;
715 /* Make sure that we're not trying to create an instance of an
717 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
718 return error_mark_node
;
720 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
721 slot
= AGGR_INIT_EXPR_SLOT (rval
);
722 else if (TREE_CODE (rval
) == CALL_EXPR
723 || TREE_CODE (rval
) == CONSTRUCTOR
)
724 slot
= build_local_temp (type
);
728 rval
= build_target_expr (slot
, rval
, complain
);
730 if (rval
!= error_mark_node
)
731 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
736 /* Subroutine of build_vec_init_expr: Build up a single element
737 intialization as a proxy for the full array initialization to get things
738 marked as used and any appropriate diagnostics.
740 This used to be necessary because we were deferring building the actual
741 constructor calls until gimplification time; now we only do it to set
742 VEC_INIT_EXPR_IS_CONSTEXPR.
744 We assume that init is either NULL_TREE, void_type_node (indicating
745 value-initialization), or another array to copy. */
748 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
750 tree inner_type
= strip_array_types (type
);
752 if (integer_zerop (array_type_nelts_total (type
))
753 || !CLASS_TYPE_P (inner_type
))
754 /* No interesting initialization to do. */
755 return integer_zero_node
;
756 else if (init
== void_type_node
)
757 return build_value_init (inner_type
, complain
);
759 releasing_vec argvec
;
760 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
762 gcc_assert (same_type_ignoring_top_level_qualifiers_p
763 (type
, TREE_TYPE (init
)));
764 tree init_type
= strip_array_types (TREE_TYPE (init
));
765 tree dummy
= build_dummy_object (init_type
);
766 if (!lvalue_p (init
))
767 dummy
= move (dummy
);
768 argvec
->quick_push (dummy
);
770 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
771 &argvec
, inner_type
, LOOKUP_NORMAL
,
774 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
775 we don't want one here because we aren't creating a temporary. */
776 if (TREE_CODE (init
) == TARGET_EXPR
)
777 init
= TARGET_EXPR_INITIAL (init
);
782 /* Return a TARGET_EXPR which expresses the initialization of an array to
783 be named later, either default-initialization or copy-initialization
784 from another array of the same type. */
787 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
789 if (init
&& TREE_CODE (init
) == VEC_INIT_EXPR
)
793 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
794 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
795 /* We built any needed constructor calls in digest_init. */
798 elt_init
= build_vec_init_elt (type
, init
, complain
);
800 bool value_init
= false;
801 if (init
== void_type_node
)
807 tree slot
= build_local_temp (type
);
808 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
809 TREE_SIDE_EFFECTS (init
) = true;
810 SET_EXPR_LOCATION (init
, input_location
);
812 if (cxx_dialect
>= cxx11
813 && potential_constant_expression (elt_init
))
814 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
815 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
820 /* Call build_vec_init to expand VEC_INIT into TARGET (for which NULL_TREE
821 means VEC_INIT_EXPR_SLOT). */
824 expand_vec_init_expr (tree target
, tree vec_init
, tsubst_flags_t complain
,
825 vec
<tree
,va_gc
> **flags
)
827 iloc_sentinel ils
= EXPR_LOCATION (vec_init
);
830 target
= VEC_INIT_EXPR_SLOT (vec_init
);
831 tree init
= VEC_INIT_EXPR_INIT (vec_init
);
832 int from_array
= (init
&& TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
);
833 return build_vec_init (target
, NULL_TREE
, init
,
834 VEC_INIT_EXPR_VALUE_INIT (vec_init
),
835 from_array
, complain
, flags
);
838 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
839 that requires a constant expression. */
842 diagnose_non_constexpr_vec_init (tree expr
)
844 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
846 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
847 init
= void_type_node
;
849 init
= VEC_INIT_EXPR_INIT (expr
);
851 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
852 require_potential_constant_expression (elt_init
);
856 build_array_copy (tree init
)
858 return get_target_expr (build_vec_init_expr
859 (TREE_TYPE (init
), init
, tf_warning_or_error
));
862 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
866 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
868 gcc_assert (!VOID_TYPE_P (type
));
869 gcc_assert (!VOID_TYPE_P (TREE_TYPE (init
)));
871 if (TREE_CODE (init
) == TARGET_EXPR
872 || init
== error_mark_node
)
874 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
875 && TREE_CODE (init
) != COND_EXPR
876 && TREE_CODE (init
) != CONSTRUCTOR
877 && TREE_CODE (init
) != VA_ARG_EXPR
878 && TREE_CODE (init
) != CALL_EXPR
)
879 /* We need to build up a copy constructor call. COND_EXPR is a special
880 case because we already have copies on the arms and we don't want
881 another one here. A CONSTRUCTOR is aggregate initialization, which
882 is handled separately. A VA_ARG_EXPR is magic creation of an
883 aggregate; there's no additional work to be done. A CALL_EXPR
884 already creates a prvalue. */
885 return force_rvalue (init
, complain
);
887 return force_target_expr (type
, init
, complain
);
890 /* Like the above function, but without the checking. This function should
891 only be used by code which is deliberately trying to subvert the type
892 system, such as call_builtin_trap. Or build_over_call, to avoid
893 infinite recursion. */
896 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
900 gcc_assert (!VOID_TYPE_P (type
));
902 slot
= build_local_temp (type
);
903 return build_target_expr (slot
, init
, complain
);
906 /* Like build_target_expr_with_type, but use the type of INIT. */
909 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
911 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
912 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
913 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
914 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
917 init
= convert_bitfield_to_declared_type (init
);
918 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
923 get_target_expr (tree init
)
925 return get_target_expr_sfinae (init
, tf_warning_or_error
);
928 /* If EXPR is a bitfield reference, convert it to the declared type of
929 the bitfield, and return the resulting expression. Otherwise,
930 return EXPR itself. */
933 convert_bitfield_to_declared_type (tree expr
)
937 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
939 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
944 /* EXPR is being used in an rvalue context. Return a version of EXPR
945 that is marked as an rvalue. */
952 if (error_operand_p (expr
))
955 expr
= mark_rvalue_use (expr
);
959 Non-class rvalues always have cv-unqualified types. */
960 type
= TREE_TYPE (expr
);
961 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
962 type
= cv_unqualified (type
);
964 /* We need to do this for rvalue refs as well to get the right answer
965 from decltype; see c++/36628. */
966 if (!processing_template_decl
&& glvalue_p (expr
))
968 /* But don't use this function for class lvalues; use move (to treat an
969 lvalue as an xvalue) or force_rvalue (to make a prvalue copy). */
970 gcc_checking_assert (!CLASS_TYPE_P (type
));
971 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
973 else if (type
!= TREE_TYPE (expr
))
974 expr
= build_nop (type
, expr
);
980 struct cplus_array_info
986 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
988 typedef cplus_array_info
*compare_type
;
990 static hashval_t
hash (tree t
);
991 static bool equal (tree
, cplus_array_info
*);
994 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
997 cplus_array_hasher::hash (tree t
)
1001 hash
= TYPE_UID (TREE_TYPE (t
));
1002 if (TYPE_DOMAIN (t
))
1003 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
1007 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
1008 of type `cplus_array_info*'. */
1011 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
1013 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
1016 /* Hash table containing dependent array types, which are unsuitable for
1017 the language-independent type hash table. */
1018 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
1020 /* Build an ARRAY_TYPE without laying it out. */
1023 build_min_array_type (tree elt_type
, tree index_type
)
1025 tree t
= cxx_make_type (ARRAY_TYPE
);
1026 TREE_TYPE (t
) = elt_type
;
1027 TYPE_DOMAIN (t
) = index_type
;
1031 /* Set TYPE_CANONICAL like build_array_type_1, but using
1032 build_cplus_array_type. */
1035 set_array_type_canon (tree t
, tree elt_type
, tree index_type
, bool dep
)
1037 /* Set the canonical type for this new node. */
1038 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1039 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1040 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1041 else if (TYPE_CANONICAL (elt_type
) != elt_type
1042 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1044 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1046 ? TYPE_CANONICAL (index_type
) : index_type
,
1049 TYPE_CANONICAL (t
) = t
;
1052 /* Like build_array_type, but handle special C++ semantics: an array of a
1053 variant element type is a variant of the array of the main variant of
1054 the element type. IS_DEPENDENT is -ve if we should determine the
1055 dependency. Otherwise its bool value indicates dependency. */
1058 build_cplus_array_type (tree elt_type
, tree index_type
, int dependent
)
1062 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1063 return error_mark_node
;
1066 dependent
= (uses_template_parms (elt_type
)
1067 || (index_type
&& uses_template_parms (index_type
)));
1069 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1070 /* Start with an array of the TYPE_MAIN_VARIANT. */
1071 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1072 index_type
, dependent
);
1075 /* Since type_hash_canon calls layout_type, we need to use our own
1077 cplus_array_info cai
;
1080 if (cplus_array_htab
== NULL
)
1081 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1083 hash
= TYPE_UID (elt_type
);
1085 hash
^= TYPE_UID (index_type
);
1086 cai
.type
= elt_type
;
1087 cai
.domain
= index_type
;
1089 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1091 /* We have found the type: we're done. */
1095 /* Build a new array type. */
1096 t
= build_min_array_type (elt_type
, index_type
);
1098 /* Store it in the hash table. */
1101 /* Set the canonical type for this new node. */
1102 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1104 /* Mark it as dependent now, this saves time later. */
1105 TYPE_DEPENDENT_P_VALID (t
) = true;
1106 TYPE_DEPENDENT_P (t
) = true;
1111 bool typeless_storage
= is_byte_access_type (elt_type
);
1112 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1114 /* Mark as non-dependenty now, this will save time later. */
1115 TYPE_DEPENDENT_P_VALID (t
) = true;
1118 /* Now check whether we already have this array variant. */
1119 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1122 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1123 if (TREE_TYPE (t
) == elt_type
1124 && TYPE_NAME (t
) == NULL_TREE
1125 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1129 t
= build_min_array_type (elt_type
, index_type
);
1130 /* Mark dependency now, this saves time later. */
1131 TYPE_DEPENDENT_P_VALID (t
) = true;
1132 TYPE_DEPENDENT_P (t
) = dependent
;
1133 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1137 /* Make sure sizes are shared with the main variant.
1138 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1139 as it will overwrite alignment etc. of all variants. */
1140 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1141 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1142 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1145 TYPE_MAIN_VARIANT (t
) = m
;
1146 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1147 TYPE_NEXT_VARIANT (m
) = t
;
1151 /* Avoid spurious warnings with VLAs (c++/54583). */
1152 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1153 suppress_warning (TYPE_SIZE (t
), OPT_Wunused
);
1155 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1156 place more easily. */
1157 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1158 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1159 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1160 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1162 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1163 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1165 /* The element type has been completed since the last time we saw
1166 this array type; update the layout and 'tor flags for any variants
1169 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1171 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1172 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1179 /* Return an ARRAY_TYPE with element type ELT and length N. */
1182 build_array_of_n_type (tree elt
, int n
)
1184 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1187 /* True iff T is an array of unknown bound. */
1190 array_of_unknown_bound_p (const_tree t
)
1192 return (TREE_CODE (t
) == ARRAY_TYPE
1193 && !TYPE_DOMAIN (t
));
1196 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1197 for C++14 but then removed. This should only be used for N3639
1198 specifically; code wondering more generally if something is a VLA should use
1202 array_of_runtime_bound_p (tree t
)
1204 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1206 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1208 tree dom
= TYPE_DOMAIN (t
);
1211 tree max
= TYPE_MAX_VALUE (dom
);
1212 return (!potential_rvalue_constant_expression (max
)
1213 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1216 /* True iff T is a variable length array. */
1221 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1223 if (tree dom
= TYPE_DOMAIN (t
))
1225 tree max
= TYPE_MAX_VALUE (dom
);
1226 if (!potential_rvalue_constant_expression (max
)
1227 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1234 /* Return a reference type node of MODE referring to TO_TYPE. If MODE
1235 is VOIDmode the standard pointer mode will be picked. If RVAL is
1236 true, return an rvalue reference type, otherwise return an lvalue
1237 reference type. If a type node exists, reuse it, otherwise create
1240 cp_build_reference_type_for_mode (tree to_type
, machine_mode mode
, bool rval
)
1244 if (to_type
== error_mark_node
)
1245 return error_mark_node
;
1247 if (TYPE_REF_P (to_type
))
1249 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1250 to_type
= TREE_TYPE (to_type
);
1253 lvalue_ref
= build_reference_type_for_mode (to_type
, mode
, false);
1258 /* This code to create rvalue reference types is based on and tied
1259 to the code creating lvalue reference types in the middle-end
1260 functions build_reference_type_for_mode and build_reference_type.
1262 It works by putting the rvalue reference type nodes after the
1263 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1264 they will effectively be ignored by the middle end. */
1266 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1267 if (TYPE_REF_IS_RVALUE (t
))
1270 t
= build_distinct_type_copy (lvalue_ref
);
1272 TYPE_REF_IS_RVALUE (t
) = true;
1273 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1274 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1276 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1277 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1278 else if (TYPE_CANONICAL (to_type
) != to_type
)
1280 = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type
), mode
, rval
);
1282 TYPE_CANONICAL (t
) = t
;
1290 /* Return a reference type node referring to TO_TYPE. If RVAL is
1291 true, return an rvalue reference type, otherwise return an lvalue
1292 reference type. If a type node exists, reuse it, otherwise create
1295 cp_build_reference_type (tree to_type
, bool rval
)
1297 return cp_build_reference_type_for_mode (to_type
, VOIDmode
, rval
);
1300 /* Returns EXPR cast to rvalue reference type, like std::move. */
1305 tree type
= TREE_TYPE (expr
);
1306 gcc_assert (!TYPE_REF_P (type
));
1307 if (xvalue_p (expr
))
1309 type
= cp_build_reference_type (type
, /*rval*/true);
1310 return build_static_cast (input_location
, type
, expr
,
1311 tf_warning_or_error
);
1314 /* Used by the C++ front end to build qualified array types. However,
1315 the C version of this function does not properly maintain canonical
1316 types (which are not used in C). */
1318 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1319 size_t /* orig_qual_indirect */)
1321 return cp_build_qualified_type (type
, type_quals
);
1325 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1326 arrays correctly. In particular, if TYPE is an array of T's, and
1327 TYPE_QUALS is non-empty, returns an array of qualified T's.
1329 FLAGS determines how to deal with ill-formed qualifications. If
1330 tf_ignore_bad_quals is set, then bad qualifications are dropped
1331 (this is permitted if TYPE was introduced via a typedef or template
1332 type parameter). If bad qualifications are dropped and tf_warning
1333 is set, then a warning is issued for non-const qualifications. If
1334 tf_ignore_bad_quals is not set and tf_error is not set, we
1335 return error_mark_node. Otherwise, we issue an error, and ignore
1338 Qualification of a reference type is valid when the reference came
1339 via a typedef or template type argument. [dcl.ref] No such
1340 dispensation is provided for qualifying a function type. [dcl.fct]
1341 DR 295 queries this and the proposed resolution brings it into line
1342 with qualifying a reference. We implement the DR. We also behave
1343 in a similar manner for restricting non-pointer types. */
1346 cp_build_qualified_type_real (tree type
,
1348 tsubst_flags_t complain
)
1351 int bad_quals
= TYPE_UNQUALIFIED
;
1353 if (type
== error_mark_node
)
1356 if (type_quals
== cp_type_quals (type
))
1359 if (TREE_CODE (type
) == ARRAY_TYPE
)
1361 /* In C++, the qualification really applies to the array element
1362 type. Obtain the appropriately qualified element type. */
1365 = cp_build_qualified_type_real (TREE_TYPE (type
),
1369 if (element_type
== error_mark_node
)
1370 return error_mark_node
;
1372 /* See if we already have an identically qualified type. Tests
1373 should be equivalent to those in check_qualified_type. */
1374 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1375 if (TREE_TYPE (t
) == element_type
1376 && TYPE_NAME (t
) == TYPE_NAME (type
)
1377 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1378 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1379 TYPE_ATTRIBUTES (type
)))
1384 /* If we already know the dependentness, tell the array type
1385 constructor. This is important for module streaming, as we cannot
1386 dynamically determine that on read in. */
1387 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
),
1388 TYPE_DEPENDENT_P_VALID (type
)
1389 ? int (TYPE_DEPENDENT_P (type
)) : -1);
1391 /* Keep the typedef name. */
1392 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1394 t
= build_variant_type_copy (t
);
1395 TYPE_NAME (t
) = TYPE_NAME (type
);
1396 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1397 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1401 /* Even if we already had this variant, we update
1402 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1403 they changed since the variant was originally created.
1405 This seems hokey; if there is some way to use a previous
1406 variant *without* coming through here,
1407 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1408 TYPE_NEEDS_CONSTRUCTING (t
)
1409 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1410 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1411 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1414 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1416 tree t
= PACK_EXPANSION_PATTERN (type
);
1418 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1419 return make_pack_expansion (t
, complain
);
1422 /* A reference or method type shall not be cv-qualified.
1423 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1424 (in CD1) we always ignore extra cv-quals on functions. */
1426 /* [dcl.ref/1] Cv-qualified references are ill-formed except when
1427 the cv-qualifiers are introduced through the use of a typedef-name
1428 ([dcl.typedef], [temp.param]) or decltype-specifier
1429 ([dcl.type.decltype]),in which case the cv-qualifiers are
1431 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1432 && (TYPE_REF_P (type
)
1433 || FUNC_OR_METHOD_TYPE_P (type
)))
1435 if (TYPE_REF_P (type
)
1436 && (!typedef_variant_p (type
) || FUNC_OR_METHOD_TYPE_P (type
)))
1437 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1438 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1441 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1442 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1443 type_quals
|= type_memfn_quals (type
);
1445 /* A restrict-qualified type must be a pointer (or reference)
1446 to object or incomplete type. */
1447 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1448 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1449 && TREE_CODE (type
) != TYPENAME_TYPE
1450 && !INDIRECT_TYPE_P (type
))
1452 bad_quals
|= TYPE_QUAL_RESTRICT
;
1453 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1456 if (bad_quals
== TYPE_UNQUALIFIED
1457 || (complain
& tf_ignore_bad_quals
))
1459 else if (!(complain
& tf_error
))
1460 return error_mark_node
;
1463 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1464 error ("%qV qualifiers cannot be applied to %qT",
1468 /* Retrieve (or create) the appropriately qualified variant. */
1469 result
= build_qualified_type (type
, type_quals
);
1474 /* Return TYPE with const and volatile removed. */
1477 cv_unqualified (tree type
)
1481 if (type
== error_mark_node
)
1484 quals
= cp_type_quals (type
);
1485 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1486 return cp_build_qualified_type (type
, quals
);
1489 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1490 from ATTRIBS that affect type identity, and no others. If any are not
1491 applied, set *remove_attributes to true. */
1494 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1496 tree first_ident
= NULL_TREE
;
1497 tree new_attribs
= NULL_TREE
;
1498 tree
*p
= &new_attribs
;
1500 if (OVERLOAD_TYPE_P (result
))
1502 /* On classes and enums all attributes are ingrained. */
1503 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1507 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1509 const attribute_spec
*as
1510 = lookup_attribute_spec (get_attribute_name (a
));
1511 if (as
&& as
->affects_type_identity
)
1515 else if (first_ident
== error_mark_node
)
1517 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1518 p
= &TREE_CHAIN (*p
);
1521 else if (first_ident
&& first_ident
!= error_mark_node
)
1523 for (tree a2
= first_ident
; a2
!= a
; a2
= TREE_CHAIN (a2
))
1525 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1526 p
= &TREE_CHAIN (*p
);
1528 first_ident
= error_mark_node
;
1531 if (first_ident
!= error_mark_node
)
1532 new_attribs
= first_ident
;
1534 if (first_ident
== attribs
)
1535 /* All attributes affected type identity. */;
1537 *remove_attributes
= true;
1539 return cp_build_type_attribute_variant (result
, new_attribs
);
1542 /* Builds a qualified variant of T that is either not a typedef variant
1543 (the default behavior) or not a typedef variant of a user-facing type
1544 (if FLAGS contains STF_USER_FACING).
1546 E.g. consider the following declarations:
1547 typedef const int ConstInt;
1548 typedef ConstInt* PtrConstInt;
1549 If T is PtrConstInt, this function returns a type representing
1551 In other words, if T is a typedef, the function returns the underlying type.
1552 The cv-qualification and attributes of the type returned match the
1554 They will always be compatible types.
1555 The returned type is built so that all of its subtypes
1556 recursively have their typedefs stripped as well.
1558 This is different from just returning TYPE_CANONICAL (T)
1559 Because of several reasons:
1560 * If T is a type that needs structural equality
1561 its TYPE_CANONICAL (T) will be NULL.
1562 * TYPE_CANONICAL (T) desn't carry type attributes
1563 and loses template parameter names.
1565 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1566 affect type identity, and set the referent to true if any were
1570 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1572 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1574 if (!t
|| t
== error_mark_node
)
1577 if (TREE_CODE (t
) == TREE_LIST
)
1579 bool changed
= false;
1582 for (; t
; t
= TREE_CHAIN (t
))
1584 gcc_assert (!TREE_PURPOSE (t
));
1585 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1586 if (elt
!= TREE_VALUE (t
))
1588 vec_safe_push (vec
, elt
);
1591 r
= build_tree_list_vec (vec
);
1595 gcc_assert (TYPE_P (t
));
1597 if (t
== TYPE_CANONICAL (t
))
1600 if (!(flags
& STF_STRIP_DEPENDENT
)
1601 && dependent_alias_template_spec_p (t
, nt_opaque
))
1602 /* DR 1558: However, if the template-id is dependent, subsequent
1603 template argument substitution still applies to the template-id. */
1606 switch (TREE_CODE (t
))
1609 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1610 result
= build_pointer_type_for_mode (type
, TYPE_MODE (t
), false);
1612 case REFERENCE_TYPE
:
1613 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1614 result
= cp_build_reference_type_for_mode (type
, TYPE_MODE (t
), TYPE_REF_IS_RVALUE (t
));
1617 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1618 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1619 result
= build_offset_type (t0
, type
);
1622 if (TYPE_PTRMEMFUNC_P (t
))
1624 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1625 remove_attributes
, flags
);
1626 result
= build_ptrmemfunc_type (t0
);
1630 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1631 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1632 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t
)
1633 || !dependent_type_p (t
));
1634 result
= build_cplus_array_type (type
, t0
, TYPE_DEPENDENT_P (t
));
1639 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1642 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1643 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1644 can't expect that re-hashing a function type will find a previous
1645 equivalent type, so try to reuse the input type if nothing has
1646 changed. If the type is itself a variant, that will change. */
1647 bool is_variant
= typedef_variant_p (t
);
1648 if (remove_attributes
1649 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1652 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1653 tree canon_spec
= (flag_noexcept_type
1654 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1656 changed
= (type
!= TREE_TYPE (t
) || is_variant
1657 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1659 for (arg_node
= TYPE_ARG_TYPES (t
);
1661 arg_node
= TREE_CHAIN (arg_node
))
1663 if (arg_node
== void_list_node
)
1665 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1666 remove_attributes
, flags
);
1667 gcc_assert (arg_type
);
1668 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1674 for (arg_node2
= TYPE_ARG_TYPES (t
);
1675 arg_node2
!= arg_node
;
1676 arg_node2
= TREE_CHAIN (arg_node2
))
1678 = tree_cons (TREE_PURPOSE (arg_node2
),
1679 TREE_VALUE (arg_node2
), arg_types
);
1683 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1690 arg_types
= nreverse (arg_types
);
1692 /* A list of parameters not ending with an ellipsis
1693 must end with void_list_node. */
1695 arg_types
= chainon (arg_types
, void_list_node
);
1697 if (TREE_CODE (t
) == METHOD_TYPE
)
1699 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1700 gcc_assert (class_type
);
1702 build_method_type_directly (class_type
, type
,
1703 TREE_CHAIN (arg_types
));
1707 result
= build_function_type (type
, arg_types
);
1708 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1711 result
= build_cp_fntype_variant (result
,
1712 type_memfn_rqual (t
), canon_spec
,
1713 TYPE_HAS_LATE_RETURN_TYPE (t
));
1718 bool changed
= false;
1719 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1720 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1721 && TREE_OPERAND (fullname
, 1))
1723 tree args
= TREE_OPERAND (fullname
, 1);
1724 tree new_args
= copy_node (args
);
1725 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1727 tree arg
= TREE_VEC_ELT (args
, i
);
1730 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1732 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1734 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1735 if (strip_arg
!= arg
)
1740 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1741 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1743 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1747 ggc_free (new_args
);
1749 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1750 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1752 tree name
= fullname
;
1753 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1754 name
= TREE_OPERAND (fullname
, 0);
1755 /* Use build_typename_type rather than make_typename_type because we
1756 don't want to resolve it here, just strip typedefs. */
1757 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1761 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1762 remove_attributes
, flags
);
1763 if (result
== DECLTYPE_TYPE_EXPR (t
))
1766 result
= (finish_decltype_type
1768 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1771 case UNDERLYING_TYPE
:
1772 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1773 remove_attributes
, flags
);
1774 result
= finish_underlying_type (type
);
1776 case TYPE_PACK_EXPANSION
:
1778 tree pat
= PACK_EXPANSION_PATTERN (t
);
1781 type
= strip_typedefs (pat
, remove_attributes
, flags
);
1784 result
= copy_node (t
);
1785 PACK_EXPANSION_PATTERN (result
) = type
;
1796 if (typedef_variant_p (t
))
1798 if ((flags
& STF_USER_VISIBLE
)
1799 && !user_facing_original_type_p (t
))
1801 /* If T is a non-template alias or typedef, we can assume that
1802 instantiating its definition will hit any substitution failure,
1803 so we don't need to retain it here as well. */
1804 if (!alias_template_specialization_p (t
, nt_opaque
))
1805 flags
|= STF_STRIP_DEPENDENT
;
1806 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1807 remove_attributes
, flags
);
1810 result
= TYPE_MAIN_VARIANT (t
);
1812 /*gcc_assert (!typedef_variant_p (result)
1813 || dependent_alias_template_spec_p (result, nt_opaque)
1814 || ((flags & STF_USER_VISIBLE)
1815 && !user_facing_original_type_p (result)));*/
1817 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1818 /* If RESULT is complete and T isn't, it's likely the case that T
1819 is a variant of RESULT which hasn't been updated yet. Skip the
1820 attribute handling. */;
1823 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1824 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1826 gcc_assert (TYPE_USER_ALIGN (t
));
1827 if (remove_attributes
)
1828 *remove_attributes
= true;
1831 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1832 result
= build_variant_type_copy (result
);
1834 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1835 TYPE_USER_ALIGN (result
) = true;
1839 if (TYPE_ATTRIBUTES (t
))
1841 if (remove_attributes
)
1842 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1845 result
= cp_build_type_attribute_variant (result
,
1846 TYPE_ATTRIBUTES (t
));
1850 return cp_build_qualified_type (result
, cp_type_quals (t
));
1853 /* Like strip_typedefs above, but works on expressions, so that in
1855 template<class T> struct A
1861 sizeof(TT) is replaced by sizeof(T). */
1864 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1868 enum tree_code code
;
1870 if (t
== NULL_TREE
|| t
== error_mark_node
)
1873 STRIP_ANY_LOCATION_WRAPPER (t
);
1875 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1878 /* Some expressions have type operands, so let's handle types here rather
1879 than check TYPE_P in multiple places below. */
1881 return strip_typedefs (t
, remove_attributes
, flags
);
1883 code
= TREE_CODE (t
);
1886 case IDENTIFIER_NODE
:
1887 case TEMPLATE_PARM_INDEX
:
1890 case ARGUMENT_PACK_SELECT
:
1895 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1896 remove_attributes
, flags
);
1897 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1898 remove_attributes
, flags
);
1899 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1900 && type2
== TRAIT_EXPR_TYPE2 (t
))
1903 TRAIT_EXPR_TYPE1 (r
) = type1
;
1904 TRAIT_EXPR_TYPE2 (r
) = type2
;
1911 bool changed
= false;
1913 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1915 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1916 remove_attributes
, flags
);
1917 vec_safe_push (vec
, val
);
1918 if (val
!= TREE_VALUE (it
))
1920 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1925 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1926 r
= tree_cons (NULL_TREE
, it
, r
);
1935 bool changed
= false;
1937 n
= TREE_VEC_LENGTH (t
);
1938 vec_safe_reserve (vec
, n
);
1939 for (i
= 0; i
< n
; ++i
)
1941 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1942 remove_attributes
, flags
);
1943 vec
->quick_push (op
);
1944 if (op
!= TREE_VEC_ELT (t
, i
))
1950 for (i
= 0; i
< n
; ++i
)
1951 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1952 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1953 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1962 bool changed
= false;
1963 vec
<constructor_elt
, va_gc
> *vec
1964 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1965 n
= CONSTRUCTOR_NELTS (t
);
1966 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1967 for (i
= 0; i
< n
; ++i
)
1969 constructor_elt
*e
= &(*vec
)[i
];
1970 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1977 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1981 if (!changed
&& type
== TREE_TYPE (t
))
1989 TREE_TYPE (r
) = type
;
1990 CONSTRUCTOR_ELTS (r
) = vec
;
1998 case STATEMENT_LIST
:
1999 error ("statement-expression in a constant expression");
2000 return error_mark_node
;
2006 gcc_assert (EXPR_P (t
));
2008 n
= cp_tree_operand_length (t
);
2009 ops
= XALLOCAVEC (tree
, n
);
2010 type
= TREE_TYPE (t
);
2015 case IMPLICIT_CONV_EXPR
:
2016 case DYNAMIC_CAST_EXPR
:
2017 case STATIC_CAST_EXPR
:
2018 case CONST_CAST_EXPR
:
2019 case REINTERPRET_CAST_EXPR
:
2022 type
= strip_typedefs (type
, remove_attributes
, flags
);
2026 for (i
= 0; i
< n
; ++i
)
2027 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
2028 remove_attributes
, flags
);
2032 /* If nothing changed, return t. */
2033 for (i
= 0; i
< n
; ++i
)
2034 if (ops
[i
] != TREE_OPERAND (t
, i
))
2036 if (i
== n
&& type
== TREE_TYPE (t
))
2040 TREE_TYPE (r
) = type
;
2041 for (i
= 0; i
< n
; ++i
)
2042 TREE_OPERAND (r
, i
) = ops
[i
];
2046 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
2047 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2048 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2049 VIRT indicates whether TYPE is inherited virtually or not.
2050 IGO_PREV points at the previous binfo of the inheritance graph
2051 order chain. The newly copied binfo's TREE_CHAIN forms this
2054 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2055 correct order. That is in the order the bases themselves should be
2058 The BINFO_INHERITANCE of a virtual base class points to the binfo
2059 of the most derived type. ??? We could probably change this so that
2060 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2061 remove a field. They currently can only differ for primary virtual
2065 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
2071 /* See if we've already made this virtual base. */
2072 new_binfo
= binfo_for_vbase (type
, t
);
2077 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
2078 BINFO_TYPE (new_binfo
) = type
;
2080 /* Chain it into the inheritance graph. */
2081 TREE_CHAIN (*igo_prev
) = new_binfo
;
2082 *igo_prev
= new_binfo
;
2084 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2089 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2091 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2092 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2094 /* We do not need to copy the accesses, as they are read only. */
2095 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2097 /* Recursively copy base binfos of BINFO. */
2098 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2100 tree new_base_binfo
;
2101 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2103 BINFO_VIRTUAL_P (base_binfo
));
2105 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2106 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2107 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2111 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2115 /* Push it onto the list after any virtual bases it contains
2116 will have been pushed. */
2117 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2118 BINFO_VIRTUAL_P (new_binfo
) = 1;
2119 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2125 /* Hashing of lists so that we don't make duplicates.
2126 The entry point is `list_hash_canon'. */
2135 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2137 typedef list_proxy
*compare_type
;
2139 static hashval_t
hash (tree
);
2140 static bool equal (tree
, list_proxy
*);
2143 /* Now here is the hash table. When recording a list, it is added
2144 to the slot whose index is the hash code mod the table size.
2145 Note that the hash table is used for several kinds of lists.
2146 While all these live in the same table, they are completely independent,
2147 and the hash code is computed differently for each of these. */
2149 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2151 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2152 for a node we are thinking about adding). */
2155 list_hasher::equal (tree t
, list_proxy
*proxy
)
2157 return (TREE_VALUE (t
) == proxy
->value
2158 && TREE_PURPOSE (t
) == proxy
->purpose
2159 && TREE_CHAIN (t
) == proxy
->chain
);
2162 /* Compute a hash code for a list (chain of TREE_LIST nodes
2163 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2164 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2167 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2169 hashval_t hashcode
= 0;
2172 hashcode
+= TREE_HASH (chain
);
2175 hashcode
+= TREE_HASH (value
);
2179 hashcode
+= TREE_HASH (purpose
);
2185 /* Hash an already existing TREE_LIST. */
2188 list_hasher::hash (tree t
)
2190 return list_hash_pieces (TREE_PURPOSE (t
),
2195 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2196 object for an identical list if one already exists. Otherwise, build a
2197 new one, and record it as the canonical object. */
2200 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2204 struct list_proxy proxy
;
2206 /* Hash the list node. */
2207 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2208 /* Create a proxy for the TREE_LIST we would like to create. We
2209 don't actually create it so as to avoid creating garbage. */
2210 proxy
.purpose
= purpose
;
2211 proxy
.value
= value
;
2212 proxy
.chain
= chain
;
2213 /* See if it is already in the table. */
2214 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2215 /* If not, create a new node. */
2217 *slot
= tree_cons (purpose
, value
, chain
);
2218 return (tree
) *slot
;
2221 /* Constructor for hashed lists. */
2224 hash_tree_chain (tree value
, tree chain
)
2226 return hash_tree_cons (NULL_TREE
, value
, chain
);
2230 debug_binfo (tree elem
)
2235 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2237 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2238 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2239 debug_tree (BINFO_TYPE (elem
));
2240 if (BINFO_VTABLE (elem
))
2241 fprintf (stderr
, "vtable decl \"%s\"\n",
2242 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2244 fprintf (stderr
, "no vtable decl yet\n");
2245 fprintf (stderr
, "virtuals:\n");
2246 virtuals
= BINFO_VIRTUALS (elem
);
2251 tree fndecl
= TREE_VALUE (virtuals
);
2252 fprintf (stderr
, "%s [%ld =? %ld]\n",
2253 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2254 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2256 virtuals
= TREE_CHAIN (virtuals
);
2260 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2261 the type of the result expression, if known, or NULL_TREE if the
2262 resulting expression is type-dependent. If TEMPLATE_P is true,
2263 NAME is known to be a template because the user explicitly used the
2264 "template" keyword after the "::".
2266 All SCOPE_REFs should be built by use of this function. */
2269 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2272 if (type
== error_mark_node
2273 || scope
== error_mark_node
2274 || name
== error_mark_node
)
2275 return error_mark_node
;
2276 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2277 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2278 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2279 PTRMEM_OK_P (t
) = true;
2281 t
= convert_from_reference (t
);
2285 /* Like check_qualified_type, but also check ref-qualifier, exception
2286 specification, and whether the return type was specified after the
2290 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2291 cp_ref_qualifier rqual
, tree raises
, bool late
)
2293 return (TYPE_QUALS (cand
) == type_quals
2294 && check_base_type (cand
, base
)
2295 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2297 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2298 && type_memfn_rqual (cand
) == rqual
);
2301 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2304 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2306 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2307 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2308 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2312 make_binding_vec (tree name
, unsigned clusters MEM_STAT_DECL
)
2314 /* Stored in an unsigned short, but we're limited to the number of
2316 gcc_checking_assert (clusters
<= (unsigned short)(~0));
2317 size_t length
= (offsetof (tree_binding_vec
, vec
)
2318 + clusters
* sizeof (binding_cluster
));
2319 tree vec
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2320 TREE_SET_CODE (vec
, BINDING_VECTOR
);
2321 BINDING_VECTOR_NAME (vec
) = name
;
2322 BINDING_VECTOR_ALLOC_CLUSTERS (vec
) = clusters
;
2323 BINDING_VECTOR_NUM_CLUSTERS (vec
) = 0;
2328 /* Make a raw overload node containing FN. */
2331 ovl_make (tree fn
, tree next
)
2333 tree result
= make_node (OVERLOAD
);
2335 if (TREE_CODE (fn
) == OVERLOAD
)
2336 OVL_NESTED_P (result
) = true;
2338 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2339 ? unknown_type_node
: TREE_TYPE (fn
));
2340 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2341 OVL_DEDUP_P (result
) = true;
2342 OVL_FUNCTION (result
) = fn
;
2343 OVL_CHAIN (result
) = next
;
2347 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2348 zero if this is a using-decl. It is > 1 if we're exporting the
2349 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2350 cannot be both using and hidden.) We keep the hidden decls first,
2351 but remaining ones are unordered. */
2354 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2356 tree result
= maybe_ovl
;
2357 tree insert_after
= NULL_TREE
;
2360 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2361 && OVL_HIDDEN_P (maybe_ovl
);
2362 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2364 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2365 insert_after
= maybe_ovl
;
2368 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2370 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2372 if (using_or_hidden
< 0)
2373 OVL_HIDDEN_P (maybe_ovl
) = true;
2374 if (using_or_hidden
> 0)
2376 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2377 if (using_or_hidden
> 1)
2378 OVL_EXPORT_P (maybe_ovl
) = true;
2386 OVL_CHAIN (insert_after
) = maybe_ovl
;
2387 TREE_TYPE (insert_after
) = unknown_type_node
;
2395 /* Skip any hidden names at the beginning of OVL. */
2398 ovl_skip_hidden (tree ovl
)
2400 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2401 ovl
= OVL_CHAIN (ovl
);
2406 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2409 ovl_iterator::reveal_node (tree overload
, tree node
)
2411 /* We cannot have returned NODE as part of a lookup overload, so we
2412 don't have to worry about preserving that. */
2414 OVL_HIDDEN_P (node
) = false;
2415 if (tree chain
= OVL_CHAIN (node
))
2416 if (TREE_CODE (chain
) == OVERLOAD
)
2418 if (OVL_HIDDEN_P (chain
))
2420 /* The node needs moving, and the simplest way is to remove it
2422 overload
= remove_node (overload
, node
);
2423 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2425 else if (OVL_DEDUP_P (chain
))
2426 OVL_DEDUP_P (node
) = true;
2431 /* NODE is on the overloads of OVL. Remove it.
2432 The removed node is unaltered and may continue to be iterated
2433 from (i.e. it is safe to remove a node from an overload one is
2434 currently iterating over). */
2437 ovl_iterator::remove_node (tree overload
, tree node
)
2439 tree
*slot
= &overload
;
2440 while (*slot
!= node
)
2443 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2445 slot
= &OVL_CHAIN (probe
);
2448 /* Stitch out NODE. We don't have to worry about now making a
2449 singleton overload (and consequently maybe setting its type),
2450 because all uses of this function will be followed by inserting a
2451 new node that must follow the place we've cut this out from. */
2452 if (TREE_CODE (node
) != OVERLOAD
)
2453 /* Cloned inherited ctors don't mark themselves as via_using. */
2456 *slot
= OVL_CHAIN (node
);
2461 /* Mark or unmark a lookup set. */
2464 lookup_mark (tree ovl
, bool val
)
2466 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2468 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2469 LOOKUP_SEEN_P (*iter
) = val
;
2473 /* Add a set of new FNS into a lookup. */
2476 lookup_add (tree fns
, tree lookup
)
2478 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2479 return error_mark_node
;
2481 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2483 lookup
= ovl_make (fns
, lookup
);
2484 OVL_LOOKUP_P (lookup
) = true;
2492 /* FNS is a new overload set, add them to LOOKUP, if they are not
2493 already present there. */
2496 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2499 for (tree next
, probe
= fns
; probe
; probe
= next
)
2504 if (TREE_CODE (probe
) == OVERLOAD
)
2506 fn
= OVL_FUNCTION (probe
);
2507 next
= OVL_CHAIN (probe
);
2510 if (!LOOKUP_SEEN_P (fn
))
2511 LOOKUP_SEEN_P (fn
) = true;
2514 /* This function was already seen. Insert all the
2515 predecessors onto the lookup. */
2516 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2518 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2519 /* Propagate OVL_USING, but OVL_HIDDEN &
2520 OVL_DEDUP_P don't matter. */
2521 if (OVL_USING_P (fns
))
2522 OVL_USING_P (lookup
) = true;
2525 /* And now skip this function. */
2531 /* We ended in a set of new functions. Add them all in one go. */
2532 lookup
= lookup_add (fns
, lookup
);
2537 /* Returns nonzero if X is an expression for a (possibly overloaded)
2538 function. If "f" is a function or function template, "f", "c->f",
2539 "c.f", "C::f", and "f<int>" will all be considered possibly
2540 overloaded functions. Returns 2 if the function is actually
2541 overloaded, i.e., if it is impossible to know the type of the
2542 function without performing overload resolution. */
2545 is_overloaded_fn (tree x
)
2547 STRIP_ANY_LOCATION_WRAPPER (x
);
2549 /* A baselink is also considered an overloaded function. */
2550 if (TREE_CODE (x
) == OFFSET_REF
2551 || TREE_CODE (x
) == COMPONENT_REF
)
2552 x
= TREE_OPERAND (x
, 1);
2553 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2554 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2555 x
= TREE_OPERAND (x
, 0);
2557 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2558 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2564 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2565 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2569 dependent_name (tree x
)
2571 /* FIXME a dependent name must be unqualified, but this function doesn't
2572 distinguish between qualified and unqualified identifiers. */
2573 if (identifier_p (x
))
2575 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2576 x
= TREE_OPERAND (x
, 0);
2578 return OVL_NAME (x
);
2582 /* Returns true iff X is an expression for an overloaded function
2583 whose type cannot be known without performing overload
2587 really_overloaded_fn (tree x
)
2589 return is_overloaded_fn (x
) == 2;
2592 /* Get the overload set FROM refers to. Returns NULL if it's not an
2596 maybe_get_fns (tree from
)
2598 STRIP_ANY_LOCATION_WRAPPER (from
);
2600 /* A baselink is also considered an overloaded function. */
2601 if (TREE_CODE (from
) == OFFSET_REF
2602 || TREE_CODE (from
) == COMPONENT_REF
)
2603 from
= TREE_OPERAND (from
, 1);
2604 if (BASELINK_P (from
))
2605 from
= BASELINK_FUNCTIONS (from
);
2606 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2607 from
= TREE_OPERAND (from
, 0);
2615 /* FROM refers to an overload set. Return that set (or die). */
2620 tree res
= maybe_get_fns (from
);
2626 /* Return the first function of the overload set FROM refers to. */
2629 get_first_fn (tree from
)
2631 return OVL_FIRST (get_fns (from
));
2634 /* Return the scope where the overloaded functions OVL were found. */
2637 ovl_scope (tree ovl
)
2639 if (TREE_CODE (ovl
) == OFFSET_REF
2640 || TREE_CODE (ovl
) == COMPONENT_REF
)
2641 ovl
= TREE_OPERAND (ovl
, 1);
2642 if (TREE_CODE (ovl
) == BASELINK
)
2643 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2644 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2645 ovl
= TREE_OPERAND (ovl
, 0);
2646 /* Skip using-declarations. */
2647 lkp_iterator
iter (ovl
);
2650 while (iter
.using_p () && ++iter
);
2652 return CP_DECL_CONTEXT (ovl
);
2655 #define PRINT_RING_SIZE 4
2658 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2660 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2661 static char *print_ring
[PRINT_RING_SIZE
];
2662 static bool trans_ring
[PRINT_RING_SIZE
];
2663 static int ring_counter
;
2666 /* Only cache functions. */
2668 || TREE_CODE (decl
) != FUNCTION_DECL
2669 || DECL_LANG_SPECIFIC (decl
) == 0)
2670 return lang_decl_name (decl
, v
, translate
);
2672 /* See if this print name is lying around. */
2673 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2674 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2675 /* yes, so return it. */
2676 return print_ring
[i
];
2678 if (++ring_counter
== PRINT_RING_SIZE
)
2681 if (current_function_decl
!= NULL_TREE
)
2683 /* There may be both translated and untranslated versions of the
2685 for (i
= 0; i
< 2; i
++)
2687 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2689 if (ring_counter
== PRINT_RING_SIZE
)
2692 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2695 free (print_ring
[ring_counter
]);
2697 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2698 uid_ring
[ring_counter
] = DECL_UID (decl
);
2699 trans_ring
[ring_counter
] = translate
;
2700 return print_ring
[ring_counter
];
2704 cxx_printable_name (tree decl
, int v
)
2706 return cxx_printable_name_internal (decl
, v
, false);
2710 cxx_printable_name_translate (tree decl
, int v
)
2712 return cxx_printable_name_internal (decl
, v
, true);
2715 /* Return the canonical version of exception-specification RAISES for a C++17
2716 function type, for use in type comparison and building TYPE_CANONICAL. */
2719 canonical_eh_spec (tree raises
)
2721 if (raises
== NULL_TREE
)
2723 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2724 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2725 || uses_template_parms (raises
)
2726 || uses_template_parms (TREE_PURPOSE (raises
)))
2727 /* Keep a dependent or deferred exception specification. */
2729 else if (nothrow_spec_p (raises
))
2730 /* throw() -> noexcept. */
2731 return noexcept_true_spec
;
2733 /* For C++17 type matching, anything else -> nothing. */
2738 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2739 tree raises
, bool late
)
2741 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2743 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2746 tree v
= TYPE_MAIN_VARIANT (type
);
2747 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2748 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2751 /* Need to build a new variant. */
2752 v
= build_variant_type_copy (type
);
2753 if (!TYPE_DEPENDENT_P (v
))
2754 /* We no longer know that it's not type-dependent. */
2755 TYPE_DEPENDENT_P_VALID (v
) = false;
2756 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2757 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2760 case REF_QUAL_RVALUE
:
2761 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2762 FUNCTION_REF_QUALIFIED (v
) = 1;
2764 case REF_QUAL_LVALUE
:
2765 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2766 FUNCTION_REF_QUALIFIED (v
) = 1;
2769 FUNCTION_REF_QUALIFIED (v
) = 0;
2773 /* Canonicalize the exception specification. */
2774 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2776 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2777 /* Propagate structural equality. */
2778 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2779 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2780 /* Build the underlying canonical type, since it is different
2782 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2785 /* T is its own canonical type. */
2786 TYPE_CANONICAL (v
) = v
;
2791 /* TYPE is a function or method type with a deferred exception
2792 specification that has been parsed to RAISES. Fixup all the type
2793 variants that are affected in place. Via decltype &| noexcept
2794 tricks, the unparsed spec could have escaped into the type system.
2795 The general case is hard to fixup canonical types for. */
2798 fixup_deferred_exception_variants (tree type
, tree raises
)
2800 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2801 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2803 gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original
));
2805 /* Though sucky, this walk will process the canonical variants
2807 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2808 variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2809 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2811 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2813 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2815 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2816 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2818 tree v
= TYPE_MAIN_VARIANT (type
);
2819 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2820 if (TYPE_CANONICAL (v
) == v
2821 && cp_check_qualified_type (v
, variant
, var_quals
,
2824 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2827 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2829 TYPE_CANONICAL (variant
) = v
;
2832 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2836 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2837 listed in RAISES. */
2840 build_exception_variant (tree type
, tree raises
)
2842 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2843 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2844 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2847 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2848 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2852 bind_template_template_parm (tree t
, tree newargs
)
2854 tree decl
= TYPE_NAME (t
);
2857 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2858 decl
= build_decl (input_location
,
2859 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2860 SET_DECL_TEMPLATE_PARM_P (decl
);
2862 /* These nodes have to be created to reflect new TYPE_DECL and template
2864 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2865 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2866 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2867 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2869 TREE_TYPE (decl
) = t2
;
2870 TYPE_NAME (t2
) = decl
;
2871 TYPE_STUB_DECL (t2
) = decl
;
2873 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2878 /* Called from count_trees via walk_tree. */
2881 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2891 /* Debugging function for measuring the rough complexity of a tree
2895 count_trees (tree t
)
2898 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2902 /* Called from verify_stmt_tree via walk_tree. */
2905 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2908 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2909 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2912 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2915 /* If this statement is already present in the hash table, then
2916 there is a circularity in the statement tree. */
2917 gcc_assert (!statements
->find (t
));
2919 slot
= statements
->find_slot (t
, INSERT
);
2925 /* Debugging function to check that the statement T has not been
2926 corrupted. For now, this function simply checks that T contains no
2930 verify_stmt_tree (tree t
)
2932 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2933 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2936 /* Check if the type T depends on a type with no linkage and if so,
2937 return it. If RELAXED_P then do not consider a class type declared
2938 within a vague-linkage function to have no linkage. Remember:
2939 no-linkage is not the same as internal-linkage*/
2942 no_linkage_check (tree t
, bool relaxed_p
)
2946 /* Lambda types that don't have mangling scope have no linkage. We
2947 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2948 when we get here from pushtag none of the lambda information is
2949 set up yet, so we want to assume that the lambda has linkage and
2950 fix it up later if not. We need to check this even in templates so
2951 that we properly handle a lambda-expression in the signature. */
2952 if (LAMBDA_TYPE_P (t
)
2953 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2955 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2960 /* Otherwise there's no point in checking linkage on template functions; we
2961 can't know their complete types. */
2962 if (processing_template_decl
)
2965 switch (TREE_CODE (t
))
2968 if (TYPE_PTRMEMFUNC_P (t
))
2972 if (!CLASS_TYPE_P (t
))
2976 /* Only treat unnamed types as having no linkage if they're at
2977 namespace scope. This is core issue 966. */
2978 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2981 for (r
= CP_TYPE_CONTEXT (t
); ; )
2983 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2984 have linkage, or we might just be in an anonymous namespace.
2985 If we're in a TREE_PUBLIC class, we have linkage. */
2986 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2987 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2988 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2990 if (!relaxed_p
|| !vague_linkage_p (r
))
2993 r
= CP_DECL_CONTEXT (r
);
3003 case REFERENCE_TYPE
:
3005 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3009 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
3013 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
3018 tree parm
= TYPE_ARG_TYPES (t
);
3019 if (TREE_CODE (t
) == METHOD_TYPE
)
3020 /* The 'this' pointer isn't interesting; a method has the same
3021 linkage (or lack thereof) as its enclosing class. */
3022 parm
= TREE_CHAIN (parm
);
3024 parm
&& parm
!= void_list_node
;
3025 parm
= TREE_CHAIN (parm
))
3027 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
3031 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3039 extern int depth_reached
;
3042 cxx_print_statistics (void)
3044 print_template_statistics ();
3045 if (GATHER_STATISTICS
)
3046 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
3050 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3051 (which is an ARRAY_TYPE). This counts only elements of the top
3055 array_type_nelts_top (tree type
)
3057 return fold_build2_loc (input_location
,
3058 PLUS_EXPR
, sizetype
,
3059 array_type_nelts (type
),
3063 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3064 (which is an ARRAY_TYPE). This one is a recursive count of all
3065 ARRAY_TYPEs that are clumped together. */
3068 array_type_nelts_total (tree type
)
3070 tree sz
= array_type_nelts_top (type
);
3071 type
= TREE_TYPE (type
);
3072 while (TREE_CODE (type
) == ARRAY_TYPE
)
3074 tree n
= array_type_nelts_top (type
);
3075 sz
= fold_build2_loc (input_location
,
3076 MULT_EXPR
, sizetype
, sz
, n
);
3077 type
= TREE_TYPE (type
);
3082 /* Return true if FNDECL is std::source_location::current () method. */
3085 source_location_current_p (tree fndecl
)
3087 gcc_checking_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
3088 && DECL_IMMEDIATE_FUNCTION_P (fndecl
));
3089 if (DECL_NAME (fndecl
) == NULL_TREE
3090 || TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
3091 || TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != RECORD_TYPE
3092 || DECL_CONTEXT (fndecl
) != TREE_TYPE (TREE_TYPE (fndecl
))
3093 || !id_equal (DECL_NAME (fndecl
), "current"))
3096 tree source_location
= DECL_CONTEXT (fndecl
);
3097 if (TYPE_NAME (source_location
) == NULL_TREE
3098 || TREE_CODE (TYPE_NAME (source_location
)) != TYPE_DECL
3099 || TYPE_IDENTIFIER (source_location
) == NULL_TREE
3100 || !id_equal (TYPE_IDENTIFIER (source_location
),
3102 || !decl_in_std_namespace_p (TYPE_NAME (source_location
)))
3110 splay_tree target_remap
;
3111 bool clear_location
;
3114 /* Called from break_out_target_exprs via mapcar. */
3117 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
3119 bot_data
&data
= *(bot_data
*)data_
;
3120 splay_tree target_remap
= data
.target_remap
;
3123 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
3125 /* There can't be any TARGET_EXPRs or their slot variables below this
3126 point. But we must make a copy, in case subsequent processing
3127 alters any part of it. For example, during gimplification a cast
3128 of the form (T) &X::f (where "f" is a member function) will lead
3129 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3131 *tp
= unshare_expr (t
);
3134 if (TREE_CODE (t
) == TARGET_EXPR
)
3138 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3140 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3141 tf_warning_or_error
);
3142 if (u
== error_mark_node
)
3144 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3145 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3148 u
= force_target_expr (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3149 tf_warning_or_error
);
3151 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3152 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3153 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3155 /* Map the old variable to the new one. */
3156 splay_tree_insert (target_remap
,
3157 (splay_tree_key
) TREE_OPERAND (t
, 0),
3158 (splay_tree_value
) TREE_OPERAND (u
, 0));
3160 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3161 data
.clear_location
);
3162 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3163 return error_mark_node
;
3165 /* Replace the old expression with the new version. */
3167 /* We don't have to go below this point; the recursive call to
3168 break_out_target_exprs will have handled anything below this
3173 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3176 splay_tree_node n
= splay_tree_lookup (target_remap
,
3177 (splay_tree_key
) t
);
3180 *tp
= (tree
)n
->value
;
3185 copy_tree_r (tp
, walk_subtrees
, NULL
);
3186 splay_tree_insert (target_remap
,
3188 (splay_tree_value
)*tp
);
3189 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3190 splay_tree_insert (target_remap
,
3191 (splay_tree_key
)*tp
,
3192 (splay_tree_value
)*tp
);
3196 if (TREE_CODE (*tp
) == DECL_EXPR
3197 && VAR_P (DECL_EXPR_DECL (*tp
))
3198 && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp
))
3199 && !TREE_STATIC (DECL_EXPR_DECL (*tp
)))
3203 = splay_tree_lookup (target_remap
,
3204 (splay_tree_key
) DECL_EXPR_DECL (*tp
));
3206 t
= (tree
) n
->value
;
3209 t
= create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp
)));
3210 DECL_INITIAL (t
) = DECL_INITIAL (DECL_EXPR_DECL (*tp
));
3211 splay_tree_insert (target_remap
,
3212 (splay_tree_key
) DECL_EXPR_DECL (*tp
),
3213 (splay_tree_value
) t
);
3215 copy_tree_r (tp
, walk_subtrees
, NULL
);
3216 DECL_EXPR_DECL (*tp
) = t
;
3217 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3218 SET_EXPR_LOCATION (*tp
, input_location
);
3221 if (TREE_CODE (*tp
) == BIND_EXPR
&& BIND_EXPR_VARS (*tp
))
3223 copy_tree_r (tp
, walk_subtrees
, NULL
);
3224 for (tree
*p
= &BIND_EXPR_VARS (*tp
); *p
; p
= &DECL_CHAIN (*p
))
3226 gcc_assert (VAR_P (*p
) && DECL_ARTIFICIAL (*p
) && !TREE_STATIC (*p
));
3227 tree t
= create_temporary_var (TREE_TYPE (*p
));
3228 DECL_INITIAL (t
) = DECL_INITIAL (*p
);
3229 DECL_CHAIN (t
) = DECL_CHAIN (*p
);
3230 splay_tree_insert (target_remap
, (splay_tree_key
) *p
,
3231 (splay_tree_value
) t
);
3234 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3235 SET_EXPR_LOCATION (*tp
, input_location
);
3239 /* Make a copy of this node. */
3240 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3241 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3242 if (!processing_template_decl
)
3243 set_flags_from_callee (*tp
);
3244 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3245 SET_EXPR_LOCATION (*tp
, input_location
);
3249 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3250 DATA is really a splay-tree mapping old variables to new
3254 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3256 bot_data
&data
= *(bot_data
*)data_
;
3257 splay_tree target_remap
= data
.target_remap
;
3261 splay_tree_node n
= splay_tree_lookup (target_remap
,
3262 (splay_tree_key
) *t
);
3264 *t
= (tree
) n
->value
;
3266 else if (TREE_CODE (*t
) == PARM_DECL
3267 && DECL_NAME (*t
) == this_identifier
3268 && !DECL_CONTEXT (*t
))
3270 /* In an NSDMI we need to replace the 'this' parameter we used for
3271 parsing with the real one for this function. */
3272 *t
= current_class_ptr
;
3274 else if (TREE_CODE (*t
) == CONVERT_EXPR
3275 && CONVERT_EXPR_VBASE_PATH (*t
))
3277 /* In an NSDMI build_base_path defers building conversions to morally
3278 virtual bases, and we handle it here. */
3279 tree basetype
= TREE_TYPE (*t
);
3280 *t
= convert_to_base (TREE_OPERAND (*t
, 0), basetype
,
3281 /*check_access=*/false, /*nonnull=*/true,
3282 tf_warning_or_error
);
3288 /* When we parse a default argument expression, we may create
3289 temporary variables via TARGET_EXPRs. When we actually use the
3290 default-argument expression, we make a copy of the expression
3291 and replace the temporaries with appropriate local versions.
3293 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3297 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3299 static int target_remap_count
;
3300 static splay_tree target_remap
;
3302 if (!target_remap_count
++)
3303 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3304 /*splay_tree_delete_key_fn=*/NULL
,
3305 /*splay_tree_delete_value_fn=*/NULL
);
3306 bot_data data
= { target_remap
, clear_location
};
3307 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3308 t
= error_mark_node
;
3309 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3311 if (!--target_remap_count
)
3313 splay_tree_delete (target_remap
);
3314 target_remap
= NULL
;
3320 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3321 which we expect to have type TYPE. */
3324 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3326 if (index
== NULL_TREE
)
3327 /* Can't refer to a particular member of a vector. */
3329 else if (TREE_CODE (index
) == INTEGER_CST
)
3330 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3332 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3333 /*reference*/false, tf_none
);
3336 tree objtype
= TREE_TYPE (obj
);
3337 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3339 /* When the destination object refers to a flexible array member
3340 verify that it matches the type of the source object except
3341 for its domain and qualifiers. */
3342 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3343 TYPE_MAIN_VARIANT (objtype
),
3344 COMPARE_REDECLARATION
));
3347 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3353 struct replace_placeholders_t
3355 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3356 tree exp
; /* The outermost exp. */
3357 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3358 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3361 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3362 build up subexpressions as we go deeper. */
3365 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3367 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3370 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3372 *walk_subtrees
= false;
3376 switch (TREE_CODE (*t
))
3378 case PLACEHOLDER_EXPR
:
3381 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3383 x
= TREE_OPERAND (x
, 0))
3384 gcc_assert (handled_component_p (x
));
3385 *t
= unshare_expr (x
);
3386 *walk_subtrees
= false;
3393 constructor_elt
*ce
;
3394 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3395 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3396 other than the d->exp one, those have PLACEHOLDER_EXPRs
3397 related to another object. */
3398 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3400 || d
->pset
->add (*t
))
3402 *walk_subtrees
= false;
3405 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3407 tree
*valp
= &ce
->value
;
3408 tree type
= TREE_TYPE (*valp
);
3411 /* Elements with RANGE_EXPR index shouldn't have any
3412 placeholders in them. */
3413 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3416 if (TREE_CODE (*valp
) == CONSTRUCTOR
3417 && AGGREGATE_TYPE_P (type
))
3419 /* If we're looking at the initializer for OBJ, then build
3420 a sub-object reference. If we're looking at an
3421 initializer for another object, just pass OBJ down. */
3422 if (same_type_ignoring_top_level_qualifiers_p
3423 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3424 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3425 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3426 valp
= &TARGET_EXPR_INITIAL (*valp
);
3429 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3432 *walk_subtrees
= false;
3437 if (d
->pset
->add (*t
))
3438 *walk_subtrees
= false;
3445 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3446 a PLACEHOLDER_EXPR has been encountered. */
3449 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3451 /* This is only relevant for C++14. */
3452 if (cxx_dialect
< cxx14
)
3455 /* If the object isn't a (member of a) class, do nothing. */
3457 while (handled_component_p (op0
))
3458 op0
= TREE_OPERAND (op0
, 0);
3459 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3463 if (TREE_CODE (exp
) == TARGET_EXPR
)
3464 tp
= &TARGET_EXPR_INITIAL (exp
);
3465 hash_set
<tree
> pset
;
3466 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3467 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3469 *seen_p
= data
.seen
;
3473 /* Callback function for find_placeholders. */
3476 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3478 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3480 *walk_subtrees
= false;
3484 switch (TREE_CODE (*t
))
3486 case PLACEHOLDER_EXPR
:
3490 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3491 *walk_subtrees
= false;
3501 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3502 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3505 find_placeholders (tree exp
)
3507 /* This is only relevant for C++14. */
3508 if (cxx_dialect
< cxx14
)
3511 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3514 /* Similar to `build_nt', but for template definitions of dependent
3518 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3525 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3529 t
= make_node (code
);
3530 SET_EXPR_LOCATION (t
, loc
);
3531 length
= TREE_CODE_LENGTH (code
);
3533 for (i
= 0; i
< length
; i
++)
3534 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3540 /* Similar to `build', but for template definitions. */
3543 build_min (enum tree_code code
, tree tt
, ...)
3550 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3554 t
= make_node (code
);
3555 length
= TREE_CODE_LENGTH (code
);
3558 for (i
= 0; i
< length
; i
++)
3560 tree x
= va_arg (p
, tree
);
3561 TREE_OPERAND (t
, i
) = x
;
3562 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3563 TREE_SIDE_EFFECTS (t
) = 1;
3571 /* Similar to `build', but for template definitions of non-dependent
3572 expressions. NON_DEP is the non-dependent expression that has been
3576 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3583 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3585 va_start (p
, non_dep
);
3587 if (REFERENCE_REF_P (non_dep
))
3588 non_dep
= TREE_OPERAND (non_dep
, 0);
3590 t
= make_node (code
);
3591 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3592 length
= TREE_CODE_LENGTH (code
);
3593 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3594 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3596 for (i
= 0; i
< length
; i
++)
3597 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3600 return convert_from_reference (t
);
3603 /* Similar to build_min_nt, but call expressions */
3606 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3611 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3612 CALL_EXPR_FN (ret
) = fn
;
3613 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3614 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3615 CALL_EXPR_ARG (ret
, ix
) = t
;
3620 /* Similar to `build_min_nt_call_vec', but for template definitions of
3621 non-dependent expressions. NON_DEP is the non-dependent expression
3622 that has been built. */
3625 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3627 tree t
= build_min_nt_call_vec (fn
, argvec
);
3628 if (REFERENCE_REF_P (non_dep
))
3629 non_dep
= TREE_OPERAND (non_dep
, 0);
3630 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3631 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3632 return convert_from_reference (t
);
3635 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3636 a call to an operator overload. OP is the operator that has been
3637 overloaded. NON_DEP is the non-dependent expression that's been built,
3638 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3639 the overload that NON_DEP is calling. */
3642 build_min_non_dep_op_overload (enum tree_code op
,
3647 int nargs
, expected_nargs
;
3650 non_dep
= extract_call_expr (non_dep
);
3652 nargs
= call_expr_nargs (non_dep
);
3654 expected_nargs
= cp_tree_code_length (op
);
3655 if ((op
== POSTINCREMENT_EXPR
3656 || op
== POSTDECREMENT_EXPR
)
3657 /* With -fpermissive non_dep could be operator++(). */
3658 && (!flag_permissive
|| nargs
!= expected_nargs
))
3659 expected_nargs
+= 1;
3660 gcc_assert (nargs
== expected_nargs
);
3663 va_start (p
, overload
);
3665 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3668 for (int i
= 0; i
< nargs
; i
++)
3670 tree arg
= va_arg (p
, tree
);
3671 vec_safe_push (args
, arg
);
3674 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3676 tree object
= va_arg (p
, tree
);
3677 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3678 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3679 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3680 object
, method
, NULL_TREE
);
3681 for (int i
= 1; i
< nargs
; i
++)
3683 tree arg
= va_arg (p
, tree
);
3684 vec_safe_push (args
, arg
);
3691 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3693 tree call_expr
= extract_call_expr (call
);
3694 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3695 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3696 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3697 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3702 /* Similar to above build_min_non_dep_op_overload, but arguments
3703 are taken from ARGS vector. */
3706 build_min_non_dep_op_overload (tree non_dep
, tree overload
, tree object
,
3707 vec
<tree
, va_gc
> *args
)
3709 non_dep
= extract_call_expr (non_dep
);
3711 unsigned int nargs
= call_expr_nargs (non_dep
);
3712 gcc_assert (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
);
3713 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3714 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3715 tree fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3716 object
, method
, NULL_TREE
);
3718 gcc_assert (vec_safe_length (args
) == nargs
);
3720 tree call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3722 tree call_expr
= extract_call_expr (call
);
3723 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3724 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3725 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3726 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3731 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3734 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3736 unsigned len
= vec_safe_length (old_vec
);
3737 gcc_assert (idx
<= len
);
3739 vec
<tree
, va_gc
> *new_vec
= NULL
;
3740 vec_alloc (new_vec
, len
+ 1);
3743 for (i
= 0; i
< len
; ++i
)
3746 new_vec
->quick_push (elt
);
3747 new_vec
->quick_push ((*old_vec
)[i
]);
3750 new_vec
->quick_push (elt
);
3756 get_type_decl (tree t
)
3758 if (TREE_CODE (t
) == TYPE_DECL
)
3761 return TYPE_STUB_DECL (t
);
3762 gcc_assert (t
== error_mark_node
);
3766 /* Returns the namespace that contains DECL, whether directly or
3770 decl_namespace_context (tree decl
)
3774 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3776 else if (TYPE_P (decl
))
3777 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3779 decl
= CP_DECL_CONTEXT (decl
);
3783 /* Returns true if decl is within an anonymous namespace, however deeply
3784 nested, or false otherwise. */
3787 decl_anon_ns_mem_p (const_tree decl
)
3789 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3791 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3793 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3795 decl
= CP_DECL_CONTEXT (decl
);
3797 return !TREE_PUBLIC (decl
);
3800 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3801 CALL_EXPRS. Return whether they are equivalent. */
3804 called_fns_equal (tree t1
, tree t2
)
3806 /* Core 1321: dependent names are equivalent even if the overload sets
3807 are different. But do compare explicit template arguments. */
3808 tree name1
= dependent_name (t1
);
3809 tree name2
= dependent_name (t2
);
3812 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3817 /* FIXME dependent_name currently returns an unqualified name regardless
3818 of whether the function was named with a qualified- or unqualified-id.
3819 Until that's fixed, check that we aren't looking at overload sets from
3820 different scopes. */
3821 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3822 && (DECL_CONTEXT (get_first_fn (t1
))
3823 != DECL_CONTEXT (get_first_fn (t2
))))
3826 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3827 targs1
= TREE_OPERAND (t1
, 1);
3828 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3829 targs2
= TREE_OPERAND (t2
, 1);
3830 return cp_tree_equal (targs1
, targs2
);
3833 return cp_tree_equal (t1
, t2
);
3836 /* Return truthvalue of whether T1 is the same tree structure as T2.
3837 Return 1 if they are the same. Return 0 if they are different. */
3840 cp_tree_equal (tree t1
, tree t2
)
3842 enum tree_code code1
, code2
;
3849 code1
= TREE_CODE (t1
);
3850 code2
= TREE_CODE (t2
);
3855 if (CONSTANT_CLASS_P (t1
)
3856 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3862 /* There's only a single VOID_CST node, so we should never reach
3867 return tree_int_cst_equal (t1
, t2
);
3870 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3873 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3874 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3875 TREE_STRING_LENGTH (t1
));
3878 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3879 TREE_FIXED_CST (t2
));
3882 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3883 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3886 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3889 /* We need to do this when determining whether or not two
3890 non-type pointer to member function template arguments
3892 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3893 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3898 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3900 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3901 if (!cp_tree_equal (field
, elt2
->index
)
3902 || !cp_tree_equal (value
, elt2
->value
))
3909 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3911 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3913 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3916 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3920 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
3923 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3926 call_expr_arg_iterator iter1
, iter2
;
3927 init_call_expr_arg_iterator (t1
, &iter1
);
3928 init_call_expr_arg_iterator (t2
, &iter2
);
3929 if (iter1
.n
!= iter2
.n
)
3932 while (more_call_expr_args_p (&iter1
))
3934 tree arg1
= next_call_expr_arg (&iter1
);
3935 tree arg2
= next_call_expr_arg (&iter2
);
3937 gcc_checking_assert (arg1
&& arg2
);
3938 if (!cp_tree_equal (arg1
, arg2
))
3947 tree o1
= TREE_OPERAND (t1
, 0);
3948 tree o2
= TREE_OPERAND (t2
, 0);
3950 /* Special case: if either target is an unallocated VAR_DECL,
3951 it means that it's going to be unified with whatever the
3952 TARGET_EXPR is really supposed to initialize, so treat it
3953 as being equivalent to anything. */
3954 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3955 && !DECL_RTL_SET_P (o1
))
3957 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3958 && !DECL_RTL_SET_P (o2
))
3960 else if (!cp_tree_equal (o1
, o2
))
3963 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3967 /* For comparing uses of parameters in late-specified return types
3968 with an out-of-class definition of the function, but can also come
3969 up for expressions that involve 'this' in a member function
3972 if (comparing_specializations
3973 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
3974 /* When comparing hash table entries, only an exact match is
3975 good enough; we don't want to replace 'this' with the
3976 version from another function. But be more flexible
3977 with parameters with identical contexts. */
3980 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3982 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3984 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3986 if (DECL_ARTIFICIAL (t1
)
3987 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3988 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3998 case IDENTIFIER_NODE
:
4001 case DEFERRED_PARSE
:
4005 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
4006 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
4007 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
4008 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
4009 BASELINK_FUNCTIONS (t2
)));
4011 case TEMPLATE_PARM_INDEX
:
4012 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
4013 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
4014 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
4015 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
4016 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
4017 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
4019 case TEMPLATE_ID_EXPR
:
4020 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4022 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
4026 case CONSTRAINT_INFO
:
4027 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
4028 CI_ASSOCIATED_CONSTRAINTS (t2
));
4031 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
4032 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
4033 CHECK_CONSTR_ARGS (t2
)));
4036 /* These are template args. Really we should be getting the
4037 caller to do this as it knows it to be true. */
4038 if (!comp_template_args (t1
, t2
, NULL
, NULL
, false))
4045 tree o1
= TREE_OPERAND (t1
, 0);
4046 tree o2
= TREE_OPERAND (t2
, 0);
4048 if (code1
== SIZEOF_EXPR
)
4050 if (SIZEOF_EXPR_TYPE_P (t1
))
4051 o1
= TREE_TYPE (o1
);
4052 if (SIZEOF_EXPR_TYPE_P (t2
))
4053 o2
= TREE_TYPE (o2
);
4055 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
4058 if (TREE_CODE (o1
) != TREE_CODE (o2
))
4061 if (ARGUMENT_PACK_P (o1
))
4062 return template_args_equal (o1
, o2
);
4063 else if (TYPE_P (o1
))
4064 return same_type_p (o1
, o2
);
4066 return cp_tree_equal (o1
, o2
);
4071 tree t1_op1
, t2_op1
;
4073 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4076 t1_op1
= TREE_OPERAND (t1
, 1);
4077 t2_op1
= TREE_OPERAND (t2
, 1);
4078 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
4081 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
4085 /* Two pointer-to-members are the same if they point to the same
4086 field or function in the same class. */
4087 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
4090 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
4094 /* Two overloads. Must be exactly the same set of decls. */
4095 lkp_iterator
first (t1
);
4096 lkp_iterator
second (t2
);
4098 for (; first
&& second
; ++first
, ++second
)
4099 if (*first
!= *second
)
4101 return !(first
|| second
);
4105 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
4107 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
4108 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
4110 case NON_LVALUE_EXPR
:
4111 case VIEW_CONVERT_EXPR
:
4112 /* Used for location wrappers with possibly NULL types. */
4113 if (!TREE_TYPE (t1
) || !TREE_TYPE (t2
))
4115 if (TREE_TYPE (t1
) || TREE_TYPE (t2
))
4122 case STATIC_CAST_EXPR
:
4123 case REINTERPRET_CAST_EXPR
:
4124 case CONST_CAST_EXPR
:
4125 case DYNAMIC_CAST_EXPR
:
4126 case IMPLICIT_CONV_EXPR
:
4130 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4132 /* Now compare operands as usual. */
4135 case DEFERRED_NOEXCEPT
:
4136 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
4137 DEFERRED_NOEXCEPT_PATTERN (t2
))
4138 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
4139 DEFERRED_NOEXCEPT_ARGS (t2
)));
4142 /* Two lambda-expressions are never considered equivalent. */
4145 case TYPE_ARGUMENT_PACK
:
4146 case NONTYPE_ARGUMENT_PACK
:
4148 tree p1
= ARGUMENT_PACK_ARGS (t1
);
4149 tree p2
= ARGUMENT_PACK_ARGS (t2
);
4150 int len
= TREE_VEC_LENGTH (p1
);
4151 if (TREE_VEC_LENGTH (p2
) != len
)
4154 for (int ix
= 0; ix
!= len
; ix
++)
4155 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
4156 TREE_VEC_ELT (p2
, ix
)))
4161 case EXPR_PACK_EXPANSION
:
4162 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
4163 PACK_EXPANSION_PATTERN (t2
)))
4165 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
4166 PACK_EXPANSION_EXTRA_ARGS (t2
)))
4174 switch (TREE_CODE_CLASS (code1
))
4178 case tcc_comparison
:
4179 case tcc_expression
:
4184 int n
= cp_tree_operand_length (t1
);
4185 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
4186 && n
!= TREE_OPERAND_LENGTH (t2
))
4189 for (int i
= 0; i
< n
; ++i
)
4190 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
4197 return same_type_p (t1
, t2
);
4203 /* We can get here with --disable-checking. */
4207 /* The type of ARG when used as an lvalue. */
4210 lvalue_type (tree arg
)
4212 tree type
= TREE_TYPE (arg
);
4216 /* The type of ARG for printing error messages; denote lvalues with
4220 error_type (tree arg
)
4222 tree type
= TREE_TYPE (arg
);
4224 if (TREE_CODE (type
) == ARRAY_TYPE
)
4226 else if (TREE_CODE (type
) == ERROR_MARK
)
4228 else if (lvalue_p (arg
))
4229 type
= build_reference_type (lvalue_type (arg
));
4230 else if (MAYBE_CLASS_TYPE_P (type
))
4231 type
= lvalue_type (arg
);
4236 /* Does FUNCTION use a variable-length argument list? */
4239 varargs_function_p (const_tree function
)
4241 return stdarg_p (TREE_TYPE (function
));
4244 /* Returns 1 if decl is a member of a class. */
4247 member_p (const_tree decl
)
4249 const_tree
const ctx
= DECL_CONTEXT (decl
);
4250 return (ctx
&& TYPE_P (ctx
));
4253 /* Create a placeholder for member access where we don't actually have an
4254 object that the access is against. For a general declval<T> equivalent,
4255 use build_stub_object instead. */
4258 build_dummy_object (tree type
)
4260 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4261 return cp_build_fold_indirect_ref (decl
);
4264 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4265 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4266 binfo path from current_class_type to TYPE, or 0. */
4269 maybe_dummy_object (tree type
, tree
* binfop
)
4273 tree current
= current_nonlambda_class_type ();
4276 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4277 tf_warning_or_error
)))
4281 /* Reference from a nested class member function. */
4283 binfo
= TYPE_BINFO (type
);
4289 if (current_class_ref
4290 /* current_class_ref might not correspond to current_class_type if
4291 we're in tsubst_default_argument or a lambda-declarator; in either
4292 case, we want to use current_class_ref if it matches CONTEXT. */
4293 && (same_type_ignoring_top_level_qualifiers_p
4294 (TREE_TYPE (current_class_ref
), context
)))
4295 decl
= current_class_ref
;
4297 decl
= build_dummy_object (context
);
4302 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4305 is_dummy_object (const_tree ob
)
4307 if (INDIRECT_REF_P (ob
))
4308 ob
= TREE_OPERAND (ob
, 0);
4309 return (TREE_CODE (ob
) == CONVERT_EXPR
4310 && TREE_OPERAND (ob
, 0) == void_node
);
4313 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4316 is_byte_access_type (tree type
)
4318 type
= TYPE_MAIN_VARIANT (type
);
4319 if (type
== char_type_node
4320 || type
== unsigned_char_type_node
)
4323 return (TREE_CODE (type
) == ENUMERAL_TYPE
4324 && TYPE_CONTEXT (type
) == std_node
4325 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4328 /* Returns true if TYPE is unsigned char or std::byte. */
4331 is_byte_access_type_not_plain_char (tree type
)
4333 type
= TYPE_MAIN_VARIANT (type
);
4334 if (type
== char_type_node
)
4337 return is_byte_access_type (type
);
4340 /* Returns 1 iff type T is something we want to treat as a scalar type for
4341 the purpose of deciding whether it is trivial/POD/standard-layout. */
4344 scalarish_type_p (const_tree t
)
4346 if (t
== error_mark_node
)
4349 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4352 /* Returns true iff T requires non-trivial default initialization. */
4355 type_has_nontrivial_default_init (const_tree t
)
4357 t
= strip_array_types (CONST_CAST_TREE (t
));
4359 if (CLASS_TYPE_P (t
))
4360 return TYPE_HAS_COMPLEX_DFLT (t
);
4365 /* Track classes with only deleted copy/move constructors so that we can warn
4366 if they are used in call/return by value. */
4368 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4370 remember_deleted_copy (const_tree t
)
4372 if (!deleted_copy_types
)
4373 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4374 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4377 maybe_warn_parm_abi (tree t
, location_t loc
)
4379 if (!deleted_copy_types
4380 || !deleted_copy_types
->contains (t
))
4383 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4384 && classtype_has_non_deleted_move_ctor (t
))
4387 auto_diagnostic_group d
;
4388 if (flag_abi_version
> 12)
4389 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4390 "the calling convention for %qT, which was "
4391 "accidentally changed in 8.1", t
);
4393 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) "
4394 "accidentally changes the calling convention for %qT",
4397 inform (location_of (t
), " declared here");
4401 auto_diagnostic_group d
;
4402 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4403 "%<-fabi-version=13%> (GCC 8.2)", t
))
4404 inform (location_of (t
), " because all of its copy and move "
4405 "constructors are deleted");
4408 /* Returns true iff copying an object of type T (including via move
4409 constructor) is non-trivial. That is, T has no non-trivial copy
4410 constructors and no non-trivial move constructors, and not all copy/move
4411 constructors are deleted. This function implements the ABI notion of
4412 non-trivial copy, which has diverged from the one in the standard. */
4415 type_has_nontrivial_copy_init (const_tree type
)
4417 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4419 if (CLASS_TYPE_P (t
))
4421 gcc_assert (COMPLETE_TYPE_P (t
));
4423 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4424 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4428 if (cxx_dialect
< cxx11
)
4429 /* No deleted functions before C++11. */
4432 /* Before ABI v12 we did a bitwise copy of types with only deleted
4433 copy/move constructors. */
4434 if (!abi_version_at_least (12)
4435 && !(warn_abi
&& abi_version_crosses (12)))
4438 bool saw_copy
= false;
4439 bool saw_non_deleted
= false;
4440 bool saw_non_deleted_move
= false;
4442 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4443 saw_copy
= saw_non_deleted
= true;
4444 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4447 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4448 /* [class.copy]/8 If the class definition declares a move
4449 constructor or move assignment operator, the implicitly declared
4450 copy constructor is defined as deleted.... */;
4452 /* Any other reason the implicitly-declared function would be
4453 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4455 saw_non_deleted
= true;
4458 if (!saw_non_deleted
)
4459 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4465 if (!DECL_DELETED_FN (fn
))
4467 /* Not deleted, therefore trivial. */
4468 saw_non_deleted
= true;
4472 else if (move_fn_p (fn
))
4473 if (!DECL_DELETED_FN (fn
))
4474 saw_non_deleted_move
= true;
4477 gcc_assert (saw_copy
);
4479 /* ABI v12 buggily ignored move constructors. */
4480 bool v11nontriv
= false;
4481 bool v12nontriv
= !saw_non_deleted
;
4482 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4483 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4484 : flag_abi_version
== 12 ? v12nontriv
4486 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4487 : warn_abi_version
== 12 ? v12nontriv
4489 if (nontriv
!= warn_nontriv
)
4490 remember_deleted_copy (t
);
4498 /* Returns 1 iff type T is a trivially copyable type, as defined in
4499 [basic.types] and [class]. */
4502 trivially_copyable_p (const_tree t
)
4504 t
= strip_array_types (CONST_CAST_TREE (t
));
4506 if (CLASS_TYPE_P (t
))
4507 return ((!TYPE_HAS_COPY_CTOR (t
)
4508 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4509 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4510 && (!TYPE_HAS_COPY_ASSIGN (t
)
4511 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4512 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4513 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4515 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4516 return scalarish_type_p (t
);
4519 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4523 trivial_type_p (const_tree t
)
4525 t
= strip_array_types (CONST_CAST_TREE (t
));
4527 if (CLASS_TYPE_P (t
))
4528 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4529 && trivially_copyable_p (t
));
4531 return scalarish_type_p (t
);
4534 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4537 pod_type_p (const_tree t
)
4539 /* This CONST_CAST is okay because strip_array_types returns its
4540 argument unmodified and we assign it to a const_tree. */
4541 t
= strip_array_types (CONST_CAST_TREE(t
));
4543 if (!CLASS_TYPE_P (t
))
4544 return scalarish_type_p (t
);
4545 else if (cxx_dialect
> cxx98
)
4546 /* [class]/10: A POD struct is a class that is both a trivial class and a
4547 standard-layout class, and has no non-static data members of type
4548 non-POD struct, non-POD union (or array of such types).
4550 We don't need to check individual members because if a member is
4551 non-std-layout or non-trivial, the class will be too. */
4552 return (std_layout_type_p (t
) && trivial_type_p (t
));
4554 /* The C++98 definition of POD is different. */
4555 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4558 /* Returns true iff T is POD for the purpose of layout, as defined in the
4562 layout_pod_type_p (const_tree t
)
4564 t
= strip_array_types (CONST_CAST_TREE (t
));
4566 if (CLASS_TYPE_P (t
))
4567 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4569 return scalarish_type_p (t
);
4572 /* Returns true iff T is a standard-layout type, as defined in
4576 std_layout_type_p (const_tree t
)
4578 t
= strip_array_types (CONST_CAST_TREE (t
));
4580 if (CLASS_TYPE_P (t
))
4581 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4583 return scalarish_type_p (t
);
4586 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4588 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4589 as defined in [meta.unary.prop]. */
4592 type_has_unique_obj_representations (const_tree t
)
4596 t
= strip_array_types (CONST_CAST_TREE (t
));
4598 if (!trivially_copyable_p (t
))
4601 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4602 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4604 switch (TREE_CODE (t
))
4608 case REFERENCE_TYPE
:
4609 /* If some backend has any paddings in these types, we should add
4610 a target hook for this and handle it there. */
4614 /* For bool values other than 0 and 1 should only appear with
4615 undefined behavior. */
4619 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4622 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4623 when storing long double values, so for that we have to return false.
4624 Other kinds of floating point values are questionable due to +.0/-.0
4625 and NaNs, let's play safe for now. */
4628 case FIXED_POINT_TYPE
:
4636 return type_has_unique_obj_representations (TREE_TYPE (t
));
4639 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4640 if (CLASS_TYPE_P (t
))
4642 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4643 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4651 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4652 if (TREE_CODE (field
) == FIELD_DECL
)
4655 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4656 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4662 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4664 if (CLASS_TYPE_P (t
))
4666 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4667 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4682 /* Helper function for type_has_unique_obj_representations. */
4685 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4687 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4688 if (TREE_CODE (field
) != FIELD_DECL
)
4690 /* For bases, can't use type_has_unique_obj_representations here, as in
4691 struct S { int i : 24; S (); };
4692 struct T : public S { int j : 8; T (); };
4693 S doesn't have unique obj representations, but T does. */
4694 else if (DECL_FIELD_IS_BASE (field
))
4696 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4700 else if (DECL_C_BIT_FIELD (field
))
4702 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4703 if (!type_has_unique_obj_representations (btype
))
4706 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4710 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4711 if (TREE_CODE (field
) == FIELD_DECL
)
4713 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4714 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4715 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4718 if (DECL_SIZE (field
))
4720 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4724 if (cur
!= wi::to_offset (sz
))
4730 /* Nonzero iff type T is a class template implicit specialization. */
4733 class_tmpl_impl_spec_p (const_tree t
)
4735 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4738 /* Returns 1 iff zero initialization of type T means actually storing
4742 zero_init_p (const_tree t
)
4744 /* This CONST_CAST is okay because strip_array_types returns its
4745 argument unmodified and we assign it to a const_tree. */
4746 t
= strip_array_types (CONST_CAST_TREE(t
));
4748 if (t
== error_mark_node
)
4751 /* NULL pointers to data members are initialized with -1. */
4752 if (TYPE_PTRDATAMEM_P (t
))
4755 /* Classes that contain types that can't be zero-initialized, cannot
4756 be zero-initialized themselves. */
4757 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4763 /* Returns true if the expression or initializer T is the result of
4764 zero-initialization for its type, taking pointers to members
4765 into consideration. */
4768 zero_init_expr_p (tree t
)
4770 tree type
= TREE_TYPE (t
);
4771 if (!type
|| uses_template_parms (type
))
4773 if (TYPE_PTRMEM_P (type
))
4774 return null_member_pointer_value_p (t
);
4775 if (TREE_CODE (t
) == CONSTRUCTOR
)
4777 if (COMPOUND_LITERAL_P (t
)
4778 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4779 /* Undigested, conversions might change the zeroness. */
4781 for (constructor_elt
&elt
: CONSTRUCTOR_ELTS (t
))
4783 if (TREE_CODE (type
) == UNION_TYPE
4784 && elt
.index
!= first_field (type
))
4786 if (!zero_init_expr_p (elt
.value
))
4791 if (zero_init_p (type
))
4792 return initializer_zerop (t
);
4796 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4797 non-type template parameter. If EXPLAIN, explain why not. */
4800 structural_type_p (tree t
, bool explain
)
4802 /* A structural type is one of the following: */
4804 /* a scalar type, or */
4805 if (SCALAR_TYPE_P (t
))
4807 /* an lvalue reference type, or */
4808 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4810 /* a literal class type with the following properties:
4811 - all base classes and non-static data members are public and non-mutable
4813 - the types of all bases classes and non-static data members are
4814 structural types or (possibly multi-dimensional) array thereof. */
4815 if (!CLASS_TYPE_P (t
))
4817 if (!literal_type_p (t
))
4820 explain_non_literal_class (t
);
4823 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4824 m
= next_initializable_field (DECL_CHAIN (m
)))
4826 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4830 if (DECL_FIELD_IS_BASE (m
))
4831 inform (location_of (m
), "base class %qT is not public",
4834 inform (location_of (m
), "%qD is not public", m
);
4838 if (DECL_MUTABLE_P (m
))
4841 inform (location_of (m
), "%qD is mutable", m
);
4844 tree mtype
= strip_array_types (TREE_TYPE (m
));
4845 if (!structural_type_p (mtype
))
4849 inform (location_of (m
), "%qD has a non-structural type", m
);
4850 structural_type_p (mtype
, true);
4858 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4859 warn_unused_result attribute. */
4862 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4863 int /*flags*/, bool *no_add_attrs
)
4865 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4867 error ("%qE attribute argument must be a string constant", name
);
4868 *no_add_attrs
= true;
4870 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4872 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4873 && !DECL_CONSTRUCTOR_P (*node
))
4874 warning_at (DECL_SOURCE_LOCATION (*node
),
4875 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4876 "return type", name
, *node
);
4878 else if (OVERLOAD_TYPE_P (*node
))
4882 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4883 "functions or to class or enumeration types", name
);
4884 *no_add_attrs
= true;
4889 /* Handle a C++20 "no_unique_address" attribute; arguments as in
4890 struct attribute_spec.handler. */
4892 handle_no_unique_addr_attribute (tree
* node
,
4898 if (TREE_CODE (*node
) != FIELD_DECL
)
4900 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4901 "non-static data members", name
);
4902 *no_add_attrs
= true;
4904 else if (DECL_C_BIT_FIELD (*node
))
4906 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4907 "a bit-field", name
);
4908 *no_add_attrs
= true;
4914 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4915 hot/cold attributes. */
4918 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4919 int flags
, bool *no_add_attrs
)
4921 *no_add_attrs
= true;
4922 if (TREE_CODE (*node
) == LABEL_DECL
4923 || TREE_CODE (*node
) == FUNCTION_DECL
)
4926 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4927 tree bname
= (is_attribute_p ("likely", name
)
4928 ? get_identifier ("hot") : get_identifier ("cold"));
4929 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4930 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4931 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4932 tree battr
= build_tree_list (bname
, NULL_TREE
);
4933 decl_attributes (node
, battr
, flags
);
4937 return error_mark_node
;
4940 /* Table of valid C++ attributes. */
4941 const struct attribute_spec cxx_attribute_table
[] =
4943 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4944 affects_type_identity, handler, exclude } */
4945 { "init_priority", 1, 1, true, false, false, false,
4946 handle_init_priority_attribute
, NULL
},
4947 { "abi_tag", 1, -1, false, false, false, true,
4948 handle_abi_tag_attribute
, NULL
},
4949 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4952 /* Table of C++ standard attributes. */
4953 const struct attribute_spec std_attribute_table
[] =
4955 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4956 affects_type_identity, handler, exclude } */
4957 { "maybe_unused", 0, 0, false, false, false, false,
4958 handle_unused_attribute
, NULL
},
4959 { "nodiscard", 0, 1, false, false, false, false,
4960 handle_nodiscard_attribute
, NULL
},
4961 { "no_unique_address", 0, 0, true, false, false, false,
4962 handle_no_unique_addr_attribute
, NULL
},
4963 { "likely", 0, 0, false, false, false, false,
4964 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4965 { "unlikely", 0, 0, false, false, false, false,
4966 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4967 { "noreturn", 0, 0, true, false, false, false,
4968 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4969 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4972 /* Handle an "init_priority" attribute; arguments as in
4973 struct attribute_spec.handler. */
4975 handle_init_priority_attribute (tree
* node
,
4981 tree initp_expr
= TREE_VALUE (args
);
4983 tree type
= TREE_TYPE (decl
);
4986 STRIP_NOPS (initp_expr
);
4987 initp_expr
= default_conversion (initp_expr
);
4989 initp_expr
= maybe_constant_value (initp_expr
);
4991 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4993 error ("requested %<init_priority%> is not an integer constant");
4994 cxx_constant_value (initp_expr
);
4995 *no_add_attrs
= true;
4999 pri
= TREE_INT_CST_LOW (initp_expr
);
5001 type
= strip_array_types (type
);
5003 if (decl
== NULL_TREE
5005 || !TREE_STATIC (decl
)
5006 || DECL_EXTERNAL (decl
)
5007 || (TREE_CODE (type
) != RECORD_TYPE
5008 && TREE_CODE (type
) != UNION_TYPE
)
5009 /* Static objects in functions are initialized the
5010 first time control passes through that
5011 function. This is not precise enough to pin down an
5012 init_priority value, so don't allow it. */
5013 || current_function_decl
)
5015 error ("can only use %qE attribute on file-scope definitions "
5016 "of objects of class type", name
);
5017 *no_add_attrs
= true;
5021 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
5023 error ("requested %<init_priority%> %i is out of range [0, %i]",
5024 pri
, MAX_INIT_PRIORITY
);
5025 *no_add_attrs
= true;
5029 /* Check for init_priorities that are reserved for
5030 language and runtime support implementations.*/
5031 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5034 (0, "requested %<init_priority%> %i is reserved for internal use",
5038 if (SUPPORTS_INIT_PRIORITY
)
5040 SET_DECL_INIT_PRIORITY (decl
, pri
);
5041 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
5046 error ("%qE attribute is not supported on this platform", name
);
5047 *no_add_attrs
= true;
5052 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
5053 and the new one has the tags in NEW_. Give an error if there are tags
5054 in NEW_ that weren't in OLD. */
5057 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
5059 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
5060 old
= TREE_VALUE (old
);
5061 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
5062 new_
= TREE_VALUE (new_
);
5064 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
5066 tree str
= TREE_VALUE (t
);
5067 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
5069 tree ostr
= TREE_VALUE (in
);
5070 if (cp_tree_equal (str
, ostr
))
5073 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
5079 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
5085 /* The abi_tag attribute with the name NAME was given ARGS. If they are
5086 ill-formed, give an error and return false; otherwise, return true. */
5089 check_abi_tag_args (tree args
, tree name
)
5093 error ("the %qE attribute requires arguments", name
);
5096 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
5098 tree elt
= TREE_VALUE (arg
);
5099 if (TREE_CODE (elt
) != STRING_CST
5100 || (!same_type_ignoring_top_level_qualifiers_p
5101 (strip_array_types (TREE_TYPE (elt
)),
5104 error ("arguments to the %qE attribute must be narrow string "
5108 const char *begin
= TREE_STRING_POINTER (elt
);
5109 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
5110 for (const char *p
= begin
; p
!= end
; ++p
)
5115 if (!ISALPHA (c
) && c
!= '_')
5117 error ("arguments to the %qE attribute must contain valid "
5118 "identifiers", name
);
5119 inform (input_location
, "%<%c%> is not a valid first "
5120 "character for an identifier", c
);
5124 else if (p
== end
- 1)
5125 gcc_assert (c
== 0);
5128 if (!ISALNUM (c
) && c
!= '_')
5130 error ("arguments to the %qE attribute must contain valid "
5131 "identifiers", name
);
5132 inform (input_location
, "%<%c%> is not a valid character "
5133 "in an identifier", c
);
5142 /* Handle an "abi_tag" attribute; arguments as in
5143 struct attribute_spec.handler. */
5146 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
5147 int flags
, bool* no_add_attrs
)
5149 if (!check_abi_tag_args (args
, name
))
5154 if (!OVERLOAD_TYPE_P (*node
))
5156 error ("%qE attribute applied to non-class, non-enum type %qT",
5160 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
5162 error ("%qE attribute applied to %qT after its definition",
5166 else if (CLASS_TYPE_P (*node
)
5167 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
5169 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5170 "template instantiation %qT", name
, *node
);
5173 else if (CLASS_TYPE_P (*node
)
5174 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
5176 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5177 "template specialization %qT", name
, *node
);
5181 tree attributes
= TYPE_ATTRIBUTES (*node
);
5182 tree decl
= TYPE_NAME (*node
);
5184 /* Make sure all declarations have the same abi tags. */
5185 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
5187 if (!check_abi_tag_redeclaration (decl
,
5188 lookup_attribute ("abi_tag",
5196 if (!VAR_OR_FUNCTION_DECL_P (*node
))
5198 error ("%qE attribute applied to non-function, non-variable %qD",
5202 else if (DECL_LANGUAGE (*node
) == lang_c
)
5204 error ("%qE attribute applied to extern \"C\" declaration %qD",
5213 *no_add_attrs
= true;
5217 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5218 thing pointed to by the constant. */
5221 make_ptrmem_cst (tree type
, tree member
)
5223 tree ptrmem_cst
= make_node (PTRMEM_CST
);
5224 TREE_TYPE (ptrmem_cst
) = type
;
5225 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5226 PTRMEM_CST_LOCATION (ptrmem_cst
) = input_location
;
5230 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5231 return an existing type if an appropriate type already exists. */
5234 cp_build_type_attribute_variant (tree type
, tree attributes
)
5238 new_type
= build_type_attribute_variant (type
, attributes
);
5239 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5240 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5242 /* Making a new main variant of a class type is broken. */
5243 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5248 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5249 Called only after doing all language independent checks. */
5252 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5254 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5256 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5258 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5260 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5261 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5264 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5265 C++, these are the exception-specifier and ref-qualifier. */
5268 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5270 tree type
= CONST_CAST_TREE (typea
);
5271 if (FUNC_OR_METHOD_TYPE_P (type
))
5272 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5273 TYPE_RAISES_EXCEPTIONS (typeb
),
5274 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5278 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5279 traversal. Called from walk_tree. */
5282 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5283 void *data
, hash_set
<tree
> *pset
)
5285 enum tree_code code
= TREE_CODE (*tp
);
5288 #define WALK_SUBTREE(NODE) \
5291 result = cp_walk_tree (&(NODE), func, data, pset); \
5292 if (result) goto out; \
5298 /* If *WALK_SUBTREES_P is 1, we're interested in the syntactic form of
5299 the argument, so don't look through typedefs, but do walk into
5300 template arguments for alias templates (and non-typedefed classes).
5302 If *WALK_SUBTREES_P > 1, we're interested in type identity or
5303 equivalence, so look through typedefs, ignoring template arguments for
5304 alias templates, and walk into template args of classes.
5306 See find_abi_tags_r for an example of setting *WALK_SUBTREES_P to 2
5307 when that's the behavior the walk_tree_fn wants. */
5308 if (*walk_subtrees_p
== 1 && typedef_variant_p (*tp
))
5310 if (tree ti
= TYPE_ALIAS_TEMPLATE_INFO (*tp
))
5311 WALK_SUBTREE (TI_ARGS (ti
));
5312 *walk_subtrees_p
= 0;
5316 if (tree ti
= TYPE_TEMPLATE_INFO (*tp
))
5317 WALK_SUBTREE (TI_ARGS (ti
));
5320 /* Not one of the easy cases. We must explicitly go through the
5325 case TEMPLATE_TYPE_PARM
:
5326 if (template_placeholder_p (*tp
))
5327 WALK_SUBTREE (CLASS_PLACEHOLDER_TEMPLATE (*tp
));
5329 case DEFERRED_PARSE
:
5330 case TEMPLATE_TEMPLATE_PARM
:
5331 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5332 case UNBOUND_CLASS_TEMPLATE
:
5333 case TEMPLATE_PARM_INDEX
:
5335 case UNDERLYING_TYPE
:
5336 /* None of these have subtrees other than those already walked
5338 *walk_subtrees_p
= 0;
5342 WALK_SUBTREE (TYPE_CONTEXT (*tp
));
5343 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (*tp
));
5344 *walk_subtrees_p
= 0;
5348 if (BASELINK_QUALIFIED_P (*tp
))
5349 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
5350 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
5351 *walk_subtrees_p
= 0;
5355 WALK_SUBTREE (TREE_TYPE (*tp
));
5356 *walk_subtrees_p
= 0;
5360 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5364 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5365 WALK_SUBTREE (OVL_CHAIN (*tp
));
5366 *walk_subtrees_p
= 0;
5370 WALK_SUBTREE (DECL_NAME (*tp
));
5371 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5372 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5373 *walk_subtrees_p
= 0;
5377 if (TYPE_PTRMEMFUNC_P (*tp
))
5378 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5381 case TYPE_ARGUMENT_PACK
:
5382 case NONTYPE_ARGUMENT_PACK
:
5384 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5385 int i
, len
= TREE_VEC_LENGTH (args
);
5386 for (i
= 0; i
< len
; i
++)
5387 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5391 case TYPE_PACK_EXPANSION
:
5392 WALK_SUBTREE (TREE_TYPE (*tp
));
5393 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5394 *walk_subtrees_p
= 0;
5397 case EXPR_PACK_EXPANSION
:
5398 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5399 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5400 *walk_subtrees_p
= 0;
5404 case REINTERPRET_CAST_EXPR
:
5405 case STATIC_CAST_EXPR
:
5406 case CONST_CAST_EXPR
:
5407 case DYNAMIC_CAST_EXPR
:
5408 case IMPLICIT_CONV_EXPR
:
5410 if (TREE_TYPE (*tp
))
5411 WALK_SUBTREE (TREE_TYPE (*tp
));
5415 if (COMPOUND_LITERAL_P (*tp
))
5416 WALK_SUBTREE (TREE_TYPE (*tp
));
5420 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5421 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5422 *walk_subtrees_p
= 0;
5426 ++cp_unevaluated_operand
;
5427 /* We can't use WALK_SUBTREE here because of the goto. */
5428 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5429 --cp_unevaluated_operand
;
5430 *walk_subtrees_p
= 0;
5436 ++cp_unevaluated_operand
;
5437 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5438 --cp_unevaluated_operand
;
5439 *walk_subtrees_p
= 0;
5443 // Only recurse through the nested expression. Do not
5444 // walk the parameter list. Doing so causes false
5445 // positives in the pack expansion checker since the
5446 // requires parameters are introduced as pack expansions.
5447 ++cp_unevaluated_operand
;
5448 result
= cp_walk_tree (&REQUIRES_EXPR_REQS (*tp
), func
, data
, pset
);
5449 --cp_unevaluated_operand
;
5450 *walk_subtrees_p
= 0;
5454 /* User variables should be mentioned in BIND_EXPR_VARS
5455 and their initializers and sizes walked when walking
5456 the containing BIND_EXPR. Compiler temporaries are
5457 handled here. And also normal variables in templates,
5458 since do_poplevel doesn't build a BIND_EXPR then. */
5459 if (VAR_P (TREE_OPERAND (*tp
, 0))
5460 && (processing_template_decl
5461 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5462 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5464 tree decl
= TREE_OPERAND (*tp
, 0);
5465 WALK_SUBTREE (DECL_INITIAL (decl
));
5466 WALK_SUBTREE (DECL_SIZE (decl
));
5467 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5472 /* Don't walk into the body of the lambda, but the capture initializers
5473 are part of the enclosing context. */
5474 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5475 cap
= TREE_CHAIN (cap
))
5476 WALK_SUBTREE (TREE_VALUE (cap
));
5480 if (TREE_OPERAND (*tp
, 1))
5481 /* Operand 1 is the tree for the relevant co_await which has any
5482 interesting sub-trees. */
5483 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5487 if (TREE_OPERAND (*tp
, 1))
5488 /* Operand 1 is frame variable. */
5489 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5490 if (TREE_OPERAND (*tp
, 2))
5491 /* Operand 2 has the initialiser, and we need to walk any subtrees
5493 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5496 case CO_RETURN_EXPR
:
5497 if (TREE_OPERAND (*tp
, 0))
5499 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5500 /* For void expressions, operand 1 is a trivial call, and any
5501 interesting subtrees will be part of operand 0. */
5502 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5503 else if (TREE_OPERAND (*tp
, 1))
5504 /* Interesting sub-trees will be in the return_value () call
5506 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5511 WALK_SUBTREE (STATIC_ASSERT_CONDITION (*tp
));
5512 WALK_SUBTREE (STATIC_ASSERT_MESSAGE (*tp
));
5519 /* We didn't find what we were looking for. */
5526 /* Like save_expr, but for C++. */
5529 cp_save_expr (tree expr
)
5531 /* There is no reason to create a SAVE_EXPR within a template; if
5532 needed, we can create the SAVE_EXPR when instantiating the
5533 template. Furthermore, the middle-end cannot handle C++-specific
5535 if (processing_template_decl
)
5538 /* TARGET_EXPRs are only expanded once. */
5539 if (TREE_CODE (expr
) == TARGET_EXPR
)
5542 return save_expr (expr
);
5545 /* Initialize tree.cc. */
5550 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5551 register_scoped_attributes (std_attribute_table
, NULL
);
5554 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5555 is. Note that sfk_none is zero, so this function can be used as a
5556 predicate to test whether or not DECL is a special function. */
5558 special_function_kind
5559 special_function_p (const_tree decl
)
5561 /* Rather than doing all this stuff with magic names, we should
5562 probably have a field of type `special_function_kind' in
5563 DECL_LANG_SPECIFIC. */
5564 if (DECL_INHERITED_CTOR (decl
))
5565 return sfk_inheriting_constructor
;
5566 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5567 return sfk_copy_constructor
;
5568 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5569 return sfk_move_constructor
;
5570 if (DECL_CONSTRUCTOR_P (decl
))
5571 return sfk_constructor
;
5572 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5573 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5575 if (copy_fn_p (decl
))
5576 return sfk_copy_assignment
;
5577 if (move_fn_p (decl
))
5578 return sfk_move_assignment
;
5580 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5581 return sfk_destructor
;
5582 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5583 return sfk_complete_destructor
;
5584 if (DECL_BASE_DESTRUCTOR_P (decl
))
5585 return sfk_base_destructor
;
5586 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5587 return sfk_deleting_destructor
;
5588 if (DECL_CONV_FN_P (decl
))
5589 return sfk_conversion
;
5590 if (deduction_guide_p (decl
))
5591 return sfk_deduction_guide
;
5592 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5593 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5594 return sfk_comparison
;
5599 /* As above, but only if DECL is a special member function as per 11.3.3
5600 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5602 special_function_kind
5603 special_memfn_p (const_tree decl
)
5605 switch (special_function_kind sfk
= special_function_p (decl
))
5607 case sfk_constructor
:
5608 if (!default_ctor_p (decl
))
5611 case sfk_copy_constructor
:
5612 case sfk_copy_assignment
:
5613 case sfk_move_assignment
:
5614 case sfk_move_constructor
:
5615 case sfk_destructor
:
5624 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5627 char_type_p (tree type
)
5629 return (same_type_p (type
, char_type_node
)
5630 || same_type_p (type
, unsigned_char_type_node
)
5631 || same_type_p (type
, signed_char_type_node
)
5632 || same_type_p (type
, char8_type_node
)
5633 || same_type_p (type
, char16_type_node
)
5634 || same_type_p (type
, char32_type_node
)
5635 || same_type_p (type
, wchar_type_node
));
5638 /* Returns the kind of linkage associated with the indicated DECL. Th
5639 value returned is as specified by the language standard; it is
5640 independent of implementation details regarding template
5641 instantiation, etc. For example, it is possible that a declaration
5642 to which this function assigns external linkage would not show up
5643 as a global symbol when you run `nm' on the resulting object file. */
5646 decl_linkage (tree decl
)
5648 /* This function doesn't attempt to calculate the linkage from first
5649 principles as given in [basic.link]. Instead, it makes use of
5650 the fact that we have already set TREE_PUBLIC appropriately, and
5651 then handles a few special cases. Ideally, we would calculate
5652 linkage first, and then transform that into a concrete
5655 /* Things that don't have names have no linkage. */
5656 if (!DECL_NAME (decl
))
5659 /* Fields have no linkage. */
5660 if (TREE_CODE (decl
) == FIELD_DECL
)
5663 /* Things in local scope do not have linkage. */
5664 if (decl_function_context (decl
))
5667 /* Things that are TREE_PUBLIC have external linkage. */
5668 if (TREE_PUBLIC (decl
))
5671 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5672 check one of the "clones" for the real linkage. */
5673 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5674 && DECL_CHAIN (decl
)
5675 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5676 return decl_linkage (DECL_CHAIN (decl
));
5678 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5681 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5683 if (TREE_CODE (decl
) == CONST_DECL
)
5684 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5686 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5687 are considered to have external linkage for language purposes, as do
5688 template instantiations on targets without weak symbols. DECLs really
5689 meant to have internal linkage have DECL_THIS_STATIC set. */
5690 if (TREE_CODE (decl
) == TYPE_DECL
)
5692 if (VAR_OR_FUNCTION_DECL_P (decl
))
5694 if (!DECL_THIS_STATIC (decl
))
5697 /* Static data members and static member functions from classes
5698 in anonymous namespace also don't have TREE_PUBLIC set. */
5699 if (DECL_CLASS_CONTEXT (decl
))
5703 /* Everything else has internal linkage. */
5707 /* Returns the storage duration of the object or reference associated with
5708 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5711 decl_storage_duration (tree decl
)
5713 if (TREE_CODE (decl
) == PARM_DECL
)
5715 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5717 gcc_assert (VAR_P (decl
));
5718 if (!TREE_STATIC (decl
)
5719 && !DECL_EXTERNAL (decl
))
5721 if (CP_DECL_THREAD_LOCAL_P (decl
))
5726 /* EXP is an expression that we want to pre-evaluate. Returns (in
5727 *INITP) an expression that will perform the pre-evaluation. The
5728 value returned by this function is a side-effect free expression
5729 equivalent to the pre-evaluated expression. Callers must ensure
5730 that *INITP is evaluated before EXP. */
5733 stabilize_expr (tree exp
, tree
* initp
)
5737 if (!TREE_SIDE_EFFECTS (exp
))
5738 init_expr
= NULL_TREE
;
5739 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5744 /* There are no expressions with REFERENCE_TYPE, but there can be call
5745 arguments with such a type; just treat it as a pointer. */
5746 else if (TYPE_REF_P (TREE_TYPE (exp
))
5747 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5748 || !glvalue_p (exp
))
5750 init_expr
= get_target_expr (exp
);
5751 exp
= TARGET_EXPR_SLOT (init_expr
);
5752 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5759 bool xval
= !lvalue_p (exp
);
5760 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5761 init_expr
= get_target_expr (exp
);
5762 exp
= TARGET_EXPR_SLOT (init_expr
);
5763 exp
= cp_build_fold_indirect_ref (exp
);
5769 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5773 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5774 similar expression ORIG. */
5777 add_stmt_to_compound (tree orig
, tree new_expr
)
5779 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5781 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5783 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5786 /* Like stabilize_expr, but for a call whose arguments we want to
5787 pre-evaluate. CALL is modified in place to use the pre-evaluated
5788 arguments, while, upon return, *INITP contains an expression to
5789 compute the arguments. */
5792 stabilize_call (tree call
, tree
*initp
)
5794 tree inits
= NULL_TREE
;
5796 int nargs
= call_expr_nargs (call
);
5798 if (call
== error_mark_node
|| processing_template_decl
)
5804 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5806 for (i
= 0; i
< nargs
; i
++)
5809 CALL_EXPR_ARG (call
, i
) =
5810 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5811 inits
= add_stmt_to_compound (inits
, init
);
5817 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5818 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5819 arguments, while, upon return, *INITP contains an expression to
5820 compute the arguments. */
5823 stabilize_aggr_init (tree call
, tree
*initp
)
5825 tree inits
= NULL_TREE
;
5827 int nargs
= aggr_init_expr_nargs (call
);
5829 if (call
== error_mark_node
)
5832 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5834 for (i
= 0; i
< nargs
; i
++)
5837 AGGR_INIT_EXPR_ARG (call
, i
) =
5838 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5839 inits
= add_stmt_to_compound (inits
, init
);
5845 /* Like stabilize_expr, but for an initialization.
5847 If the initialization is for an object of class type, this function
5848 takes care not to introduce additional temporaries.
5850 Returns TRUE iff the expression was successfully pre-evaluated,
5851 i.e., if INIT is now side-effect free, except for, possibly, a
5852 single call to a constructor. */
5855 stabilize_init (tree init
, tree
*initp
)
5861 if (t
== error_mark_node
|| processing_template_decl
)
5864 if (TREE_CODE (t
) == INIT_EXPR
)
5865 t
= TREE_OPERAND (t
, 1);
5866 if (TREE_CODE (t
) == TARGET_EXPR
)
5867 t
= TARGET_EXPR_INITIAL (t
);
5869 /* If the RHS can be stabilized without breaking copy elision, stabilize
5870 it. We specifically don't stabilize class prvalues here because that
5871 would mean an extra copy, but they might be stabilized below. */
5872 if (TREE_CODE (init
) == INIT_EXPR
5873 && TREE_CODE (t
) != CONSTRUCTOR
5874 && TREE_CODE (t
) != AGGR_INIT_EXPR
5875 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5878 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5882 if (TREE_CODE (t
) == COMPOUND_EXPR
5883 && TREE_CODE (init
) == INIT_EXPR
)
5885 tree last
= expr_last (t
);
5886 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5887 if (!TREE_SIDE_EFFECTS (last
))
5890 TREE_OPERAND (init
, 1) = last
;
5895 if (TREE_CODE (t
) == CONSTRUCTOR
)
5897 /* Aggregate initialization: stabilize each of the field
5900 constructor_elt
*ce
;
5902 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5903 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5905 tree type
= TREE_TYPE (ce
->value
);
5907 if (TYPE_REF_P (type
)
5908 || SCALAR_TYPE_P (type
))
5909 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5910 else if (!stabilize_init (ce
->value
, &subinit
))
5912 *initp
= add_stmt_to_compound (*initp
, subinit
);
5917 if (TREE_CODE (t
) == CALL_EXPR
)
5919 stabilize_call (t
, initp
);
5923 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5925 stabilize_aggr_init (t
, initp
);
5929 /* The initialization is being performed via a bitwise copy -- and
5930 the item copied may have side effects. */
5931 return !TREE_SIDE_EFFECTS (init
);
5934 /* Returns true if a cast to TYPE may appear in an integral constant
5938 cast_valid_in_integral_constant_expression_p (tree type
)
5940 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5941 || cxx_dialect
>= cxx11
5942 || dependent_type_p (type
)
5943 || type
== error_mark_node
);
5946 /* Return true if we need to fix linkage information of DECL. */
5949 cp_fix_function_decl_p (tree decl
)
5951 /* Skip if DECL is not externally visible. */
5952 if (!TREE_PUBLIC (decl
))
5955 /* We need to fix DECL if it a appears to be exported but with no
5956 function body. Thunks do not have CFGs and we may need to
5957 handle them specially later. */
5958 if (!gimple_has_body_p (decl
)
5959 && !DECL_THUNK_P (decl
)
5960 && !DECL_EXTERNAL (decl
))
5962 struct cgraph_node
*node
= cgraph_node::get (decl
);
5964 /* Don't fix same_body aliases. Although they don't have their own
5965 CFG, they share it with what they alias to. */
5966 if (!node
|| !node
->alias
|| !node
->num_references ())
5973 /* Clean the C++ specific parts of the tree T. */
5976 cp_free_lang_data (tree t
)
5978 if (FUNC_OR_METHOD_TYPE_P (t
))
5980 /* Default args are not interesting anymore. */
5981 tree argtypes
= TYPE_ARG_TYPES (t
);
5984 TREE_PURPOSE (argtypes
) = 0;
5985 argtypes
= TREE_CHAIN (argtypes
);
5988 else if (TREE_CODE (t
) == FUNCTION_DECL
5989 && cp_fix_function_decl_p (t
))
5991 /* If T is used in this translation unit at all, the definition
5992 must exist somewhere else since we have decided to not emit it
5993 in this TU. So make it an external reference. */
5994 DECL_EXTERNAL (t
) = 1;
5995 TREE_STATIC (t
) = 0;
5997 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5998 /* We do not need the leftover chaining of namespaces from the
6000 DECL_CHAIN (t
) = NULL_TREE
;
6003 /* Stub for c-common. Please keep in sync with c-decl.cc.
6004 FIXME: If address space support is target specific, then this
6005 should be a C target hook. But currently this is not possible,
6006 because this function is called via REGISTER_TARGET_PRAGMAS. */
6008 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
6012 /* Return the number of operands in T that we care about for things like
6016 cp_tree_operand_length (const_tree t
)
6018 enum tree_code code
= TREE_CODE (t
);
6020 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
6021 return VL_EXP_OPERAND_LENGTH (t
);
6023 return cp_tree_code_length (code
);
6026 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
6029 cp_tree_code_length (enum tree_code code
)
6031 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6035 case PREINCREMENT_EXPR
:
6036 case PREDECREMENT_EXPR
:
6037 case POSTINCREMENT_EXPR
:
6038 case POSTDECREMENT_EXPR
:
6044 case EXPR_PACK_EXPANSION
:
6048 return TREE_CODE_LENGTH (code
);
6052 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
6056 cp_expr_location (const_tree t_
)
6058 tree t
= CONST_CAST_TREE (t_
);
6060 return UNKNOWN_LOCATION
;
6061 switch (TREE_CODE (t
))
6064 return LAMBDA_EXPR_LOCATION (t
);
6066 return STATIC_ASSERT_SOURCE_LOCATION (t
);
6068 return TRAIT_EXPR_LOCATION (t
);
6070 return PTRMEM_CST_LOCATION (t
);
6072 return EXPR_LOCATION (t
);
6076 /* Implement -Wzero_as_null_pointer_constant. Return true if the
6077 conditions for the warning hold, false otherwise. */
6079 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
6081 if (c_inhibit_evaluation_warnings
== 0
6082 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6084 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
6085 "zero as null pointer constant");
6091 /* Release memory we no longer need after parsing. */
6093 cp_tree_c_finish_parsing ()
6095 if (previous_class_level
)
6096 invalidate_class_lookup_cache ();
6097 deleted_copy_types
= NULL
;
6100 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6101 /* Complain that some language-specific thing hanging off a tree
6102 node has been accessed improperly. */
6105 lang_check_failed (const char* file
, int line
, const char* function
)
6107 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
6108 function
, trim_filename (file
), line
);
6110 #endif /* ENABLE_TREE_CHECKING */
6114 namespace selftest
{
6116 /* Verify that lvalue_kind () works, for various expressions,
6117 and that location wrappers don't affect the results. */
6122 location_t loc
= BUILTINS_LOCATION
;
6124 /* Verify constants and parameters, without and with
6125 location wrappers. */
6126 tree int_cst
= build_int_cst (integer_type_node
, 42);
6127 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
6129 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
6130 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
6131 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
6133 tree string_lit
= build_string (4, "foo");
6134 TREE_TYPE (string_lit
) = char_array_type_node
;
6135 string_lit
= fix_string_type (string_lit
);
6136 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
6138 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
6139 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
6140 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
6142 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
6143 get_identifier ("some_parm"),
6145 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
6147 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
6148 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
6149 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
6151 /* Verify that lvalue_kind of std::move on a parm isn't
6152 affected by location wrappers. */
6153 tree rvalue_ref_of_parm
= move (parm
);
6154 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
6155 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
6156 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
6158 /* Verify lvalue_p. */
6159 ASSERT_FALSE (lvalue_p (int_cst
));
6160 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
6161 ASSERT_TRUE (lvalue_p (parm
));
6162 ASSERT_TRUE (lvalue_p (wrapped_parm
));
6163 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
6164 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
6167 /* Run all of the selftests within this file. */
6172 test_lvalue_kind ();
6175 } // namespace selftest
6177 #endif /* #if CHECKING_P */
6180 #include "gt-cp-tree.h"