1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2023 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
)));
311 case NON_DEPENDENT_EXPR
:
313 return lvalue_kind (TREE_OPERAND (ref
, 0));
315 case TEMPLATE_PARM_INDEX
:
316 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
317 /* A template parameter object is an lvalue. */
323 if (!TREE_TYPE (ref
))
325 if (CLASS_TYPE_P (TREE_TYPE (ref
))
326 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
331 /* If one operand is not an lvalue at all, then this expression is
333 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
336 /* Otherwise, it's an lvalue, and it has all the odd properties
337 contributed by either operand. */
338 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
339 /* It's not an ordinary lvalue if it involves any other kind. */
340 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
341 op1_lvalue_kind
&= ~clk_ordinary
;
342 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
343 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
344 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
345 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
346 op1_lvalue_kind
= clk_none
;
347 return op1_lvalue_kind
;
350 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
353 real_lvalue_p (const_tree ref
)
355 cp_lvalue_kind kind
= lvalue_kind (ref
);
356 if (kind
& (clk_rvalueref
|clk_class
))
362 /* c-common wants us to return bool. */
365 lvalue_p (const_tree t
)
367 return real_lvalue_p (t
);
370 /* This differs from lvalue_p in that xvalues are included. */
373 glvalue_p (const_tree ref
)
375 cp_lvalue_kind kind
= lvalue_kind (ref
);
376 if (kind
& clk_class
)
379 return (kind
!= clk_none
);
382 /* This differs from glvalue_p in that class prvalues are included. */
385 obvalue_p (const_tree ref
)
387 return (lvalue_kind (ref
) != clk_none
);
390 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
391 reference), false otherwise. */
394 xvalue_p (const_tree ref
)
396 return (lvalue_kind (ref
) & clk_rvalueref
);
399 /* True if REF is a bit-field. */
402 bitfield_p (const_tree ref
)
404 return (lvalue_kind (ref
) & clk_bitfield
);
407 /* C++-specific version of stabilize_reference. */
410 cp_stabilize_reference (tree ref
)
412 STRIP_ANY_LOCATION_WRAPPER (ref
);
413 switch (TREE_CODE (ref
))
415 case NON_DEPENDENT_EXPR
:
416 /* We aren't actually evaluating this. */
419 /* We need to treat specially anything stabilize_reference doesn't
420 handle specifically. */
431 case ARRAY_RANGE_REF
:
435 cp_lvalue_kind kind
= lvalue_kind (ref
);
436 if ((kind
& ~clk_class
) != clk_none
)
438 tree type
= unlowered_expr_type (ref
);
439 bool rval
= !!(kind
& clk_rvalueref
);
440 type
= cp_build_reference_type (type
, rval
);
441 /* This inhibits warnings in, eg, cxx_mark_addressable
443 warning_sentinel
s (extra_warnings
);
444 ref
= build_static_cast (input_location
, type
, ref
,
449 return stabilize_reference (ref
);
452 /* Test whether DECL is a builtin that may appear in a
453 constant-expression. */
456 builtin_valid_in_constant_expr_p (const_tree decl
)
458 STRIP_ANY_LOCATION_WRAPPER (decl
);
459 if (TREE_CODE (decl
) != FUNCTION_DECL
)
460 /* Not a function. */
462 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
464 if (fndecl_built_in_p (decl
, BUILT_IN_FRONTEND
))
465 switch (DECL_FE_FUNCTION_CODE (decl
))
467 case CP_BUILT_IN_IS_CONSTANT_EVALUATED
:
468 case CP_BUILT_IN_SOURCE_LOCATION
:
469 case CP_BUILT_IN_IS_CORRESPONDING_MEMBER
:
470 case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS
:
475 /* Not a built-in. */
478 switch (DECL_FUNCTION_CODE (decl
))
480 /* These always have constant results like the corresponding
483 case BUILT_IN_FUNCTION
:
486 /* The following built-ins are valid in constant expressions
487 when their arguments are. */
488 case BUILT_IN_ADD_OVERFLOW_P
:
489 case BUILT_IN_SUB_OVERFLOW_P
:
490 case BUILT_IN_MUL_OVERFLOW_P
:
492 /* These have constant results even if their operands are
494 case BUILT_IN_CONSTANT_P
:
495 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
502 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
505 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
508 tree type
= TREE_TYPE (decl
);
510 value
= mark_rvalue_use (value
);
512 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
513 || TREE_TYPE (decl
) == TREE_TYPE (value
)
514 /* On ARM ctors return 'this'. */
515 || (TYPE_PTR_P (TREE_TYPE (value
))
516 && TREE_CODE (value
) == CALL_EXPR
)
517 || useless_type_conversion_p (TREE_TYPE (decl
),
520 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
521 moving a constant aggregate into .rodata. */
522 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
523 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
524 && !VOID_TYPE_P (TREE_TYPE (value
))
525 && !TYPE_HAS_MUTABLE_P (type
)
526 && reduced_constant_expression_p (value
))
527 TREE_READONLY (decl
) = true;
529 if (complain
& tf_no_cleanup
)
530 /* The caller is building a new-expr and does not need a cleanup. */
534 t
= cxx_maybe_build_cleanup (decl
, complain
);
535 if (t
== error_mark_node
)
536 return error_mark_node
;
539 set_target_expr_eliding (value
);
541 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
542 if (location_t eloc
= cp_expr_location (value
))
543 SET_EXPR_LOCATION (t
, eloc
);
544 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
545 ignore the TARGET_EXPR. If there really turn out to be no
546 side-effects, then the optimizer should be able to get rid of
547 whatever code is generated anyhow. */
548 TREE_SIDE_EFFECTS (t
) = 1;
553 /* Return an undeclared local temporary of type TYPE for use in building a
557 build_local_temp (tree type
)
559 tree slot
= build_decl (input_location
,
560 VAR_DECL
, NULL_TREE
, type
);
561 DECL_ARTIFICIAL (slot
) = 1;
562 DECL_IGNORED_P (slot
) = 1;
563 DECL_CONTEXT (slot
) = current_function_decl
;
564 layout_decl (slot
, 0);
568 /* Return whether DECL is such a local temporary (or one from
569 create_tmp_var_raw). */
572 is_local_temp (tree decl
)
574 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
575 && !TREE_STATIC (decl
));
578 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
581 process_aggr_init_operands (tree t
)
585 side_effects
= TREE_SIDE_EFFECTS (t
);
589 n
= TREE_OPERAND_LENGTH (t
);
590 for (i
= 1; i
< n
; i
++)
592 tree op
= TREE_OPERAND (t
, i
);
593 if (op
&& TREE_SIDE_EFFECTS (op
))
600 TREE_SIDE_EFFECTS (t
) = side_effects
;
603 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
604 FN, and SLOT. NARGS is the number of call arguments which are specified
605 as a tree array ARGS. */
608 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
614 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
615 TREE_TYPE (t
) = return_type
;
616 AGGR_INIT_EXPR_FN (t
) = fn
;
617 AGGR_INIT_EXPR_SLOT (t
) = slot
;
618 for (i
= 0; i
< nargs
; i
++)
619 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
620 process_aggr_init_operands (t
);
624 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
625 target. TYPE is the type to be initialized.
627 Build an AGGR_INIT_EXPR to represent the initialization. This function
628 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
629 to initialize another object, whereas a TARGET_EXPR can either
630 initialize another object or create its own temporary object, and as a
631 result building up a TARGET_EXPR requires that the type's destructor be
635 build_aggr_init_expr (tree type
, tree init
)
642 gcc_assert (!VOID_TYPE_P (type
));
644 /* Don't build AGGR_INIT_EXPR in a template. */
645 if (processing_template_decl
)
648 fn
= cp_get_callee (init
);
650 return convert (type
, init
);
652 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
653 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
654 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
656 /* We split the CALL_EXPR into its function and its arguments here.
657 Then, in expand_expr, we put them back together. The reason for
658 this is that this expression might be a default argument
659 expression. In that case, we need a new temporary every time the
660 expression is used. That's what break_out_target_exprs does; it
661 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
662 temporary slot. Then, expand_expr builds up a call-expression
663 using the new slot. */
665 /* If we don't need to use a constructor to create an object of this
666 type, don't mess with AGGR_INIT_EXPR. */
667 if (is_ctor
|| TREE_ADDRESSABLE (type
))
669 slot
= build_local_temp (type
);
671 if (TREE_CODE (init
) == CALL_EXPR
)
673 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
674 call_expr_nargs (init
),
675 CALL_EXPR_ARGP (init
));
676 AGGR_INIT_FROM_THUNK_P (rval
)
677 = CALL_FROM_THUNK_P (init
);
681 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
682 aggr_init_expr_nargs (init
),
683 AGGR_INIT_EXPR_ARGP (init
));
684 AGGR_INIT_FROM_THUNK_P (rval
)
685 = AGGR_INIT_FROM_THUNK_P (init
);
687 TREE_SIDE_EFFECTS (rval
) = 1;
688 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
689 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
690 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
691 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
692 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (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 (CAN_HAVE_LOCATION_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;
1917 for (; t
; t
= TREE_CHAIN (t
))
1919 gcc_assert (!TREE_PURPOSE (t
));
1920 tree elt
= strip_typedefs (TREE_VALUE (t
),
1921 remove_attributes
, flags
);
1922 if (elt
!= TREE_VALUE (t
))
1924 vec_safe_push (vec
, elt
);
1927 r
= build_tree_list_vec (vec
);
1933 bool changed
= false;
1935 n
= TREE_VEC_LENGTH (t
);
1936 vec_safe_reserve (vec
, n
);
1937 for (i
= 0; i
< n
; ++i
)
1939 tree op
= strip_typedefs (TREE_VEC_ELT (t
, i
),
1940 remove_attributes
, flags
);
1941 vec
->quick_push (op
);
1942 if (op
!= TREE_VEC_ELT (t
, i
))
1948 for (i
= 0; i
< n
; ++i
)
1949 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1950 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1951 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1960 bool changed
= false;
1961 vec
<constructor_elt
, va_gc
> *vec
1962 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1963 n
= CONSTRUCTOR_NELTS (t
);
1964 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1965 for (i
= 0; i
< n
; ++i
)
1967 constructor_elt
*e
= &(*vec
)[i
];
1968 tree op
= strip_typedefs (e
->value
, remove_attributes
, flags
);
1975 (e
->index
== strip_typedefs (e
->index
, remove_attributes
,
1979 if (!changed
&& type
== TREE_TYPE (t
))
1987 TREE_TYPE (r
) = type
;
1988 CONSTRUCTOR_ELTS (r
) = vec
;
1996 case STATEMENT_LIST
:
1997 error ("statement-expression in a constant expression");
1998 return error_mark_node
;
2004 gcc_assert (EXPR_P (t
));
2006 n
= cp_tree_operand_length (t
);
2007 ops
= XALLOCAVEC (tree
, n
);
2008 type
= TREE_TYPE (t
);
2013 case IMPLICIT_CONV_EXPR
:
2014 case DYNAMIC_CAST_EXPR
:
2015 case STATIC_CAST_EXPR
:
2016 case CONST_CAST_EXPR
:
2017 case REINTERPRET_CAST_EXPR
:
2020 type
= strip_typedefs (type
, remove_attributes
, flags
);
2024 for (i
= 0; i
< n
; ++i
)
2025 ops
[i
] = strip_typedefs (TREE_OPERAND (t
, i
),
2026 remove_attributes
, flags
);
2030 /* If nothing changed, return t. */
2031 for (i
= 0; i
< n
; ++i
)
2032 if (ops
[i
] != TREE_OPERAND (t
, i
))
2034 if (i
== n
&& type
== TREE_TYPE (t
))
2038 TREE_TYPE (r
) = type
;
2039 for (i
= 0; i
< n
; ++i
)
2040 TREE_OPERAND (r
, i
) = ops
[i
];
2044 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
2045 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2046 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2047 VIRT indicates whether TYPE is inherited virtually or not.
2048 IGO_PREV points at the previous binfo of the inheritance graph
2049 order chain. The newly copied binfo's TREE_CHAIN forms this
2052 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2053 correct order. That is in the order the bases themselves should be
2056 The BINFO_INHERITANCE of a virtual base class points to the binfo
2057 of the most derived type. ??? We could probably change this so that
2058 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2059 remove a field. They currently can only differ for primary virtual
2063 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
2069 /* See if we've already made this virtual base. */
2070 new_binfo
= binfo_for_vbase (type
, t
);
2075 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
2076 BINFO_TYPE (new_binfo
) = type
;
2078 /* Chain it into the inheritance graph. */
2079 TREE_CHAIN (*igo_prev
) = new_binfo
;
2080 *igo_prev
= new_binfo
;
2082 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2087 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2089 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2090 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2092 /* We do not need to copy the accesses, as they are read only. */
2093 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2095 /* Recursively copy base binfos of BINFO. */
2096 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2098 tree new_base_binfo
;
2099 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2101 BINFO_VIRTUAL_P (base_binfo
));
2103 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2104 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2105 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2109 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2113 /* Push it onto the list after any virtual bases it contains
2114 will have been pushed. */
2115 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2116 BINFO_VIRTUAL_P (new_binfo
) = 1;
2117 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2123 /* Hashing of lists so that we don't make duplicates.
2124 The entry point is `list_hash_canon'. */
2133 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2135 typedef list_proxy
*compare_type
;
2137 static hashval_t
hash (tree
);
2138 static bool equal (tree
, list_proxy
*);
2141 /* Now here is the hash table. When recording a list, it is added
2142 to the slot whose index is the hash code mod the table size.
2143 Note that the hash table is used for several kinds of lists.
2144 While all these live in the same table, they are completely independent,
2145 and the hash code is computed differently for each of these. */
2147 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2149 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2150 for a node we are thinking about adding). */
2153 list_hasher::equal (tree t
, list_proxy
*proxy
)
2155 return (TREE_VALUE (t
) == proxy
->value
2156 && TREE_PURPOSE (t
) == proxy
->purpose
2157 && TREE_CHAIN (t
) == proxy
->chain
);
2160 /* Compute a hash code for a list (chain of TREE_LIST nodes
2161 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2162 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2165 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2167 hashval_t hashcode
= 0;
2170 hashcode
+= TREE_HASH (chain
);
2173 hashcode
+= TREE_HASH (value
);
2177 hashcode
+= TREE_HASH (purpose
);
2183 /* Hash an already existing TREE_LIST. */
2186 list_hasher::hash (tree t
)
2188 return list_hash_pieces (TREE_PURPOSE (t
),
2193 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2194 object for an identical list if one already exists. Otherwise, build a
2195 new one, and record it as the canonical object. */
2198 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2202 struct list_proxy proxy
;
2204 /* Hash the list node. */
2205 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2206 /* Create a proxy for the TREE_LIST we would like to create. We
2207 don't actually create it so as to avoid creating garbage. */
2208 proxy
.purpose
= purpose
;
2209 proxy
.value
= value
;
2210 proxy
.chain
= chain
;
2211 /* See if it is already in the table. */
2212 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2213 /* If not, create a new node. */
2215 *slot
= tree_cons (purpose
, value
, chain
);
2216 return (tree
) *slot
;
2219 /* Constructor for hashed lists. */
2222 hash_tree_chain (tree value
, tree chain
)
2224 return hash_tree_cons (NULL_TREE
, value
, chain
);
2228 debug_binfo (tree elem
)
2233 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2235 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2236 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2237 debug_tree (BINFO_TYPE (elem
));
2238 if (BINFO_VTABLE (elem
))
2239 fprintf (stderr
, "vtable decl \"%s\"\n",
2240 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2242 fprintf (stderr
, "no vtable decl yet\n");
2243 fprintf (stderr
, "virtuals:\n");
2244 virtuals
= BINFO_VIRTUALS (elem
);
2249 tree fndecl
= TREE_VALUE (virtuals
);
2250 fprintf (stderr
, "%s [%ld =? %ld]\n",
2251 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2252 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2254 virtuals
= TREE_CHAIN (virtuals
);
2258 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2259 the type of the result expression, if known, or NULL_TREE if the
2260 resulting expression is type-dependent. If TEMPLATE_P is true,
2261 NAME is known to be a template because the user explicitly used the
2262 "template" keyword after the "::".
2264 All SCOPE_REFs should be built by use of this function. */
2267 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2270 if (type
== error_mark_node
2271 || scope
== error_mark_node
2272 || name
== error_mark_node
)
2273 return error_mark_node
;
2274 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2275 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2276 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2277 PTRMEM_OK_P (t
) = true;
2279 t
= convert_from_reference (t
);
2283 /* Like check_qualified_type, but also check ref-qualifier, exception
2284 specification, and whether the return type was specified after the
2288 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2289 cp_ref_qualifier rqual
, tree raises
, bool late
)
2291 return (TYPE_QUALS (cand
) == type_quals
2292 && check_base_type (cand
, base
)
2293 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2295 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2296 && type_memfn_rqual (cand
) == rqual
);
2299 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2302 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2304 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2305 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2306 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2310 make_binding_vec (tree name
, unsigned clusters MEM_STAT_DECL
)
2312 /* Stored in an unsigned short, but we're limited to the number of
2314 gcc_checking_assert (clusters
<= (unsigned short)(~0));
2315 size_t length
= (offsetof (tree_binding_vec
, vec
)
2316 + clusters
* sizeof (binding_cluster
));
2317 tree vec
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2318 TREE_SET_CODE (vec
, BINDING_VECTOR
);
2319 BINDING_VECTOR_NAME (vec
) = name
;
2320 BINDING_VECTOR_ALLOC_CLUSTERS (vec
) = clusters
;
2321 BINDING_VECTOR_NUM_CLUSTERS (vec
) = 0;
2326 /* Make a raw overload node containing FN. */
2329 ovl_make (tree fn
, tree next
)
2331 tree result
= make_node (OVERLOAD
);
2333 if (TREE_CODE (fn
) == OVERLOAD
)
2334 OVL_NESTED_P (result
) = true;
2336 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2337 ? unknown_type_node
: TREE_TYPE (fn
));
2338 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2339 OVL_DEDUP_P (result
) = true;
2340 OVL_FUNCTION (result
) = fn
;
2341 OVL_CHAIN (result
) = next
;
2345 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2346 zero if this is a using-decl. It is > 1 if we're exporting the
2347 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2348 cannot be both using and hidden.) We keep the hidden decls first,
2349 but remaining ones are unordered. */
2352 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2354 tree result
= maybe_ovl
;
2355 tree insert_after
= NULL_TREE
;
2358 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2359 && OVL_HIDDEN_P (maybe_ovl
);
2360 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2362 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2363 insert_after
= maybe_ovl
;
2366 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2368 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2370 if (using_or_hidden
< 0)
2371 OVL_HIDDEN_P (maybe_ovl
) = true;
2372 if (using_or_hidden
> 0)
2374 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2375 if (using_or_hidden
> 1)
2376 OVL_EXPORT_P (maybe_ovl
) = true;
2384 OVL_CHAIN (insert_after
) = maybe_ovl
;
2385 TREE_TYPE (insert_after
) = unknown_type_node
;
2393 /* Skip any hidden names at the beginning of OVL. */
2396 ovl_skip_hidden (tree ovl
)
2398 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2399 ovl
= OVL_CHAIN (ovl
);
2404 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2407 ovl_iterator::reveal_node (tree overload
, tree node
)
2409 /* We cannot have returned NODE as part of a lookup overload, so we
2410 don't have to worry about preserving that. */
2412 OVL_HIDDEN_P (node
) = false;
2413 if (tree chain
= OVL_CHAIN (node
))
2414 if (TREE_CODE (chain
) == OVERLOAD
)
2416 if (OVL_HIDDEN_P (chain
))
2418 /* The node needs moving, and the simplest way is to remove it
2420 overload
= remove_node (overload
, node
);
2421 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2423 else if (OVL_DEDUP_P (chain
))
2424 OVL_DEDUP_P (node
) = true;
2429 /* NODE is on the overloads of OVL. Remove it.
2430 The removed node is unaltered and may continue to be iterated
2431 from (i.e. it is safe to remove a node from an overload one is
2432 currently iterating over). */
2435 ovl_iterator::remove_node (tree overload
, tree node
)
2437 tree
*slot
= &overload
;
2438 while (*slot
!= node
)
2441 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2443 slot
= &OVL_CHAIN (probe
);
2446 /* Stitch out NODE. We don't have to worry about now making a
2447 singleton overload (and consequently maybe setting its type),
2448 because all uses of this function will be followed by inserting a
2449 new node that must follow the place we've cut this out from. */
2450 if (TREE_CODE (node
) != OVERLOAD
)
2451 /* Cloned inherited ctors don't mark themselves as via_using. */
2454 *slot
= OVL_CHAIN (node
);
2459 /* Mark or unmark a lookup set. */
2462 lookup_mark (tree ovl
, bool val
)
2464 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2466 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2467 LOOKUP_SEEN_P (*iter
) = val
;
2471 /* Add a set of new FNS into a lookup. */
2474 lookup_add (tree fns
, tree lookup
)
2476 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2477 return error_mark_node
;
2479 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2481 lookup
= ovl_make (fns
, lookup
);
2482 OVL_LOOKUP_P (lookup
) = true;
2490 /* FNS is a new overload set, add them to LOOKUP, if they are not
2491 already present there. */
2494 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2497 for (tree next
, probe
= fns
; probe
; probe
= next
)
2502 if (TREE_CODE (probe
) == OVERLOAD
)
2504 fn
= OVL_FUNCTION (probe
);
2505 next
= OVL_CHAIN (probe
);
2508 if (!LOOKUP_SEEN_P (fn
))
2509 LOOKUP_SEEN_P (fn
) = true;
2512 /* This function was already seen. Insert all the
2513 predecessors onto the lookup. */
2514 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2516 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2517 /* Propagate OVL_USING, but OVL_HIDDEN &
2518 OVL_DEDUP_P don't matter. */
2519 if (OVL_USING_P (fns
))
2520 OVL_USING_P (lookup
) = true;
2523 /* And now skip this function. */
2529 /* We ended in a set of new functions. Add them all in one go. */
2530 lookup
= lookup_add (fns
, lookup
);
2535 /* Returns nonzero if X is an expression for a (possibly overloaded)
2536 function. If "f" is a function or function template, "f", "c->f",
2537 "c.f", "C::f", and "f<int>" will all be considered possibly
2538 overloaded functions. Returns 2 if the function is actually
2539 overloaded, i.e., if it is impossible to know the type of the
2540 function without performing overload resolution. */
2543 is_overloaded_fn (tree x
)
2545 STRIP_ANY_LOCATION_WRAPPER (x
);
2547 /* A baselink is also considered an overloaded function. */
2548 if (TREE_CODE (x
) == OFFSET_REF
2549 || TREE_CODE (x
) == COMPONENT_REF
)
2550 x
= TREE_OPERAND (x
, 1);
2551 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2552 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2553 x
= TREE_OPERAND (x
, 0);
2555 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2556 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2562 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2563 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2567 dependent_name (tree x
)
2569 /* FIXME a dependent name must be unqualified, but this function doesn't
2570 distinguish between qualified and unqualified identifiers. */
2571 if (identifier_p (x
))
2573 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2574 x
= TREE_OPERAND (x
, 0);
2576 return OVL_NAME (x
);
2580 /* Like dependent_name, but instead takes a CALL_EXPR and also checks
2584 call_expr_dependent_name (tree x
)
2586 if (TREE_TYPE (x
) != NULL_TREE
)
2587 /* X isn't dependent, so its callee isn't a dependent name. */
2589 return dependent_name (CALL_EXPR_FN (x
));
2592 /* Returns true iff X is an expression for an overloaded function
2593 whose type cannot be known without performing overload
2597 really_overloaded_fn (tree x
)
2599 return is_overloaded_fn (x
) == 2;
2602 /* Get the overload set FROM refers to. Returns NULL if it's not an
2606 maybe_get_fns (tree from
)
2608 STRIP_ANY_LOCATION_WRAPPER (from
);
2610 /* A baselink is also considered an overloaded function. */
2611 if (TREE_CODE (from
) == OFFSET_REF
2612 || TREE_CODE (from
) == COMPONENT_REF
)
2613 from
= TREE_OPERAND (from
, 1);
2614 if (BASELINK_P (from
))
2615 from
= BASELINK_FUNCTIONS (from
);
2616 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2617 from
= TREE_OPERAND (from
, 0);
2625 /* FROM refers to an overload set. Return that set (or die). */
2630 tree res
= maybe_get_fns (from
);
2636 /* Return the first function of the overload set FROM refers to. */
2639 get_first_fn (tree from
)
2641 return OVL_FIRST (get_fns (from
));
2644 /* Return the scope where the overloaded functions OVL were found. */
2647 ovl_scope (tree ovl
)
2649 if (TREE_CODE (ovl
) == OFFSET_REF
2650 || TREE_CODE (ovl
) == COMPONENT_REF
)
2651 ovl
= TREE_OPERAND (ovl
, 1);
2652 if (TREE_CODE (ovl
) == BASELINK
)
2653 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2654 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2655 ovl
= TREE_OPERAND (ovl
, 0);
2656 /* Skip using-declarations. */
2657 lkp_iterator
iter (ovl
);
2660 while (iter
.using_p () && ++iter
);
2662 return CP_DECL_CONTEXT (ovl
);
2665 #define PRINT_RING_SIZE 4
2668 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2670 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2671 static char *print_ring
[PRINT_RING_SIZE
];
2672 static bool trans_ring
[PRINT_RING_SIZE
];
2673 static int ring_counter
;
2676 /* Only cache functions. */
2678 || TREE_CODE (decl
) != FUNCTION_DECL
2679 || DECL_LANG_SPECIFIC (decl
) == 0)
2680 return lang_decl_name (decl
, v
, translate
);
2682 /* See if this print name is lying around. */
2683 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2684 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2685 /* yes, so return it. */
2686 return print_ring
[i
];
2688 if (++ring_counter
== PRINT_RING_SIZE
)
2691 if (current_function_decl
!= NULL_TREE
)
2693 /* There may be both translated and untranslated versions of the
2695 for (i
= 0; i
< 2; i
++)
2697 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2699 if (ring_counter
== PRINT_RING_SIZE
)
2702 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2705 free (print_ring
[ring_counter
]);
2707 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2708 uid_ring
[ring_counter
] = DECL_UID (decl
);
2709 trans_ring
[ring_counter
] = translate
;
2710 return print_ring
[ring_counter
];
2714 cxx_printable_name (tree decl
, int v
)
2716 return cxx_printable_name_internal (decl
, v
, false);
2720 cxx_printable_name_translate (tree decl
, int v
)
2722 return cxx_printable_name_internal (decl
, v
, true);
2725 /* Return the canonical version of exception-specification RAISES for a C++17
2726 function type, for use in type comparison and building TYPE_CANONICAL. */
2729 canonical_eh_spec (tree raises
)
2731 if (raises
== NULL_TREE
)
2733 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2734 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2735 || uses_template_parms (raises
)
2736 || uses_template_parms (TREE_PURPOSE (raises
)))
2737 /* Keep a dependent or deferred exception specification. */
2739 else if (nothrow_spec_p (raises
))
2740 /* throw() -> noexcept. */
2741 return noexcept_true_spec
;
2743 /* For C++17 type matching, anything else -> nothing. */
2748 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2749 tree raises
, bool late
)
2751 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2753 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2756 tree v
= TYPE_MAIN_VARIANT (type
);
2757 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2758 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2761 /* Need to build a new variant. */
2762 v
= build_variant_type_copy (type
);
2763 if (!TYPE_DEPENDENT_P (v
))
2764 /* We no longer know that it's not type-dependent. */
2765 TYPE_DEPENDENT_P_VALID (v
) = false;
2766 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2767 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2770 case REF_QUAL_RVALUE
:
2771 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2772 FUNCTION_REF_QUALIFIED (v
) = 1;
2774 case REF_QUAL_LVALUE
:
2775 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2776 FUNCTION_REF_QUALIFIED (v
) = 1;
2779 FUNCTION_REF_QUALIFIED (v
) = 0;
2783 /* Canonicalize the exception specification. */
2784 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2786 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2787 /* Propagate structural equality. */
2788 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2789 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2790 /* Build the underlying canonical type, since it is different
2792 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2795 /* T is its own canonical type. */
2796 TYPE_CANONICAL (v
) = v
;
2801 /* TYPE is a function or method type with a deferred exception
2802 specification that has been parsed to RAISES. Fixup all the type
2803 variants that are affected in place. Via decltype &| noexcept
2804 tricks, the unparsed spec could have escaped into the type system.
2805 The general case is hard to fixup canonical types for. */
2808 fixup_deferred_exception_variants (tree type
, tree raises
)
2810 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2811 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2813 gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original
));
2815 /* Though sucky, this walk will process the canonical variants
2817 tree prev
= NULL_TREE
;
2818 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2819 variant
; prev
= variant
, variant
= TYPE_NEXT_VARIANT (variant
))
2820 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2822 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2824 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2826 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2827 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2829 /* If VARIANT would become a dup (cp_check_qualified_type-wise)
2830 of an existing variant in the variant list of TYPE after its
2831 exception specification has been parsed, elide it. Otherwise,
2832 build_cp_fntype_variant could use it, leading to "canonical
2833 types differ for identical types." */
2834 tree v
= TYPE_MAIN_VARIANT (type
);
2835 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2836 if (cp_check_qualified_type (v
, variant
, var_quals
,
2839 /* The main variant will not match V, so PREV will never
2841 TYPE_NEXT_VARIANT (prev
) = TYPE_NEXT_VARIANT (variant
);
2844 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2847 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2849 TYPE_CANONICAL (variant
) = TYPE_CANONICAL (v
);
2852 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2854 if (!TYPE_DEPENDENT_P (variant
))
2855 /* We no longer know that it's not type-dependent. */
2856 TYPE_DEPENDENT_P_VALID (variant
) = false;
2860 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2861 listed in RAISES. */
2864 build_exception_variant (tree type
, tree raises
)
2866 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2867 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2868 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2871 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2872 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2876 bind_template_template_parm (tree t
, tree newargs
)
2878 tree decl
= TYPE_NAME (t
);
2881 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2882 decl
= build_decl (input_location
,
2883 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2884 SET_DECL_TEMPLATE_PARM_P (decl
);
2886 /* These nodes have to be created to reflect new TYPE_DECL and template
2888 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2889 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2890 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2891 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2893 TREE_TYPE (decl
) = t2
;
2894 TYPE_NAME (t2
) = decl
;
2895 TYPE_STUB_DECL (t2
) = decl
;
2898 if (any_template_arguments_need_structural_equality_p (newargs
))
2899 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2901 TYPE_CANONICAL (t2
) = canonical_type_parameter (t2
);
2906 /* Called from count_trees via walk_tree. */
2909 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2919 /* Debugging function for measuring the rough complexity of a tree
2923 count_trees (tree t
)
2926 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2930 /* Called from verify_stmt_tree via walk_tree. */
2933 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2936 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2937 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2940 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2943 /* If this statement is already present in the hash table, then
2944 there is a circularity in the statement tree. */
2945 gcc_assert (!statements
->find (t
));
2947 slot
= statements
->find_slot (t
, INSERT
);
2953 /* Debugging function to check that the statement T has not been
2954 corrupted. For now, this function simply checks that T contains no
2958 verify_stmt_tree (tree t
)
2960 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2961 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2964 /* Check if the type T depends on a type with no linkage and if so,
2965 return it. If RELAXED_P then do not consider a class type declared
2966 within a vague-linkage function to have no linkage. Remember:
2967 no-linkage is not the same as internal-linkage. */
2970 no_linkage_check (tree t
, bool relaxed_p
)
2974 /* Lambda types that don't have mangling scope have no linkage. We
2975 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2976 when we get here from pushtag none of the lambda information is
2977 set up yet, so we want to assume that the lambda has linkage and
2978 fix it up later if not. We need to check this even in templates so
2979 that we properly handle a lambda-expression in the signature. */
2980 if (LAMBDA_TYPE_P (t
)
2981 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2983 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2988 /* Otherwise there's no point in checking linkage on template functions; we
2989 can't know their complete types. */
2990 if (processing_template_decl
)
2993 switch (TREE_CODE (t
))
2996 if (TYPE_PTRMEMFUNC_P (t
))
3000 if (!CLASS_TYPE_P (t
))
3004 /* Only treat unnamed types as having no linkage if they're at
3005 namespace scope. This is core issue 966. */
3006 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
3009 for (r
= CP_TYPE_CONTEXT (t
); ; )
3011 /* If we're a nested type of a !TREE_PUBLIC class, we might not
3012 have linkage, or we might just be in an anonymous namespace.
3013 If we're in a TREE_PUBLIC class, we have linkage. */
3014 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
3015 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
3016 else if (TREE_CODE (r
) == FUNCTION_DECL
)
3018 if (!relaxed_p
|| !vague_linkage_p (r
))
3021 r
= CP_DECL_CONTEXT (r
);
3031 case REFERENCE_TYPE
:
3033 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3037 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
3041 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
3046 tree parm
= TYPE_ARG_TYPES (t
);
3047 if (TREE_CODE (t
) == METHOD_TYPE
)
3048 /* The 'this' pointer isn't interesting; a method has the same
3049 linkage (or lack thereof) as its enclosing class. */
3050 parm
= TREE_CHAIN (parm
);
3052 parm
&& parm
!= void_list_node
;
3053 parm
= TREE_CHAIN (parm
))
3055 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
3059 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3067 extern int depth_reached
;
3070 cxx_print_statistics (void)
3072 print_template_statistics ();
3073 if (GATHER_STATISTICS
)
3074 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
3078 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3079 (which is an ARRAY_TYPE). This counts only elements of the top
3083 array_type_nelts_top (tree type
)
3085 return fold_build2_loc (input_location
,
3086 PLUS_EXPR
, sizetype
,
3087 array_type_nelts (type
),
3091 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3092 (which is an ARRAY_TYPE). This one is a recursive count of all
3093 ARRAY_TYPEs that are clumped together. */
3096 array_type_nelts_total (tree type
)
3098 tree sz
= array_type_nelts_top (type
);
3099 type
= TREE_TYPE (type
);
3100 while (TREE_CODE (type
) == ARRAY_TYPE
)
3102 tree n
= array_type_nelts_top (type
);
3103 sz
= fold_build2_loc (input_location
,
3104 MULT_EXPR
, sizetype
, sz
, n
);
3105 type
= TREE_TYPE (type
);
3112 splay_tree target_remap
;
3113 bool clear_location
;
3116 /* Called from break_out_target_exprs via mapcar. */
3119 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
3121 bot_data
&data
= *(bot_data
*)data_
;
3122 splay_tree target_remap
= data
.target_remap
;
3125 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
3127 /* There can't be any TARGET_EXPRs or their slot variables below this
3128 point. But we must make a copy, in case subsequent processing
3129 alters any part of it. For example, during gimplification a cast
3130 of the form (T) &X::f (where "f" is a member function) will lead
3131 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3133 *tp
= unshare_expr (t
);
3136 if (TREE_CODE (t
) == TARGET_EXPR
)
3140 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3142 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3143 tf_warning_or_error
);
3144 if (u
== error_mark_node
)
3146 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3147 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3150 u
= force_target_expr (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3151 tf_warning_or_error
);
3153 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3154 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3155 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3156 TARGET_EXPR_ELIDING_P (u
) = TARGET_EXPR_ELIDING_P (t
);
3158 /* Map the old variable to the new one. */
3159 splay_tree_insert (target_remap
,
3160 (splay_tree_key
) TREE_OPERAND (t
, 0),
3161 (splay_tree_value
) TREE_OPERAND (u
, 0));
3163 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3164 data
.clear_location
);
3165 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3166 return error_mark_node
;
3168 /* Replace the old expression with the new version. */
3170 /* We don't have to go below this point; the recursive call to
3171 break_out_target_exprs will have handled anything below this
3176 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3179 splay_tree_node n
= splay_tree_lookup (target_remap
,
3180 (splay_tree_key
) t
);
3183 *tp
= (tree
)n
->value
;
3188 copy_tree_r (tp
, walk_subtrees
, NULL
);
3189 splay_tree_insert (target_remap
,
3191 (splay_tree_value
)*tp
);
3192 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3193 splay_tree_insert (target_remap
,
3194 (splay_tree_key
)*tp
,
3195 (splay_tree_value
)*tp
);
3199 if (TREE_CODE (*tp
) == DECL_EXPR
3200 && VAR_P (DECL_EXPR_DECL (*tp
))
3201 && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp
))
3202 && !TREE_STATIC (DECL_EXPR_DECL (*tp
)))
3206 = splay_tree_lookup (target_remap
,
3207 (splay_tree_key
) DECL_EXPR_DECL (*tp
));
3209 t
= (tree
) n
->value
;
3212 t
= create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp
)));
3213 DECL_INITIAL (t
) = DECL_INITIAL (DECL_EXPR_DECL (*tp
));
3214 splay_tree_insert (target_remap
,
3215 (splay_tree_key
) DECL_EXPR_DECL (*tp
),
3216 (splay_tree_value
) t
);
3218 copy_tree_r (tp
, walk_subtrees
, NULL
);
3219 DECL_EXPR_DECL (*tp
) = t
;
3220 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3221 SET_EXPR_LOCATION (*tp
, input_location
);
3224 if (TREE_CODE (*tp
) == BIND_EXPR
&& BIND_EXPR_VARS (*tp
))
3226 copy_tree_r (tp
, walk_subtrees
, NULL
);
3227 for (tree
*p
= &BIND_EXPR_VARS (*tp
); *p
; p
= &DECL_CHAIN (*p
))
3229 gcc_assert (VAR_P (*p
) && DECL_ARTIFICIAL (*p
) && !TREE_STATIC (*p
));
3230 tree t
= create_temporary_var (TREE_TYPE (*p
));
3231 DECL_INITIAL (t
) = DECL_INITIAL (*p
);
3232 DECL_CHAIN (t
) = DECL_CHAIN (*p
);
3233 splay_tree_insert (target_remap
, (splay_tree_key
) *p
,
3234 (splay_tree_value
) t
);
3237 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3238 SET_EXPR_LOCATION (*tp
, input_location
);
3242 /* Make a copy of this node. */
3243 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3244 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3245 if (!processing_template_decl
)
3246 set_flags_from_callee (*tp
);
3247 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3248 SET_EXPR_LOCATION (*tp
, input_location
);
3252 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3253 DATA is really a splay-tree mapping old variables to new
3257 bot_replace (tree
* t
, int */
*walk_subtrees*/
, void* data_
)
3259 bot_data
&data
= *(bot_data
*)data_
;
3260 splay_tree target_remap
= data
.target_remap
;
3264 splay_tree_node n
= splay_tree_lookup (target_remap
,
3265 (splay_tree_key
) *t
);
3267 *t
= (tree
) n
->value
;
3269 else if (TREE_CODE (*t
) == PARM_DECL
3270 && DECL_NAME (*t
) == this_identifier
3271 && !DECL_CONTEXT (*t
))
3273 /* In an NSDMI we need to replace the 'this' parameter we used for
3274 parsing with the real one for this function. */
3275 *t
= current_class_ptr
;
3277 else if (TREE_CODE (*t
) == CONVERT_EXPR
3278 && CONVERT_EXPR_VBASE_PATH (*t
))
3280 /* In an NSDMI build_base_path defers building conversions to morally
3281 virtual bases, and we handle it here. */
3282 tree basetype
= TREE_TYPE (*t
);
3283 *t
= convert_to_base (TREE_OPERAND (*t
, 0), basetype
,
3284 /*check_access=*/false, /*nonnull=*/true,
3285 tf_warning_or_error
);
3291 /* When we parse a default argument expression, we may create
3292 temporary variables via TARGET_EXPRs. When we actually use the
3293 default-argument expression, we make a copy of the expression
3294 and replace the temporaries with appropriate local versions.
3296 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3300 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3302 static int target_remap_count
;
3303 static splay_tree target_remap
;
3305 /* We shouldn't be called on templated trees, nor do we want to
3307 gcc_checking_assert (!processing_template_decl
);
3309 if (!target_remap_count
++)
3310 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3311 /*splay_tree_delete_key_fn=*/NULL
,
3312 /*splay_tree_delete_value_fn=*/NULL
);
3313 bot_data data
= { target_remap
, clear_location
};
3314 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3315 t
= error_mark_node
;
3316 if (cp_walk_tree (&t
, bot_replace
, &data
, NULL
) == error_mark_node
)
3317 t
= error_mark_node
;
3319 if (!--target_remap_count
)
3321 splay_tree_delete (target_remap
);
3322 target_remap
= NULL
;
3328 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3329 which we expect to have type TYPE. */
3332 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3334 if (index
== NULL_TREE
)
3335 /* Can't refer to a particular member of a vector. */
3337 else if (TREE_CODE (index
) == INTEGER_CST
)
3338 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3340 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3341 /*reference*/false, tf_none
);
3344 tree objtype
= TREE_TYPE (obj
);
3345 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3347 /* When the destination object refers to a flexible array member
3348 verify that it matches the type of the source object except
3349 for its domain and qualifiers. */
3350 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3351 TYPE_MAIN_VARIANT (objtype
),
3352 COMPARE_REDECLARATION
));
3355 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3361 struct replace_placeholders_t
3363 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3364 tree exp
; /* The outermost exp. */
3365 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3366 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3369 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3370 build up subexpressions as we go deeper. */
3373 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3375 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3378 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3380 *walk_subtrees
= false;
3384 switch (TREE_CODE (*t
))
3386 case PLACEHOLDER_EXPR
:
3389 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3391 x
= TREE_OPERAND (x
, 0))
3392 gcc_assert (handled_component_p (x
));
3393 *t
= unshare_expr (x
);
3394 *walk_subtrees
= false;
3401 constructor_elt
*ce
;
3402 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3403 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3404 other than the d->exp one, those have PLACEHOLDER_EXPRs
3405 related to another object. */
3406 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3408 || d
->pset
->add (*t
))
3410 *walk_subtrees
= false;
3413 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3415 tree
*valp
= &ce
->value
;
3416 tree type
= TREE_TYPE (*valp
);
3419 /* Elements with RANGE_EXPR index shouldn't have any
3420 placeholders in them. */
3421 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3424 if (TREE_CODE (*valp
) == CONSTRUCTOR
3425 && AGGREGATE_TYPE_P (type
))
3427 /* If we're looking at the initializer for OBJ, then build
3428 a sub-object reference. If we're looking at an
3429 initializer for another object, just pass OBJ down. */
3430 if (same_type_ignoring_top_level_qualifiers_p
3431 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3432 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3433 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3434 valp
= &TARGET_EXPR_INITIAL (*valp
);
3437 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3440 *walk_subtrees
= false;
3445 if (d
->pset
->add (*t
))
3446 *walk_subtrees
= false;
3453 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3454 a PLACEHOLDER_EXPR has been encountered. */
3457 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3459 /* This is only relevant for C++14. */
3460 if (cxx_dialect
< cxx14
)
3463 /* If the object isn't a (member of a) class, do nothing. */
3465 while (handled_component_p (op0
))
3466 op0
= TREE_OPERAND (op0
, 0);
3467 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3471 if (TREE_CODE (exp
) == TARGET_EXPR
)
3472 tp
= &TARGET_EXPR_INITIAL (exp
);
3473 hash_set
<tree
> pset
;
3474 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3475 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3477 *seen_p
= data
.seen
;
3481 /* Callback function for find_placeholders. */
3484 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3486 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3488 *walk_subtrees
= false;
3492 switch (TREE_CODE (*t
))
3494 case PLACEHOLDER_EXPR
:
3498 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3499 *walk_subtrees
= false;
3509 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3510 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3513 find_placeholders (tree exp
)
3515 /* This is only relevant for C++14. */
3516 if (cxx_dialect
< cxx14
)
3519 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3522 /* Similar to `build_nt', but for template definitions of dependent
3526 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3533 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3537 t
= make_node (code
);
3538 SET_EXPR_LOCATION (t
, loc
);
3539 length
= TREE_CODE_LENGTH (code
);
3541 for (i
= 0; i
< length
; i
++)
3542 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3548 /* Similar to `build', but for template definitions. */
3551 build_min (enum tree_code code
, tree tt
, ...)
3558 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3562 t
= make_node (code
);
3563 length
= TREE_CODE_LENGTH (code
);
3566 for (i
= 0; i
< length
; i
++)
3568 tree x
= va_arg (p
, tree
);
3569 TREE_OPERAND (t
, i
) = x
;
3570 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3571 TREE_SIDE_EFFECTS (t
) = 1;
3579 /* Similar to `build', but for template definitions of non-dependent
3580 expressions. NON_DEP is the non-dependent expression that has been
3584 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3591 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3593 va_start (p
, non_dep
);
3595 if (REFERENCE_REF_P (non_dep
))
3596 non_dep
= TREE_OPERAND (non_dep
, 0);
3598 t
= make_node (code
);
3599 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3600 length
= TREE_CODE_LENGTH (code
);
3601 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3602 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3604 for (i
= 0; i
< length
; i
++)
3605 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3608 return convert_from_reference (t
);
3611 /* Similar to build_min_nt, but call expressions */
3614 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3619 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3620 CALL_EXPR_FN (ret
) = fn
;
3621 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3622 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3623 CALL_EXPR_ARG (ret
, ix
) = t
;
3628 /* Similar to `build_min_nt_call_vec', but for template definitions of
3629 non-dependent expressions. NON_DEP is the non-dependent expression
3630 that has been built. */
3633 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3635 tree t
= build_min_nt_call_vec (fn
, argvec
);
3636 if (REFERENCE_REF_P (non_dep
))
3637 non_dep
= TREE_OPERAND (non_dep
, 0);
3638 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3639 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3640 return convert_from_reference (t
);
3643 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3644 a call to an operator overload. OP is the operator that has been
3645 overloaded. NON_DEP is the non-dependent expression that's been built,
3646 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3647 the overload that NON_DEP is calling. */
3650 build_min_non_dep_op_overload (enum tree_code op
,
3655 int nargs
, expected_nargs
;
3656 tree fn
, call
, obj
= NULL_TREE
;
3658 non_dep
= extract_call_expr (non_dep
);
3660 nargs
= call_expr_nargs (non_dep
);
3662 expected_nargs
= cp_tree_code_length (op
);
3663 if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
3664 /* For ARRAY_REF, operator[] is either a non-static member or newly
3665 static member, never out of class and for the static member case
3666 if user uses single index the operator[] needs to have a single
3667 argument as well, but the function is called with 2 - the object
3668 it is invoked on and the index. */
3670 expected_nargs
-= 1;
3671 if ((op
== POSTINCREMENT_EXPR
3672 || op
== POSTDECREMENT_EXPR
)
3673 /* With -fpermissive non_dep could be operator++(). */
3674 && (!flag_permissive
|| nargs
!= expected_nargs
))
3675 expected_nargs
+= 1;
3676 gcc_assert (nargs
== expected_nargs
);
3679 va_start (p
, overload
);
3681 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3684 if (op
== ARRAY_REF
)
3685 obj
= va_arg (p
, tree
);
3686 for (int i
= 0; i
< nargs
; i
++)
3688 tree arg
= va_arg (p
, tree
);
3689 vec_safe_push (args
, arg
);
3692 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3694 tree object
= va_arg (p
, tree
);
3695 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3696 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3697 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3698 object
, method
, NULL_TREE
);
3699 for (int i
= 0; i
< nargs
; i
++)
3701 tree arg
= va_arg (p
, tree
);
3702 vec_safe_push (args
, arg
);
3709 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3711 tree call_expr
= extract_call_expr (call
);
3712 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3713 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3714 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3715 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3718 return keep_unused_object_arg (call
, obj
, overload
);
3722 /* Similar to above build_min_non_dep_op_overload, but arguments
3723 are taken from ARGS vector. */
3726 build_min_non_dep_op_overload (tree non_dep
, tree overload
, tree object
,
3727 vec
<tree
, va_gc
> *args
)
3729 non_dep
= extract_call_expr (non_dep
);
3731 unsigned int nargs
= call_expr_nargs (non_dep
);
3733 if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3735 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3736 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3737 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3738 object
, method
, NULL_TREE
);
3741 gcc_assert (vec_safe_length (args
) == nargs
);
3743 tree call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3745 tree call_expr
= extract_call_expr (call
);
3746 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3747 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3748 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3749 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3752 return keep_unused_object_arg (call
, object
, overload
);
3756 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3759 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3761 unsigned len
= vec_safe_length (old_vec
);
3762 gcc_assert (idx
<= len
);
3764 vec
<tree
, va_gc
> *new_vec
= NULL
;
3765 vec_alloc (new_vec
, len
+ 1);
3768 for (i
= 0; i
< len
; ++i
)
3771 new_vec
->quick_push (elt
);
3772 new_vec
->quick_push ((*old_vec
)[i
]);
3775 new_vec
->quick_push (elt
);
3781 get_type_decl (tree t
)
3783 if (TREE_CODE (t
) == TYPE_DECL
)
3786 return TYPE_STUB_DECL (t
);
3787 gcc_assert (t
== error_mark_node
);
3791 /* Returns the namespace that contains DECL, whether directly or
3795 decl_namespace_context (tree decl
)
3799 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3801 else if (TYPE_P (decl
))
3802 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3804 decl
= CP_DECL_CONTEXT (decl
);
3808 /* Returns true if decl is within an anonymous namespace, however deeply
3809 nested, or false otherwise. */
3812 decl_anon_ns_mem_p (tree decl
)
3814 return !TREE_PUBLIC (decl_namespace_context (decl
));
3817 /* Returns true if the enclosing scope of DECL has internal or no linkage. */
3820 decl_internal_context_p (const_tree decl
)
3822 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3824 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3826 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3828 decl
= CP_DECL_CONTEXT (decl
);
3830 return !TREE_PUBLIC (decl
);
3833 /* Subroutine of cp_tree_equal: t1 and t2 are two CALL_EXPRs.
3834 Return whether their CALL_EXPR_FNs are equivalent. */
3837 called_fns_equal (tree t1
, tree t2
)
3839 /* Core 1321: dependent names are equivalent even if the overload sets
3840 are different. But do compare explicit template arguments. */
3841 tree name1
= call_expr_dependent_name (t1
);
3842 tree name2
= call_expr_dependent_name (t2
);
3843 t1
= CALL_EXPR_FN (t1
);
3844 t2
= CALL_EXPR_FN (t2
);
3847 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3852 /* FIXME dependent_name currently returns an unqualified name regardless
3853 of whether the function was named with a qualified- or unqualified-id.
3854 Until that's fixed, check that we aren't looking at overload sets from
3855 different scopes. */
3856 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3857 && (DECL_CONTEXT (get_first_fn (t1
))
3858 != DECL_CONTEXT (get_first_fn (t2
))))
3861 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3862 targs1
= TREE_OPERAND (t1
, 1);
3863 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3864 targs2
= TREE_OPERAND (t2
, 1);
3865 return cp_tree_equal (targs1
, targs2
);
3868 return cp_tree_equal (t1
, t2
);
3871 bool comparing_override_contracts
;
3873 /* In a component reference, return the innermost object of
3874 the postfix-expression. */
3877 get_innermost_component (tree t
)
3879 gcc_assert (TREE_CODE (t
) == COMPONENT_REF
);
3880 while (TREE_CODE (t
) == COMPONENT_REF
)
3881 t
= TREE_OPERAND (t
, 0);
3885 /* Returns true if T is a possibly converted 'this' or '*this' expression. */
3888 is_this_expression (tree t
)
3890 t
= get_innermost_component (t
);
3891 /* See through deferences and no-op conversions. */
3892 if (INDIRECT_REF_P (t
))
3893 t
= TREE_OPERAND (t
, 0);
3894 if (TREE_CODE (t
) == NOP_EXPR
)
3895 t
= TREE_OPERAND (t
, 0);
3896 return is_this_parameter (t
);
3900 comparing_this_references (tree t1
, tree t2
)
3902 return is_this_expression (t1
) && is_this_expression (t2
);
3906 equivalent_member_references (tree t1
, tree t2
)
3908 if (!comparing_this_references (t1
, t2
))
3910 t1
= TREE_OPERAND (t1
, 1);
3911 t2
= TREE_OPERAND (t2
, 1);
3915 /* Return truthvalue of whether T1 is the same tree structure as T2.
3916 Return 1 if they are the same. Return 0 if they are different. */
3919 cp_tree_equal (tree t1
, tree t2
)
3921 enum tree_code code1
, code2
;
3928 code1
= TREE_CODE (t1
);
3929 code2
= TREE_CODE (t2
);
3934 if (CONSTANT_CLASS_P (t1
)
3935 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3941 /* There's only a single VOID_CST node, so we should never reach
3946 return tree_int_cst_equal (t1
, t2
);
3949 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3952 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3953 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3954 TREE_STRING_LENGTH (t1
));
3957 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3958 TREE_FIXED_CST (t2
));
3961 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3962 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3965 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3968 /* We need to do this when determining whether or not two
3969 non-type pointer to member function template arguments
3971 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3972 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3977 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3979 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3980 if (!cp_tree_equal (field
, elt2
->index
)
3981 || !cp_tree_equal (value
, elt2
->value
))
3988 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3990 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3992 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3995 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3999 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
4002 if (!called_fns_equal (t1
, t2
))
4005 call_expr_arg_iterator iter1
, iter2
;
4006 init_call_expr_arg_iterator (t1
, &iter1
);
4007 init_call_expr_arg_iterator (t2
, &iter2
);
4008 if (iter1
.n
!= iter2
.n
)
4011 while (more_call_expr_args_p (&iter1
))
4013 tree arg1
= next_call_expr_arg (&iter1
);
4014 tree arg2
= next_call_expr_arg (&iter2
);
4016 gcc_checking_assert (arg1
&& arg2
);
4017 if (!cp_tree_equal (arg1
, arg2
))
4026 tree o1
= TREE_OPERAND (t1
, 0);
4027 tree o2
= TREE_OPERAND (t2
, 0);
4029 /* Special case: if either target is an unallocated VAR_DECL,
4030 it means that it's going to be unified with whatever the
4031 TARGET_EXPR is really supposed to initialize, so treat it
4032 as being equivalent to anything. */
4033 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
4034 && !DECL_RTL_SET_P (o1
))
4036 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
4037 && !DECL_RTL_SET_P (o2
))
4039 else if (!cp_tree_equal (o1
, o2
))
4042 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4046 /* For comparing uses of parameters in late-specified return types
4047 with an out-of-class definition of the function, but can also come
4048 up for expressions that involve 'this' in a member function
4051 if (comparing_specializations
4052 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
4053 /* When comparing hash table entries, only an exact match is
4054 good enough; we don't want to replace 'this' with the
4055 version from another function. But be more flexible
4056 with parameters with identical contexts. */
4059 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4061 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
4063 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
4065 if (DECL_ARTIFICIAL (t1
)
4066 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
4067 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
4077 case IDENTIFIER_NODE
:
4080 case DEFERRED_PARSE
:
4084 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
4085 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
4086 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
4087 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
4088 BASELINK_FUNCTIONS (t2
)));
4090 case TEMPLATE_PARM_INDEX
:
4091 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
4092 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
4093 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
4094 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
4095 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
4096 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
4098 case TEMPLATE_ID_EXPR
:
4099 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4101 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
4105 case CONSTRAINT_INFO
:
4106 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
4107 CI_ASSOCIATED_CONSTRAINTS (t2
));
4110 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
4111 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
4112 CHECK_CONSTR_ARGS (t2
)));
4115 /* These are template args. Really we should be getting the
4116 caller to do this as it knows it to be true. */
4117 if (!comp_template_args (t1
, t2
, NULL
, NULL
, false))
4124 tree o1
= TREE_OPERAND (t1
, 0);
4125 tree o2
= TREE_OPERAND (t2
, 0);
4127 if (code1
== SIZEOF_EXPR
)
4129 if (SIZEOF_EXPR_TYPE_P (t1
))
4130 o1
= TREE_TYPE (o1
);
4131 if (SIZEOF_EXPR_TYPE_P (t2
))
4132 o2
= TREE_TYPE (o2
);
4134 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
4137 if (TREE_CODE (o1
) != TREE_CODE (o2
))
4140 if (ARGUMENT_PACK_P (o1
))
4141 return template_args_equal (o1
, o2
);
4142 else if (TYPE_P (o1
))
4143 return same_type_p (o1
, o2
);
4145 return cp_tree_equal (o1
, o2
);
4150 tree t1_op1
, t2_op1
;
4152 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4155 t1_op1
= TREE_OPERAND (t1
, 1);
4156 t2_op1
= TREE_OPERAND (t2
, 1);
4157 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
4160 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
4164 /* Two pointer-to-members are the same if they point to the same
4165 field or function in the same class. */
4166 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
4169 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
4173 /* Two overloads. Must be exactly the same set of decls. */
4174 lkp_iterator
first (t1
);
4175 lkp_iterator
second (t2
);
4177 for (; first
&& second
; ++first
, ++second
)
4178 if (*first
!= *second
)
4180 return !(first
|| second
);
4184 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
4186 return cp_tree_equal (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
4187 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
4189 case NON_LVALUE_EXPR
:
4190 case VIEW_CONVERT_EXPR
:
4191 /* Used for location wrappers with possibly NULL types. */
4192 if (!TREE_TYPE (t1
) || !TREE_TYPE (t2
))
4194 if (TREE_TYPE (t1
) || TREE_TYPE (t2
))
4201 case STATIC_CAST_EXPR
:
4202 case REINTERPRET_CAST_EXPR
:
4203 case CONST_CAST_EXPR
:
4204 case DYNAMIC_CAST_EXPR
:
4205 case IMPLICIT_CONV_EXPR
:
4209 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4211 /* Now compare operands as usual. */
4214 case DEFERRED_NOEXCEPT
:
4215 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
4216 DEFERRED_NOEXCEPT_PATTERN (t2
))
4217 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
4218 DEFERRED_NOEXCEPT_ARGS (t2
)));
4221 /* Two lambda-expressions are never considered equivalent. */
4224 case TYPE_ARGUMENT_PACK
:
4225 case NONTYPE_ARGUMENT_PACK
:
4227 tree p1
= ARGUMENT_PACK_ARGS (t1
);
4228 tree p2
= ARGUMENT_PACK_ARGS (t2
);
4229 int len
= TREE_VEC_LENGTH (p1
);
4230 if (TREE_VEC_LENGTH (p2
) != len
)
4233 for (int ix
= 0; ix
!= len
; ix
++)
4234 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
4235 TREE_VEC_ELT (p2
, ix
)))
4240 case EXPR_PACK_EXPANSION
:
4241 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
4242 PACK_EXPANSION_PATTERN (t2
)))
4244 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
4245 PACK_EXPANSION_EXTRA_ARGS (t2
)))
4250 /* If we're comparing contract conditions of overrides, member references
4251 compare equal if they designate the same member. */
4252 if (comparing_override_contracts
)
4253 return equivalent_member_references (t1
, t2
);
4260 switch (TREE_CODE_CLASS (code1
))
4264 case tcc_comparison
:
4265 case tcc_expression
:
4270 int n
= cp_tree_operand_length (t1
);
4271 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
4272 && n
!= TREE_OPERAND_LENGTH (t2
))
4275 for (int i
= 0; i
< n
; ++i
)
4276 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
4283 return same_type_p (t1
, t2
);
4289 /* We can get here with --disable-checking. */
4293 /* The type of ARG when used as an lvalue. */
4296 lvalue_type (tree arg
)
4298 tree type
= TREE_TYPE (arg
);
4302 /* The type of ARG for printing error messages; denote lvalues with
4306 error_type (tree arg
)
4308 tree type
= TREE_TYPE (arg
);
4310 if (TREE_CODE (type
) == ARRAY_TYPE
)
4312 else if (TREE_CODE (type
) == ERROR_MARK
)
4314 else if (lvalue_p (arg
))
4315 type
= build_reference_type (lvalue_type (arg
));
4316 else if (MAYBE_CLASS_TYPE_P (type
))
4317 type
= lvalue_type (arg
);
4322 /* Does FUNCTION use a variable-length argument list? */
4325 varargs_function_p (const_tree function
)
4327 return stdarg_p (TREE_TYPE (function
));
4330 /* Returns 1 if decl is a member of a class. */
4333 member_p (const_tree decl
)
4335 const_tree
const ctx
= DECL_CONTEXT (decl
);
4336 return (ctx
&& TYPE_P (ctx
));
4339 /* Create a placeholder for member access where we don't actually have an
4340 object that the access is against. For a general declval<T> equivalent,
4341 use build_stub_object instead. */
4344 build_dummy_object (tree type
)
4346 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4347 return cp_build_fold_indirect_ref (decl
);
4350 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4351 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4352 binfo path from current_class_type to TYPE, or 0. */
4355 maybe_dummy_object (tree type
, tree
* binfop
)
4359 tree current
= current_nonlambda_class_type ();
4362 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4363 tf_warning_or_error
)))
4367 /* Reference from a nested class member function. */
4369 binfo
= TYPE_BINFO (type
);
4375 /* current_class_ref might not correspond to current_class_type if
4376 we're in tsubst_default_argument or a lambda-declarator; in either
4377 case, we want to use current_class_ref if it matches CONTEXT. */
4378 tree ctype
= current_class_ref
? TREE_TYPE (current_class_ref
) : NULL_TREE
;
4380 && same_type_ignoring_top_level_qualifiers_p (ctype
, context
))
4381 decl
= current_class_ref
;
4384 /* Return a dummy object whose cv-quals are consistent with (the
4385 non-lambda) 'this' if available. */
4388 int quals
= TYPE_UNQUALIFIED
;
4389 if (tree lambda
= CLASSTYPE_LAMBDA_EXPR (ctype
))
4391 if (tree cap
= lambda_expr_this_capture (lambda
, false))
4392 quals
= cp_type_quals (TREE_TYPE (TREE_TYPE (cap
)));
4395 quals
= cp_type_quals (ctype
);
4396 context
= cp_build_qualified_type (context
, quals
);
4398 decl
= build_dummy_object (context
);
4404 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4407 is_dummy_object (const_tree ob
)
4409 if (INDIRECT_REF_P (ob
))
4410 ob
= TREE_OPERAND (ob
, 0);
4411 return (TREE_CODE (ob
) == CONVERT_EXPR
4412 && TREE_OPERAND (ob
, 0) == void_node
);
4415 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4418 is_byte_access_type (tree type
)
4420 type
= TYPE_MAIN_VARIANT (type
);
4421 if (type
== char_type_node
4422 || type
== unsigned_char_type_node
)
4425 return (TREE_CODE (type
) == ENUMERAL_TYPE
4426 && TYPE_CONTEXT (type
) == std_node
4427 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4430 /* Returns true if TYPE is unsigned char or std::byte. */
4433 is_byte_access_type_not_plain_char (tree type
)
4435 type
= TYPE_MAIN_VARIANT (type
);
4436 if (type
== char_type_node
)
4439 return is_byte_access_type (type
);
4442 /* Returns 1 iff type T is something we want to treat as a scalar type for
4443 the purpose of deciding whether it is trivial/POD/standard-layout. */
4446 scalarish_type_p (const_tree t
)
4448 if (t
== error_mark_node
)
4451 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4454 /* Returns true iff T requires non-trivial default initialization. */
4457 type_has_nontrivial_default_init (const_tree t
)
4459 t
= strip_array_types (CONST_CAST_TREE (t
));
4461 if (CLASS_TYPE_P (t
))
4462 return TYPE_HAS_COMPLEX_DFLT (t
);
4467 /* Track classes with only deleted copy/move constructors so that we can warn
4468 if they are used in call/return by value. */
4470 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4472 remember_deleted_copy (const_tree t
)
4474 if (!deleted_copy_types
)
4475 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4476 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4479 maybe_warn_parm_abi (tree t
, location_t loc
)
4481 if (!deleted_copy_types
4482 || !deleted_copy_types
->contains (t
))
4485 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4486 && classtype_has_non_deleted_move_ctor (t
))
4489 auto_diagnostic_group d
;
4490 if (flag_abi_version
> 12)
4491 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4492 "the calling convention for %qT, which was "
4493 "accidentally changed in 8.1", t
);
4495 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) "
4496 "accidentally changes the calling convention for %qT",
4499 inform (location_of (t
), " declared here");
4503 auto_diagnostic_group d
;
4504 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4505 "%<-fabi-version=13%> (GCC 8.2)", t
))
4506 inform (location_of (t
), " because all of its copy and move "
4507 "constructors are deleted");
4510 /* Returns true iff copying an object of type T (including via move
4511 constructor) is non-trivial. That is, T has no non-trivial copy
4512 constructors and no non-trivial move constructors, and not all copy/move
4513 constructors are deleted. This function implements the ABI notion of
4514 non-trivial copy, which has diverged from the one in the standard. */
4517 type_has_nontrivial_copy_init (const_tree type
)
4519 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4521 if (CLASS_TYPE_P (t
))
4523 gcc_assert (COMPLETE_TYPE_P (t
));
4525 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4526 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4530 if (cxx_dialect
< cxx11
)
4531 /* No deleted functions before C++11. */
4534 /* Before ABI v12 we did a bitwise copy of types with only deleted
4535 copy/move constructors. */
4536 if (!abi_version_at_least (12)
4537 && !(warn_abi
&& abi_version_crosses (12)))
4540 bool saw_copy
= false;
4541 bool saw_non_deleted
= false;
4542 bool saw_non_deleted_move
= false;
4544 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4545 saw_copy
= saw_non_deleted
= true;
4546 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4549 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4550 /* [class.copy]/8 If the class definition declares a move
4551 constructor or move assignment operator, the implicitly declared
4552 copy constructor is defined as deleted.... */;
4554 /* Any other reason the implicitly-declared function would be
4555 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4557 saw_non_deleted
= true;
4560 if (!saw_non_deleted
)
4561 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4567 if (!DECL_DELETED_FN (fn
))
4569 /* Not deleted, therefore trivial. */
4570 saw_non_deleted
= true;
4574 else if (move_fn_p (fn
))
4575 if (!DECL_DELETED_FN (fn
))
4576 saw_non_deleted_move
= true;
4579 gcc_assert (saw_copy
);
4581 /* ABI v12 buggily ignored move constructors. */
4582 bool v11nontriv
= false;
4583 bool v12nontriv
= !saw_non_deleted
;
4584 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4585 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4586 : flag_abi_version
== 12 ? v12nontriv
4588 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4589 : warn_abi_version
== 12 ? v12nontriv
4591 if (nontriv
!= warn_nontriv
)
4592 remember_deleted_copy (t
);
4600 /* Returns 1 iff type T is a trivially copyable type, as defined in
4601 [basic.types] and [class]. */
4604 trivially_copyable_p (const_tree t
)
4606 t
= strip_array_types (CONST_CAST_TREE (t
));
4608 if (CLASS_TYPE_P (t
))
4609 return ((!TYPE_HAS_COPY_CTOR (t
)
4610 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4611 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4612 && (!TYPE_HAS_COPY_ASSIGN (t
)
4613 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4614 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4615 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4617 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4618 return scalarish_type_p (t
);
4621 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4625 trivial_type_p (const_tree t
)
4627 t
= strip_array_types (CONST_CAST_TREE (t
));
4629 if (CLASS_TYPE_P (t
))
4630 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4631 && trivially_copyable_p (t
));
4633 return scalarish_type_p (t
);
4636 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4639 pod_type_p (const_tree t
)
4641 /* This CONST_CAST is okay because strip_array_types returns its
4642 argument unmodified and we assign it to a const_tree. */
4643 t
= strip_array_types (CONST_CAST_TREE(t
));
4645 if (!CLASS_TYPE_P (t
))
4646 return scalarish_type_p (t
);
4647 else if (cxx_dialect
> cxx98
)
4648 /* [class]/10: A POD struct is a class that is both a trivial class and a
4649 standard-layout class, and has no non-static data members of type
4650 non-POD struct, non-POD union (or array of such types).
4652 We don't need to check individual members because if a member is
4653 non-std-layout or non-trivial, the class will be too. */
4654 return (std_layout_type_p (t
) && trivial_type_p (t
));
4656 /* The C++98 definition of POD is different. */
4657 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4660 /* Returns true iff T is POD for the purpose of layout, as defined in the
4664 layout_pod_type_p (const_tree t
)
4666 t
= strip_array_types (CONST_CAST_TREE (t
));
4668 if (CLASS_TYPE_P (t
))
4669 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4671 return scalarish_type_p (t
);
4674 /* Returns true iff T is a standard-layout type, as defined in
4678 std_layout_type_p (const_tree t
)
4680 t
= strip_array_types (CONST_CAST_TREE (t
));
4682 if (CLASS_TYPE_P (t
))
4683 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4685 return scalarish_type_p (t
);
4688 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4690 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4691 as defined in [meta.unary.prop]. */
4694 type_has_unique_obj_representations (const_tree t
)
4698 t
= strip_array_types (CONST_CAST_TREE (t
));
4700 if (!trivially_copyable_p (t
))
4703 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4704 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4706 switch (TREE_CODE (t
))
4710 case REFERENCE_TYPE
:
4711 /* If some backend has any paddings in these types, we should add
4712 a target hook for this and handle it there. */
4716 /* For bool values other than 0 and 1 should only appear with
4717 undefined behavior. */
4721 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4724 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4725 when storing long double values, so for that we have to return false.
4726 Other kinds of floating point values are questionable due to +.0/-.0
4727 and NaNs, let's play safe for now. */
4730 case FIXED_POINT_TYPE
:
4738 return type_has_unique_obj_representations (TREE_TYPE (t
));
4741 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4742 if (CLASS_TYPE_P (t
))
4744 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4745 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4753 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4754 if (TREE_CODE (field
) == FIELD_DECL
)
4757 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4758 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4764 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4766 if (CLASS_TYPE_P (t
))
4768 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4769 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4784 /* Helper function for type_has_unique_obj_representations. */
4787 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4789 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4790 if (TREE_CODE (field
) != FIELD_DECL
)
4792 /* For bases, can't use type_has_unique_obj_representations here, as in
4793 struct S { int i : 24; S (); };
4794 struct T : public S { int j : 8; T (); };
4795 S doesn't have unique obj representations, but T does. */
4796 else if (DECL_FIELD_IS_BASE (field
))
4798 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4802 else if (DECL_C_BIT_FIELD (field
) && !DECL_UNNAMED_BIT_FIELD (field
))
4804 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4805 if (!type_has_unique_obj_representations (btype
))
4808 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4812 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4813 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_UNNAMED_BIT_FIELD (field
))
4815 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4816 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4817 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4820 if (DECL_SIZE (field
))
4822 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4826 if (cur
!= wi::to_offset (sz
))
4832 /* Nonzero iff type T is a class template implicit specialization. */
4835 class_tmpl_impl_spec_p (const_tree t
)
4837 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4840 /* Returns 1 iff zero initialization of type T means actually storing
4844 zero_init_p (const_tree t
)
4846 /* This CONST_CAST is okay because strip_array_types returns its
4847 argument unmodified and we assign it to a const_tree. */
4848 t
= strip_array_types (CONST_CAST_TREE(t
));
4850 if (t
== error_mark_node
)
4853 /* NULL pointers to data members are initialized with -1. */
4854 if (TYPE_PTRDATAMEM_P (t
))
4857 /* Classes that contain types that can't be zero-initialized, cannot
4858 be zero-initialized themselves. */
4859 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4865 /* Returns true if the expression or initializer T is the result of
4866 zero-initialization for its type, taking pointers to members
4867 into consideration. */
4870 zero_init_expr_p (tree t
)
4872 tree type
= TREE_TYPE (t
);
4873 if (!type
|| uses_template_parms (type
))
4875 if (TYPE_PTRMEM_P (type
))
4876 return null_member_pointer_value_p (t
);
4877 if (TREE_CODE (t
) == CONSTRUCTOR
)
4879 if (COMPOUND_LITERAL_P (t
)
4880 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4881 /* Undigested, conversions might change the zeroness. */
4883 for (constructor_elt
&elt
: CONSTRUCTOR_ELTS (t
))
4885 if (TREE_CODE (type
) == UNION_TYPE
4886 && elt
.index
!= first_field (type
))
4888 if (!zero_init_expr_p (elt
.value
))
4893 if (zero_init_p (type
))
4894 return initializer_zerop (t
);
4898 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4899 non-type template parameter. If EXPLAIN, explain why not. */
4902 structural_type_p (tree t
, bool explain
)
4904 /* A structural type is one of the following: */
4906 /* a scalar type, or */
4907 if (SCALAR_TYPE_P (t
))
4909 /* an lvalue reference type, or */
4910 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4912 /* a literal class type with the following properties:
4913 - all base classes and non-static data members are public and non-mutable
4915 - the types of all bases classes and non-static data members are
4916 structural types or (possibly multi-dimensional) array thereof. */
4917 if (!CLASS_TYPE_P (t
))
4919 if (!literal_type_p (t
))
4922 explain_non_literal_class (t
);
4925 for (tree m
= next_aggregate_field (TYPE_FIELDS (t
)); m
;
4926 m
= next_aggregate_field (DECL_CHAIN (m
)))
4928 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4932 if (DECL_FIELD_IS_BASE (m
))
4933 inform (location_of (m
), "base class %qT is not public",
4936 inform (location_of (m
), "%qD is not public", m
);
4940 if (DECL_MUTABLE_P (m
))
4943 inform (location_of (m
), "%qD is mutable", m
);
4946 tree mtype
= strip_array_types (TREE_TYPE (m
));
4947 if (!structural_type_p (mtype
))
4951 inform (location_of (m
), "%qD has a non-structural type", m
);
4952 structural_type_p (mtype
, true);
4960 /* Partially handle the C++11 [[carries_dependency]] attribute.
4961 Just emit a different diagnostics when it is used on something the
4962 spec doesn't allow vs. where it allows and we just choose to ignore
4966 handle_carries_dependency_attribute (tree
*node
, tree name
,
4967 tree
ARG_UNUSED (args
),
4968 int ARG_UNUSED (flags
),
4971 if (TREE_CODE (*node
) != FUNCTION_DECL
4972 && TREE_CODE (*node
) != PARM_DECL
)
4974 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4975 "functions or parameters", name
);
4976 *no_add_attrs
= true;
4980 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4981 *no_add_attrs
= true;
4986 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4987 warn_unused_result attribute. */
4990 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4991 int /*flags*/, bool *no_add_attrs
)
4993 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4995 error ("%qE attribute argument must be a string constant", name
);
4996 *no_add_attrs
= true;
4998 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5000 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
5001 && !DECL_CONSTRUCTOR_P (*node
))
5002 warning_at (DECL_SOURCE_LOCATION (*node
),
5003 OPT_Wattributes
, "%qE attribute applied to %qD with void "
5004 "return type", name
, *node
);
5006 else if (OVERLOAD_TYPE_P (*node
))
5010 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5011 "functions or to class or enumeration types", name
);
5012 *no_add_attrs
= true;
5017 /* Handle a C++20 "no_unique_address" attribute; arguments as in
5018 struct attribute_spec.handler. */
5020 handle_no_unique_addr_attribute (tree
* node
,
5026 if (TREE_CODE (*node
) == VAR_DECL
)
5028 DECL_MERGEABLE (*node
) = true;
5030 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5031 "non-static data members", name
);
5033 else if (TREE_CODE (*node
) != FIELD_DECL
)
5035 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
5036 "non-static data members", name
);
5037 *no_add_attrs
= true;
5039 else if (DECL_C_BIT_FIELD (*node
))
5041 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
5042 "a bit-field", name
);
5043 *no_add_attrs
= true;
5049 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
5050 hot/cold attributes. */
5053 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
5054 int flags
, bool *no_add_attrs
)
5056 *no_add_attrs
= true;
5057 if (TREE_CODE (*node
) == LABEL_DECL
5058 || TREE_CODE (*node
) == FUNCTION_DECL
)
5061 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
5062 tree bname
= (is_attribute_p ("likely", name
)
5063 ? get_identifier ("hot") : get_identifier ("cold"));
5064 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5065 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
5066 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
5067 tree battr
= build_tree_list (bname
, NULL_TREE
);
5068 decl_attributes (node
, battr
, flags
);
5072 return error_mark_node
;
5075 /* Table of valid C++ attributes. */
5076 const struct attribute_spec cxx_attribute_table
[] =
5078 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5079 affects_type_identity, handler, exclude } */
5080 { "init_priority", 1, 1, true, false, false, false,
5081 handle_init_priority_attribute
, NULL
},
5082 { "abi_tag", 1, -1, false, false, false, true,
5083 handle_abi_tag_attribute
, NULL
},
5084 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
5087 /* Table of C++ standard attributes. */
5088 const struct attribute_spec std_attribute_table
[] =
5090 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5091 affects_type_identity, handler, exclude } */
5092 { "maybe_unused", 0, 0, false, false, false, false,
5093 handle_unused_attribute
, NULL
},
5094 { "nodiscard", 0, 1, false, false, false, false,
5095 handle_nodiscard_attribute
, NULL
},
5096 { "no_unique_address", 0, 0, true, false, false, false,
5097 handle_no_unique_addr_attribute
, NULL
},
5098 { "likely", 0, 0, false, false, false, false,
5099 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
5100 { "unlikely", 0, 0, false, false, false, false,
5101 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
5102 { "noreturn", 0, 0, true, false, false, false,
5103 handle_noreturn_attribute
, attr_noreturn_exclusions
},
5104 { "carries_dependency", 0, 0, true, false, false, false,
5105 handle_carries_dependency_attribute
, NULL
},
5106 { "pre", 0, -1, false, false, false, false,
5107 handle_contract_attribute
, NULL
},
5108 { "post", 0, -1, false, false, false, false,
5109 handle_contract_attribute
, NULL
},
5110 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
5113 /* Handle an "init_priority" attribute; arguments as in
5114 struct attribute_spec.handler. */
5116 handle_init_priority_attribute (tree
* node
,
5122 if (!SUPPORTS_INIT_PRIORITY
)
5123 /* Treat init_priority as an unrecognized attribute (mirroring
5124 __has_attribute) if the target doesn't support init priorities. */
5125 return error_mark_node
;
5127 tree initp_expr
= TREE_VALUE (args
);
5129 tree type
= TREE_TYPE (decl
);
5132 STRIP_NOPS (initp_expr
);
5133 initp_expr
= default_conversion (initp_expr
);
5135 initp_expr
= maybe_constant_value (initp_expr
);
5137 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
5139 error ("requested %<init_priority%> is not an integer constant");
5140 cxx_constant_value (initp_expr
);
5141 *no_add_attrs
= true;
5145 pri
= TREE_INT_CST_LOW (initp_expr
);
5147 type
= strip_array_types (type
);
5149 if (decl
== NULL_TREE
5151 || !TREE_STATIC (decl
)
5152 || DECL_EXTERNAL (decl
)
5153 || (TREE_CODE (type
) != RECORD_TYPE
5154 && TREE_CODE (type
) != UNION_TYPE
)
5155 /* Static objects in functions are initialized the
5156 first time control passes through that
5157 function. This is not precise enough to pin down an
5158 init_priority value, so don't allow it. */
5159 || current_function_decl
)
5161 error ("can only use %qE attribute on file-scope definitions "
5162 "of objects of class type", name
);
5163 *no_add_attrs
= true;
5167 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
5169 error ("requested %<init_priority%> %i is out of range [0, %i]",
5170 pri
, MAX_INIT_PRIORITY
);
5171 *no_add_attrs
= true;
5175 /* Check for init_priorities that are reserved for
5176 language and runtime support implementations.*/
5177 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5180 (0, "requested %<init_priority%> %i is reserved for internal use",
5184 SET_DECL_INIT_PRIORITY (decl
, pri
);
5185 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
5189 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
5190 and the new one has the tags in NEW_. Give an error if there are tags
5191 in NEW_ that weren't in OLD. */
5194 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
5196 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
5197 old
= TREE_VALUE (old
);
5198 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
5199 new_
= TREE_VALUE (new_
);
5201 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
5203 tree str
= TREE_VALUE (t
);
5204 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
5206 tree ostr
= TREE_VALUE (in
);
5207 if (cp_tree_equal (str
, ostr
))
5210 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
5216 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
5222 /* The abi_tag attribute with the name NAME was given ARGS. If they are
5223 ill-formed, give an error and return false; otherwise, return true. */
5226 check_abi_tag_args (tree args
, tree name
)
5230 error ("the %qE attribute requires arguments", name
);
5233 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
5235 tree elt
= TREE_VALUE (arg
);
5236 if (TREE_CODE (elt
) != STRING_CST
5237 || (!same_type_ignoring_top_level_qualifiers_p
5238 (strip_array_types (TREE_TYPE (elt
)),
5241 error ("arguments to the %qE attribute must be narrow string "
5245 const char *begin
= TREE_STRING_POINTER (elt
);
5246 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
5247 for (const char *p
= begin
; p
!= end
; ++p
)
5252 if (!ISALPHA (c
) && c
!= '_')
5254 error ("arguments to the %qE attribute must contain valid "
5255 "identifiers", name
);
5256 inform (input_location
, "%<%c%> is not a valid first "
5257 "character for an identifier", c
);
5261 else if (p
== end
- 1)
5262 gcc_assert (c
== 0);
5265 if (!ISALNUM (c
) && c
!= '_')
5267 error ("arguments to the %qE attribute must contain valid "
5268 "identifiers", name
);
5269 inform (input_location
, "%<%c%> is not a valid character "
5270 "in an identifier", c
);
5279 /* Handle an "abi_tag" attribute; arguments as in
5280 struct attribute_spec.handler. */
5283 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
5284 int flags
, bool* no_add_attrs
)
5286 if (!check_abi_tag_args (args
, name
))
5291 if (!OVERLOAD_TYPE_P (*node
))
5293 error ("%qE attribute applied to non-class, non-enum type %qT",
5297 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
5299 error ("%qE attribute applied to %qT after its definition",
5303 else if (CLASS_TYPE_P (*node
)
5304 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
5306 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5307 "template instantiation %qT", name
, *node
);
5310 else if (CLASS_TYPE_P (*node
)
5311 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
5313 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5314 "template specialization %qT", name
, *node
);
5318 tree attributes
= TYPE_ATTRIBUTES (*node
);
5319 tree decl
= TYPE_NAME (*node
);
5321 /* Make sure all declarations have the same abi tags. */
5322 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
5324 if (!check_abi_tag_redeclaration (decl
,
5325 lookup_attribute ("abi_tag",
5333 if (!VAR_OR_FUNCTION_DECL_P (*node
))
5335 error ("%qE attribute applied to non-function, non-variable %qD",
5339 else if (DECL_LANGUAGE (*node
) == lang_c
)
5341 error ("%qE attribute applied to extern \"C\" declaration %qD",
5350 *no_add_attrs
= true;
5354 /* Perform checking for contract attributes. */
5357 handle_contract_attribute (tree
*ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
5358 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5359 bool *ARG_UNUSED (no_add_attrs
))
5361 /* TODO: Is there any checking we could do here? */
5365 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5366 thing pointed to by the constant. */
5369 make_ptrmem_cst (tree type
, tree member
)
5371 tree ptrmem_cst
= make_node (PTRMEM_CST
);
5372 TREE_TYPE (ptrmem_cst
) = type
;
5373 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5374 PTRMEM_CST_LOCATION (ptrmem_cst
) = input_location
;
5378 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5379 return an existing type if an appropriate type already exists. */
5382 cp_build_type_attribute_variant (tree type
, tree attributes
)
5386 new_type
= build_type_attribute_variant (type
, attributes
);
5387 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5388 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5390 /* Making a new main variant of a class type is broken. */
5391 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5396 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5397 Called only after doing all language independent checks. */
5400 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5402 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5404 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5406 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5408 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5409 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5412 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5413 C++, these are the exception-specifier and ref-qualifier. */
5416 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5418 tree type
= CONST_CAST_TREE (typea
);
5419 if (FUNC_OR_METHOD_TYPE_P (type
))
5420 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5421 TYPE_RAISES_EXCEPTIONS (typeb
),
5422 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5426 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5427 traversal. Called from walk_tree. */
5430 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5431 void *data
, hash_set
<tree
> *pset
)
5434 enum tree_code code
= TREE_CODE (t
);
5437 #define WALK_SUBTREE(NODE) \
5440 result = cp_walk_tree (&(NODE), func, data, pset); \
5441 if (result) goto out; \
5447 /* If *WALK_SUBTREES_P is 1, we're interested in the syntactic form of
5448 the argument, so don't look through typedefs, but do walk into
5449 template arguments for alias templates (and non-typedefed classes).
5451 If *WALK_SUBTREES_P > 1, we're interested in type identity or
5452 equivalence, so look through typedefs, ignoring template arguments for
5453 alias templates, and walk into template args of classes.
5455 See find_abi_tags_r for an example of setting *WALK_SUBTREES_P to 2
5456 when that's the behavior the walk_tree_fn wants. */
5457 if (*walk_subtrees_p
== 1 && typedef_variant_p (t
))
5459 if (tree ti
= TYPE_ALIAS_TEMPLATE_INFO (t
))
5460 WALK_SUBTREE (TI_ARGS (ti
));
5461 *walk_subtrees_p
= 0;
5465 if (tree ti
= TYPE_TEMPLATE_INFO (t
))
5466 WALK_SUBTREE (TI_ARGS (ti
));
5469 /* Not one of the easy cases. We must explicitly go through the
5474 case TEMPLATE_TYPE_PARM
:
5475 if (template_placeholder_p (t
))
5476 WALK_SUBTREE (CLASS_PLACEHOLDER_TEMPLATE (t
));
5478 case DEFERRED_PARSE
:
5479 case TEMPLATE_TEMPLATE_PARM
:
5480 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5481 case UNBOUND_CLASS_TEMPLATE
:
5482 case TEMPLATE_PARM_INDEX
:
5484 /* None of these have subtrees other than those already walked
5486 *walk_subtrees_p
= 0;
5490 WALK_SUBTREE (TYPE_CONTEXT (t
));
5491 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
5492 *walk_subtrees_p
= 0;
5496 if (BASELINK_QUALIFIED_P (t
))
5497 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (t
)));
5498 WALK_SUBTREE (BASELINK_FUNCTIONS (t
));
5499 *walk_subtrees_p
= 0;
5503 WALK_SUBTREE (TREE_TYPE (t
));
5504 *walk_subtrees_p
= 0;
5508 WALK_SUBTREE (TREE_PURPOSE (t
));
5512 WALK_SUBTREE (OVL_FUNCTION (t
));
5513 WALK_SUBTREE (OVL_CHAIN (t
));
5514 *walk_subtrees_p
= 0;
5518 WALK_SUBTREE (DECL_NAME (t
));
5519 WALK_SUBTREE (USING_DECL_SCOPE (t
));
5520 WALK_SUBTREE (USING_DECL_DECLS (t
));
5521 *walk_subtrees_p
= 0;
5525 if (TYPE_PTRMEMFUNC_P (t
))
5526 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (t
));
5529 case TYPE_ARGUMENT_PACK
:
5530 case NONTYPE_ARGUMENT_PACK
:
5532 tree args
= ARGUMENT_PACK_ARGS (t
);
5533 for (tree arg
: tree_vec_range (args
))
5538 case TYPE_PACK_EXPANSION
:
5539 WALK_SUBTREE (TREE_TYPE (t
));
5540 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t
));
5541 *walk_subtrees_p
= 0;
5544 case EXPR_PACK_EXPANSION
:
5545 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5546 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t
));
5547 *walk_subtrees_p
= 0;
5551 case REINTERPRET_CAST_EXPR
:
5552 case STATIC_CAST_EXPR
:
5553 case CONST_CAST_EXPR
:
5554 case DYNAMIC_CAST_EXPR
:
5555 case IMPLICIT_CONV_EXPR
:
5558 WALK_SUBTREE (TREE_TYPE (t
));
5562 if (COMPOUND_LITERAL_P (t
))
5563 WALK_SUBTREE (TREE_TYPE (t
));
5567 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (t
));
5568 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (t
));
5569 *walk_subtrees_p
= 0;
5573 WALK_SUBTREE (TRAIT_TYPE_TYPE1 (t
));
5574 WALK_SUBTREE (TRAIT_TYPE_TYPE2 (t
));
5575 *walk_subtrees_p
= 0;
5581 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (t
));
5582 *walk_subtrees_p
= 0;
5591 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5592 *walk_subtrees_p
= 0;
5599 for (tree parm
= REQUIRES_EXPR_PARMS (t
); parm
; parm
= DECL_CHAIN (parm
))
5600 /* Walk the types of each parameter, but not the parameter itself,
5601 since doing so would cause false positives in the unexpanded pack
5602 checker if the requires-expr introduces a function parameter pack,
5603 e.g. requires (Ts... ts) { }. */
5604 WALK_SUBTREE (TREE_TYPE (parm
));
5605 WALK_SUBTREE (REQUIRES_EXPR_REQS (t
));
5606 *walk_subtrees_p
= 0;
5611 /* User variables should be mentioned in BIND_EXPR_VARS
5612 and their initializers and sizes walked when walking
5613 the containing BIND_EXPR. Compiler temporaries are
5614 handled here. And also normal variables in templates,
5615 since do_poplevel doesn't build a BIND_EXPR then. */
5616 if (VAR_P (TREE_OPERAND (t
, 0))
5617 && (processing_template_decl
5618 || (DECL_ARTIFICIAL (TREE_OPERAND (t
, 0))
5619 && !TREE_STATIC (TREE_OPERAND (t
, 0)))))
5621 tree decl
= TREE_OPERAND (t
, 0);
5622 WALK_SUBTREE (DECL_INITIAL (decl
));
5623 WALK_SUBTREE (DECL_SIZE (decl
));
5624 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5629 /* Don't walk into the body of the lambda, but the capture initializers
5630 are part of the enclosing context. */
5631 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
5632 cap
= TREE_CHAIN (cap
))
5633 WALK_SUBTREE (TREE_VALUE (cap
));
5637 if (TREE_OPERAND (t
, 1))
5638 /* Operand 1 is the tree for the relevant co_await which has any
5639 interesting sub-trees. */
5640 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5644 if (TREE_OPERAND (t
, 1))
5645 /* Operand 1 is frame variable. */
5646 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5647 if (TREE_OPERAND (t
, 2))
5648 /* Operand 2 has the initialiser, and we need to walk any subtrees
5650 WALK_SUBTREE (TREE_OPERAND (t
, 2));
5653 case CO_RETURN_EXPR
:
5654 if (TREE_OPERAND (t
, 0))
5656 if (VOID_TYPE_P (TREE_OPERAND (t
, 0)))
5657 /* For void expressions, operand 1 is a trivial call, and any
5658 interesting subtrees will be part of operand 0. */
5659 WALK_SUBTREE (TREE_OPERAND (t
, 0));
5660 else if (TREE_OPERAND (t
, 1))
5661 /* Interesting sub-trees will be in the return_value () call
5663 WALK_SUBTREE (TREE_OPERAND (t
, 1));
5668 WALK_SUBTREE (STATIC_ASSERT_CONDITION (t
));
5669 WALK_SUBTREE (STATIC_ASSERT_MESSAGE (t
));
5676 /* We didn't find what we were looking for. */
5683 /* Like save_expr, but for C++. */
5686 cp_save_expr (tree expr
)
5688 /* There is no reason to create a SAVE_EXPR within a template; if
5689 needed, we can create the SAVE_EXPR when instantiating the
5690 template. Furthermore, the middle-end cannot handle C++-specific
5692 if (processing_template_decl
)
5695 /* TARGET_EXPRs are only expanded once. */
5696 if (TREE_CODE (expr
) == TARGET_EXPR
)
5699 return save_expr (expr
);
5702 /* Initialize tree.cc. */
5707 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5708 register_scoped_attributes (std_attribute_table
, NULL
);
5711 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5712 is. Note that sfk_none is zero, so this function can be used as a
5713 predicate to test whether or not DECL is a special function. */
5715 special_function_kind
5716 special_function_p (const_tree decl
)
5718 /* Rather than doing all this stuff with magic names, we should
5719 probably have a field of type `special_function_kind' in
5720 DECL_LANG_SPECIFIC. */
5721 if (DECL_INHERITED_CTOR (decl
))
5722 return sfk_inheriting_constructor
;
5723 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5724 return sfk_copy_constructor
;
5725 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5726 return sfk_move_constructor
;
5727 if (DECL_CONSTRUCTOR_P (decl
))
5728 return sfk_constructor
;
5729 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5730 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5732 if (copy_fn_p (decl
))
5733 return sfk_copy_assignment
;
5734 if (move_fn_p (decl
))
5735 return sfk_move_assignment
;
5737 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5738 return sfk_destructor
;
5739 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5740 return sfk_complete_destructor
;
5741 if (DECL_BASE_DESTRUCTOR_P (decl
))
5742 return sfk_base_destructor
;
5743 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5744 return sfk_deleting_destructor
;
5745 if (DECL_CONV_FN_P (decl
))
5746 return sfk_conversion
;
5747 if (deduction_guide_p (decl
))
5748 return sfk_deduction_guide
;
5749 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5750 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5751 return sfk_comparison
;
5756 /* As above, but only if DECL is a special member function as per 11.3.3
5757 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5759 special_function_kind
5760 special_memfn_p (const_tree decl
)
5762 switch (special_function_kind sfk
= special_function_p (decl
))
5764 case sfk_constructor
:
5765 if (!default_ctor_p (decl
))
5768 case sfk_copy_constructor
:
5769 case sfk_copy_assignment
:
5770 case sfk_move_assignment
:
5771 case sfk_move_constructor
:
5772 case sfk_destructor
:
5781 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5784 char_type_p (tree type
)
5786 return (same_type_p (type
, char_type_node
)
5787 || same_type_p (type
, unsigned_char_type_node
)
5788 || same_type_p (type
, signed_char_type_node
)
5789 || same_type_p (type
, char8_type_node
)
5790 || same_type_p (type
, char16_type_node
)
5791 || same_type_p (type
, char32_type_node
)
5792 || same_type_p (type
, wchar_type_node
));
5795 /* Returns the kind of linkage associated with the indicated DECL. Th
5796 value returned is as specified by the language standard; it is
5797 independent of implementation details regarding template
5798 instantiation, etc. For example, it is possible that a declaration
5799 to which this function assigns external linkage would not show up
5800 as a global symbol when you run `nm' on the resulting object file. */
5803 decl_linkage (tree decl
)
5805 /* This function doesn't attempt to calculate the linkage from first
5806 principles as given in [basic.link]. Instead, it makes use of
5807 the fact that we have already set TREE_PUBLIC appropriately, and
5808 then handles a few special cases. Ideally, we would calculate
5809 linkage first, and then transform that into a concrete
5812 /* Things that don't have names have no linkage. */
5813 if (!DECL_NAME (decl
))
5816 /* Fields have no linkage. */
5817 if (TREE_CODE (decl
) == FIELD_DECL
)
5820 /* Things in local scope do not have linkage. */
5821 if (decl_function_context (decl
))
5824 /* Things that are TREE_PUBLIC have external linkage. */
5825 if (TREE_PUBLIC (decl
))
5828 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5829 check one of the "clones" for the real linkage. */
5830 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5831 && DECL_CHAIN (decl
)
5832 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5833 return decl_linkage (DECL_CHAIN (decl
));
5835 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5838 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5840 if (TREE_CODE (decl
) == CONST_DECL
)
5841 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5843 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5844 are considered to have external linkage for language purposes, as do
5845 template instantiations on targets without weak symbols. DECLs really
5846 meant to have internal linkage have DECL_THIS_STATIC set. */
5847 if (TREE_CODE (decl
) == TYPE_DECL
)
5849 if (VAR_OR_FUNCTION_DECL_P (decl
))
5851 if (!DECL_THIS_STATIC (decl
))
5854 /* Static data members and static member functions from classes
5855 in anonymous namespace also don't have TREE_PUBLIC set. */
5856 if (DECL_CLASS_CONTEXT (decl
))
5860 /* Everything else has internal linkage. */
5864 /* Returns the storage duration of the object or reference associated with
5865 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5868 decl_storage_duration (tree decl
)
5870 if (TREE_CODE (decl
) == PARM_DECL
)
5872 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5874 gcc_assert (VAR_P (decl
));
5875 if (!TREE_STATIC (decl
)
5876 && !DECL_EXTERNAL (decl
))
5878 if (CP_DECL_THREAD_LOCAL_P (decl
))
5883 /* EXP is an expression that we want to pre-evaluate. Returns (in
5884 *INITP) an expression that will perform the pre-evaluation. The
5885 value returned by this function is a side-effect free expression
5886 equivalent to the pre-evaluated expression. Callers must ensure
5887 that *INITP is evaluated before EXP. */
5890 stabilize_expr (tree exp
, tree
* initp
)
5894 if (!TREE_SIDE_EFFECTS (exp
))
5895 init_expr
= NULL_TREE
;
5896 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5901 /* There are no expressions with REFERENCE_TYPE, but there can be call
5902 arguments with such a type; just treat it as a pointer. */
5903 else if (TYPE_REF_P (TREE_TYPE (exp
))
5904 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5905 || !glvalue_p (exp
))
5907 init_expr
= get_target_expr (exp
);
5908 exp
= TARGET_EXPR_SLOT (init_expr
);
5909 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5916 bool xval
= !lvalue_p (exp
);
5917 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5918 init_expr
= get_target_expr (exp
);
5919 exp
= TARGET_EXPR_SLOT (init_expr
);
5920 exp
= cp_build_fold_indirect_ref (exp
);
5926 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5930 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5931 similar expression ORIG. */
5934 add_stmt_to_compound (tree orig
, tree new_expr
)
5936 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5938 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5940 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5943 /* Like stabilize_expr, but for a call whose arguments we want to
5944 pre-evaluate. CALL is modified in place to use the pre-evaluated
5945 arguments, while, upon return, *INITP contains an expression to
5946 compute the arguments. */
5949 stabilize_call (tree call
, tree
*initp
)
5951 tree inits
= NULL_TREE
;
5953 int nargs
= call_expr_nargs (call
);
5955 if (call
== error_mark_node
|| processing_template_decl
)
5961 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5963 for (i
= 0; i
< nargs
; i
++)
5966 CALL_EXPR_ARG (call
, i
) =
5967 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5968 inits
= add_stmt_to_compound (inits
, init
);
5974 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5975 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5976 arguments, while, upon return, *INITP contains an expression to
5977 compute the arguments. */
5980 stabilize_aggr_init (tree call
, tree
*initp
)
5982 tree inits
= NULL_TREE
;
5984 int nargs
= aggr_init_expr_nargs (call
);
5986 if (call
== error_mark_node
)
5989 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5991 for (i
= 0; i
< nargs
; i
++)
5994 AGGR_INIT_EXPR_ARG (call
, i
) =
5995 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5996 inits
= add_stmt_to_compound (inits
, init
);
6002 /* Like stabilize_expr, but for an initialization.
6004 If the initialization is for an object of class type, this function
6005 takes care not to introduce additional temporaries.
6007 Returns TRUE iff the expression was successfully pre-evaluated,
6008 i.e., if INIT is now side-effect free, except for, possibly, a
6009 single call to a constructor. */
6012 stabilize_init (tree init
, tree
*initp
)
6018 if (t
== error_mark_node
|| processing_template_decl
)
6021 if (TREE_CODE (t
) == INIT_EXPR
)
6022 t
= TREE_OPERAND (t
, 1);
6023 if (TREE_CODE (t
) == TARGET_EXPR
)
6024 t
= TARGET_EXPR_INITIAL (t
);
6026 /* If the RHS can be stabilized without breaking copy elision, stabilize
6027 it. We specifically don't stabilize class prvalues here because that
6028 would mean an extra copy, but they might be stabilized below. */
6029 if (TREE_CODE (init
) == INIT_EXPR
6030 && TREE_CODE (t
) != CONSTRUCTOR
6031 && TREE_CODE (t
) != AGGR_INIT_EXPR
6032 && (SCALAR_TYPE_P (TREE_TYPE (t
))
6035 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
6039 if (TREE_CODE (t
) == COMPOUND_EXPR
6040 && TREE_CODE (init
) == INIT_EXPR
)
6042 tree last
= expr_last (t
);
6043 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
6044 if (!TREE_SIDE_EFFECTS (last
))
6047 TREE_OPERAND (init
, 1) = last
;
6052 if (TREE_CODE (t
) == CONSTRUCTOR
)
6054 /* Aggregate initialization: stabilize each of the field
6057 constructor_elt
*ce
;
6059 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
6060 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
6062 tree type
= TREE_TYPE (ce
->value
);
6064 if (TYPE_REF_P (type
)
6065 || SCALAR_TYPE_P (type
))
6066 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
6067 else if (!stabilize_init (ce
->value
, &subinit
))
6069 *initp
= add_stmt_to_compound (*initp
, subinit
);
6074 if (TREE_CODE (t
) == CALL_EXPR
)
6076 stabilize_call (t
, initp
);
6080 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
6082 stabilize_aggr_init (t
, initp
);
6086 /* The initialization is being performed via a bitwise copy -- and
6087 the item copied may have side effects. */
6088 return !TREE_SIDE_EFFECTS (init
);
6091 /* Returns true if a cast to TYPE may appear in an integral constant
6095 cast_valid_in_integral_constant_expression_p (tree type
)
6097 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6098 || cxx_dialect
>= cxx11
6099 || dependent_type_p (type
)
6100 || type
== error_mark_node
);
6103 /* Return true if we need to fix linkage information of DECL. */
6106 cp_fix_function_decl_p (tree decl
)
6108 /* Skip if DECL is not externally visible. */
6109 if (!TREE_PUBLIC (decl
))
6112 /* We need to fix DECL if it a appears to be exported but with no
6113 function body. Thunks do not have CFGs and we may need to
6114 handle them specially later. */
6115 if (!gimple_has_body_p (decl
)
6116 && !DECL_THUNK_P (decl
)
6117 && !DECL_EXTERNAL (decl
))
6119 struct cgraph_node
*node
= cgraph_node::get (decl
);
6121 /* Don't fix same_body aliases. Although they don't have their own
6122 CFG, they share it with what they alias to. */
6123 if (!node
|| !node
->alias
|| !node
->num_references ())
6130 /* Clean the C++ specific parts of the tree T. */
6133 cp_free_lang_data (tree t
)
6135 if (FUNC_OR_METHOD_TYPE_P (t
))
6137 /* Default args are not interesting anymore. */
6138 tree argtypes
= TYPE_ARG_TYPES (t
);
6141 TREE_PURPOSE (argtypes
) = 0;
6142 argtypes
= TREE_CHAIN (argtypes
);
6145 else if (TREE_CODE (t
) == FUNCTION_DECL
6146 && cp_fix_function_decl_p (t
))
6148 /* If T is used in this translation unit at all, the definition
6149 must exist somewhere else since we have decided to not emit it
6150 in this TU. So make it an external reference. */
6151 DECL_EXTERNAL (t
) = 1;
6152 TREE_STATIC (t
) = 0;
6154 if (TREE_CODE (t
) == NAMESPACE_DECL
)
6155 /* We do not need the leftover chaining of namespaces from the
6157 DECL_CHAIN (t
) = NULL_TREE
;
6160 /* Stub for c-common. Please keep in sync with c-decl.cc.
6161 FIXME: If address space support is target specific, then this
6162 should be a C target hook. But currently this is not possible,
6163 because this function is called via REGISTER_TARGET_PRAGMAS. */
6165 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
6169 /* Return the number of operands in T that we care about for things like
6173 cp_tree_operand_length (const_tree t
)
6175 enum tree_code code
= TREE_CODE (t
);
6177 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
6178 return VL_EXP_OPERAND_LENGTH (t
);
6180 return cp_tree_code_length (code
);
6183 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
6186 cp_tree_code_length (enum tree_code code
)
6188 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6192 case PREINCREMENT_EXPR
:
6193 case PREDECREMENT_EXPR
:
6194 case POSTINCREMENT_EXPR
:
6195 case POSTDECREMENT_EXPR
:
6201 case EXPR_PACK_EXPANSION
:
6205 return TREE_CODE_LENGTH (code
);
6209 /* Implement -Wzero_as_null_pointer_constant. Return true if the
6210 conditions for the warning hold, false otherwise. */
6212 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
6214 if (c_inhibit_evaluation_warnings
== 0
6215 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6217 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
6218 "zero as null pointer constant");
6224 /* FNDECL is a function declaration whose type may have been altered by
6225 adding extra parameters such as this, in-charge, or VTT. When this
6226 takes place, the positional arguments supplied by the user (as in the
6227 'format' attribute arguments) may refer to the wrong argument. This
6228 function returns an integer indicating how many arguments should be
6232 maybe_adjust_arg_pos_for_attribute (const_tree fndecl
)
6236 int n
= num_artificial_parms_for (fndecl
);
6237 /* The manual states that it's the user's responsibility to account
6238 for the implicit this parameter. */
6239 return n
> 0 ? n
- 1 : 0;
6243 /* Release memory we no longer need after parsing. */
6245 cp_tree_c_finish_parsing ()
6247 if (previous_class_level
)
6248 invalidate_class_lookup_cache ();
6249 deleted_copy_types
= NULL
;
6252 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6253 /* Complain that some language-specific thing hanging off a tree
6254 node has been accessed improperly. */
6257 lang_check_failed (const char* file
, int line
, const char* function
)
6259 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
6260 function
, trim_filename (file
), line
);
6262 #endif /* ENABLE_TREE_CHECKING */
6266 namespace selftest
{
6268 /* Verify that lvalue_kind () works, for various expressions,
6269 and that location wrappers don't affect the results. */
6274 location_t loc
= BUILTINS_LOCATION
;
6276 /* Verify constants and parameters, without and with
6277 location wrappers. */
6278 tree int_cst
= build_int_cst (integer_type_node
, 42);
6279 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
6281 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
6282 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
6283 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
6285 tree string_lit
= build_string (4, "foo");
6286 TREE_TYPE (string_lit
) = char_array_type_node
;
6287 string_lit
= fix_string_type (string_lit
);
6288 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
6290 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
6291 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
6292 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
6294 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
6295 get_identifier ("some_parm"),
6297 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
6299 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
6300 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
6301 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
6303 /* Verify that lvalue_kind of std::move on a parm isn't
6304 affected by location wrappers. */
6305 tree rvalue_ref_of_parm
= move (parm
);
6306 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
6307 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
6308 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
6310 /* Verify lvalue_p. */
6311 ASSERT_FALSE (lvalue_p (int_cst
));
6312 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
6313 ASSERT_TRUE (lvalue_p (parm
));
6314 ASSERT_TRUE (lvalue_p (wrapped_parm
));
6315 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
6316 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
6319 /* Run all of the selftests within this file. */
6324 test_lvalue_kind ();
6327 } // namespace selftest
6329 #endif /* #if CHECKING_P */
6332 #include "gt-cp-tree.h"