1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2024 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 *);
49 static tree
handle_contract_attribute (tree
*, tree
, tree
, int, bool *);
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
55 lvalue_kind (const_tree ref
)
57 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
58 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
64 if (REFERENCE_REF_P (ref
))
65 return lvalue_kind (TREE_OPERAND (ref
, 0));
68 && TYPE_REF_P (TREE_TYPE (ref
)))
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
72 && TREE_CODE (ref
) != PARM_DECL
74 && TREE_CODE (ref
) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 op1_lvalue_kind
= clk_rvalueref
;
79 if (implicit_rvalue_p (ref
))
80 op1_lvalue_kind
|= clk_implicit_rval
;
81 return op1_lvalue_kind
;
84 /* lvalue references and named rvalue references are lvalues. */
88 if (ref
== current_class_ptr
)
91 /* Expressions with cv void type are prvalues. */
92 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
95 switch (TREE_CODE (ref
))
100 /* preincrements and predecrements are valid lvals, provided
101 what they refer to are valid lvals. */
102 case PREINCREMENT_EXPR
:
103 case PREDECREMENT_EXPR
:
107 case VIEW_CONVERT_EXPR
:
108 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
109 /* As for ARRAY_REF and COMPONENT_REF, these codes turn a class prvalue
110 into an xvalue: we need to materialize the temporary before we mess
111 with it. Except VIEW_CONVERT_EXPR that doesn't actually change the
112 type, as in location wrapper and REF_PARENTHESIZED_P. */
113 if (op1_lvalue_kind
== clk_class
114 && !(TREE_CODE (ref
) == VIEW_CONVERT_EXPR
115 && (same_type_ignoring_top_level_qualifiers_p
116 (TREE_TYPE (ref
), TREE_TYPE (TREE_OPERAND (ref
, 0))))))
117 return clk_rvalueref
;
118 return op1_lvalue_kind
;
122 tree op1
= TREE_OPERAND (ref
, 0);
123 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
125 op1_lvalue_kind
= lvalue_kind (op1
);
126 if (op1_lvalue_kind
== clk_class
)
127 /* in the case of an array operand, the result is an lvalue if
128 that operand is an lvalue and an xvalue otherwise */
129 op1_lvalue_kind
= clk_rvalueref
;
130 return op1_lvalue_kind
;
138 if (TREE_CODE (ref
) == MEMBER_REF
)
139 op1_lvalue_kind
= clk_ordinary
;
141 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
142 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
143 op1_lvalue_kind
= clk_none
;
144 else if (op1_lvalue_kind
== clk_class
)
145 /* The result of a .* expression whose second operand is a pointer to a
146 data member is an lvalue if the first operand is an lvalue and an
148 op1_lvalue_kind
= clk_rvalueref
;
149 return op1_lvalue_kind
;
152 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
154 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
156 /* For static member function recurse on the BASELINK, we can get
157 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
158 OVERLOAD, the overload is resolved first if possible through
159 resolve_address_of_overloaded_function. */
160 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
161 return lvalue_kind (TREE_OPERAND (ref
, 1));
163 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
164 if (op1_lvalue_kind
== clk_class
)
165 /* If E1 is an lvalue, then E1.E2 is an lvalue;
166 otherwise E1.E2 is an xvalue. */
167 op1_lvalue_kind
= clk_rvalueref
;
169 /* Look at the member designator. */
170 if (!op1_lvalue_kind
)
172 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
173 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
174 situations. If we're seeing a COMPONENT_REF, it's a non-static
175 member, so it isn't an lvalue. */
176 op1_lvalue_kind
= clk_none
;
177 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
178 /* This can be IDENTIFIER_NODE in a template. */;
179 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
181 /* Clear the ordinary bit. If this object was a class
182 rvalue we want to preserve that information. */
183 op1_lvalue_kind
&= ~clk_ordinary
;
184 /* The lvalue is for a bitfield. */
185 op1_lvalue_kind
|= clk_bitfield
;
187 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
188 op1_lvalue_kind
|= clk_packed
;
190 return op1_lvalue_kind
;
193 case COMPOUND_LITERAL_EXPR
:
197 /* CONST_DECL without TREE_STATIC are enumeration values and
198 thus not lvalues. With TREE_STATIC they are used by ObjC++
199 in objc_build_string_object and need to be considered as
201 if (! TREE_STATIC (ref
))
205 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
206 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
208 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
209 && DECL_LANG_SPECIFIC (ref
)
210 && DECL_IN_AGGR_P (ref
))
217 case PLACEHOLDER_EXPR
:
220 /* A scope ref in a template, left as SCOPE_REF to support later
223 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
225 tree op
= TREE_OPERAND (ref
, 1);
226 if (TREE_CODE (op
) == FIELD_DECL
)
227 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
229 return lvalue_kind (op
);
234 /* Disallow <? and >? as lvalues if either argument side-effects. */
235 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
236 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
238 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
239 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
243 if (processing_template_decl
)
245 /* Within templates, a REFERENCE_TYPE will indicate whether
246 the COND_EXPR result is an ordinary lvalue or rvalueref.
247 Since REFERENCE_TYPEs are handled above, if we reach this
248 point, we know we got a plain rvalue. Unless we have a
249 type-dependent expr, that is, but we shouldn't be testing
250 lvalueness if we can't even tell the types yet! */
251 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
255 tree op1
= TREE_OPERAND (ref
, 1);
256 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
257 tree op2
= TREE_OPERAND (ref
, 2);
258 op1_lvalue_kind
= lvalue_kind (op1
);
259 op2_lvalue_kind
= lvalue_kind (op2
);
260 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
262 /* The second or the third operand (but not both) is a
263 throw-expression; the result is of the type
264 and value category of the other. */
265 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
266 op2_lvalue_kind
= op1_lvalue_kind
;
267 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
268 op1_lvalue_kind
= op2_lvalue_kind
;
274 /* We expect to see unlowered MODOP_EXPRs only during
275 template processing. */
276 gcc_assert (processing_template_decl
);
284 return lvalue_kind (TREE_OPERAND (ref
, 1));
290 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
293 /* We can see calls outside of TARGET_EXPR in templates. */
294 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
299 /* All functions (except non-static-member functions) are
301 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
302 ? clk_none
: clk_ordinary
);
305 /* We now represent a reference to a single static member function
307 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
308 its argument unmodified and we assign it to a const_tree. */
309 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
312 return lvalue_kind (TREE_OPERAND (ref
, 0));
314 case TEMPLATE_PARM_INDEX
:
315 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
316 /* A template parameter object is an lvalue. */
322 if (!TREE_TYPE (ref
))
324 if (CLASS_TYPE_P (TREE_TYPE (ref
))
325 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
330 /* If one operand is not an lvalue at all, then this expression is
332 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
335 /* Otherwise, it's an lvalue, and it has all the odd properties
336 contributed by either operand. */
337 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
338 /* It's not an ordinary lvalue if it involves any other kind. */
339 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
340 op1_lvalue_kind
&= ~clk_ordinary
;
341 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
342 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
343 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
344 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
345 op1_lvalue_kind
= clk_none
;
346 return op1_lvalue_kind
;
349 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
352 real_lvalue_p (const_tree ref
)
354 cp_lvalue_kind kind
= lvalue_kind (ref
);
355 if (kind
& (clk_rvalueref
|clk_class
))
361 /* c-common wants us to return bool. */
364 lvalue_p (const_tree t
)
366 return real_lvalue_p (t
);
369 /* This differs from lvalue_p in that xvalues are included. */
372 glvalue_p (const_tree ref
)
374 cp_lvalue_kind kind
= lvalue_kind (ref
);
375 if (kind
& clk_class
)
378 return (kind
!= clk_none
);
381 /* This differs from glvalue_p in that class prvalues are included. */
384 obvalue_p (const_tree ref
)
386 return (lvalue_kind (ref
) != clk_none
);
389 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
390 reference), false otherwise. */
393 xvalue_p (const_tree ref
)
395 return (lvalue_kind (ref
) & clk_rvalueref
);
398 /* True if REF is a bit-field. */
401 bitfield_p (const_tree ref
)
403 return (lvalue_kind (ref
) & clk_bitfield
);
406 /* C++-specific version of stabilize_reference. */
409 cp_stabilize_reference (tree ref
)
411 if (processing_template_decl
)
412 /* As in cp_save_expr. */
415 STRIP_ANY_LOCATION_WRAPPER (ref
);
416 switch (TREE_CODE (ref
))
418 /* We need to treat specially anything stabilize_reference doesn't
419 handle specifically. */
430 case ARRAY_RANGE_REF
:
434 cp_lvalue_kind kind
= lvalue_kind (ref
);
435 if ((kind
& ~clk_class
) != clk_none
)
437 tree type
= unlowered_expr_type (ref
);
438 bool rval
= !!(kind
& clk_rvalueref
);
439 type
= cp_build_reference_type (type
, rval
);
440 /* This inhibits warnings in, eg, cxx_mark_addressable
442 warning_sentinel
s (extra_warnings
);
443 ref
= build_static_cast (input_location
, type
, ref
,
448 return stabilize_reference (ref
);
451 /* Test whether DECL is a builtin that may appear in a
452 constant-expression. */
455 builtin_valid_in_constant_expr_p (const_tree decl
)
457 STRIP_ANY_LOCATION_WRAPPER (decl
);
458 if (TREE_CODE (decl
) != FUNCTION_DECL
)
459 /* Not a function. */
461 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
463 if (fndecl_built_in_p (decl
, BUILT_IN_FRONTEND
))
464 switch (DECL_FE_FUNCTION_CODE (decl
))
466 case CP_BUILT_IN_IS_CONSTANT_EVALUATED
:
467 case CP_BUILT_IN_SOURCE_LOCATION
:
468 case CP_BUILT_IN_IS_CORRESPONDING_MEMBER
:
469 case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS
:
474 /* Not a built-in. */
477 switch (DECL_FUNCTION_CODE (decl
))
479 /* These always have constant results like the corresponding
482 case BUILT_IN_FUNCTION
:
485 /* The following built-ins are valid in constant expressions
486 when their arguments are. */
487 case BUILT_IN_ADD_OVERFLOW_P
:
488 case BUILT_IN_SUB_OVERFLOW_P
:
489 case BUILT_IN_MUL_OVERFLOW_P
:
491 /* These have constant results even if their operands are
493 case BUILT_IN_CONSTANT_P
:
494 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
501 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
504 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
507 tree type
= TREE_TYPE (decl
);
509 value
= mark_rvalue_use (value
);
511 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
512 || TREE_TYPE (decl
) == TREE_TYPE (value
)
513 /* On ARM ctors return 'this'. */
514 || (TYPE_PTR_P (TREE_TYPE (value
))
515 && TREE_CODE (value
) == CALL_EXPR
)
516 || useless_type_conversion_p (TREE_TYPE (decl
),
519 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
520 moving a constant aggregate into .rodata. */
521 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
522 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
523 && !VOID_TYPE_P (TREE_TYPE (value
))
524 && !TYPE_HAS_MUTABLE_P (type
)
525 && reduced_constant_expression_p (value
))
526 TREE_READONLY (decl
) = true;
528 if (complain
& tf_no_cleanup
)
529 /* The caller is building a new-expr and does not need a cleanup. */
533 t
= cxx_maybe_build_cleanup (decl
, complain
);
534 if (t
== error_mark_node
)
535 return error_mark_node
;
538 set_target_expr_eliding (value
);
540 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
541 if (location_t eloc
= cp_expr_location (value
))
542 SET_EXPR_LOCATION (t
, eloc
);
543 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
544 ignore the TARGET_EXPR. If there really turn out to be no
545 side-effects, then the optimizer should be able to get rid of
546 whatever code is generated anyhow. */
547 TREE_SIDE_EFFECTS (t
) = 1;
552 /* Return an undeclared local temporary of type TYPE for use in building a
556 build_local_temp (tree type
)
558 tree slot
= build_decl (input_location
,
559 VAR_DECL
, NULL_TREE
, type
);
560 DECL_ARTIFICIAL (slot
) = 1;
561 DECL_IGNORED_P (slot
) = 1;
562 DECL_CONTEXT (slot
) = current_function_decl
;
563 layout_decl (slot
, 0);
567 /* Return whether DECL is such a local temporary (or one from
568 create_tmp_var_raw). */
571 is_local_temp (tree decl
)
573 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
574 && !TREE_STATIC (decl
));
577 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
580 process_aggr_init_operands (tree t
)
584 side_effects
= TREE_SIDE_EFFECTS (t
);
588 n
= TREE_OPERAND_LENGTH (t
);
589 for (i
= 1; i
< n
; i
++)
591 tree op
= TREE_OPERAND (t
, i
);
592 if (op
&& TREE_SIDE_EFFECTS (op
))
599 TREE_SIDE_EFFECTS (t
) = side_effects
;
602 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
603 FN, and SLOT. NARGS is the number of call arguments which are specified
604 as a tree array ARGS. */
607 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
613 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
614 TREE_TYPE (t
) = return_type
;
615 AGGR_INIT_EXPR_FN (t
) = fn
;
616 AGGR_INIT_EXPR_SLOT (t
) = slot
;
617 for (i
= 0; i
< nargs
; i
++)
618 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
619 process_aggr_init_operands (t
);
623 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
624 target. TYPE is the type to be initialized.
626 Build an AGGR_INIT_EXPR to represent the initialization. This function
627 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
628 to initialize another object, whereas a TARGET_EXPR can either
629 initialize another object or create its own temporary object, and as a
630 result building up a TARGET_EXPR requires that the type's destructor be
634 build_aggr_init_expr (tree type
, tree init
)
641 gcc_assert (!VOID_TYPE_P (type
));
643 /* Don't build AGGR_INIT_EXPR in a template. */
644 if (processing_template_decl
)
647 fn
= cp_get_callee (init
);
649 return convert (type
, init
);
651 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
652 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
653 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
655 /* We split the CALL_EXPR into its function and its arguments here.
656 Then, in expand_expr, we put them back together. The reason for
657 this is that this expression might be a default argument
658 expression. In that case, we need a new temporary every time the
659 expression is used. That's what break_out_target_exprs does; it
660 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
661 temporary slot. Then, expand_expr builds up a call-expression
662 using the new slot. */
664 /* If we don't need to use a constructor to create an object of this
665 type, don't mess with AGGR_INIT_EXPR. */
666 if (is_ctor
|| TREE_ADDRESSABLE (type
))
668 slot
= build_local_temp (type
);
670 if (TREE_CODE (init
) == CALL_EXPR
)
672 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
673 call_expr_nargs (init
),
674 CALL_EXPR_ARGP (init
));
675 AGGR_INIT_FROM_THUNK_P (rval
)
676 = CALL_FROM_THUNK_P (init
);
680 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
681 aggr_init_expr_nargs (init
),
682 AGGR_INIT_EXPR_ARGP (init
));
683 AGGR_INIT_FROM_THUNK_P (rval
)
684 = AGGR_INIT_FROM_THUNK_P (init
);
686 TREE_SIDE_EFFECTS (rval
) = 1;
687 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
688 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
689 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
690 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
691 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
692 SET_EXPR_LOCATION (rval
, EXPR_LOCATION (init
));
700 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
701 target. TYPE is the type that this initialization should appear to
704 Build an encapsulation of the initialization to perform
705 and return it so that it can be processed by language-independent
706 and language-specific expression expanders. */
709 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
711 /* This function should cope with what build_special_member_call
712 can produce. When performing parenthesized aggregate initialization,
713 it can produce a { }. */
714 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
716 gcc_assert (cxx_dialect
>= cxx20
);
717 return finish_compound_literal (type
, init
, complain
);
720 tree rval
= build_aggr_init_expr (type
, init
);
723 if (init
== error_mark_node
)
724 return error_mark_node
;
726 if (!complete_type_or_maybe_complain (type
, init
, complain
))
727 return error_mark_node
;
729 /* Make sure that we're not trying to create an instance of an
731 if (abstract_virtuals_error (NULL_TREE
, type
, complain
))
732 return error_mark_node
;
734 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
735 slot
= AGGR_INIT_EXPR_SLOT (rval
);
736 else if (TREE_CODE (rval
) == CALL_EXPR
737 || TREE_CODE (rval
) == CONSTRUCTOR
)
738 slot
= build_local_temp (type
);
742 rval
= build_target_expr (slot
, rval
, complain
);
744 if (rval
!= error_mark_node
)
745 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
750 /* Subroutine of build_vec_init_expr: Build up a single element
751 intialization as a proxy for the full array initialization to get things
752 marked as used and any appropriate diagnostics.
754 This used to be necessary because we were deferring building the actual
755 constructor calls until gimplification time; now we only do it to set
756 VEC_INIT_EXPR_IS_CONSTEXPR.
758 We assume that init is either NULL_TREE, {}, void_type_node (indicating
759 value-initialization), or another array to copy. */
762 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
764 tree inner_type
= strip_array_types (type
);
766 if (integer_zerop (array_type_nelts_total (type
))
767 || !CLASS_TYPE_P (inner_type
))
768 /* No interesting initialization to do. */
769 return integer_zero_node
;
770 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
772 /* Even if init has initializers for some array elements,
773 we're interested in the {}-init of trailing elements. */
774 if (CP_AGGREGATE_TYPE_P (inner_type
))
776 tree empty
= build_constructor (init_list_type_node
, nullptr);
777 return digest_init (inner_type
, empty
, complain
);
780 /* It's equivalent to value-init. */
781 init
= void_type_node
;
783 if (init
== void_type_node
)
784 return build_value_init (inner_type
, complain
);
786 releasing_vec argvec
;
787 if (init
&& !BRACE_ENCLOSED_INITIALIZER_P (init
))
789 tree init_type
= strip_array_types (TREE_TYPE (init
));
790 tree dummy
= build_dummy_object (init_type
);
791 if (!lvalue_p (init
))
792 dummy
= move (dummy
);
793 argvec
->quick_push (dummy
);
795 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
796 &argvec
, inner_type
, LOOKUP_NORMAL
,
799 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
800 we don't want one here because we aren't creating a temporary. */
801 if (TREE_CODE (init
) == TARGET_EXPR
)
802 init
= TARGET_EXPR_INITIAL (init
);
807 /* Return a TARGET_EXPR which expresses the initialization of an array to
808 be named later, either default-initialization or copy-initialization
809 from another array of the same type. */
812 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
814 if (tree vi
= get_vec_init_expr (init
))
818 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
819 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
820 /* We built any needed constructor calls in digest_init. */
823 elt_init
= build_vec_init_elt (type
, init
, complain
);
825 bool value_init
= false;
826 if (init
== void_type_node
)
832 tree slot
= build_local_temp (type
);
833 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
834 TREE_SIDE_EFFECTS (init
) = true;
835 SET_EXPR_LOCATION (init
, input_location
);
837 if (cxx_dialect
>= cxx11
)
839 bool cx
= potential_constant_expression (elt_init
);
840 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
841 cx
&= potential_constant_expression (init
);
842 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = cx
;
844 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
849 /* Call build_vec_init to expand VEC_INIT into TARGET (for which NULL_TREE
850 means VEC_INIT_EXPR_SLOT). */
853 expand_vec_init_expr (tree target
, tree vec_init
, tsubst_flags_t complain
,
854 vec
<tree
,va_gc
> **flags
)
856 iloc_sentinel ils
= EXPR_LOCATION (vec_init
);
859 target
= VEC_INIT_EXPR_SLOT (vec_init
);
860 tree init
= VEC_INIT_EXPR_INIT (vec_init
);
861 int from_array
= (init
&& TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
);
862 return build_vec_init (target
, NULL_TREE
, init
,
863 VEC_INIT_EXPR_VALUE_INIT (vec_init
),
864 from_array
, complain
, flags
);
867 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
868 that requires a constant expression. */
871 diagnose_non_constexpr_vec_init (tree expr
)
873 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
875 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
876 init
= void_type_node
;
878 init
= VEC_INIT_EXPR_INIT (expr
);
880 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
881 require_potential_constant_expression (elt_init
);
885 build_array_copy (tree init
)
887 return get_target_expr (build_vec_init_expr
888 (TREE_TYPE (init
), init
, tf_warning_or_error
));
891 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
895 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
897 gcc_assert (!VOID_TYPE_P (type
));
898 gcc_assert (!VOID_TYPE_P (TREE_TYPE (init
)));
900 if (TREE_CODE (init
) == TARGET_EXPR
901 || init
== error_mark_node
)
903 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
904 && TREE_CODE (init
) != COND_EXPR
905 && TREE_CODE (init
) != CONSTRUCTOR
906 && TREE_CODE (init
) != VA_ARG_EXPR
907 && TREE_CODE (init
) != CALL_EXPR
)
908 /* We need to build up a copy constructor call. COND_EXPR is a special
909 case because we already have copies on the arms and we don't want
910 another one here. A CONSTRUCTOR is aggregate initialization, which
911 is handled separately. A VA_ARG_EXPR is magic creation of an
912 aggregate; there's no additional work to be done. A CALL_EXPR
913 already creates a prvalue. */
914 return force_rvalue (init
, complain
);
916 return force_target_expr (type
, init
, complain
);
919 /* Like the above function, but without the checking. This function should
920 only be used by code which is deliberately trying to subvert the type
921 system, such as call_builtin_trap. Or build_over_call, to avoid
922 infinite recursion. */
925 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
929 gcc_assert (!VOID_TYPE_P (type
));
931 slot
= build_local_temp (type
);
932 return build_target_expr (slot
, init
, complain
);
935 /* Like build_target_expr_with_type, but use the type of INIT. */
938 get_target_expr (tree init
, tsubst_flags_t complain
/* = tf_warning_or_error */)
940 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
941 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
942 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
943 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
946 init
= convert_bitfield_to_declared_type (init
);
947 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
951 /* If EXPR is a bitfield reference, convert it to the declared type of
952 the bitfield, and return the resulting expression. Otherwise,
953 return EXPR itself. */
956 convert_bitfield_to_declared_type (tree expr
)
960 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
962 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
967 /* EXPR is being used in an rvalue context. Return a version of EXPR
968 that is marked as an rvalue. */
975 if (error_operand_p (expr
))
978 expr
= mark_rvalue_use (expr
);
982 Non-class rvalues always have cv-unqualified types. */
983 type
= TREE_TYPE (expr
);
984 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
985 type
= cv_unqualified (type
);
987 /* We need to do this for rvalue refs as well to get the right answer
988 from decltype; see c++/36628. */
989 if (!processing_template_decl
&& glvalue_p (expr
))
991 /* But don't use this function for class lvalues; use move (to treat an
992 lvalue as an xvalue) or force_rvalue (to make a prvalue copy). */
993 gcc_checking_assert (!CLASS_TYPE_P (type
));
994 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
996 else if (type
!= TREE_TYPE (expr
))
997 expr
= build_nop (type
, expr
);
1003 struct cplus_array_info
1009 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
1011 typedef cplus_array_info
*compare_type
;
1013 static hashval_t
hash (tree t
);
1014 static bool equal (tree
, cplus_array_info
*);
1017 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
1020 cplus_array_hasher::hash (tree t
)
1024 hash
= TYPE_UID (TREE_TYPE (t
));
1025 if (TYPE_DOMAIN (t
))
1026 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
1030 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
1031 of type `cplus_array_info*'. */
1034 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
1036 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
1039 /* Hash table containing dependent array types, which are unsuitable for
1040 the language-independent type hash table. */
1041 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
1043 /* Build an ARRAY_TYPE without laying it out. */
1046 build_min_array_type (tree elt_type
, tree index_type
)
1048 tree t
= cxx_make_type (ARRAY_TYPE
);
1049 TREE_TYPE (t
) = elt_type
;
1050 TYPE_DOMAIN (t
) = index_type
;
1054 /* Set TYPE_CANONICAL like build_array_type_1, but using
1055 build_cplus_array_type. */
1058 set_array_type_canon (tree t
, tree elt_type
, tree index_type
, bool dep
)
1060 /* Set the canonical type for this new node. */
1061 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1062 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1063 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1064 else if (TYPE_CANONICAL (elt_type
) != elt_type
1065 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1067 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1069 ? TYPE_CANONICAL (index_type
) : index_type
,
1072 TYPE_CANONICAL (t
) = t
;
1075 /* Like build_array_type, but handle special C++ semantics: an array of a
1076 variant element type is a variant of the array of the main variant of
1077 the element type. IS_DEPENDENT is -ve if we should determine the
1078 dependency. Otherwise its bool value indicates dependency. */
1081 build_cplus_array_type (tree elt_type
, tree index_type
, int dependent
)
1085 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1086 return error_mark_node
;
1089 dependent
= (uses_template_parms (elt_type
)
1090 || (index_type
&& uses_template_parms (index_type
)));
1092 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1093 /* Start with an array of the TYPE_MAIN_VARIANT. */
1094 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1095 index_type
, dependent
);
1098 /* Since type_hash_canon calls layout_type, we need to use our own
1100 cplus_array_info cai
;
1103 if (cplus_array_htab
== NULL
)
1104 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1106 hash
= TYPE_UID (elt_type
);
1108 hash
^= TYPE_UID (index_type
);
1109 cai
.type
= elt_type
;
1110 cai
.domain
= index_type
;
1112 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1114 /* We have found the type: we're done. */
1118 /* Build a new array type. */
1119 t
= build_min_array_type (elt_type
, index_type
);
1121 /* Store it in the hash table. */
1124 /* Set the canonical type for this new node. */
1125 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1127 /* Mark it as dependent now, this saves time later. */
1128 TYPE_DEPENDENT_P_VALID (t
) = true;
1129 TYPE_DEPENDENT_P (t
) = true;
1134 bool typeless_storage
= is_byte_access_type (elt_type
);
1135 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1137 /* Mark as non-dependenty now, this will save time later. */
1138 TYPE_DEPENDENT_P_VALID (t
) = true;
1141 /* Now check whether we already have this array variant. */
1142 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1145 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1146 if (TREE_TYPE (t
) == elt_type
1147 && TYPE_NAME (t
) == NULL_TREE
1148 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1152 t
= build_min_array_type (elt_type
, index_type
);
1153 /* Mark dependency now, this saves time later. */
1154 TYPE_DEPENDENT_P_VALID (t
) = true;
1155 TYPE_DEPENDENT_P (t
) = dependent
;
1156 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1160 /* Make sure sizes are shared with the main variant.
1161 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1162 as it will overwrite alignment etc. of all variants. */
1163 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1164 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1165 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1168 TYPE_MAIN_VARIANT (t
) = m
;
1169 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1170 TYPE_NEXT_VARIANT (m
) = t
;
1174 /* Avoid spurious warnings with VLAs (c++/54583). */
1175 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1176 suppress_warning (TYPE_SIZE (t
), OPT_Wunused
);
1178 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1179 place more easily. */
1180 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1181 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1182 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1183 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1185 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1186 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1188 /* The element type has been completed since the last time we saw
1189 this array type; update the layout and 'tor flags for any variants
1192 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1194 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1195 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1202 /* Return an ARRAY_TYPE with element type ELT and length N. */
1205 build_array_of_n_type (tree elt
, int n
)
1207 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1210 /* True iff T is an array of unknown bound. */
1213 array_of_unknown_bound_p (const_tree t
)
1215 return (TREE_CODE (t
) == ARRAY_TYPE
1216 && !TYPE_DOMAIN (t
));
1219 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1220 for C++14 but then removed. This should only be used for N3639
1221 specifically; code wondering more generally if something is a VLA should use
1225 array_of_runtime_bound_p (tree t
)
1227 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1229 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1231 tree dom
= TYPE_DOMAIN (t
);
1234 tree max
= TYPE_MAX_VALUE (dom
);
1235 return (!potential_rvalue_constant_expression (max
)
1236 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1239 /* True iff T is a variable length array. */
1244 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1246 if (tree dom
= TYPE_DOMAIN (t
))
1248 tree max
= TYPE_MAX_VALUE (dom
);
1249 if (!potential_rvalue_constant_expression (max
)
1250 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1257 /* Return a reference type node of MODE referring to TO_TYPE. If MODE
1258 is VOIDmode the standard pointer mode will be picked. If RVAL is
1259 true, return an rvalue reference type, otherwise return an lvalue
1260 reference type. If a type node exists, reuse it, otherwise create
1263 cp_build_reference_type_for_mode (tree to_type
, machine_mode mode
, bool rval
)
1267 if (to_type
== error_mark_node
)
1268 return error_mark_node
;
1270 if (TYPE_REF_P (to_type
))
1272 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1273 to_type
= TREE_TYPE (to_type
);
1276 lvalue_ref
= build_reference_type_for_mode (to_type
, mode
, false);
1281 /* This code to create rvalue reference types is based on and tied
1282 to the code creating lvalue reference types in the middle-end
1283 functions build_reference_type_for_mode and build_reference_type.
1285 It works by putting the rvalue reference type nodes after the
1286 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1287 they will effectively be ignored by the middle end. */
1289 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1290 if (TYPE_REF_IS_RVALUE (t
))
1293 t
= build_distinct_type_copy (lvalue_ref
);
1295 TYPE_REF_IS_RVALUE (t
) = true;
1296 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1297 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1299 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1300 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1301 else if (TYPE_CANONICAL (to_type
) != to_type
)
1303 = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type
), mode
, rval
);
1305 TYPE_CANONICAL (t
) = t
;
1313 /* Return a reference type node referring to TO_TYPE. If RVAL is
1314 true, return an rvalue reference type, otherwise return an lvalue
1315 reference type. If a type node exists, reuse it, otherwise create
1318 cp_build_reference_type (tree to_type
, bool rval
)
1320 return cp_build_reference_type_for_mode (to_type
, VOIDmode
, rval
);
1323 /* Returns EXPR cast to rvalue reference type, like std::move. */
1328 tree type
= TREE_TYPE (expr
);
1329 gcc_assert (!TYPE_REF_P (type
));
1330 if (xvalue_p (expr
))
1332 type
= cp_build_reference_type (type
, /*rval*/true);
1333 return build_static_cast (input_location
, type
, expr
,
1334 tf_warning_or_error
);
1337 /* Used by the C++ front end to build qualified array types. However,
1338 the C version of this function does not properly maintain canonical
1339 types (which are not used in C). */
1341 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1342 size_t /* orig_qual_indirect */)
1344 return cp_build_qualified_type (type
, type_quals
);
1348 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1349 arrays correctly. In particular, if TYPE is an array of T's, and
1350 TYPE_QUALS is non-empty, returns an array of qualified T's.
1352 FLAGS determines how to deal with ill-formed qualifications. If
1353 tf_ignore_bad_quals is set, then bad qualifications are dropped
1354 (this is permitted if TYPE was introduced via a typedef or template
1355 type parameter). If bad qualifications are dropped and tf_warning
1356 is set, then a warning is issued for non-const qualifications. If
1357 tf_ignore_bad_quals is not set and tf_error is not set, we
1358 return error_mark_node. Otherwise, we issue an error, and ignore
1361 Qualification of a reference type is valid when the reference came
1362 via a typedef or template type argument. [dcl.ref] No such
1363 dispensation is provided for qualifying a function type. [dcl.fct]
1364 DR 295 queries this and the proposed resolution brings it into line
1365 with qualifying a reference. We implement the DR. We also behave
1366 in a similar manner for restricting non-pointer types. */
1369 cp_build_qualified_type (tree type
, int type_quals
,
1370 tsubst_flags_t complain
/* = tf_warning_or_error */)
1373 int bad_quals
= TYPE_UNQUALIFIED
;
1375 if (type
== error_mark_node
)
1378 if (type_quals
== cp_type_quals (type
))
1381 if (TREE_CODE (type
) == ARRAY_TYPE
)
1383 /* In C++, the qualification really applies to the array element
1384 type. Obtain the appropriately qualified element type. */
1387 = cp_build_qualified_type (TREE_TYPE (type
), type_quals
, complain
);
1389 if (element_type
== error_mark_node
)
1390 return error_mark_node
;
1392 /* See if we already have an identically qualified type. Tests
1393 should be equivalent to those in check_qualified_type. */
1394 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1395 if (TREE_TYPE (t
) == element_type
1396 && TYPE_NAME (t
) == TYPE_NAME (type
)
1397 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1398 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1399 TYPE_ATTRIBUTES (type
)))
1404 /* If we already know the dependentness, tell the array type
1405 constructor. This is important for module streaming, as we cannot
1406 dynamically determine that on read in. */
1407 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
),
1408 TYPE_DEPENDENT_P_VALID (type
)
1409 ? int (TYPE_DEPENDENT_P (type
)) : -1);
1411 /* Keep the typedef name. */
1412 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1414 t
= build_variant_type_copy (t
);
1415 TYPE_NAME (t
) = TYPE_NAME (type
);
1416 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1417 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1421 /* Even if we already had this variant, we update
1422 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1423 they changed since the variant was originally created.
1425 This seems hokey; if there is some way to use a previous
1426 variant *without* coming through here,
1427 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1428 TYPE_NEEDS_CONSTRUCTING (t
)
1429 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1430 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1431 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1434 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1436 tree t
= PACK_EXPANSION_PATTERN (type
);
1438 t
= cp_build_qualified_type (t
, type_quals
, complain
);
1439 return make_pack_expansion (t
, complain
);
1442 /* A reference or method type shall not be cv-qualified.
1443 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1444 (in CD1) we always ignore extra cv-quals on functions. */
1446 /* [dcl.ref/1] Cv-qualified references are ill-formed except when
1447 the cv-qualifiers are introduced through the use of a typedef-name
1448 ([dcl.typedef], [temp.param]) or decltype-specifier
1449 ([dcl.type.decltype]),in which case the cv-qualifiers are
1451 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1452 && (TYPE_REF_P (type
)
1453 || FUNC_OR_METHOD_TYPE_P (type
)))
1455 if (TYPE_REF_P (type
)
1456 && (!typedef_variant_p (type
) || FUNC_OR_METHOD_TYPE_P (type
)))
1457 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1458 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1461 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1462 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1463 type_quals
|= type_memfn_quals (type
);
1465 /* A restrict-qualified type must be a pointer (or reference)
1466 to object or incomplete type. */
1467 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1468 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1469 && TREE_CODE (type
) != TYPENAME_TYPE
1470 && !INDIRECT_TYPE_P (type
))
1472 bad_quals
|= TYPE_QUAL_RESTRICT
;
1473 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1476 if (bad_quals
== TYPE_UNQUALIFIED
1477 || (complain
& tf_ignore_bad_quals
))
1479 else if (!(complain
& tf_error
))
1480 return error_mark_node
;
1483 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1484 error ("%qV qualifiers cannot be applied to %qT",
1488 /* Retrieve (or create) the appropriately qualified variant. */
1489 result
= build_qualified_type (type
, type_quals
);
1494 /* Return TYPE with const and volatile removed. */
1497 cv_unqualified (tree type
)
1501 if (type
== error_mark_node
)
1504 quals
= cp_type_quals (type
);
1505 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1506 return cp_build_qualified_type (type
, quals
);
1509 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1510 from ATTRIBS that affect type identity, and no others. If any are not
1511 applied, set *remove_attributes to true. */
1514 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1516 tree first_ident
= NULL_TREE
;
1517 tree new_attribs
= NULL_TREE
;
1518 tree
*p
= &new_attribs
;
1520 if (OVERLOAD_TYPE_P (result
))
1522 /* On classes and enums all attributes are ingrained. */
1523 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1527 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1529 const attribute_spec
*as
1530 = lookup_attribute_spec (get_attribute_name (a
));
1531 if (as
&& as
->affects_type_identity
)
1535 else if (first_ident
== error_mark_node
)
1537 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1538 p
= &TREE_CHAIN (*p
);
1541 else if (first_ident
&& first_ident
!= error_mark_node
)
1543 for (tree a2
= first_ident
; a2
!= a
; a2
= TREE_CHAIN (a2
))
1545 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1546 p
= &TREE_CHAIN (*p
);
1548 first_ident
= error_mark_node
;
1551 if (first_ident
!= error_mark_node
)
1552 new_attribs
= first_ident
;
1554 if (first_ident
== attribs
)
1555 /* All attributes affected type identity. */;
1557 *remove_attributes
= true;
1559 return cp_build_type_attribute_variant (result
, new_attribs
);
1562 /* Builds a qualified variant of T that is either not a typedef variant
1563 (the default behavior) or not a typedef variant of a user-facing type
1564 (if FLAGS contains STF_USER_FACING). If T is not a type, then this
1565 just dispatches to strip_typedefs_expr.
1567 E.g. consider the following declarations:
1568 typedef const int ConstInt;
1569 typedef ConstInt* PtrConstInt;
1570 If T is PtrConstInt, this function returns a type representing
1572 In other words, if T is a typedef, the function returns the underlying type.
1573 The cv-qualification and attributes of the type returned match the
1575 They will always be compatible types.
1576 The returned type is built so that all of its subtypes
1577 recursively have their typedefs stripped as well.
1579 This is different from just returning TYPE_CANONICAL (T)
1580 Because of several reasons:
1581 * If T is a type that needs structural equality
1582 its TYPE_CANONICAL (T) will be NULL.
1583 * TYPE_CANONICAL (T) desn't carry type attributes
1584 and loses template parameter names.
1586 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1587 affect type identity, and set the referent to true if any were
1591 strip_typedefs (tree t
, bool *remove_attributes
/* = NULL */,
1592 unsigned int flags
/* = 0 */)
1594 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1596 if (!t
|| t
== error_mark_node
)
1600 return strip_typedefs_expr (t
, remove_attributes
, flags
);
1602 if (t
== TYPE_CANONICAL (t
))
1605 if (!(flags
& STF_STRIP_DEPENDENT
)
1606 && dependent_alias_template_spec_p (t
, nt_opaque
))
1607 /* DR 1558: However, if the template-id is dependent, subsequent
1608 template argument substitution still applies to the template-id. */
1611 switch (TREE_CODE (t
))
1614 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1615 result
= build_pointer_type_for_mode (type
, TYPE_MODE (t
), false);
1617 case REFERENCE_TYPE
:
1618 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1619 result
= cp_build_reference_type_for_mode (type
, TYPE_MODE (t
), TYPE_REF_IS_RVALUE (t
));
1622 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1623 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1624 result
= build_offset_type (t0
, type
);
1627 if (TYPE_PTRMEMFUNC_P (t
))
1629 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1630 remove_attributes
, flags
);
1631 result
= build_ptrmemfunc_type (t0
);
1635 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1636 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1637 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t
)
1638 || !dependent_type_p (t
));
1639 result
= build_cplus_array_type (type
, t0
, TYPE_DEPENDENT_P (t
));
1644 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1647 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1648 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1649 can't expect that re-hashing a function type will find a previous
1650 equivalent type, so try to reuse the input type if nothing has
1651 changed. If the type is itself a variant, that will change. */
1652 bool is_variant
= typedef_variant_p (t
);
1653 if (remove_attributes
1654 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1657 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1658 tree canon_spec
= (flag_noexcept_type
1659 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1661 changed
= (type
!= TREE_TYPE (t
) || is_variant
1662 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1664 for (arg_node
= TYPE_ARG_TYPES (t
);
1666 arg_node
= TREE_CHAIN (arg_node
))
1668 if (arg_node
== void_list_node
)
1670 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1671 remove_attributes
, flags
);
1672 gcc_assert (arg_type
);
1673 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1679 for (arg_node2
= TYPE_ARG_TYPES (t
);
1680 arg_node2
!= arg_node
;
1681 arg_node2
= TREE_CHAIN (arg_node2
))
1683 = tree_cons (TREE_PURPOSE (arg_node2
),
1684 TREE_VALUE (arg_node2
), arg_types
);
1688 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1695 arg_types
= nreverse (arg_types
);
1697 /* A list of parameters not ending with an ellipsis
1698 must end with void_list_node. */
1700 arg_types
= chainon (arg_types
, void_list_node
);
1702 if (TREE_CODE (t
) == METHOD_TYPE
)
1704 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1705 gcc_assert (class_type
);
1707 build_method_type_directly (class_type
, type
,
1708 TREE_CHAIN (arg_types
));
1712 result
= build_function_type (type
, arg_types
);
1713 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1716 result
= build_cp_fntype_variant (result
,
1717 type_memfn_rqual (t
), canon_spec
,
1718 TYPE_HAS_LATE_RETURN_TYPE (t
));
1723 bool changed
= false;
1724 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1725 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1726 && TREE_OPERAND (fullname
, 1))
1728 tree args
= TREE_OPERAND (fullname
, 1);
1729 tree new_args
= copy_node (args
);
1730 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1732 tree arg
= TREE_VEC_ELT (args
, i
);
1733 tree strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
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
),
1773 tree type1
= strip_typedefs (TRAIT_TYPE_TYPE1 (t
),
1774 remove_attributes
, flags
);
1775 tree type2
= strip_typedefs (TRAIT_TYPE_TYPE2 (t
),
1776 remove_attributes
, flags
);
1777 if (type1
== TRAIT_TYPE_TYPE1 (t
) && type2
== TRAIT_TYPE_TYPE2 (t
))
1780 result
= finish_trait_type (TRAIT_TYPE_KIND (t
), type1
, type2
,
1781 tf_warning_or_error
);
1784 case TYPE_PACK_EXPANSION
:
1786 tree pat
= PACK_EXPANSION_PATTERN (t
);
1789 type
= strip_typedefs (pat
, remove_attributes
, flags
);
1792 result
= build_distinct_type_copy (t
);
1793 PACK_EXPANSION_PATTERN (result
) = type
;
1804 if (typedef_variant_p (t
))
1806 if ((flags
& STF_USER_VISIBLE
)
1807 && !user_facing_original_type_p (t
))
1809 /* If T is a non-template alias or typedef, we can assume that
1810 instantiating its definition will hit any substitution failure,
1811 so we don't need to retain it here as well. */
1812 if (!alias_template_specialization_p (t
, nt_opaque
))
1813 flags
|= STF_STRIP_DEPENDENT
;
1814 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1815 remove_attributes
, flags
);
1818 result
= TYPE_MAIN_VARIANT (t
);
1820 /*gcc_assert (!typedef_variant_p (result)
1821 || dependent_alias_template_spec_p (result, nt_opaque)
1822 || ((flags & STF_USER_VISIBLE)
1823 && !user_facing_original_type_p (result)));*/
1825 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1826 /* If RESULT is complete and T isn't, it's likely the case that T
1827 is a variant of RESULT which hasn't been updated yet. Skip the
1828 attribute handling. */;
1831 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1832 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1834 gcc_assert (TYPE_USER_ALIGN (t
));
1835 if (remove_attributes
)
1836 *remove_attributes
= true;
1839 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1840 result
= build_variant_type_copy (result
);
1842 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1843 TYPE_USER_ALIGN (result
) = true;
1847 if (TYPE_ATTRIBUTES (t
))
1849 if (remove_attributes
)
1850 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1853 result
= cp_build_type_attribute_variant (result
,
1854 TYPE_ATTRIBUTES (t
));
1858 return cp_build_qualified_type (result
, cp_type_quals (t
));
1861 /* Like strip_typedefs above, but works on expressions (and other
1862 non-types such as TREE_VEC), so that in
1864 template<class T> struct A
1870 sizeof(TT) is replaced by sizeof(T). */
1873 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1877 enum tree_code code
;
1879 if (t
== NULL_TREE
|| t
== error_mark_node
)
1882 STRIP_ANY_LOCATION_WRAPPER (t
);
1884 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1887 code
= TREE_CODE (t
);
1890 case IDENTIFIER_NODE
:
1891 case TEMPLATE_PARM_INDEX
:
1894 case ARGUMENT_PACK_SELECT
:
1899 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1900 remove_attributes
, flags
);
1901 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1902 remove_attributes
, flags
);
1903 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1904 && type2
== TRAIT_EXPR_TYPE2 (t
))
1907 TRAIT_EXPR_TYPE1 (r
) = type1
;
1908 TRAIT_EXPR_TYPE2 (r
) = type2
;
1914 bool changed
= false;
1915 auto_vec
<tree_pair
, 4> vec
;
1917 for (; t
; t
= TREE_CHAIN (t
))
1919 tree purpose
= strip_typedefs (TREE_PURPOSE (t
),
1920 remove_attributes
, flags
);
1921 tree value
= strip_typedefs (TREE_VALUE (t
),
1922 remove_attributes
, flags
);
1923 if (purpose
!= TREE_PURPOSE (t
) || value
!= TREE_VALUE (t
))
1925 vec
.safe_push ({purpose
, value
});
1930 for (int i
= vec
.length () - 1; i
>= 0; i
--)
1931 r
= tree_cons (vec
[i
].first
, vec
[i
].second
, r
);
1938 bool changed
= false;
1940 n
= TREE_VEC_LENGTH (t
);
1941 vec_safe_reserve (vec
, n
);
1942 for (i
= 0; i
< n
; ++i
)
1944 tree op
= strip_typedefs (TREE_VEC_ELT (t
, i
),
1945 remove_attributes
, flags
);
1946 vec
->quick_push (op
);
1947 if (op
!= TREE_VEC_ELT (t
, i
))
1953 for (i
= 0; i
< n
; ++i
)
1954 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1955 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1956 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1965 bool changed
= false;
1966 vec
<constructor_elt
, va_gc
> *vec
1967 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1968 n
= CONSTRUCTOR_NELTS (t
);
1969 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1970 for (i
= 0; i
< n
; ++i
)
1972 constructor_elt
*e
= &(*vec
)[i
];
1973 tree op
= strip_typedefs (e
->value
, remove_attributes
, flags
);
1980 (e
->index
== strip_typedefs (e
->index
, remove_attributes
,
1984 if (!changed
&& type
== TREE_TYPE (t
))
1992 TREE_TYPE (r
) = type
;
1993 CONSTRUCTOR_ELTS (r
) = vec
;
2001 case STATEMENT_LIST
:
2002 error ("statement-expression in a constant expression");
2003 return error_mark_node
;
2009 gcc_assert (EXPR_P (t
));
2011 n
= cp_tree_operand_length (t
);
2012 ops
= XALLOCAVEC (tree
, n
);
2013 type
= TREE_TYPE (t
);
2018 case IMPLICIT_CONV_EXPR
:
2019 case DYNAMIC_CAST_EXPR
:
2020 case STATIC_CAST_EXPR
:
2021 case CONST_CAST_EXPR
:
2022 case REINTERPRET_CAST_EXPR
:
2025 type
= strip_typedefs (type
, remove_attributes
, flags
);
2029 for (i
= 0; i
< n
; ++i
)
2030 ops
[i
] = strip_typedefs (TREE_OPERAND (t
, i
),
2031 remove_attributes
, flags
);
2035 /* If nothing changed, return t. */
2036 for (i
= 0; i
< n
; ++i
)
2037 if (ops
[i
] != TREE_OPERAND (t
, i
))
2039 if (i
== n
&& type
== TREE_TYPE (t
))
2043 TREE_TYPE (r
) = type
;
2044 for (i
= 0; i
< n
; ++i
)
2045 TREE_OPERAND (r
, i
) = ops
[i
];
2049 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
2050 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2051 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2052 VIRT indicates whether TYPE is inherited virtually or not.
2053 IGO_PREV points at the previous binfo of the inheritance graph
2054 order chain. The newly copied binfo's TREE_CHAIN forms this
2057 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2058 correct order. That is in the order the bases themselves should be
2061 The BINFO_INHERITANCE of a virtual base class points to the binfo
2062 of the most derived type. ??? We could probably change this so that
2063 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2064 remove a field. They currently can only differ for primary virtual
2068 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
2074 /* See if we've already made this virtual base. */
2075 new_binfo
= binfo_for_vbase (type
, t
);
2080 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
2081 BINFO_TYPE (new_binfo
) = type
;
2083 /* Chain it into the inheritance graph. */
2084 TREE_CHAIN (*igo_prev
) = new_binfo
;
2085 *igo_prev
= new_binfo
;
2087 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2092 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2094 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2095 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2097 /* We do not need to copy the accesses, as they are read only. */
2098 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2100 /* Recursively copy base binfos of BINFO. */
2101 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2103 tree new_base_binfo
;
2104 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2106 BINFO_VIRTUAL_P (base_binfo
));
2108 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2109 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2110 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2114 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2118 /* Push it onto the list after any virtual bases it contains
2119 will have been pushed. */
2120 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2121 BINFO_VIRTUAL_P (new_binfo
) = 1;
2122 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2128 /* Hashing of lists so that we don't make duplicates.
2129 The entry point is `list_hash_canon'. */
2138 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2140 typedef list_proxy
*compare_type
;
2142 static hashval_t
hash (tree
);
2143 static bool equal (tree
, list_proxy
*);
2146 /* Now here is the hash table. When recording a list, it is added
2147 to the slot whose index is the hash code mod the table size.
2148 Note that the hash table is used for several kinds of lists.
2149 While all these live in the same table, they are completely independent,
2150 and the hash code is computed differently for each of these. */
2152 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2154 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2155 for a node we are thinking about adding). */
2158 list_hasher::equal (tree t
, list_proxy
*proxy
)
2160 return (TREE_VALUE (t
) == proxy
->value
2161 && TREE_PURPOSE (t
) == proxy
->purpose
2162 && TREE_CHAIN (t
) == proxy
->chain
);
2165 /* Compute a hash code for a list (chain of TREE_LIST nodes
2166 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2167 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2170 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2172 hashval_t hashcode
= 0;
2175 hashcode
+= TREE_HASH (chain
);
2178 hashcode
+= TREE_HASH (value
);
2182 hashcode
+= TREE_HASH (purpose
);
2188 /* Hash an already existing TREE_LIST. */
2191 list_hasher::hash (tree t
)
2193 return list_hash_pieces (TREE_PURPOSE (t
),
2198 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2199 object for an identical list if one already exists. Otherwise, build a
2200 new one, and record it as the canonical object. */
2203 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2207 struct list_proxy proxy
;
2209 /* Hash the list node. */
2210 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2211 /* Create a proxy for the TREE_LIST we would like to create. We
2212 don't actually create it so as to avoid creating garbage. */
2213 proxy
.purpose
= purpose
;
2214 proxy
.value
= value
;
2215 proxy
.chain
= chain
;
2216 /* See if it is already in the table. */
2217 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2218 /* If not, create a new node. */
2220 *slot
= tree_cons (purpose
, value
, chain
);
2221 return (tree
) *slot
;
2224 /* Constructor for hashed lists. */
2227 hash_tree_chain (tree value
, tree chain
)
2229 return hash_tree_cons (NULL_TREE
, value
, chain
);
2233 debug_binfo (tree elem
)
2238 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2240 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2241 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2242 debug_tree (BINFO_TYPE (elem
));
2243 if (BINFO_VTABLE (elem
))
2244 fprintf (stderr
, "vtable decl \"%s\"\n",
2245 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2247 fprintf (stderr
, "no vtable decl yet\n");
2248 fprintf (stderr
, "virtuals:\n");
2249 virtuals
= BINFO_VIRTUALS (elem
);
2254 tree fndecl
= TREE_VALUE (virtuals
);
2255 fprintf (stderr
, "%s [%ld =? %ld]\n",
2256 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2257 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2259 virtuals
= TREE_CHAIN (virtuals
);
2263 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2264 the type of the result expression, if known, or NULL_TREE if the
2265 resulting expression is type-dependent. If TEMPLATE_P is true,
2266 NAME is known to be a template because the user explicitly used the
2267 "template" keyword after the "::".
2269 All SCOPE_REFs should be built by use of this function. */
2272 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2275 if (type
== error_mark_node
2276 || scope
== error_mark_node
2277 || name
== error_mark_node
)
2278 return error_mark_node
;
2279 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2280 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2281 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2282 PTRMEM_OK_P (t
) = true;
2284 t
= convert_from_reference (t
);
2288 /* Like check_qualified_type, but also check ref-qualifier, exception
2289 specification, and whether the return type was specified after the
2293 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2294 cp_ref_qualifier rqual
, tree raises
, bool late
)
2296 return (TYPE_QUALS (cand
) == type_quals
2297 && check_base_type (cand
, base
)
2298 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2300 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2301 && type_memfn_rqual (cand
) == rqual
);
2304 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2307 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2309 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2310 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2311 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2315 make_binding_vec (tree name
, unsigned clusters MEM_STAT_DECL
)
2317 /* Stored in an unsigned short, but we're limited to the number of
2319 gcc_checking_assert (clusters
<= (unsigned short)(~0));
2320 size_t length
= (offsetof (tree_binding_vec
, vec
)
2321 + clusters
* sizeof (binding_cluster
));
2322 tree vec
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2323 TREE_SET_CODE (vec
, BINDING_VECTOR
);
2324 BINDING_VECTOR_NAME (vec
) = name
;
2325 BINDING_VECTOR_ALLOC_CLUSTERS (vec
) = clusters
;
2326 BINDING_VECTOR_NUM_CLUSTERS (vec
) = 0;
2331 /* Make a raw overload node containing FN. */
2334 ovl_make (tree fn
, tree next
)
2336 tree result
= make_node (OVERLOAD
);
2338 if (TREE_CODE (fn
) == OVERLOAD
)
2339 OVL_NESTED_P (result
) = true;
2341 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2342 ? unknown_type_node
: TREE_TYPE (fn
));
2343 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2344 OVL_DEDUP_P (result
) = true;
2345 OVL_FUNCTION (result
) = fn
;
2346 OVL_CHAIN (result
) = next
;
2350 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2351 zero if this is a using-decl. It is > 1 if we're exporting the
2352 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2353 cannot be both using and hidden.) We keep the hidden decls first,
2354 but remaining ones are unordered. */
2357 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2359 tree result
= maybe_ovl
;
2360 tree insert_after
= NULL_TREE
;
2363 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2364 && OVL_HIDDEN_P (maybe_ovl
);
2365 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2367 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2368 insert_after
= maybe_ovl
;
2371 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2373 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2375 if (using_or_hidden
< 0)
2376 OVL_HIDDEN_P (maybe_ovl
) = true;
2377 if (using_or_hidden
> 0)
2379 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2380 if (using_or_hidden
> 1)
2381 OVL_EXPORT_P (maybe_ovl
) = true;
2389 OVL_CHAIN (insert_after
) = maybe_ovl
;
2390 TREE_TYPE (insert_after
) = unknown_type_node
;
2398 /* Skip any hidden names at the beginning of OVL. */
2401 ovl_skip_hidden (tree ovl
)
2403 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2404 ovl
= OVL_CHAIN (ovl
);
2409 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2412 ovl_iterator::reveal_node (tree overload
, tree node
)
2414 /* We cannot have returned NODE as part of a lookup overload, so we
2415 don't have to worry about preserving that. */
2417 OVL_HIDDEN_P (node
) = false;
2418 if (tree chain
= OVL_CHAIN (node
))
2419 if (TREE_CODE (chain
) == OVERLOAD
)
2421 if (OVL_HIDDEN_P (chain
))
2423 /* The node needs moving, and the simplest way is to remove it
2425 overload
= remove_node (overload
, node
);
2426 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2428 else if (OVL_DEDUP_P (chain
))
2429 OVL_DEDUP_P (node
) = true;
2434 /* NODE is on the overloads of OVL. Remove it.
2435 The removed node is unaltered and may continue to be iterated
2436 from (i.e. it is safe to remove a node from an overload one is
2437 currently iterating over). */
2440 ovl_iterator::remove_node (tree overload
, tree node
)
2442 tree
*slot
= &overload
;
2443 while (*slot
!= node
)
2446 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2448 slot
= &OVL_CHAIN (probe
);
2451 /* Stitch out NODE. We don't have to worry about now making a
2452 singleton overload (and consequently maybe setting its type),
2453 because all uses of this function will be followed by inserting a
2454 new node that must follow the place we've cut this out from. */
2455 if (TREE_CODE (node
) != OVERLOAD
)
2456 /* Cloned inherited ctors don't mark themselves as via_using. */
2459 *slot
= OVL_CHAIN (node
);
2464 /* Mark or unmark a lookup set. */
2467 lookup_mark (tree ovl
, bool val
)
2469 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2471 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2472 LOOKUP_SEEN_P (*iter
) = val
;
2476 /* Add a set of new FNS into a lookup. */
2479 lookup_add (tree fns
, tree lookup
)
2481 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2482 return error_mark_node
;
2484 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2486 lookup
= ovl_make (fns
, lookup
);
2487 OVL_LOOKUP_P (lookup
) = true;
2495 /* FNS is a new overload set, add them to LOOKUP, if they are not
2496 already present there. */
2499 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2502 for (tree next
, probe
= fns
; probe
; probe
= next
)
2507 if (TREE_CODE (probe
) == OVERLOAD
)
2509 fn
= OVL_FUNCTION (probe
);
2510 next
= OVL_CHAIN (probe
);
2513 if (!LOOKUP_SEEN_P (fn
))
2514 LOOKUP_SEEN_P (fn
) = true;
2517 /* This function was already seen. Insert all the
2518 predecessors onto the lookup. */
2519 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2521 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2522 /* Propagate OVL_USING, but OVL_HIDDEN &
2523 OVL_DEDUP_P don't matter. */
2524 if (OVL_USING_P (fns
))
2525 OVL_USING_P (lookup
) = true;
2528 /* And now skip this function. */
2534 /* We ended in a set of new functions. Add them all in one go. */
2535 lookup
= lookup_add (fns
, lookup
);
2540 /* Returns nonzero if X is an expression for a (possibly overloaded)
2541 function. If "f" is a function or function template, "f", "c->f",
2542 "c.f", "C::f", and "f<int>" will all be considered possibly
2543 overloaded functions. Returns 2 if the function is actually
2544 overloaded, i.e., if it is impossible to know the type of the
2545 function without performing overload resolution. */
2548 is_overloaded_fn (tree x
)
2550 STRIP_ANY_LOCATION_WRAPPER (x
);
2552 /* A baselink is also considered an overloaded function. */
2553 if (TREE_CODE (x
) == OFFSET_REF
2554 || TREE_CODE (x
) == COMPONENT_REF
)
2555 x
= TREE_OPERAND (x
, 1);
2556 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2557 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2558 x
= TREE_OPERAND (x
, 0);
2560 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2561 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2567 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2568 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2572 dependent_name (tree x
)
2574 /* FIXME a dependent name must be unqualified, but this function doesn't
2575 distinguish between qualified and unqualified identifiers. */
2576 if (identifier_p (x
))
2578 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2579 x
= TREE_OPERAND (x
, 0);
2581 return OVL_NAME (x
);
2585 /* Like dependent_name, but instead takes a CALL_EXPR and also checks
2589 call_expr_dependent_name (tree x
)
2591 if (TREE_TYPE (x
) != NULL_TREE
)
2592 /* X isn't dependent, so its callee isn't a dependent name. */
2594 return dependent_name (CALL_EXPR_FN (x
));
2597 /* Returns true iff X is an expression for an overloaded function
2598 whose type cannot be known without performing overload
2602 really_overloaded_fn (tree x
)
2604 return is_overloaded_fn (x
) == 2;
2607 /* Get the overload set FROM refers to. Returns NULL if it's not an
2611 maybe_get_fns (tree from
)
2613 STRIP_ANY_LOCATION_WRAPPER (from
);
2615 /* A baselink is also considered an overloaded function. */
2616 if (TREE_CODE (from
) == OFFSET_REF
2617 || TREE_CODE (from
) == COMPONENT_REF
)
2618 from
= TREE_OPERAND (from
, 1);
2619 if (BASELINK_P (from
))
2620 from
= BASELINK_FUNCTIONS (from
);
2621 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2622 from
= TREE_OPERAND (from
, 0);
2630 /* FROM refers to an overload set. Return that set (or die). */
2635 tree res
= maybe_get_fns (from
);
2641 /* Return the first function of the overload set FROM refers to. */
2644 get_first_fn (tree from
)
2646 return OVL_FIRST (get_fns (from
));
2649 /* Return the scope where the overloaded functions OVL were found. */
2652 ovl_scope (tree ovl
)
2654 if (TREE_CODE (ovl
) == OFFSET_REF
2655 || TREE_CODE (ovl
) == COMPONENT_REF
)
2656 ovl
= TREE_OPERAND (ovl
, 1);
2657 if (TREE_CODE (ovl
) == BASELINK
)
2658 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2659 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2660 ovl
= TREE_OPERAND (ovl
, 0);
2661 /* Skip using-declarations. */
2662 lkp_iterator
iter (ovl
);
2665 while (iter
.using_p () && ++iter
);
2667 return CP_DECL_CONTEXT (ovl
);
2670 #define PRINT_RING_SIZE 4
2673 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2675 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2676 static char *print_ring
[PRINT_RING_SIZE
];
2677 static bool trans_ring
[PRINT_RING_SIZE
];
2678 static int ring_counter
;
2681 /* Only cache functions. */
2683 || TREE_CODE (decl
) != FUNCTION_DECL
2684 || DECL_LANG_SPECIFIC (decl
) == 0)
2685 return lang_decl_name (decl
, v
, translate
);
2687 /* See if this print name is lying around. */
2688 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2689 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2690 /* yes, so return it. */
2691 return print_ring
[i
];
2693 if (++ring_counter
== PRINT_RING_SIZE
)
2696 if (current_function_decl
!= NULL_TREE
)
2698 /* There may be both translated and untranslated versions of the
2700 for (i
= 0; i
< 2; i
++)
2702 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2704 if (ring_counter
== PRINT_RING_SIZE
)
2707 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2710 free (print_ring
[ring_counter
]);
2712 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2713 uid_ring
[ring_counter
] = DECL_UID (decl
);
2714 trans_ring
[ring_counter
] = translate
;
2715 return print_ring
[ring_counter
];
2719 cxx_printable_name (tree decl
, int v
)
2721 return cxx_printable_name_internal (decl
, v
, false);
2725 cxx_printable_name_translate (tree decl
, int v
)
2727 return cxx_printable_name_internal (decl
, v
, true);
2730 /* Return the canonical version of exception-specification RAISES for a C++17
2731 function type, for use in type comparison and building TYPE_CANONICAL. */
2734 canonical_eh_spec (tree raises
)
2736 if (raises
== NULL_TREE
)
2738 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2739 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2740 || uses_template_parms (raises
)
2741 || uses_template_parms (TREE_PURPOSE (raises
)))
2742 /* Keep a dependent or deferred exception specification. */
2744 else if (nothrow_spec_p (raises
))
2745 /* throw() -> noexcept. */
2746 return noexcept_true_spec
;
2748 /* For C++17 type matching, anything else -> nothing. */
2753 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2754 tree raises
, bool late
)
2756 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2758 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2761 tree v
= TYPE_MAIN_VARIANT (type
);
2762 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2763 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2766 /* Need to build a new variant. */
2767 v
= build_variant_type_copy (type
);
2768 if (!TYPE_DEPENDENT_P (v
))
2769 /* We no longer know that it's not type-dependent. */
2770 TYPE_DEPENDENT_P_VALID (v
) = false;
2771 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2772 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2775 case REF_QUAL_RVALUE
:
2776 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2777 FUNCTION_REF_QUALIFIED (v
) = 1;
2779 case REF_QUAL_LVALUE
:
2780 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2781 FUNCTION_REF_QUALIFIED (v
) = 1;
2784 FUNCTION_REF_QUALIFIED (v
) = 0;
2788 /* Canonicalize the exception specification. */
2789 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2791 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2792 /* Propagate structural equality. */
2793 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2794 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2795 /* Build the underlying canonical type, since it is different
2797 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2800 /* T is its own canonical type. */
2801 TYPE_CANONICAL (v
) = v
;
2806 /* TYPE is a function or method type with a deferred exception
2807 specification that has been parsed to RAISES. Fixup all the type
2808 variants that are affected in place. Via decltype &| noexcept
2809 tricks, the unparsed spec could have escaped into the type system.
2810 The general case is hard to fixup canonical types for. */
2813 fixup_deferred_exception_variants (tree type
, tree raises
)
2815 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2816 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2818 gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original
));
2820 /* Though sucky, this walk will process the canonical variants
2822 tree prev
= NULL_TREE
;
2823 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2824 variant
; prev
= variant
, variant
= TYPE_NEXT_VARIANT (variant
))
2825 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2827 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2829 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2831 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2832 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2834 /* If VARIANT would become a dup (cp_check_qualified_type-wise)
2835 of an existing variant in the variant list of TYPE after its
2836 exception specification has been parsed, elide it. Otherwise,
2837 build_cp_fntype_variant could use it, leading to "canonical
2838 types differ for identical types." */
2839 tree v
= TYPE_MAIN_VARIANT (type
);
2840 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2841 if (cp_check_qualified_type (v
, variant
, var_quals
,
2844 /* The main variant will not match V, so PREV will never
2846 TYPE_NEXT_VARIANT (prev
) = TYPE_NEXT_VARIANT (variant
);
2849 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2852 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2854 TYPE_CANONICAL (variant
) = TYPE_CANONICAL (v
);
2857 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2859 if (!TYPE_DEPENDENT_P (variant
))
2860 /* We no longer know that it's not type-dependent. */
2861 TYPE_DEPENDENT_P_VALID (variant
) = false;
2865 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2866 listed in RAISES. */
2869 build_exception_variant (tree type
, tree raises
)
2871 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2872 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2873 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2876 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2877 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2881 bind_template_template_parm (tree t
, tree newargs
)
2883 tree decl
= TYPE_NAME (t
);
2886 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2887 decl
= build_decl (input_location
,
2888 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2889 SET_DECL_TEMPLATE_PARM_P (decl
);
2891 /* These nodes have to be created to reflect new TYPE_DECL and template
2893 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2894 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2895 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2896 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2898 TREE_TYPE (decl
) = t2
;
2899 TYPE_NAME (t2
) = decl
;
2900 TYPE_STUB_DECL (t2
) = decl
;
2903 if (any_template_arguments_need_structural_equality_p (newargs
))
2904 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2906 TYPE_CANONICAL (t2
) = canonical_type_parameter (t2
);
2911 /* Called from count_trees via walk_tree. */
2914 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2924 /* Debugging function for measuring the rough complexity of a tree
2928 count_trees (tree t
)
2931 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2935 /* Called from verify_stmt_tree via walk_tree. */
2938 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2941 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2942 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2945 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2948 /* If this statement is already present in the hash table, then
2949 there is a circularity in the statement tree. */
2950 gcc_assert (!statements
->find (t
));
2952 slot
= statements
->find_slot (t
, INSERT
);
2958 /* Debugging function to check that the statement T has not been
2959 corrupted. For now, this function simply checks that T contains no
2963 verify_stmt_tree (tree t
)
2965 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2966 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2969 /* Check if the type T depends on a type with no linkage and if so,
2970 return it. If RELAXED_P then do not consider a class type declared
2971 within a vague-linkage function to have no linkage. Remember:
2972 no-linkage is not the same as internal-linkage. */
2975 no_linkage_check (tree t
, bool relaxed_p
)
2979 /* Lambda types that don't have mangling scope have no linkage. We
2980 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2981 when we get here from pushtag none of the lambda information is
2982 set up yet, so we want to assume that the lambda has linkage and
2983 fix it up later if not. We need to check this even in templates so
2984 that we properly handle a lambda-expression in the signature. */
2985 if (LAMBDA_TYPE_P (t
)
2986 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2988 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2993 /* Otherwise there's no point in checking linkage on template functions; we
2994 can't know their complete types. */
2995 if (processing_template_decl
)
2998 switch (TREE_CODE (t
))
3001 if (TYPE_PTRMEMFUNC_P (t
))
3005 if (!CLASS_TYPE_P (t
))
3009 /* Only treat unnamed types as having no linkage if they're at
3010 namespace scope. This is core issue 966. */
3011 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
3014 for (r
= CP_TYPE_CONTEXT (t
); ; )
3016 /* If we're a nested type of a !TREE_PUBLIC class, we might not
3017 have linkage, or we might just be in an anonymous namespace.
3018 If we're in a TREE_PUBLIC class, we have linkage. */
3019 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
3020 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
3021 else if (TREE_CODE (r
) == FUNCTION_DECL
)
3023 if (!relaxed_p
|| !vague_linkage_p (r
))
3026 r
= CP_DECL_CONTEXT (r
);
3036 case REFERENCE_TYPE
:
3038 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3042 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
3046 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
3051 tree parm
= TYPE_ARG_TYPES (t
);
3052 if (TREE_CODE (t
) == METHOD_TYPE
)
3053 /* The 'this' pointer isn't interesting; a method has the same
3054 linkage (or lack thereof) as its enclosing class. */
3055 parm
= TREE_CHAIN (parm
);
3057 parm
&& parm
!= void_list_node
;
3058 parm
= TREE_CHAIN (parm
))
3060 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
3064 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3072 extern int depth_reached
;
3075 cxx_print_statistics (void)
3077 print_template_statistics ();
3078 if (GATHER_STATISTICS
)
3079 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
3083 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3084 (which is an ARRAY_TYPE). This counts only elements of the top
3088 array_type_nelts_top (tree type
)
3090 return fold_build2_loc (input_location
,
3091 PLUS_EXPR
, sizetype
,
3092 array_type_nelts (type
),
3096 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3097 (which is an ARRAY_TYPE). This one is a recursive count of all
3098 ARRAY_TYPEs that are clumped together. */
3101 array_type_nelts_total (tree type
)
3103 tree sz
= array_type_nelts_top (type
);
3104 type
= TREE_TYPE (type
);
3105 while (TREE_CODE (type
) == ARRAY_TYPE
)
3107 tree n
= array_type_nelts_top (type
);
3108 sz
= fold_build2_loc (input_location
,
3109 MULT_EXPR
, sizetype
, sz
, n
);
3110 type
= TREE_TYPE (type
);
3117 splay_tree target_remap
;
3118 bool clear_location
;
3121 /* Called from break_out_target_exprs via mapcar. */
3124 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
3126 bot_data
&data
= *(bot_data
*)data_
;
3127 splay_tree target_remap
= data
.target_remap
;
3130 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
3132 /* There can't be any TARGET_EXPRs or their slot variables below this
3133 point. But we must make a copy, in case subsequent processing
3134 alters any part of it. For example, during gimplification a cast
3135 of the form (T) &X::f (where "f" is a member function) will lead
3136 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3138 *tp
= unshare_expr (t
);
3141 if (TREE_CODE (t
) == TARGET_EXPR
)
3145 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3147 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3148 tf_warning_or_error
);
3149 if (u
== error_mark_node
)
3151 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3152 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3155 u
= force_target_expr (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3156 tf_warning_or_error
);
3158 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3159 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3160 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3161 TARGET_EXPR_ELIDING_P (u
) = TARGET_EXPR_ELIDING_P (t
);
3163 /* Map the old variable to the new one. */
3164 splay_tree_insert (target_remap
,
3165 (splay_tree_key
) TREE_OPERAND (t
, 0),
3166 (splay_tree_value
) TREE_OPERAND (u
, 0));
3168 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3169 data
.clear_location
);
3170 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3171 return error_mark_node
;
3173 if (data
.clear_location
)
3174 SET_EXPR_LOCATION (u
, input_location
);
3176 /* Replace the old expression with the new version. */
3178 /* We don't have to go below this point; the recursive call to
3179 break_out_target_exprs will have handled anything below this
3184 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3187 splay_tree_node n
= splay_tree_lookup (target_remap
,
3188 (splay_tree_key
) t
);
3191 *tp
= (tree
)n
->value
;
3196 copy_tree_r (tp
, walk_subtrees
, NULL
);
3197 splay_tree_insert (target_remap
,
3199 (splay_tree_value
)*tp
);
3200 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3201 splay_tree_insert (target_remap
,
3202 (splay_tree_key
)*tp
,
3203 (splay_tree_value
)*tp
);
3207 if (TREE_CODE (*tp
) == DECL_EXPR
3208 && VAR_P (DECL_EXPR_DECL (*tp
))
3209 && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp
))
3210 && !TREE_STATIC (DECL_EXPR_DECL (*tp
)))
3214 = splay_tree_lookup (target_remap
,
3215 (splay_tree_key
) DECL_EXPR_DECL (*tp
));
3217 t
= (tree
) n
->value
;
3220 t
= create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp
)));
3221 DECL_INITIAL (t
) = DECL_INITIAL (DECL_EXPR_DECL (*tp
));
3222 splay_tree_insert (target_remap
,
3223 (splay_tree_key
) DECL_EXPR_DECL (*tp
),
3224 (splay_tree_value
) t
);
3226 copy_tree_r (tp
, walk_subtrees
, NULL
);
3227 DECL_EXPR_DECL (*tp
) = t
;
3228 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3229 SET_EXPR_LOCATION (*tp
, input_location
);
3232 if (TREE_CODE (*tp
) == BIND_EXPR
&& BIND_EXPR_VARS (*tp
))
3234 copy_tree_r (tp
, walk_subtrees
, NULL
);
3235 for (tree
*p
= &BIND_EXPR_VARS (*tp
); *p
; p
= &DECL_CHAIN (*p
))
3237 gcc_assert (VAR_P (*p
) && DECL_ARTIFICIAL (*p
) && !TREE_STATIC (*p
));
3238 tree t
= create_temporary_var (TREE_TYPE (*p
));
3239 DECL_INITIAL (t
) = DECL_INITIAL (*p
);
3240 DECL_CHAIN (t
) = DECL_CHAIN (*p
);
3241 splay_tree_insert (target_remap
, (splay_tree_key
) *p
,
3242 (splay_tree_value
) t
);
3245 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3246 SET_EXPR_LOCATION (*tp
, input_location
);
3250 /* Make a copy of this node. */
3251 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3252 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3253 if (!processing_template_decl
)
3254 set_flags_from_callee (*tp
);
3255 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3256 SET_EXPR_LOCATION (*tp
, input_location
);
3260 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3261 DATA is really a splay-tree mapping old variables to new
3265 bot_replace (tree
* t
, int */
*walk_subtrees*/
, void* data_
)
3267 bot_data
&data
= *(bot_data
*)data_
;
3268 splay_tree target_remap
= data
.target_remap
;
3272 splay_tree_node n
= splay_tree_lookup (target_remap
,
3273 (splay_tree_key
) *t
);
3275 *t
= (tree
) n
->value
;
3277 else if (TREE_CODE (*t
) == PARM_DECL
3278 && DECL_NAME (*t
) == this_identifier
3279 && !DECL_CONTEXT (*t
))
3281 /* In an NSDMI we need to replace the 'this' parameter we used for
3282 parsing with the real one for this function. */
3283 *t
= current_class_ptr
;
3285 else if (TREE_CODE (*t
) == CONVERT_EXPR
3286 && CONVERT_EXPR_VBASE_PATH (*t
))
3288 /* In an NSDMI build_base_path defers building conversions to morally
3289 virtual bases, and we handle it here. */
3290 tree basetype
= TREE_TYPE (*t
);
3291 *t
= convert_to_base (TREE_OPERAND (*t
, 0), basetype
,
3292 /*check_access=*/false, /*nonnull=*/true,
3293 tf_warning_or_error
);
3299 /* When we parse a default argument expression, we may create
3300 temporary variables via TARGET_EXPRs. When we actually use the
3301 default-argument expression, we make a copy of the expression
3302 and replace the temporaries with appropriate local versions.
3304 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3308 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3310 static int target_remap_count
;
3311 static splay_tree target_remap
;
3313 /* We shouldn't be called on templated trees, nor do we want to
3315 gcc_checking_assert (!processing_template_decl
);
3317 if (!target_remap_count
++)
3318 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3319 /*splay_tree_delete_key_fn=*/NULL
,
3320 /*splay_tree_delete_value_fn=*/NULL
);
3321 bot_data data
= { target_remap
, clear_location
};
3322 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3323 t
= error_mark_node
;
3324 if (cp_walk_tree (&t
, bot_replace
, &data
, NULL
) == error_mark_node
)
3325 t
= error_mark_node
;
3327 if (!--target_remap_count
)
3329 splay_tree_delete (target_remap
);
3330 target_remap
= NULL
;
3336 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3337 which we expect to have type TYPE. */
3340 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3342 if (index
== NULL_TREE
)
3343 /* Can't refer to a particular member of a vector. */
3345 else if (TREE_CODE (index
) == INTEGER_CST
)
3346 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3348 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3349 /*reference*/false, tf_none
);
3352 tree objtype
= TREE_TYPE (obj
);
3353 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3355 /* When the destination object refers to a flexible array member
3356 verify that it matches the type of the source object except
3357 for its domain and qualifiers. */
3358 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3359 TYPE_MAIN_VARIANT (objtype
),
3360 COMPARE_REDECLARATION
));
3363 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3369 struct replace_placeholders_t
3371 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3372 tree exp
; /* The outermost exp. */
3373 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3374 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3377 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3378 build up subexpressions as we go deeper. */
3381 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3383 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3386 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3388 *walk_subtrees
= false;
3392 switch (TREE_CODE (*t
))
3394 case PLACEHOLDER_EXPR
:
3397 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3399 x
= TREE_OPERAND (x
, 0))
3400 gcc_assert (handled_component_p (x
));
3401 *t
= unshare_expr (x
);
3402 *walk_subtrees
= false;
3409 constructor_elt
*ce
;
3410 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3411 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3412 other than the d->exp one, those have PLACEHOLDER_EXPRs
3413 related to another object. */
3414 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3416 || d
->pset
->add (*t
))
3418 *walk_subtrees
= false;
3421 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3423 tree
*valp
= &ce
->value
;
3424 tree type
= TREE_TYPE (*valp
);
3427 /* Elements with RANGE_EXPR index shouldn't have any
3428 placeholders in them. */
3429 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3432 if (TREE_CODE (*valp
) == CONSTRUCTOR
3433 && AGGREGATE_TYPE_P (type
))
3435 /* If we're looking at the initializer for OBJ, then build
3436 a sub-object reference. If we're looking at an
3437 initializer for another object, just pass OBJ down. */
3438 if (same_type_ignoring_top_level_qualifiers_p
3439 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3440 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3441 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3442 valp
= &TARGET_EXPR_INITIAL (*valp
);
3445 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3448 *walk_subtrees
= false;
3453 if (d
->pset
->add (*t
))
3454 *walk_subtrees
= false;
3461 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3462 a PLACEHOLDER_EXPR has been encountered. */
3465 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3467 /* This is only relevant for C++14. */
3468 if (cxx_dialect
< cxx14
)
3471 /* If the object isn't a (member of a) class, do nothing. */
3473 while (handled_component_p (op0
))
3474 op0
= TREE_OPERAND (op0
, 0);
3475 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3479 if (TREE_CODE (exp
) == TARGET_EXPR
)
3480 tp
= &TARGET_EXPR_INITIAL (exp
);
3481 hash_set
<tree
> pset
;
3482 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3483 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3485 *seen_p
= data
.seen
;
3489 /* Callback function for find_placeholders. */
3492 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3494 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3496 *walk_subtrees
= false;
3500 switch (TREE_CODE (*t
))
3502 case PLACEHOLDER_EXPR
:
3506 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3507 *walk_subtrees
= false;
3517 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3518 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3521 find_placeholders (tree exp
)
3523 /* This is only relevant for C++14. */
3524 if (cxx_dialect
< cxx14
)
3527 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3530 /* Similar to `build_nt', but for template definitions of dependent
3534 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3541 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3545 t
= make_node (code
);
3546 SET_EXPR_LOCATION (t
, loc
);
3547 length
= TREE_CODE_LENGTH (code
);
3549 for (i
= 0; i
< length
; i
++)
3550 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3556 /* Similar to `build', but for template definitions. */
3559 build_min (enum tree_code code
, tree tt
, ...)
3566 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3570 t
= make_node (code
);
3571 length
= TREE_CODE_LENGTH (code
);
3574 for (i
= 0; i
< length
; i
++)
3576 tree x
= va_arg (p
, tree
);
3577 TREE_OPERAND (t
, i
) = x
;
3578 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3579 TREE_SIDE_EFFECTS (t
) = 1;
3587 /* Similar to `build', but for template definitions of non-dependent
3588 expressions. NON_DEP is the non-dependent expression that has been
3592 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3599 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3601 va_start (p
, non_dep
);
3603 if (REFERENCE_REF_P (non_dep
))
3604 non_dep
= TREE_OPERAND (non_dep
, 0);
3606 t
= make_node (code
);
3607 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3608 length
= TREE_CODE_LENGTH (code
);
3609 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3610 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3612 for (i
= 0; i
< length
; i
++)
3614 tree x
= va_arg (p
, tree
);
3615 TREE_OPERAND (t
, i
) = x
;
3616 if (x
&& !TYPE_P (x
))
3617 TREE_SIDE_EFFECTS (t
) |= TREE_SIDE_EFFECTS (x
);
3621 return convert_from_reference (t
);
3624 /* Similar to build_min_nt, but call expressions */
3627 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3632 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3633 CALL_EXPR_FN (ret
) = fn
;
3634 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3635 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3636 CALL_EXPR_ARG (ret
, ix
) = t
;
3641 /* Similar to `build_min_nt_call_vec', but for template definitions of
3642 non-dependent expressions. NON_DEP is the non-dependent expression
3643 that has been built. */
3646 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3648 tree t
= build_min_nt_call_vec (fn
, argvec
);
3649 if (REFERENCE_REF_P (non_dep
))
3650 non_dep
= TREE_OPERAND (non_dep
, 0);
3651 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3652 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3654 for (tree x
: *argvec
)
3655 if (x
&& !TYPE_P (x
))
3656 TREE_SIDE_EFFECTS (t
) |= TREE_SIDE_EFFECTS (x
);
3657 return convert_from_reference (t
);
3660 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3661 a call to an operator overload. OP is the operator that has been
3662 overloaded. NON_DEP is the non-dependent expression that's been built,
3663 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3664 the overload that NON_DEP is calling. */
3667 build_min_non_dep_op_overload (enum tree_code op
,
3672 int nargs
, expected_nargs
;
3673 tree fn
, call
, obj
= NULL_TREE
;
3675 non_dep
= extract_call_expr (non_dep
);
3677 nargs
= call_expr_nargs (non_dep
);
3679 expected_nargs
= cp_tree_code_length (op
);
3680 if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
3681 /* For ARRAY_REF, operator[] is either a non-static member or newly
3682 static member, never out of class and for the static member case
3683 if user uses single index the operator[] needs to have a single
3684 argument as well, but the function is called with 2 - the object
3685 it is invoked on and the index. */
3687 expected_nargs
-= 1;
3688 if ((op
== POSTINCREMENT_EXPR
3689 || op
== POSTDECREMENT_EXPR
)
3690 /* With -fpermissive non_dep could be operator++(). */
3691 && (!flag_permissive
|| nargs
!= expected_nargs
))
3692 expected_nargs
+= 1;
3693 gcc_assert (nargs
== expected_nargs
);
3696 va_start (p
, overload
);
3698 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3701 if (op
== ARRAY_REF
)
3702 obj
= va_arg (p
, tree
);
3703 for (int i
= 0; i
< nargs
; i
++)
3705 tree arg
= va_arg (p
, tree
);
3706 vec_safe_push (args
, arg
);
3709 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3711 tree object
= va_arg (p
, tree
);
3712 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3713 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3714 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3715 object
, method
, NULL_TREE
);
3716 for (int i
= 0; i
< nargs
; i
++)
3718 tree arg
= va_arg (p
, tree
);
3719 vec_safe_push (args
, arg
);
3726 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3728 tree call_expr
= extract_call_expr (call
);
3729 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3730 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3731 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3732 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3735 return keep_unused_object_arg (call
, obj
, overload
);
3739 /* Similar to above build_min_non_dep_op_overload, but arguments
3740 are taken from ARGS vector. */
3743 build_min_non_dep_op_overload (tree non_dep
, tree overload
, tree object
,
3744 vec
<tree
, va_gc
> *args
)
3746 non_dep
= extract_call_expr (non_dep
);
3748 unsigned int nargs
= call_expr_nargs (non_dep
);
3750 if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3752 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3753 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3754 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3755 object
, method
, NULL_TREE
);
3758 gcc_assert (vec_safe_length (args
) == nargs
);
3760 tree call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3762 tree call_expr
= extract_call_expr (call
);
3763 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3764 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3765 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3766 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3769 return keep_unused_object_arg (call
, object
, overload
);
3773 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3776 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3778 unsigned len
= vec_safe_length (old_vec
);
3779 gcc_assert (idx
<= len
);
3781 vec
<tree
, va_gc
> *new_vec
= NULL
;
3782 vec_alloc (new_vec
, len
+ 1);
3785 for (i
= 0; i
< len
; ++i
)
3788 new_vec
->quick_push (elt
);
3789 new_vec
->quick_push ((*old_vec
)[i
]);
3792 new_vec
->quick_push (elt
);
3798 get_type_decl (tree t
)
3800 if (TREE_CODE (t
) == TYPE_DECL
)
3803 return TYPE_STUB_DECL (t
);
3804 gcc_assert (t
== error_mark_node
);
3808 /* Returns the namespace that contains DECL, whether directly or
3812 decl_namespace_context (tree decl
)
3816 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3818 else if (TYPE_P (decl
))
3819 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3821 decl
= CP_DECL_CONTEXT (decl
);
3825 /* Returns true if decl is within an anonymous namespace, however deeply
3826 nested, or false otherwise. */
3829 decl_anon_ns_mem_p (tree decl
)
3831 return !TREE_PUBLIC (decl_namespace_context (decl
));
3834 /* Returns true if the enclosing scope of DECL has internal or no linkage. */
3837 decl_internal_context_p (const_tree decl
)
3839 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3841 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3843 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3845 decl
= CP_DECL_CONTEXT (decl
);
3847 return !TREE_PUBLIC (decl
);
3850 /* Subroutine of cp_tree_equal: t1 and t2 are two CALL_EXPRs.
3851 Return whether their CALL_EXPR_FNs are equivalent. */
3854 called_fns_equal (tree t1
, tree t2
)
3856 /* Core 1321: dependent names are equivalent even if the overload sets
3857 are different. But do compare explicit template arguments. */
3858 tree name1
= call_expr_dependent_name (t1
);
3859 tree name2
= call_expr_dependent_name (t2
);
3860 t1
= CALL_EXPR_FN (t1
);
3861 t2
= CALL_EXPR_FN (t2
);
3864 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3869 /* FIXME dependent_name currently returns an unqualified name regardless
3870 of whether the function was named with a qualified- or unqualified-id.
3871 Until that's fixed, check that we aren't looking at overload sets from
3872 different scopes. */
3873 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3874 && (DECL_CONTEXT (get_first_fn (t1
))
3875 != DECL_CONTEXT (get_first_fn (t2
))))
3878 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3879 targs1
= TREE_OPERAND (t1
, 1);
3880 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3881 targs2
= TREE_OPERAND (t2
, 1);
3882 return cp_tree_equal (targs1
, targs2
);
3885 return cp_tree_equal (t1
, t2
);
3888 bool comparing_override_contracts
;
3890 /* In a component reference, return the innermost object of
3891 the postfix-expression. */
3894 get_innermost_component (tree t
)
3896 gcc_assert (TREE_CODE (t
) == COMPONENT_REF
);
3897 while (TREE_CODE (t
) == COMPONENT_REF
)
3898 t
= TREE_OPERAND (t
, 0);
3902 /* Returns true if T is a possibly converted 'this' or '*this' expression. */
3905 is_this_expression (tree t
)
3907 t
= get_innermost_component (t
);
3908 /* See through deferences and no-op conversions. */
3909 if (INDIRECT_REF_P (t
))
3910 t
= TREE_OPERAND (t
, 0);
3911 if (TREE_CODE (t
) == NOP_EXPR
)
3912 t
= TREE_OPERAND (t
, 0);
3913 return is_this_parameter (t
);
3917 comparing_this_references (tree t1
, tree t2
)
3919 return is_this_expression (t1
) && is_this_expression (t2
);
3923 equivalent_member_references (tree t1
, tree t2
)
3925 if (!comparing_this_references (t1
, t2
))
3927 t1
= TREE_OPERAND (t1
, 1);
3928 t2
= TREE_OPERAND (t2
, 1);
3932 /* Return truthvalue of whether T1 is the same tree structure as T2.
3933 Return 1 if they are the same. Return 0 if they are different. */
3936 cp_tree_equal (tree t1
, tree t2
)
3938 enum tree_code code1
, code2
;
3945 code1
= TREE_CODE (t1
);
3946 code2
= TREE_CODE (t2
);
3951 if (CONSTANT_CLASS_P (t1
)
3952 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3958 /* There's only a single VOID_CST node, so we should never reach
3963 return tree_int_cst_equal (t1
, t2
);
3966 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3969 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3970 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3971 TREE_STRING_LENGTH (t1
));
3974 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3975 TREE_FIXED_CST (t2
));
3978 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3979 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3982 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3985 /* We need to do this when determining whether or not two
3986 non-type pointer to member function template arguments
3988 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3989 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3994 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3996 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3997 if (!cp_tree_equal (field
, elt2
->index
)
3998 || !cp_tree_equal (value
, elt2
->value
))
4005 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
4007 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
4009 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
4012 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4016 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
4019 if (!called_fns_equal (t1
, t2
))
4022 call_expr_arg_iterator iter1
, iter2
;
4023 init_call_expr_arg_iterator (t1
, &iter1
);
4024 init_call_expr_arg_iterator (t2
, &iter2
);
4025 if (iter1
.n
!= iter2
.n
)
4028 while (more_call_expr_args_p (&iter1
))
4030 tree arg1
= next_call_expr_arg (&iter1
);
4031 tree arg2
= next_call_expr_arg (&iter2
);
4033 gcc_checking_assert (arg1
&& arg2
);
4034 if (!cp_tree_equal (arg1
, arg2
))
4043 tree o1
= TREE_OPERAND (t1
, 0);
4044 tree o2
= TREE_OPERAND (t2
, 0);
4046 /* Special case: if either target is an unallocated VAR_DECL,
4047 it means that it's going to be unified with whatever the
4048 TARGET_EXPR is really supposed to initialize, so treat it
4049 as being equivalent to anything. */
4050 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
4051 && !DECL_RTL_SET_P (o1
))
4053 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
4054 && !DECL_RTL_SET_P (o2
))
4056 else if (!cp_tree_equal (o1
, o2
))
4059 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4063 /* For comparing uses of parameters in late-specified return types
4064 with an out-of-class definition of the function, but can also come
4065 up for expressions that involve 'this' in a member function
4068 if (comparing_specializations
4069 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
4070 /* When comparing hash table entries, only an exact match is
4071 good enough; we don't want to replace 'this' with the
4072 version from another function. But be more flexible
4073 with parameters with identical contexts. */
4076 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4078 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
4080 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
4082 if (DECL_ARTIFICIAL (t1
)
4083 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
4084 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
4094 case IDENTIFIER_NODE
:
4097 case DEFERRED_PARSE
:
4101 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
4102 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
4103 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
4104 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
4105 BASELINK_FUNCTIONS (t2
)));
4107 case TEMPLATE_PARM_INDEX
:
4108 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
4109 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
4110 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
4111 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
4112 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
4113 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
4115 case TEMPLATE_ID_EXPR
:
4116 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4118 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
4122 case CONSTRAINT_INFO
:
4123 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
4124 CI_ASSOCIATED_CONSTRAINTS (t2
));
4127 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
4128 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
4129 CHECK_CONSTR_ARGS (t2
)));
4132 /* These are template args. Really we should be getting the
4133 caller to do this as it knows it to be true. */
4134 if (!comp_template_args (t1
, t2
))
4141 tree o1
= TREE_OPERAND (t1
, 0);
4142 tree o2
= TREE_OPERAND (t2
, 0);
4144 if (code1
== SIZEOF_EXPR
)
4146 if (SIZEOF_EXPR_TYPE_P (t1
))
4147 o1
= TREE_TYPE (o1
);
4148 if (SIZEOF_EXPR_TYPE_P (t2
))
4149 o2
= TREE_TYPE (o2
);
4151 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
4154 if (TREE_CODE (o1
) != TREE_CODE (o2
))
4157 if (ARGUMENT_PACK_P (o1
))
4158 return template_args_equal (o1
, o2
);
4159 else if (TYPE_P (o1
))
4160 return same_type_p (o1
, o2
);
4162 return cp_tree_equal (o1
, o2
);
4167 tree t1_op1
, t2_op1
;
4169 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4172 t1_op1
= TREE_OPERAND (t1
, 1);
4173 t2_op1
= TREE_OPERAND (t2
, 1);
4174 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
4177 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
4181 /* Two pointer-to-members are the same if they point to the same
4182 field or function in the same class. */
4183 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
4186 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
4190 /* Two overloads. Must be exactly the same set of decls. */
4191 lkp_iterator
first (t1
);
4192 lkp_iterator
second (t2
);
4194 for (; first
&& second
; ++first
, ++second
)
4195 if (*first
!= *second
)
4197 return !(first
|| second
);
4201 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
4203 return cp_tree_equal (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
4204 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
4206 case NON_LVALUE_EXPR
:
4207 case VIEW_CONVERT_EXPR
:
4208 /* Used for location wrappers with possibly NULL types. */
4209 if (!TREE_TYPE (t1
) || !TREE_TYPE (t2
))
4211 if (TREE_TYPE (t1
) || TREE_TYPE (t2
))
4218 case STATIC_CAST_EXPR
:
4219 case REINTERPRET_CAST_EXPR
:
4220 case CONST_CAST_EXPR
:
4221 case DYNAMIC_CAST_EXPR
:
4222 case IMPLICIT_CONV_EXPR
:
4226 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4228 /* Now compare operands as usual. */
4231 case DEFERRED_NOEXCEPT
:
4232 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
4233 DEFERRED_NOEXCEPT_PATTERN (t2
))
4234 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
4235 DEFERRED_NOEXCEPT_ARGS (t2
)));
4238 /* Two lambda-expressions are never considered equivalent. */
4241 case TYPE_ARGUMENT_PACK
:
4242 case NONTYPE_ARGUMENT_PACK
:
4244 tree p1
= ARGUMENT_PACK_ARGS (t1
);
4245 tree p2
= ARGUMENT_PACK_ARGS (t2
);
4246 int len
= TREE_VEC_LENGTH (p1
);
4247 if (TREE_VEC_LENGTH (p2
) != len
)
4250 for (int ix
= 0; ix
!= len
; ix
++)
4251 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
4252 TREE_VEC_ELT (p2
, ix
)))
4257 case EXPR_PACK_EXPANSION
:
4258 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
4259 PACK_EXPANSION_PATTERN (t2
)))
4261 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
4262 PACK_EXPANSION_EXTRA_ARGS (t2
)))
4267 /* If we're comparing contract conditions of overrides, member references
4268 compare equal if they designate the same member. */
4269 if (comparing_override_contracts
)
4270 return equivalent_member_references (t1
, t2
);
4277 switch (TREE_CODE_CLASS (code1
))
4281 case tcc_comparison
:
4282 case tcc_expression
:
4287 int n
= cp_tree_operand_length (t1
);
4288 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
4289 && n
!= TREE_OPERAND_LENGTH (t2
))
4292 for (int i
= 0; i
< n
; ++i
)
4293 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
4300 return same_type_p (t1
, t2
);
4306 /* We can get here with --disable-checking. */
4310 /* The type of ARG when used as an lvalue. */
4313 lvalue_type (tree arg
)
4315 tree type
= TREE_TYPE (arg
);
4319 /* The type of ARG for printing error messages; denote lvalues with
4323 error_type (tree arg
)
4325 tree type
= TREE_TYPE (arg
);
4327 if (TREE_CODE (type
) == ARRAY_TYPE
)
4329 else if (TREE_CODE (type
) == ERROR_MARK
)
4331 else if (lvalue_p (arg
))
4332 type
= build_reference_type (lvalue_type (arg
));
4333 else if (MAYBE_CLASS_TYPE_P (type
))
4334 type
= lvalue_type (arg
);
4339 /* Does FUNCTION use a variable-length argument list? */
4342 varargs_function_p (const_tree function
)
4344 return stdarg_p (TREE_TYPE (function
));
4347 /* Returns 1 if decl is a member of a class. */
4350 member_p (const_tree decl
)
4352 const_tree
const ctx
= DECL_CONTEXT (decl
);
4353 return (ctx
&& TYPE_P (ctx
));
4356 /* Create a placeholder for member access where we don't actually have an
4357 object that the access is against. For a general declval<T> equivalent,
4358 use build_stub_object instead. */
4361 build_dummy_object (tree type
)
4363 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4364 return cp_build_fold_indirect_ref (decl
);
4367 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4368 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4369 binfo path from current_class_type to TYPE, or 0. */
4372 maybe_dummy_object (tree type
, tree
* binfop
)
4376 tree current
= current_nonlambda_class_type ();
4379 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4380 tf_warning_or_error
)))
4384 /* Reference from a nested class member function. */
4386 binfo
= TYPE_BINFO (type
);
4392 /* current_class_ref might not correspond to current_class_type if
4393 we're in tsubst_default_argument or a lambda-declarator; in either
4394 case, we want to use current_class_ref if it matches CONTEXT. */
4395 tree ctype
= current_class_ref
? TREE_TYPE (current_class_ref
) : NULL_TREE
;
4397 && same_type_ignoring_top_level_qualifiers_p (ctype
, context
))
4398 decl
= current_class_ref
;
4401 /* Return a dummy object whose cv-quals are consistent with (the
4402 non-lambda) 'this' if available. */
4405 int quals
= TYPE_UNQUALIFIED
;
4406 if (tree lambda
= CLASSTYPE_LAMBDA_EXPR (ctype
))
4408 if (tree cap
= lambda_expr_this_capture (lambda
, false))
4409 quals
= cp_type_quals (TREE_TYPE (TREE_TYPE (cap
)));
4412 quals
= cp_type_quals (ctype
);
4413 context
= cp_build_qualified_type (context
, quals
);
4415 decl
= build_dummy_object (context
);
4421 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4424 is_dummy_object (const_tree ob
)
4426 if (INDIRECT_REF_P (ob
))
4427 ob
= TREE_OPERAND (ob
, 0);
4428 return (TREE_CODE (ob
) == CONVERT_EXPR
4429 && TREE_OPERAND (ob
, 0) == void_node
);
4432 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4435 is_byte_access_type (tree type
)
4437 type
= TYPE_MAIN_VARIANT (type
);
4438 if (type
== char_type_node
4439 || type
== unsigned_char_type_node
)
4442 return (TREE_CODE (type
) == ENUMERAL_TYPE
4443 && TYPE_CONTEXT (type
) == std_node
4444 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4447 /* Returns true if TYPE is unsigned char or std::byte. */
4450 is_byte_access_type_not_plain_char (tree type
)
4452 type
= TYPE_MAIN_VARIANT (type
);
4453 if (type
== char_type_node
)
4456 return is_byte_access_type (type
);
4459 /* Returns 1 iff type T is something we want to treat as a scalar type for
4460 the purpose of deciding whether it is trivial/POD/standard-layout. */
4463 scalarish_type_p (const_tree t
)
4465 if (t
== error_mark_node
)
4468 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4471 /* Returns true iff T requires non-trivial default initialization. */
4474 type_has_nontrivial_default_init (const_tree t
)
4476 t
= strip_array_types (CONST_CAST_TREE (t
));
4478 if (CLASS_TYPE_P (t
))
4479 return TYPE_HAS_COMPLEX_DFLT (t
);
4484 /* Track classes with only deleted copy/move constructors so that we can warn
4485 if they are used in call/return by value. */
4487 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4489 remember_deleted_copy (const_tree t
)
4491 if (!deleted_copy_types
)
4492 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4493 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4496 maybe_warn_parm_abi (tree t
, location_t loc
)
4498 if (!deleted_copy_types
4499 || !deleted_copy_types
->contains (t
))
4502 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4503 && classtype_has_non_deleted_move_ctor (t
))
4506 auto_diagnostic_group d
;
4507 if (flag_abi_version
> 12)
4508 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4509 "the calling convention for %qT, which was "
4510 "accidentally changed in 8.1", t
);
4512 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) "
4513 "accidentally changes the calling convention for %qT",
4516 inform (location_of (t
), " declared here");
4520 auto_diagnostic_group d
;
4521 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4522 "%<-fabi-version=13%> (GCC 8.2)", t
))
4523 inform (location_of (t
), " because all of its copy and move "
4524 "constructors are deleted");
4527 /* Returns true iff copying an object of type T (including via move
4528 constructor) is non-trivial. That is, T has no non-trivial copy
4529 constructors and no non-trivial move constructors, and not all copy/move
4530 constructors are deleted. This function implements the ABI notion of
4531 non-trivial copy, which has diverged from the one in the standard. */
4534 type_has_nontrivial_copy_init (const_tree type
)
4536 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4538 if (CLASS_TYPE_P (t
))
4540 gcc_assert (COMPLETE_TYPE_P (t
));
4542 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4543 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4547 if (cxx_dialect
< cxx11
)
4548 /* No deleted functions before C++11. */
4551 /* Before ABI v12 we did a bitwise copy of types with only deleted
4552 copy/move constructors. */
4553 if (!abi_version_at_least (12)
4554 && !(warn_abi
&& abi_version_crosses (12)))
4557 bool saw_copy
= false;
4558 bool saw_non_deleted
= false;
4559 bool saw_non_deleted_move
= false;
4561 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4562 saw_copy
= saw_non_deleted
= true;
4563 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4566 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4567 /* [class.copy]/8 If the class definition declares a move
4568 constructor or move assignment operator, the implicitly declared
4569 copy constructor is defined as deleted.... */;
4571 /* Any other reason the implicitly-declared function would be
4572 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4574 saw_non_deleted
= true;
4577 if (!saw_non_deleted
)
4578 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4584 if (!DECL_DELETED_FN (fn
))
4586 /* Not deleted, therefore trivial. */
4587 saw_non_deleted
= true;
4591 else if (move_fn_p (fn
))
4592 if (!DECL_DELETED_FN (fn
))
4593 saw_non_deleted_move
= true;
4596 gcc_assert (saw_copy
);
4598 /* ABI v12 buggily ignored move constructors. */
4599 bool v11nontriv
= false;
4600 bool v12nontriv
= !saw_non_deleted
;
4601 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4602 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4603 : flag_abi_version
== 12 ? v12nontriv
4605 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4606 : warn_abi_version
== 12 ? v12nontriv
4608 if (nontriv
!= warn_nontriv
)
4609 remember_deleted_copy (t
);
4617 /* Returns 1 iff type T is a trivially copyable type, as defined in
4618 [basic.types] and [class]. */
4621 trivially_copyable_p (const_tree t
)
4623 t
= strip_array_types (CONST_CAST_TREE (t
));
4625 if (CLASS_TYPE_P (t
))
4626 return ((!TYPE_HAS_COPY_CTOR (t
)
4627 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4628 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4629 && (!TYPE_HAS_COPY_ASSIGN (t
)
4630 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4631 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4632 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4634 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4635 return scalarish_type_p (t
);
4638 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4642 trivial_type_p (const_tree t
)
4644 t
= strip_array_types (CONST_CAST_TREE (t
));
4646 if (CLASS_TYPE_P (t
))
4647 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4648 && trivially_copyable_p (t
));
4650 return scalarish_type_p (t
);
4653 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4656 pod_type_p (const_tree t
)
4658 /* This CONST_CAST is okay because strip_array_types returns its
4659 argument unmodified and we assign it to a const_tree. */
4660 t
= strip_array_types (CONST_CAST_TREE(t
));
4662 if (!CLASS_TYPE_P (t
))
4663 return scalarish_type_p (t
);
4664 else if (cxx_dialect
> cxx98
)
4665 /* [class]/10: A POD struct is a class that is both a trivial class and a
4666 standard-layout class, and has no non-static data members of type
4667 non-POD struct, non-POD union (or array of such types).
4669 We don't need to check individual members because if a member is
4670 non-std-layout or non-trivial, the class will be too. */
4671 return (std_layout_type_p (t
) && trivial_type_p (t
));
4673 /* The C++98 definition of POD is different. */
4674 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4677 /* Returns true iff T is POD for the purpose of layout, as defined in the
4681 layout_pod_type_p (const_tree t
)
4683 t
= strip_array_types (CONST_CAST_TREE (t
));
4685 if (CLASS_TYPE_P (t
))
4686 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4688 return scalarish_type_p (t
);
4691 /* Returns true iff T is a standard-layout type, as defined in
4695 std_layout_type_p (const_tree t
)
4697 t
= strip_array_types (CONST_CAST_TREE (t
));
4699 if (CLASS_TYPE_P (t
))
4700 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4702 return scalarish_type_p (t
);
4705 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4707 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4708 as defined in [meta.unary.prop]. */
4711 type_has_unique_obj_representations (const_tree t
)
4715 t
= strip_array_types (CONST_CAST_TREE (t
));
4717 if (!trivially_copyable_p (t
))
4720 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4721 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4723 switch (TREE_CODE (t
))
4727 case REFERENCE_TYPE
:
4728 /* If some backend has any paddings in these types, we should add
4729 a target hook for this and handle it there. */
4733 /* For bool values other than 0 and 1 should only appear with
4734 undefined behavior. */
4738 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4741 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4742 when storing long double values, so for that we have to return false.
4743 Other kinds of floating point values are questionable due to +.0/-.0
4744 and NaNs, let's play safe for now. */
4747 case FIXED_POINT_TYPE
:
4755 return type_has_unique_obj_representations (TREE_TYPE (t
));
4758 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4759 if (CLASS_TYPE_P (t
))
4761 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4762 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4770 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4771 if (TREE_CODE (field
) == FIELD_DECL
)
4774 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4775 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4781 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4783 if (CLASS_TYPE_P (t
))
4785 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4786 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4801 /* Helper function for type_has_unique_obj_representations. */
4804 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4806 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4807 if (TREE_CODE (field
) != FIELD_DECL
)
4809 /* For bases, can't use type_has_unique_obj_representations here, as in
4810 struct S { int i : 24; S (); };
4811 struct T : public S { int j : 8; T (); };
4812 S doesn't have unique obj representations, but T does. */
4813 else if (DECL_FIELD_IS_BASE (field
))
4815 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4819 else if (DECL_C_BIT_FIELD (field
) && !DECL_UNNAMED_BIT_FIELD (field
))
4821 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4822 if (!type_has_unique_obj_representations (btype
))
4825 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4829 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4830 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_UNNAMED_BIT_FIELD (field
))
4832 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4833 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4834 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4837 if (DECL_SIZE (field
))
4839 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4843 if (cur
!= wi::to_offset (sz
))
4849 /* Nonzero iff type T is a class template implicit specialization. */
4852 class_tmpl_impl_spec_p (const_tree t
)
4854 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4857 /* Returns 1 iff zero initialization of type T means actually storing
4861 zero_init_p (const_tree t
)
4863 /* This CONST_CAST is okay because strip_array_types returns its
4864 argument unmodified and we assign it to a const_tree. */
4865 t
= strip_array_types (CONST_CAST_TREE(t
));
4867 if (t
== error_mark_node
)
4870 /* NULL pointers to data members are initialized with -1. */
4871 if (TYPE_PTRDATAMEM_P (t
))
4874 /* Classes that contain types that can't be zero-initialized, cannot
4875 be zero-initialized themselves. */
4876 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4882 /* Returns true if the expression or initializer T is the result of
4883 zero-initialization for its type, taking pointers to members
4884 into consideration. */
4887 zero_init_expr_p (tree t
)
4889 tree type
= TREE_TYPE (t
);
4890 if (!type
|| uses_template_parms (type
))
4892 if (TYPE_PTRMEM_P (type
))
4893 return null_member_pointer_value_p (t
);
4894 if (TREE_CODE (t
) == CONSTRUCTOR
)
4896 if (COMPOUND_LITERAL_P (t
)
4897 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4898 /* Undigested, conversions might change the zeroness. */
4900 for (constructor_elt
&elt
: CONSTRUCTOR_ELTS (t
))
4902 if (TREE_CODE (type
) == UNION_TYPE
4903 && elt
.index
!= first_field (type
))
4905 if (!zero_init_expr_p (elt
.value
))
4910 if (zero_init_p (type
))
4911 return initializer_zerop (t
);
4915 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4916 non-type template parameter. If EXPLAIN, explain why not. */
4919 structural_type_p (tree t
, bool explain
)
4921 /* A structural type is one of the following: */
4923 /* a scalar type, or */
4924 if (SCALAR_TYPE_P (t
))
4926 /* an lvalue reference type, or */
4927 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4929 /* a literal class type with the following properties:
4930 - all base classes and non-static data members are public and non-mutable
4932 - the types of all bases classes and non-static data members are
4933 structural types or (possibly multi-dimensional) array thereof. */
4934 if (!CLASS_TYPE_P (t
))
4936 if (!literal_type_p (t
))
4939 explain_non_literal_class (t
);
4942 for (tree m
= next_aggregate_field (TYPE_FIELDS (t
)); m
;
4943 m
= next_aggregate_field (DECL_CHAIN (m
)))
4945 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4949 if (DECL_FIELD_IS_BASE (m
))
4950 inform (location_of (m
), "base class %qT is not public",
4953 inform (location_of (m
), "%qD is not public", m
);
4957 if (DECL_MUTABLE_P (m
))
4960 inform (location_of (m
), "%qD is mutable", m
);
4963 tree mtype
= strip_array_types (TREE_TYPE (m
));
4964 if (!structural_type_p (mtype
))
4968 inform (location_of (m
), "%qD has a non-structural type", m
);
4969 structural_type_p (mtype
, true);
4977 /* Partially handle the C++11 [[carries_dependency]] attribute.
4978 Just emit a different diagnostics when it is used on something the
4979 spec doesn't allow vs. where it allows and we just choose to ignore
4983 handle_carries_dependency_attribute (tree
*node
, tree name
,
4984 tree
ARG_UNUSED (args
),
4985 int ARG_UNUSED (flags
),
4988 if (TREE_CODE (*node
) != FUNCTION_DECL
4989 && TREE_CODE (*node
) != PARM_DECL
)
4991 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4992 "functions or parameters", name
);
4993 *no_add_attrs
= true;
4997 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4998 *no_add_attrs
= true;
5003 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
5004 warn_unused_result attribute. */
5007 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
5008 int /*flags*/, bool *no_add_attrs
)
5010 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
5012 error ("%qE attribute argument must be a string constant", name
);
5013 *no_add_attrs
= true;
5015 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5017 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
5018 && !DECL_CONSTRUCTOR_P (*node
))
5019 warning_at (DECL_SOURCE_LOCATION (*node
),
5020 OPT_Wattributes
, "%qE attribute applied to %qD with void "
5021 "return type", name
, *node
);
5023 else if (OVERLOAD_TYPE_P (*node
))
5027 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5028 "functions or to class or enumeration types", name
);
5029 *no_add_attrs
= true;
5034 /* Handle a C++20 "no_unique_address" attribute; arguments as in
5035 struct attribute_spec.handler. */
5037 handle_no_unique_addr_attribute (tree
* node
,
5043 if (TREE_CODE (*node
) == VAR_DECL
)
5045 DECL_MERGEABLE (*node
) = true;
5047 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5048 "non-static data members", name
);
5050 else if (TREE_CODE (*node
) != FIELD_DECL
)
5052 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5053 "non-static data members", name
);
5054 *no_add_attrs
= true;
5056 else if (DECL_C_BIT_FIELD (*node
))
5058 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
5059 "a bit-field", name
);
5060 *no_add_attrs
= true;
5066 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
5067 hot/cold attributes. */
5070 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
5071 int flags
, bool *no_add_attrs
)
5073 *no_add_attrs
= true;
5074 if (TREE_CODE (*node
) == LABEL_DECL
5075 || TREE_CODE (*node
) == FUNCTION_DECL
)
5078 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
5079 tree bname
= (is_attribute_p ("likely", name
)
5080 ? get_identifier ("hot") : get_identifier ("cold"));
5081 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5082 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
5083 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
5084 tree battr
= build_tree_list (bname
, NULL_TREE
);
5085 decl_attributes (node
, battr
, flags
);
5089 return error_mark_node
;
5092 /* Table of valid C++ attributes. */
5093 static const attribute_spec cxx_gnu_attributes
[] =
5095 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5096 affects_type_identity, handler, exclude } */
5097 { "init_priority", 1, 1, true, false, false, false,
5098 handle_init_priority_attribute
, NULL
},
5099 { "abi_tag", 1, -1, false, false, false, true,
5100 handle_abi_tag_attribute
, NULL
},
5103 const scoped_attribute_specs cxx_gnu_attribute_table
=
5105 "gnu", { cxx_gnu_attributes
}
5108 /* Table of C++ standard attributes. */
5109 static const attribute_spec std_attributes
[] =
5111 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5112 affects_type_identity, handler, exclude } */
5113 { "maybe_unused", 0, 0, false, false, false, false,
5114 handle_unused_attribute
, NULL
},
5115 { "nodiscard", 0, 1, false, false, false, false,
5116 handle_nodiscard_attribute
, NULL
},
5117 { "no_unique_address", 0, 0, true, false, false, false,
5118 handle_no_unique_addr_attribute
, NULL
},
5119 { "likely", 0, 0, false, false, false, false,
5120 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
5121 { "unlikely", 0, 0, false, false, false, false,
5122 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
5123 { "noreturn", 0, 0, true, false, false, false,
5124 handle_noreturn_attribute
, attr_noreturn_exclusions
},
5125 { "carries_dependency", 0, 0, true, false, false, false,
5126 handle_carries_dependency_attribute
, NULL
},
5127 { "pre", 0, -1, false, false, false, false,
5128 handle_contract_attribute
, NULL
},
5129 { "post", 0, -1, false, false, false, false,
5130 handle_contract_attribute
, NULL
}
5133 const scoped_attribute_specs std_attribute_table
=
5135 nullptr, { std_attributes
}
5138 /* Handle an "init_priority" attribute; arguments as in
5139 struct attribute_spec.handler. */
5141 handle_init_priority_attribute (tree
* node
,
5147 if (!SUPPORTS_INIT_PRIORITY
)
5148 /* Treat init_priority as an unrecognized attribute (mirroring
5149 __has_attribute) if the target doesn't support init priorities. */
5150 return error_mark_node
;
5152 tree initp_expr
= TREE_VALUE (args
);
5154 tree type
= TREE_TYPE (decl
);
5157 STRIP_NOPS (initp_expr
);
5158 initp_expr
= default_conversion (initp_expr
);
5160 initp_expr
= maybe_constant_value (initp_expr
);
5162 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
5164 error ("requested %<init_priority%> is not an integer constant");
5165 cxx_constant_value (initp_expr
);
5166 *no_add_attrs
= true;
5170 pri
= TREE_INT_CST_LOW (initp_expr
);
5172 type
= strip_array_types (type
);
5174 if (decl
== NULL_TREE
5176 || !TREE_STATIC (decl
)
5177 || DECL_EXTERNAL (decl
)
5178 || (TREE_CODE (type
) != RECORD_TYPE
5179 && TREE_CODE (type
) != UNION_TYPE
)
5180 /* Static objects in functions are initialized the
5181 first time control passes through that
5182 function. This is not precise enough to pin down an
5183 init_priority value, so don't allow it. */
5184 || current_function_decl
)
5186 error ("can only use %qE attribute on file-scope definitions "
5187 "of objects of class type", name
);
5188 *no_add_attrs
= true;
5192 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
5194 error ("requested %<init_priority%> %i is out of range [0, %i]",
5195 pri
, MAX_INIT_PRIORITY
);
5196 *no_add_attrs
= true;
5200 /* Check for init_priorities that are reserved for
5201 language and runtime support implementations.*/
5202 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5205 (0, "requested %<init_priority%> %i is reserved for internal use",
5209 SET_DECL_INIT_PRIORITY (decl
, pri
);
5210 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
5214 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
5215 and the new one has the tags in NEW_. Give an error if there are tags
5216 in NEW_ that weren't in OLD. */
5219 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
5221 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
5222 old
= TREE_VALUE (old
);
5223 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
5224 new_
= TREE_VALUE (new_
);
5226 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
5228 tree str
= TREE_VALUE (t
);
5229 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
5231 tree ostr
= TREE_VALUE (in
);
5232 if (cp_tree_equal (str
, ostr
))
5235 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
5241 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
5247 /* The abi_tag attribute with the name NAME was given ARGS. If they are
5248 ill-formed, give an error and return false; otherwise, return true. */
5251 check_abi_tag_args (tree args
, tree name
)
5255 error ("the %qE attribute requires arguments", name
);
5258 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
5260 tree elt
= TREE_VALUE (arg
);
5261 if (TREE_CODE (elt
) != STRING_CST
5262 || (!same_type_ignoring_top_level_qualifiers_p
5263 (strip_array_types (TREE_TYPE (elt
)),
5266 error ("arguments to the %qE attribute must be narrow string "
5270 const char *begin
= TREE_STRING_POINTER (elt
);
5271 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
5272 for (const char *p
= begin
; p
!= end
; ++p
)
5277 if (!ISALPHA (c
) && c
!= '_')
5279 error ("arguments to the %qE attribute must contain valid "
5280 "identifiers", name
);
5281 inform (input_location
, "%<%c%> is not a valid first "
5282 "character for an identifier", c
);
5286 else if (p
== end
- 1)
5287 gcc_assert (c
== 0);
5290 if (!ISALNUM (c
) && c
!= '_')
5292 error ("arguments to the %qE attribute must contain valid "
5293 "identifiers", name
);
5294 inform (input_location
, "%<%c%> is not a valid character "
5295 "in an identifier", c
);
5304 /* Handle an "abi_tag" attribute; arguments as in
5305 struct attribute_spec.handler. */
5308 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
5309 int flags
, bool* no_add_attrs
)
5311 if (!check_abi_tag_args (args
, name
))
5316 if (!OVERLOAD_TYPE_P (*node
))
5318 error ("%qE attribute applied to non-class, non-enum type %qT",
5322 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
5324 error ("%qE attribute applied to %qT after its definition",
5328 else if (CLASS_TYPE_P (*node
)
5329 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
5331 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5332 "template instantiation %qT", name
, *node
);
5335 else if (CLASS_TYPE_P (*node
)
5336 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
5338 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5339 "template specialization %qT", name
, *node
);
5343 tree attributes
= TYPE_ATTRIBUTES (*node
);
5344 tree decl
= TYPE_NAME (*node
);
5346 /* Make sure all declarations have the same abi tags. */
5347 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
5349 if (!check_abi_tag_redeclaration (decl
,
5350 lookup_attribute ("abi_tag",
5358 if (!VAR_OR_FUNCTION_DECL_P (*node
))
5360 error ("%qE attribute applied to non-function, non-variable %qD",
5364 else if (DECL_LANGUAGE (*node
) == lang_c
)
5366 error ("%qE attribute applied to extern \"C\" declaration %qD",
5375 *no_add_attrs
= true;
5379 /* Perform checking for contract attributes. */
5382 handle_contract_attribute (tree
*ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
5383 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5384 bool *ARG_UNUSED (no_add_attrs
))
5386 /* TODO: Is there any checking we could do here? */
5390 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5391 thing pointed to by the constant. */
5394 make_ptrmem_cst (tree type
, tree member
)
5396 tree ptrmem_cst
= make_node (PTRMEM_CST
);
5397 TREE_TYPE (ptrmem_cst
) = type
;
5398 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5399 PTRMEM_CST_LOCATION (ptrmem_cst
) = input_location
;
5403 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5404 return an existing type if an appropriate type already exists. */
5407 cp_build_type_attribute_variant (tree type
, tree attributes
)
5411 new_type
= build_type_attribute_variant (type
, attributes
);
5412 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5413 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5415 /* Making a new main variant of a class type is broken. */
5416 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5421 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5422 Called only after doing all language independent checks. */
5425 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5427 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5429 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5431 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5433 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5434 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5437 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5438 C++, these are the exception-specifier and ref-qualifier. */
5441 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5443 tree type
= CONST_CAST_TREE (typea
);
5444 if (FUNC_OR_METHOD_TYPE_P (type
))
5445 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5446 TYPE_RAISES_EXCEPTIONS (typeb
),
5447 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5451 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5452 traversal. Called from walk_tree. */
5455 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5456 void *data
, hash_set
<tree
> *pset
)
5459 enum tree_code code
= TREE_CODE (t
);
5462 #define WALK_SUBTREE(NODE) \
5465 result = cp_walk_tree (&(NODE), func, data, pset); \
5466 if (result) goto out; \
5472 /* If *WALK_SUBTREES_P is 1, we're interested in the syntactic form of
5473 the argument, so don't look through typedefs, but do walk into
5474 template arguments for alias templates (and non-typedefed classes).
5476 If *WALK_SUBTREES_P > 1, we're interested in type identity or
5477 equivalence, so look through typedefs, ignoring template arguments for
5478 alias templates, and walk into template args of classes.
5480 See find_abi_tags_r for an example of setting *WALK_SUBTREES_P to 2
5481 when that's the behavior the walk_tree_fn wants. */
5482 if (*walk_subtrees_p
== 1 && typedef_variant_p (t
))
5484 if (tree ti
= TYPE_ALIAS_TEMPLATE_INFO (t
))
5485 WALK_SUBTREE (TI_ARGS (ti
));
5486 *walk_subtrees_p
= 0;
5490 if (tree ti
= TYPE_TEMPLATE_INFO (t
))
5491 WALK_SUBTREE (TI_ARGS (ti
));
5494 /* Not one of the easy cases. We must explicitly go through the
5499 case TEMPLATE_TYPE_PARM
:
5500 if (template_placeholder_p (t
))
5501 WALK_SUBTREE (CLASS_PLACEHOLDER_TEMPLATE (t
));
5503 case DEFERRED_PARSE
:
5504 case TEMPLATE_TEMPLATE_PARM
:
5505 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5506 case UNBOUND_CLASS_TEMPLATE
:
5507 case TEMPLATE_PARM_INDEX
:
5509 /* None of these have subtrees other than those already walked
5511 *walk_subtrees_p
= 0;
5515 WALK_SUBTREE (TYPE_CONTEXT (t
));
5516 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
5517 *walk_subtrees_p
= 0;
5521 if (BASELINK_QUALIFIED_P (t
))
5522 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (t
)));
5523 WALK_SUBTREE (BASELINK_FUNCTIONS (t
));
5524 *walk_subtrees_p
= 0;
5528 WALK_SUBTREE (TREE_TYPE (t
));
5529 *walk_subtrees_p
= 0;
5533 WALK_SUBTREE (TREE_PURPOSE (t
));
5537 WALK_SUBTREE (OVL_FUNCTION (t
));
5538 WALK_SUBTREE (OVL_CHAIN (t
));
5539 *walk_subtrees_p
= 0;
5543 WALK_SUBTREE (DECL_NAME (t
));
5544 WALK_SUBTREE (USING_DECL_SCOPE (t
));
5545 WALK_SUBTREE (USING_DECL_DECLS (t
));
5546 *walk_subtrees_p
= 0;
5550 if (TYPE_PTRMEMFUNC_P (t
))
5551 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (t
));
5554 case TYPE_ARGUMENT_PACK
:
5555 case NONTYPE_ARGUMENT_PACK
:
5557 tree args
= ARGUMENT_PACK_ARGS (t
);
5558 for (tree arg
: tree_vec_range (args
))
5563 case TYPE_PACK_EXPANSION
:
5564 WALK_SUBTREE (TREE_TYPE (t
));
5565 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t
));
5566 *walk_subtrees_p
= 0;
5569 case EXPR_PACK_EXPANSION
:
5570 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5571 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t
));
5572 *walk_subtrees_p
= 0;
5576 case REINTERPRET_CAST_EXPR
:
5577 case STATIC_CAST_EXPR
:
5578 case CONST_CAST_EXPR
:
5579 case DYNAMIC_CAST_EXPR
:
5580 case IMPLICIT_CONV_EXPR
:
5583 WALK_SUBTREE (TREE_TYPE (t
));
5587 if (COMPOUND_LITERAL_P (t
))
5588 WALK_SUBTREE (TREE_TYPE (t
));
5592 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (t
));
5593 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (t
));
5594 *walk_subtrees_p
= 0;
5598 WALK_SUBTREE (TRAIT_TYPE_TYPE1 (t
));
5599 WALK_SUBTREE (TRAIT_TYPE_TYPE2 (t
));
5600 *walk_subtrees_p
= 0;
5606 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (t
));
5607 *walk_subtrees_p
= 0;
5616 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5617 *walk_subtrees_p
= 0;
5624 for (tree parm
= REQUIRES_EXPR_PARMS (t
); parm
; parm
= DECL_CHAIN (parm
))
5625 /* Walk the types of each parameter, but not the parameter itself,
5626 since doing so would cause false positives in the unexpanded pack
5627 checker if the requires-expr introduces a function parameter pack,
5628 e.g. requires (Ts... ts) { }. */
5629 WALK_SUBTREE (TREE_TYPE (parm
));
5630 WALK_SUBTREE (REQUIRES_EXPR_REQS (t
));
5631 *walk_subtrees_p
= 0;
5636 /* User variables should be mentioned in BIND_EXPR_VARS
5637 and their initializers and sizes walked when walking
5638 the containing BIND_EXPR. Compiler temporaries are
5639 handled here. And also normal variables in templates,
5640 since do_poplevel doesn't build a BIND_EXPR then. */
5641 if (VAR_P (TREE_OPERAND (t
, 0))
5642 && (processing_template_decl
5643 || (DECL_ARTIFICIAL (TREE_OPERAND (t
, 0))
5644 && !TREE_STATIC (TREE_OPERAND (t
, 0)))))
5646 tree decl
= TREE_OPERAND (t
, 0);
5647 WALK_SUBTREE (DECL_INITIAL (decl
));
5648 WALK_SUBTREE (DECL_SIZE (decl
));
5649 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5654 /* Don't walk into the body of the lambda, but the capture initializers
5655 are part of the enclosing context. */
5656 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
5657 cap
= TREE_CHAIN (cap
))
5658 WALK_SUBTREE (TREE_VALUE (cap
));
5662 if (TREE_OPERAND (t
, 1))
5663 /* Operand 1 is the tree for the relevant co_await which has any
5664 interesting sub-trees. */
5665 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5669 if (TREE_OPERAND (t
, 1))
5670 /* Operand 1 is frame variable. */
5671 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5672 if (TREE_OPERAND (t
, 2))
5673 /* Operand 2 has the initialiser, and we need to walk any subtrees
5675 WALK_SUBTREE (TREE_OPERAND (t
, 2));
5678 case CO_RETURN_EXPR
:
5679 if (TREE_OPERAND (t
, 0))
5681 if (VOID_TYPE_P (TREE_OPERAND (t
, 0)))
5682 /* For void expressions, operand 1 is a trivial call, and any
5683 interesting subtrees will be part of operand 0. */
5684 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5685 else if (TREE_OPERAND (t
, 1))
5686 /* Interesting sub-trees will be in the return_value () call
5688 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5693 WALK_SUBTREE (STATIC_ASSERT_CONDITION (t
));
5694 WALK_SUBTREE (STATIC_ASSERT_MESSAGE (t
));
5701 /* We didn't find what we were looking for. */
5708 /* Like save_expr, but for C++. */
5711 cp_save_expr (tree expr
)
5713 /* There is no reason to create a SAVE_EXPR within a template; if
5714 needed, we can create the SAVE_EXPR when instantiating the
5715 template. Furthermore, the middle-end cannot handle C++-specific
5717 if (processing_template_decl
)
5720 /* TARGET_EXPRs are only expanded once. */
5721 if (TREE_CODE (expr
) == TARGET_EXPR
)
5724 return save_expr (expr
);
5727 /* Initialize tree.cc. */
5732 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5735 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5736 is. Note that sfk_none is zero, so this function can be used as a
5737 predicate to test whether or not DECL is a special function. */
5739 special_function_kind
5740 special_function_p (const_tree decl
)
5742 /* Rather than doing all this stuff with magic names, we should
5743 probably have a field of type `special_function_kind' in
5744 DECL_LANG_SPECIFIC. */
5745 if (DECL_INHERITED_CTOR (decl
))
5746 return sfk_inheriting_constructor
;
5747 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5748 return sfk_copy_constructor
;
5749 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5750 return sfk_move_constructor
;
5751 if (DECL_CONSTRUCTOR_P (decl
))
5752 return sfk_constructor
;
5753 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5754 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5756 if (copy_fn_p (decl
))
5757 return sfk_copy_assignment
;
5758 if (move_fn_p (decl
))
5759 return sfk_move_assignment
;
5761 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5762 return sfk_destructor
;
5763 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5764 return sfk_complete_destructor
;
5765 if (DECL_BASE_DESTRUCTOR_P (decl
))
5766 return sfk_base_destructor
;
5767 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5768 return sfk_deleting_destructor
;
5769 if (DECL_CONV_FN_P (decl
))
5770 return sfk_conversion
;
5771 if (deduction_guide_p (decl
))
5772 return sfk_deduction_guide
;
5773 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5774 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5775 return sfk_comparison
;
5780 /* As above, but only if DECL is a special member function as per 11.3.3
5781 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5783 special_function_kind
5784 special_memfn_p (const_tree decl
)
5786 switch (special_function_kind sfk
= special_function_p (decl
))
5788 case sfk_constructor
:
5789 if (!default_ctor_p (decl
))
5792 case sfk_copy_constructor
:
5793 case sfk_copy_assignment
:
5794 case sfk_move_assignment
:
5795 case sfk_move_constructor
:
5796 case sfk_destructor
:
5805 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5808 char_type_p (tree type
)
5810 return (same_type_p (type
, char_type_node
)
5811 || same_type_p (type
, unsigned_char_type_node
)
5812 || same_type_p (type
, signed_char_type_node
)
5813 || same_type_p (type
, char8_type_node
)
5814 || same_type_p (type
, char16_type_node
)
5815 || same_type_p (type
, char32_type_node
)
5816 || same_type_p (type
, wchar_type_node
));
5819 /* Returns the kind of linkage associated with the indicated DECL. Th
5820 value returned is as specified by the language standard; it is
5821 independent of implementation details regarding template
5822 instantiation, etc. For example, it is possible that a declaration
5823 to which this function assigns external linkage would not show up
5824 as a global symbol when you run `nm' on the resulting object file. */
5827 decl_linkage (tree decl
)
5829 /* This function doesn't attempt to calculate the linkage from first
5830 principles as given in [basic.link]. Instead, it makes use of
5831 the fact that we have already set TREE_PUBLIC appropriately, and
5832 then handles a few special cases. Ideally, we would calculate
5833 linkage first, and then transform that into a concrete
5836 /* Things that don't have names have no linkage. */
5837 if (!DECL_NAME (decl
))
5840 /* Fields have no linkage. */
5841 if (TREE_CODE (decl
) == FIELD_DECL
)
5844 /* Things in local scope do not have linkage. */
5845 if (decl_function_context (decl
))
5848 /* Things that are TREE_PUBLIC have external linkage. */
5849 if (TREE_PUBLIC (decl
))
5852 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5853 check one of the "clones" for the real linkage. */
5854 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5855 && DECL_CHAIN (decl
)
5856 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5857 return decl_linkage (DECL_CHAIN (decl
));
5859 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5862 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5864 if (TREE_CODE (decl
) == CONST_DECL
)
5865 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5867 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5868 are considered to have external linkage for language purposes, as do
5869 template instantiations on targets without weak symbols. DECLs really
5870 meant to have internal linkage have DECL_THIS_STATIC set. */
5871 if (TREE_CODE (decl
) == TYPE_DECL
)
5873 if (VAR_OR_FUNCTION_DECL_P (decl
))
5875 if (!DECL_THIS_STATIC (decl
))
5878 /* Static data members and static member functions from classes
5879 in anonymous namespace also don't have TREE_PUBLIC set. */
5880 if (DECL_CLASS_CONTEXT (decl
))
5884 /* Everything else has internal linkage. */
5888 /* Returns the storage duration of the object or reference associated with
5889 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5892 decl_storage_duration (tree decl
)
5894 if (TREE_CODE (decl
) == PARM_DECL
)
5896 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5898 gcc_assert (VAR_P (decl
));
5899 if (!TREE_STATIC (decl
)
5900 && !DECL_EXTERNAL (decl
))
5902 if (CP_DECL_THREAD_LOCAL_P (decl
))
5907 /* EXP is an expression that we want to pre-evaluate. Returns (in
5908 *INITP) an expression that will perform the pre-evaluation. The
5909 value returned by this function is a side-effect free expression
5910 equivalent to the pre-evaluated expression. Callers must ensure
5911 that *INITP is evaluated before EXP. */
5914 stabilize_expr (tree exp
, tree
* initp
)
5918 if (!TREE_SIDE_EFFECTS (exp
))
5919 init_expr
= NULL_TREE
;
5920 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5925 /* There are no expressions with REFERENCE_TYPE, but there can be call
5926 arguments with such a type; just treat it as a pointer. */
5927 else if (TYPE_REF_P (TREE_TYPE (exp
))
5928 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5929 || !glvalue_p (exp
))
5931 init_expr
= get_target_expr (exp
);
5932 exp
= TARGET_EXPR_SLOT (init_expr
);
5933 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5940 bool xval
= !lvalue_p (exp
);
5941 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5942 init_expr
= get_target_expr (exp
);
5943 exp
= TARGET_EXPR_SLOT (init_expr
);
5944 exp
= cp_build_fold_indirect_ref (exp
);
5950 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5954 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5955 similar expression ORIG. */
5958 add_stmt_to_compound (tree orig
, tree new_expr
)
5960 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5962 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5964 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5967 /* Like stabilize_expr, but for a call whose arguments we want to
5968 pre-evaluate. CALL is modified in place to use the pre-evaluated
5969 arguments, while, upon return, *INITP contains an expression to
5970 compute the arguments. */
5973 stabilize_call (tree call
, tree
*initp
)
5975 tree inits
= NULL_TREE
;
5977 int nargs
= call_expr_nargs (call
);
5979 if (call
== error_mark_node
|| processing_template_decl
)
5985 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5987 for (i
= 0; i
< nargs
; i
++)
5990 CALL_EXPR_ARG (call
, i
) =
5991 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5992 inits
= add_stmt_to_compound (inits
, init
);
5998 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5999 to pre-evaluate. CALL is modified in place to use the pre-evaluated
6000 arguments, while, upon return, *INITP contains an expression to
6001 compute the arguments. */
6004 stabilize_aggr_init (tree call
, tree
*initp
)
6006 tree inits
= NULL_TREE
;
6008 int nargs
= aggr_init_expr_nargs (call
);
6010 if (call
== error_mark_node
)
6013 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
6015 for (i
= 0; i
< nargs
; i
++)
6018 AGGR_INIT_EXPR_ARG (call
, i
) =
6019 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
6020 inits
= add_stmt_to_compound (inits
, init
);
6026 /* Like stabilize_expr, but for an initialization.
6028 If the initialization is for an object of class type, this function
6029 takes care not to introduce additional temporaries.
6031 Returns TRUE iff the expression was successfully pre-evaluated,
6032 i.e., if INIT is now side-effect free, except for, possibly, a
6033 single call to a constructor. */
6036 stabilize_init (tree init
, tree
*initp
)
6042 if (t
== error_mark_node
|| processing_template_decl
)
6045 if (TREE_CODE (t
) == INIT_EXPR
)
6046 t
= TREE_OPERAND (t
, 1);
6047 if (TREE_CODE (t
) == TARGET_EXPR
)
6048 t
= TARGET_EXPR_INITIAL (t
);
6050 /* If the RHS can be stabilized without breaking copy elision, stabilize
6051 it. We specifically don't stabilize class prvalues here because that
6052 would mean an extra copy, but they might be stabilized below. */
6053 if (TREE_CODE (init
) == INIT_EXPR
6054 && TREE_CODE (t
) != CONSTRUCTOR
6055 && TREE_CODE (t
) != AGGR_INIT_EXPR
6056 && (SCALAR_TYPE_P (TREE_TYPE (t
))
6059 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
6063 if (TREE_CODE (t
) == COMPOUND_EXPR
6064 && TREE_CODE (init
) == INIT_EXPR
)
6066 tree last
= expr_last (t
);
6067 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
6068 if (!TREE_SIDE_EFFECTS (last
))
6071 TREE_OPERAND (init
, 1) = last
;
6076 if (TREE_CODE (t
) == CONSTRUCTOR
)
6078 /* Aggregate initialization: stabilize each of the field
6081 constructor_elt
*ce
;
6083 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6084 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6086 tree type
= TREE_TYPE (ce
->value
);
6088 if (TYPE_REF_P (type
)
6089 || SCALAR_TYPE_P (type
))
6090 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
6091 else if (!stabilize_init (ce
->value
, &subinit
))
6093 *initp
= add_stmt_to_compound (*initp
, subinit
);
6098 if (TREE_CODE (t
) == CALL_EXPR
)
6100 stabilize_call (t
, initp
);
6104 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
6106 stabilize_aggr_init (t
, initp
);
6110 /* The initialization is being performed via a bitwise copy -- and
6111 the item copied may have side effects. */
6112 return !TREE_SIDE_EFFECTS (init
);
6115 /* Returns true if a cast to TYPE may appear in an integral constant
6119 cast_valid_in_integral_constant_expression_p (tree type
)
6121 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6122 || cxx_dialect
>= cxx11
6123 || dependent_type_p (type
)
6124 || type
== error_mark_node
);
6127 /* Return true if we need to fix linkage information of DECL. */
6130 cp_fix_function_decl_p (tree decl
)
6132 /* Skip if DECL is not externally visible. */
6133 if (!TREE_PUBLIC (decl
))
6136 /* We need to fix DECL if it a appears to be exported but with no
6137 function body. Thunks do not have CFGs and we may need to
6138 handle them specially later. */
6139 if (!gimple_has_body_p (decl
)
6140 && !DECL_THUNK_P (decl
)
6141 && !DECL_EXTERNAL (decl
))
6143 struct cgraph_node
*node
= cgraph_node::get (decl
);
6145 /* Don't fix same_body aliases. Although they don't have their own
6146 CFG, they share it with what they alias to. */
6147 if (!node
|| !node
->alias
|| !node
->num_references ())
6154 /* Clean the C++ specific parts of the tree T. */
6157 cp_free_lang_data (tree t
)
6159 if (FUNC_OR_METHOD_TYPE_P (t
))
6161 /* Default args are not interesting anymore. */
6162 tree argtypes
= TYPE_ARG_TYPES (t
);
6165 TREE_PURPOSE (argtypes
) = 0;
6166 argtypes
= TREE_CHAIN (argtypes
);
6169 else if (TREE_CODE (t
) == FUNCTION_DECL
6170 && cp_fix_function_decl_p (t
))
6172 /* If T is used in this translation unit at all, the definition
6173 must exist somewhere else since we have decided to not emit it
6174 in this TU. So make it an external reference. */
6175 DECL_EXTERNAL (t
) = 1;
6176 TREE_STATIC (t
) = 0;
6178 if (TREE_CODE (t
) == NAMESPACE_DECL
)
6179 /* We do not need the leftover chaining of namespaces from the
6181 DECL_CHAIN (t
) = NULL_TREE
;
6184 /* Stub for c-common. Please keep in sync with c-decl.cc.
6185 FIXME: If address space support is target specific, then this
6186 should be a C target hook. But currently this is not possible,
6187 because this function is called via REGISTER_TARGET_PRAGMAS. */
6189 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
6193 /* Return the number of operands in T that we care about for things like
6197 cp_tree_operand_length (const_tree t
)
6199 enum tree_code code
= TREE_CODE (t
);
6201 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
6202 return VL_EXP_OPERAND_LENGTH (t
);
6204 return cp_tree_code_length (code
);
6207 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
6210 cp_tree_code_length (enum tree_code code
)
6212 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6216 case PREINCREMENT_EXPR
:
6217 case PREDECREMENT_EXPR
:
6218 case POSTINCREMENT_EXPR
:
6219 case POSTDECREMENT_EXPR
:
6225 case EXPR_PACK_EXPANSION
:
6229 return TREE_CODE_LENGTH (code
);
6233 /* Implement -Wzero_as_null_pointer_constant. Return true if the
6234 conditions for the warning hold, false otherwise. */
6236 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
6238 if (c_inhibit_evaluation_warnings
== 0
6239 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6241 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
6242 "zero as null pointer constant");
6248 /* FNDECL is a function declaration whose type may have been altered by
6249 adding extra parameters such as this, in-charge, or VTT. When this
6250 takes place, the positional arguments supplied by the user (as in the
6251 'format' attribute arguments) may refer to the wrong argument. This
6252 function returns an integer indicating how many arguments should be
6256 maybe_adjust_arg_pos_for_attribute (const_tree fndecl
)
6260 int n
= num_artificial_parms_for (fndecl
);
6261 /* The manual states that it's the user's responsibility to account
6262 for the implicit this parameter. */
6263 return n
> 0 ? n
- 1 : 0;
6267 /* Release memory we no longer need after parsing. */
6269 cp_tree_c_finish_parsing ()
6271 if (previous_class_level
)
6272 invalidate_class_lookup_cache ();
6273 deleted_copy_types
= NULL
;
6276 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6277 /* Complain that some language-specific thing hanging off a tree
6278 node has been accessed improperly. */
6281 lang_check_failed (const char* file
, int line
, const char* function
)
6283 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
6284 function
, trim_filename (file
), line
);
6286 #endif /* ENABLE_TREE_CHECKING */
6290 namespace selftest
{
6292 /* Verify that lvalue_kind () works, for various expressions,
6293 and that location wrappers don't affect the results. */
6298 location_t loc
= BUILTINS_LOCATION
;
6300 /* Verify constants and parameters, without and with
6301 location wrappers. */
6302 tree int_cst
= build_int_cst (integer_type_node
, 42);
6303 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
6305 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
6306 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
6307 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
6309 tree string_lit
= build_string (4, "foo");
6310 TREE_TYPE (string_lit
) = char_array_type_node
;
6311 string_lit
= fix_string_type (string_lit
);
6312 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
6314 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
6315 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
6316 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
6318 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
6319 get_identifier ("some_parm"),
6321 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
6323 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
6324 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
6325 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
6327 /* Verify that lvalue_kind of std::move on a parm isn't
6328 affected by location wrappers. */
6329 tree rvalue_ref_of_parm
= move (parm
);
6330 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
6331 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
6332 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
6334 /* Verify lvalue_p. */
6335 ASSERT_FALSE (lvalue_p (int_cst
));
6336 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
6337 ASSERT_TRUE (lvalue_p (parm
));
6338 ASSERT_TRUE (lvalue_p (wrapped_parm
));
6339 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
6340 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
6343 /* Run all of the selftests within this file. */
6348 test_lvalue_kind ();
6351 } // namespace selftest
6353 #endif /* #if CHECKING_P */
6356 #include "gt-cp-tree.h"