1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
77 op1_lvalue_kind
= clk_rvalueref
;
78 if (implicit_rvalue_p (ref
))
79 op1_lvalue_kind
|= clk_implicit_rval
;
80 return op1_lvalue_kind
;
83 /* lvalue references and named rvalue references are lvalues. */
87 if (ref
== current_class_ptr
)
90 /* Expressions with cv void type are prvalues. */
91 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
94 switch (TREE_CODE (ref
))
99 /* preincrements and predecrements are valid lvals, provided
100 what they refer to are valid lvals. */
101 case PREINCREMENT_EXPR
:
102 case PREDECREMENT_EXPR
:
106 case VIEW_CONVERT_EXPR
:
107 return lvalue_kind (TREE_OPERAND (ref
, 0));
111 tree op1
= TREE_OPERAND (ref
, 0);
112 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
114 op1_lvalue_kind
= lvalue_kind (op1
);
115 if (op1_lvalue_kind
== clk_class
)
116 /* in the case of an array operand, the result is an lvalue if
117 that operand is an lvalue and an xvalue otherwise */
118 op1_lvalue_kind
= clk_rvalueref
;
119 return op1_lvalue_kind
;
127 if (TREE_CODE (ref
) == MEMBER_REF
)
128 op1_lvalue_kind
= clk_ordinary
;
130 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
131 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
132 op1_lvalue_kind
= clk_none
;
133 else if (op1_lvalue_kind
== clk_class
)
134 /* The result of a .* expression whose second operand is a pointer to a
135 data member is an lvalue if the first operand is an lvalue and an
137 op1_lvalue_kind
= clk_rvalueref
;
138 return op1_lvalue_kind
;
141 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
143 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
145 /* For static member function recurse on the BASELINK, we can get
146 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
147 OVERLOAD, the overload is resolved first if possible through
148 resolve_address_of_overloaded_function. */
149 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
150 return lvalue_kind (TREE_OPERAND (ref
, 1));
152 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
153 if (op1_lvalue_kind
== clk_class
)
154 /* If E1 is an lvalue, then E1.E2 is an lvalue;
155 otherwise E1.E2 is an xvalue. */
156 op1_lvalue_kind
= clk_rvalueref
;
158 /* Look at the member designator. */
159 if (!op1_lvalue_kind
)
161 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
162 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
163 situations. If we're seeing a COMPONENT_REF, it's a non-static
164 member, so it isn't an lvalue. */
165 op1_lvalue_kind
= clk_none
;
166 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
167 /* This can be IDENTIFIER_NODE in a template. */;
168 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
170 /* Clear the ordinary bit. If this object was a class
171 rvalue we want to preserve that information. */
172 op1_lvalue_kind
&= ~clk_ordinary
;
173 /* The lvalue is for a bitfield. */
174 op1_lvalue_kind
|= clk_bitfield
;
176 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
177 op1_lvalue_kind
|= clk_packed
;
179 return op1_lvalue_kind
;
182 case COMPOUND_LITERAL_EXPR
:
186 /* CONST_DECL without TREE_STATIC are enumeration values and
187 thus not lvalues. With TREE_STATIC they are used by ObjC++
188 in objc_build_string_object and need to be considered as
190 if (! TREE_STATIC (ref
))
194 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
195 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
197 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
198 && DECL_LANG_SPECIFIC (ref
)
199 && DECL_IN_AGGR_P (ref
))
206 case PLACEHOLDER_EXPR
:
209 /* A scope ref in a template, left as SCOPE_REF to support later
212 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
214 tree op
= TREE_OPERAND (ref
, 1);
215 if (TREE_CODE (op
) == FIELD_DECL
)
216 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
218 return lvalue_kind (op
);
223 /* Disallow <? and >? as lvalues if either argument side-effects. */
224 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
225 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
227 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
228 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
232 if (processing_template_decl
)
234 /* Within templates, a REFERENCE_TYPE will indicate whether
235 the COND_EXPR result is an ordinary lvalue or rvalueref.
236 Since REFERENCE_TYPEs are handled above, if we reach this
237 point, we know we got a plain rvalue. Unless we have a
238 type-dependent expr, that is, but we shouldn't be testing
239 lvalueness if we can't even tell the types yet! */
240 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
244 tree op1
= TREE_OPERAND (ref
, 1);
245 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
246 tree op2
= TREE_OPERAND (ref
, 2);
247 op1_lvalue_kind
= lvalue_kind (op1
);
248 op2_lvalue_kind
= lvalue_kind (op2
);
249 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
251 /* The second or the third operand (but not both) is a
252 throw-expression; the result is of the type
253 and value category of the other. */
254 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
255 op2_lvalue_kind
= op1_lvalue_kind
;
256 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
257 op1_lvalue_kind
= op2_lvalue_kind
;
263 /* We expect to see unlowered MODOP_EXPRs only during
264 template processing. */
265 gcc_assert (processing_template_decl
);
273 return lvalue_kind (TREE_OPERAND (ref
, 1));
279 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
282 /* We can see calls outside of TARGET_EXPR in templates. */
283 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
288 /* All functions (except non-static-member functions) are
290 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
291 ? clk_none
: clk_ordinary
);
294 /* We now represent a reference to a single static member function
296 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
297 its argument unmodified and we assign it to a const_tree. */
298 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
300 case NON_DEPENDENT_EXPR
:
302 return lvalue_kind (TREE_OPERAND (ref
, 0));
304 case TEMPLATE_PARM_INDEX
:
305 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
306 /* A template parameter object is an lvalue. */
312 if (!TREE_TYPE (ref
))
314 if (CLASS_TYPE_P (TREE_TYPE (ref
))
315 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
320 /* If one operand is not an lvalue at all, then this expression is
322 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
325 /* Otherwise, it's an lvalue, and it has all the odd properties
326 contributed by either operand. */
327 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
328 /* It's not an ordinary lvalue if it involves any other kind. */
329 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
330 op1_lvalue_kind
&= ~clk_ordinary
;
331 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
332 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
333 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
334 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
335 op1_lvalue_kind
= clk_none
;
336 return op1_lvalue_kind
;
339 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
342 real_lvalue_p (const_tree ref
)
344 cp_lvalue_kind kind
= lvalue_kind (ref
);
345 if (kind
& (clk_rvalueref
|clk_class
))
351 /* c-common wants us to return bool. */
354 lvalue_p (const_tree t
)
356 return real_lvalue_p (t
);
359 /* This differs from lvalue_p in that xvalues are included. */
362 glvalue_p (const_tree ref
)
364 cp_lvalue_kind kind
= lvalue_kind (ref
);
365 if (kind
& clk_class
)
368 return (kind
!= clk_none
);
371 /* This differs from glvalue_p in that class prvalues are included. */
374 obvalue_p (const_tree ref
)
376 return (lvalue_kind (ref
) != clk_none
);
379 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
380 reference), false otherwise. */
383 xvalue_p (const_tree ref
)
385 return (lvalue_kind (ref
) == clk_rvalueref
);
388 /* True if REF is a bit-field. */
391 bitfield_p (const_tree ref
)
393 return (lvalue_kind (ref
) & clk_bitfield
);
396 /* C++-specific version of stabilize_reference. */
399 cp_stabilize_reference (tree ref
)
401 STRIP_ANY_LOCATION_WRAPPER (ref
);
402 switch (TREE_CODE (ref
))
404 case NON_DEPENDENT_EXPR
:
405 /* We aren't actually evaluating this. */
408 /* We need to treat specially anything stabilize_reference doesn't
409 handle specifically. */
420 case ARRAY_RANGE_REF
:
424 cp_lvalue_kind kind
= lvalue_kind (ref
);
425 if ((kind
& ~clk_class
) != clk_none
)
427 tree type
= unlowered_expr_type (ref
);
428 bool rval
= !!(kind
& clk_rvalueref
);
429 type
= cp_build_reference_type (type
, rval
);
430 /* This inhibits warnings in, eg, cxx_mark_addressable
432 warning_sentinel
s (extra_warnings
);
433 ref
= build_static_cast (input_location
, type
, ref
,
438 return stabilize_reference (ref
);
441 /* Test whether DECL is a builtin that may appear in a
442 constant-expression. */
445 builtin_valid_in_constant_expr_p (const_tree decl
)
447 STRIP_ANY_LOCATION_WRAPPER (decl
);
448 if (TREE_CODE (decl
) != FUNCTION_DECL
)
449 /* Not a function. */
451 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
453 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
455 || fndecl_built_in_p (decl
, CP_BUILT_IN_SOURCE_LOCATION
,
458 /* Not a built-in. */
461 switch (DECL_FUNCTION_CODE (decl
))
463 /* These always have constant results like the corresponding
466 case BUILT_IN_FUNCTION
:
469 /* The following built-ins are valid in constant expressions
470 when their arguments are. */
471 case BUILT_IN_ADD_OVERFLOW_P
:
472 case BUILT_IN_SUB_OVERFLOW_P
:
473 case BUILT_IN_MUL_OVERFLOW_P
:
475 /* These have constant results even if their operands are
477 case BUILT_IN_CONSTANT_P
:
478 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
485 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
488 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
491 tree type
= TREE_TYPE (decl
);
493 value
= mark_rvalue_use (value
);
495 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
496 || TREE_TYPE (decl
) == TREE_TYPE (value
)
497 /* On ARM ctors return 'this'. */
498 || (TYPE_PTR_P (TREE_TYPE (value
))
499 && TREE_CODE (value
) == CALL_EXPR
)
500 || useless_type_conversion_p (TREE_TYPE (decl
),
503 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
504 moving a constant aggregate into .rodata. */
505 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
506 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
507 && !VOID_TYPE_P (TREE_TYPE (value
))
508 && reduced_constant_expression_p (value
))
509 TREE_READONLY (decl
) = true;
511 if (complain
& tf_no_cleanup
)
512 /* The caller is building a new-expr and does not need a cleanup. */
516 t
= cxx_maybe_build_cleanup (decl
, complain
);
517 if (t
== error_mark_node
)
518 return error_mark_node
;
520 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
521 if (location_t eloc
= cp_expr_location (value
))
522 SET_EXPR_LOCATION (t
, eloc
);
523 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
524 ignore the TARGET_EXPR. If there really turn out to be no
525 side-effects, then the optimizer should be able to get rid of
526 whatever code is generated anyhow. */
527 TREE_SIDE_EFFECTS (t
) = 1;
532 /* Return an undeclared local temporary of type TYPE for use in building a
536 build_local_temp (tree type
)
538 tree slot
= build_decl (input_location
,
539 VAR_DECL
, NULL_TREE
, type
);
540 DECL_ARTIFICIAL (slot
) = 1;
541 DECL_IGNORED_P (slot
) = 1;
542 DECL_CONTEXT (slot
) = current_function_decl
;
543 layout_decl (slot
, 0);
547 /* Return whether DECL is such a local temporary (or one from
548 create_tmp_var_raw). */
551 is_local_temp (tree decl
)
553 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
554 && !TREE_STATIC (decl
)
555 && DECL_FUNCTION_SCOPE_P (decl
));
558 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
561 process_aggr_init_operands (tree t
)
565 side_effects
= TREE_SIDE_EFFECTS (t
);
569 n
= TREE_OPERAND_LENGTH (t
);
570 for (i
= 1; i
< n
; i
++)
572 tree op
= TREE_OPERAND (t
, i
);
573 if (op
&& TREE_SIDE_EFFECTS (op
))
580 TREE_SIDE_EFFECTS (t
) = side_effects
;
583 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
584 FN, and SLOT. NARGS is the number of call arguments which are specified
585 as a tree array ARGS. */
588 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
594 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
595 TREE_TYPE (t
) = return_type
;
596 AGGR_INIT_EXPR_FN (t
) = fn
;
597 AGGR_INIT_EXPR_SLOT (t
) = slot
;
598 for (i
= 0; i
< nargs
; i
++)
599 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
600 process_aggr_init_operands (t
);
604 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
605 target. TYPE is the type to be initialized.
607 Build an AGGR_INIT_EXPR to represent the initialization. This function
608 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
609 to initialize another object, whereas a TARGET_EXPR can either
610 initialize another object or create its own temporary object, and as a
611 result building up a TARGET_EXPR requires that the type's destructor be
615 build_aggr_init_expr (tree type
, tree init
)
622 gcc_assert (!VOID_TYPE_P (type
));
624 /* Don't build AGGR_INIT_EXPR in a template. */
625 if (processing_template_decl
)
628 fn
= cp_get_callee (init
);
630 return convert (type
, init
);
632 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
633 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
634 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
636 /* We split the CALL_EXPR into its function and its arguments here.
637 Then, in expand_expr, we put them back together. The reason for
638 this is that this expression might be a default argument
639 expression. In that case, we need a new temporary every time the
640 expression is used. That's what break_out_target_exprs does; it
641 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
642 temporary slot. Then, expand_expr builds up a call-expression
643 using the new slot. */
645 /* If we don't need to use a constructor to create an object of this
646 type, don't mess with AGGR_INIT_EXPR. */
647 if (is_ctor
|| TREE_ADDRESSABLE (type
))
649 slot
= build_local_temp (type
);
651 if (TREE_CODE (init
) == CALL_EXPR
)
653 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
654 call_expr_nargs (init
),
655 CALL_EXPR_ARGP (init
));
656 AGGR_INIT_FROM_THUNK_P (rval
)
657 = CALL_FROM_THUNK_P (init
);
661 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
662 aggr_init_expr_nargs (init
),
663 AGGR_INIT_EXPR_ARGP (init
));
664 AGGR_INIT_FROM_THUNK_P (rval
)
665 = AGGR_INIT_FROM_THUNK_P (init
);
667 TREE_SIDE_EFFECTS (rval
) = 1;
668 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
669 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
670 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
671 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
672 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
677 if (location_t loc
= EXPR_LOCATION (init
))
678 SET_EXPR_LOCATION (rval
, loc
);
683 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
684 target. TYPE is the type that this initialization should appear to
687 Build an encapsulation of the initialization to perform
688 and return it so that it can be processed by language-independent
689 and language-specific expression expanders. */
692 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
694 /* This function should cope with what build_special_member_call
695 can produce. When performing parenthesized aggregate initialization,
696 it can produce a { }. */
697 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
699 gcc_assert (cxx_dialect
>= cxx20
);
700 return finish_compound_literal (type
, init
, complain
);
703 tree rval
= build_aggr_init_expr (type
, init
);
706 if (init
== error_mark_node
)
707 return error_mark_node
;
709 if (!complete_type_or_maybe_complain (type
, init
, complain
))
710 return error_mark_node
;
712 /* Make sure that we're not trying to create an instance of an
714 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
715 return error_mark_node
;
717 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
718 slot
= AGGR_INIT_EXPR_SLOT (rval
);
719 else if (TREE_CODE (rval
) == CALL_EXPR
720 || TREE_CODE (rval
) == CONSTRUCTOR
)
721 slot
= build_local_temp (type
);
725 rval
= build_target_expr (slot
, rval
, complain
);
727 if (rval
!= error_mark_node
)
728 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
733 /* Subroutine of build_vec_init_expr: Build up a single element
734 intialization as a proxy for the full array initialization to get things
735 marked as used and any appropriate diagnostics.
737 Since we're deferring building the actual constructor calls until
738 gimplification time, we need to build one now and throw it away so
739 that the relevant constructor gets mark_used before cgraph decides
740 what functions are needed. Here we assume that init is either
741 NULL_TREE, void_type_node (indicating value-initialization), or
742 another array to copy. */
745 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
747 tree inner_type
= strip_array_types (type
);
749 if (integer_zerop (array_type_nelts_total (type
))
750 || !CLASS_TYPE_P (inner_type
))
751 /* No interesting initialization to do. */
752 return integer_zero_node
;
753 else if (init
== void_type_node
)
754 return build_value_init (inner_type
, complain
);
756 gcc_assert (init
== NULL_TREE
757 || (same_type_ignoring_top_level_qualifiers_p
758 (type
, TREE_TYPE (init
))));
760 releasing_vec argvec
;
763 tree init_type
= strip_array_types (TREE_TYPE (init
));
764 tree dummy
= build_dummy_object (init_type
);
765 if (!lvalue_p (init
))
766 dummy
= move (dummy
);
767 argvec
->quick_push (dummy
);
769 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
770 &argvec
, inner_type
, LOOKUP_NORMAL
,
773 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
774 we don't want one here because we aren't creating a temporary. */
775 if (TREE_CODE (init
) == TARGET_EXPR
)
776 init
= TARGET_EXPR_INITIAL (init
);
781 /* Return a TARGET_EXPR which expresses the initialization of an array to
782 be named later, either default-initialization or copy-initialization
783 from another array of the same type. */
786 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
789 bool value_init
= false;
790 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
792 if (init
== void_type_node
)
798 slot
= build_local_temp (type
);
799 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
800 TREE_SIDE_EFFECTS (init
) = true;
801 SET_EXPR_LOCATION (init
, input_location
);
803 if (cxx_dialect
>= cxx11
804 && potential_constant_expression (elt_init
))
805 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
806 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
811 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
812 that requires a constant expression. */
815 diagnose_non_constexpr_vec_init (tree expr
)
817 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
819 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
820 init
= void_type_node
;
822 init
= VEC_INIT_EXPR_INIT (expr
);
824 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
825 require_potential_constant_expression (elt_init
);
829 build_array_copy (tree init
)
831 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
834 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
838 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
840 gcc_assert (!VOID_TYPE_P (type
));
842 if (TREE_CODE (init
) == TARGET_EXPR
843 || init
== error_mark_node
)
845 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
846 && !VOID_TYPE_P (TREE_TYPE (init
))
847 && TREE_CODE (init
) != COND_EXPR
848 && TREE_CODE (init
) != CONSTRUCTOR
849 && TREE_CODE (init
) != VA_ARG_EXPR
)
850 /* We need to build up a copy constructor call. A void initializer
851 means we're being called from bot_manip. COND_EXPR is a special
852 case because we already have copies on the arms and we don't want
853 another one here. A CONSTRUCTOR is aggregate initialization, which
854 is handled separately. A VA_ARG_EXPR is magic creation of an
855 aggregate; there's no additional work to be done. */
856 return force_rvalue (init
, complain
);
858 return force_target_expr (type
, init
, complain
);
861 /* Like the above function, but without the checking. This function should
862 only be used by code which is deliberately trying to subvert the type
863 system, such as call_builtin_trap. Or build_over_call, to avoid
864 infinite recursion. */
867 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
871 gcc_assert (!VOID_TYPE_P (type
));
873 slot
= build_local_temp (type
);
874 return build_target_expr (slot
, init
, complain
);
877 /* Like build_target_expr_with_type, but use the type of INIT. */
880 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
882 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
883 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
884 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
885 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
888 init
= convert_bitfield_to_declared_type (init
);
889 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
894 get_target_expr (tree init
)
896 return get_target_expr_sfinae (init
, tf_warning_or_error
);
899 /* If EXPR is a bitfield reference, convert it to the declared type of
900 the bitfield, and return the resulting expression. Otherwise,
901 return EXPR itself. */
904 convert_bitfield_to_declared_type (tree expr
)
908 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
910 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
915 /* EXPR is being used in an rvalue context. Return a version of EXPR
916 that is marked as an rvalue. */
923 if (error_operand_p (expr
))
926 expr
= mark_rvalue_use (expr
);
930 Non-class rvalues always have cv-unqualified types. */
931 type
= TREE_TYPE (expr
);
932 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
933 type
= cv_unqualified (type
);
935 /* We need to do this for rvalue refs as well to get the right answer
936 from decltype; see c++/36628. */
937 if (!processing_template_decl
&& glvalue_p (expr
))
938 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
939 else if (type
!= TREE_TYPE (expr
))
940 expr
= build_nop (type
, expr
);
946 struct cplus_array_info
952 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
954 typedef cplus_array_info
*compare_type
;
956 static hashval_t
hash (tree t
);
957 static bool equal (tree
, cplus_array_info
*);
960 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
963 cplus_array_hasher::hash (tree t
)
967 hash
= TYPE_UID (TREE_TYPE (t
));
969 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
973 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
974 of type `cplus_array_info*'. */
977 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
979 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
982 /* Hash table containing dependent array types, which are unsuitable for
983 the language-independent type hash table. */
984 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
986 /* Build an ARRAY_TYPE without laying it out. */
989 build_min_array_type (tree elt_type
, tree index_type
)
991 tree t
= cxx_make_type (ARRAY_TYPE
);
992 TREE_TYPE (t
) = elt_type
;
993 TYPE_DOMAIN (t
) = index_type
;
997 /* Set TYPE_CANONICAL like build_array_type_1, but using
998 build_cplus_array_type. */
1001 set_array_type_canon (tree t
, tree elt_type
, tree index_type
, bool dep
)
1003 /* Set the canonical type for this new node. */
1004 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1005 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1006 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1007 else if (TYPE_CANONICAL (elt_type
) != elt_type
1008 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1010 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1012 ? TYPE_CANONICAL (index_type
) : index_type
,
1015 TYPE_CANONICAL (t
) = t
;
1018 /* Like build_array_type, but handle special C++ semantics: an array of a
1019 variant element type is a variant of the array of the main variant of
1020 the element type. IS_DEPENDENT is -ve if we should determine the
1021 dependency. Otherwise its bool value indicates dependency. */
1024 build_cplus_array_type (tree elt_type
, tree index_type
, int dependent
)
1028 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1029 return error_mark_node
;
1032 dependent
= (uses_template_parms (elt_type
)
1033 || (index_type
&& uses_template_parms (index_type
)));
1035 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1036 /* Start with an array of the TYPE_MAIN_VARIANT. */
1037 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1038 index_type
, dependent
);
1041 /* Since type_hash_canon calls layout_type, we need to use our own
1043 cplus_array_info cai
;
1046 if (cplus_array_htab
== NULL
)
1047 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1049 hash
= TYPE_UID (elt_type
);
1051 hash
^= TYPE_UID (index_type
);
1052 cai
.type
= elt_type
;
1053 cai
.domain
= index_type
;
1055 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1057 /* We have found the type: we're done. */
1061 /* Build a new array type. */
1062 t
= build_min_array_type (elt_type
, index_type
);
1064 /* Store it in the hash table. */
1067 /* Set the canonical type for this new node. */
1068 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1070 /* Mark it as dependent now, this saves time later. */
1071 TYPE_DEPENDENT_P_VALID (t
) = true;
1072 TYPE_DEPENDENT_P (t
) = true;
1077 bool typeless_storage
= is_byte_access_type (elt_type
);
1078 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1080 /* Mark as non-dependenty now, this will save time later. */
1081 TYPE_DEPENDENT_P_VALID (t
) = true;
1084 /* Now check whether we already have this array variant. */
1085 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1088 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1089 if (TREE_TYPE (t
) == elt_type
1090 && TYPE_NAME (t
) == NULL_TREE
1091 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1095 t
= build_min_array_type (elt_type
, index_type
);
1096 /* Mark dependency now, this saves time later. */
1097 TYPE_DEPENDENT_P_VALID (t
) = true;
1098 TYPE_DEPENDENT_P (t
) = dependent
;
1099 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1103 /* Make sure sizes are shared with the main variant.
1104 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1105 as it will overwrite alignment etc. of all variants. */
1106 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1107 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1108 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1111 TYPE_MAIN_VARIANT (t
) = m
;
1112 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1113 TYPE_NEXT_VARIANT (m
) = t
;
1117 /* Avoid spurious warnings with VLAs (c++/54583). */
1118 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1119 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1121 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1122 place more easily. */
1123 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1124 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1125 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1126 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1128 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1129 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1131 /* The element type has been completed since the last time we saw
1132 this array type; update the layout and 'tor flags for any variants
1135 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1137 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1138 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1145 /* Return an ARRAY_TYPE with element type ELT and length N. */
1148 build_array_of_n_type (tree elt
, int n
)
1150 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1153 /* True iff T is an array of unknown bound. */
1156 array_of_unknown_bound_p (const_tree t
)
1158 return (TREE_CODE (t
) == ARRAY_TYPE
1159 && !TYPE_DOMAIN (t
));
1162 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1163 for C++14 but then removed. This should only be used for N3639
1164 specifically; code wondering more generally if something is a VLA should use
1168 array_of_runtime_bound_p (tree t
)
1170 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1172 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1174 tree dom
= TYPE_DOMAIN (t
);
1177 tree max
= TYPE_MAX_VALUE (dom
);
1178 return (!potential_rvalue_constant_expression (max
)
1179 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1182 /* True iff T is a variable length array. */
1187 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1189 if (tree dom
= TYPE_DOMAIN (t
))
1191 tree max
= TYPE_MAX_VALUE (dom
);
1192 if (!potential_rvalue_constant_expression (max
)
1193 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1199 /* Return a reference type node referring to TO_TYPE. If RVAL is
1200 true, return an rvalue reference type, otherwise return an lvalue
1201 reference type. If a type node exists, reuse it, otherwise create
1204 cp_build_reference_type (tree to_type
, bool rval
)
1208 if (to_type
== error_mark_node
)
1209 return error_mark_node
;
1211 if (TYPE_REF_P (to_type
))
1213 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1214 to_type
= TREE_TYPE (to_type
);
1217 lvalue_ref
= build_reference_type (to_type
);
1221 /* This code to create rvalue reference types is based on and tied
1222 to the code creating lvalue reference types in the middle-end
1223 functions build_reference_type_for_mode and build_reference_type.
1225 It works by putting the rvalue reference type nodes after the
1226 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1227 they will effectively be ignored by the middle end. */
1229 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1230 if (TYPE_REF_IS_RVALUE (t
))
1233 t
= build_distinct_type_copy (lvalue_ref
);
1235 TYPE_REF_IS_RVALUE (t
) = true;
1236 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1237 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1239 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1240 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1241 else if (TYPE_CANONICAL (to_type
) != to_type
)
1243 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1245 TYPE_CANONICAL (t
) = t
;
1253 /* Returns EXPR cast to rvalue reference type, like std::move. */
1258 tree type
= TREE_TYPE (expr
);
1259 gcc_assert (!TYPE_REF_P (type
));
1260 type
= cp_build_reference_type (type
, /*rval*/true);
1261 return build_static_cast (input_location
, type
, expr
,
1262 tf_warning_or_error
);
1265 /* Used by the C++ front end to build qualified array types. However,
1266 the C version of this function does not properly maintain canonical
1267 types (which are not used in C). */
1269 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1270 size_t /* orig_qual_indirect */)
1272 return cp_build_qualified_type (type
, type_quals
);
1276 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1277 arrays correctly. In particular, if TYPE is an array of T's, and
1278 TYPE_QUALS is non-empty, returns an array of qualified T's.
1280 FLAGS determines how to deal with ill-formed qualifications. If
1281 tf_ignore_bad_quals is set, then bad qualifications are dropped
1282 (this is permitted if TYPE was introduced via a typedef or template
1283 type parameter). If bad qualifications are dropped and tf_warning
1284 is set, then a warning is issued for non-const qualifications. If
1285 tf_ignore_bad_quals is not set and tf_error is not set, we
1286 return error_mark_node. Otherwise, we issue an error, and ignore
1289 Qualification of a reference type is valid when the reference came
1290 via a typedef or template type argument. [dcl.ref] No such
1291 dispensation is provided for qualifying a function type. [dcl.fct]
1292 DR 295 queries this and the proposed resolution brings it into line
1293 with qualifying a reference. We implement the DR. We also behave
1294 in a similar manner for restricting non-pointer types. */
1297 cp_build_qualified_type_real (tree type
,
1299 tsubst_flags_t complain
)
1302 int bad_quals
= TYPE_UNQUALIFIED
;
1304 if (type
== error_mark_node
)
1307 if (type_quals
== cp_type_quals (type
))
1310 if (TREE_CODE (type
) == ARRAY_TYPE
)
1312 /* In C++, the qualification really applies to the array element
1313 type. Obtain the appropriately qualified element type. */
1316 = cp_build_qualified_type_real (TREE_TYPE (type
),
1320 if (element_type
== error_mark_node
)
1321 return error_mark_node
;
1323 /* See if we already have an identically qualified type. Tests
1324 should be equivalent to those in check_qualified_type. */
1325 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1326 if (TREE_TYPE (t
) == element_type
1327 && TYPE_NAME (t
) == TYPE_NAME (type
)
1328 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1329 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1330 TYPE_ATTRIBUTES (type
)))
1335 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (type
)
1336 || !dependent_type_p (type
));
1337 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
),
1338 TYPE_DEPENDENT_P (type
));
1340 /* Keep the typedef name. */
1341 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1343 t
= build_variant_type_copy (t
);
1344 TYPE_NAME (t
) = TYPE_NAME (type
);
1345 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1346 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1350 /* Even if we already had this variant, we update
1351 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1352 they changed since the variant was originally created.
1354 This seems hokey; if there is some way to use a previous
1355 variant *without* coming through here,
1356 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1357 TYPE_NEEDS_CONSTRUCTING (t
)
1358 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1359 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1360 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1363 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1365 tree t
= PACK_EXPANSION_PATTERN (type
);
1367 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1368 return make_pack_expansion (t
, complain
);
1371 /* A reference or method type shall not be cv-qualified.
1372 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1373 (in CD1) we always ignore extra cv-quals on functions. */
1374 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1375 && (TYPE_REF_P (type
)
1376 || FUNC_OR_METHOD_TYPE_P (type
)))
1378 if (TYPE_REF_P (type
))
1379 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1380 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1383 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1384 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1385 type_quals
|= type_memfn_quals (type
);
1387 /* A restrict-qualified type must be a pointer (or reference)
1388 to object or incomplete type. */
1389 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1390 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1391 && TREE_CODE (type
) != TYPENAME_TYPE
1392 && !INDIRECT_TYPE_P (type
))
1394 bad_quals
|= TYPE_QUAL_RESTRICT
;
1395 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1398 if (bad_quals
== TYPE_UNQUALIFIED
1399 || (complain
& tf_ignore_bad_quals
))
1401 else if (!(complain
& tf_error
))
1402 return error_mark_node
;
1405 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1406 error ("%qV qualifiers cannot be applied to %qT",
1410 /* Retrieve (or create) the appropriately qualified variant. */
1411 result
= build_qualified_type (type
, type_quals
);
1416 /* Return TYPE with const and volatile removed. */
1419 cv_unqualified (tree type
)
1423 if (type
== error_mark_node
)
1426 quals
= cp_type_quals (type
);
1427 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1428 return cp_build_qualified_type (type
, quals
);
1431 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1432 from ATTRIBS that affect type identity, and no others. If any are not
1433 applied, set *remove_attributes to true. */
1436 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1438 tree first_ident
= NULL_TREE
;
1439 tree new_attribs
= NULL_TREE
;
1440 tree
*p
= &new_attribs
;
1442 if (OVERLOAD_TYPE_P (result
))
1444 /* On classes and enums all attributes are ingrained. */
1445 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1449 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1451 const attribute_spec
*as
1452 = lookup_attribute_spec (get_attribute_name (a
));
1453 if (as
&& as
->affects_type_identity
)
1457 else if (first_ident
== error_mark_node
)
1459 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1460 p
= &TREE_CHAIN (*p
);
1463 else if (first_ident
)
1465 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1467 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1468 p
= &TREE_CHAIN (*p
);
1470 first_ident
= error_mark_node
;
1473 if (first_ident
!= error_mark_node
)
1474 new_attribs
= first_ident
;
1476 if (first_ident
== attribs
)
1477 /* All attributes affected type identity. */;
1479 *remove_attributes
= true;
1481 return cp_build_type_attribute_variant (result
, new_attribs
);
1484 /* Builds a qualified variant of T that is either not a typedef variant
1485 (the default behavior) or not a typedef variant of a user-facing type
1486 (if FLAGS contains STF_USER_FACING).
1488 E.g. consider the following declarations:
1489 typedef const int ConstInt;
1490 typedef ConstInt* PtrConstInt;
1491 If T is PtrConstInt, this function returns a type representing
1493 In other words, if T is a typedef, the function returns the underlying type.
1494 The cv-qualification and attributes of the type returned match the
1496 They will always be compatible types.
1497 The returned type is built so that all of its subtypes
1498 recursively have their typedefs stripped as well.
1500 This is different from just returning TYPE_CANONICAL (T)
1501 Because of several reasons:
1502 * If T is a type that needs structural equality
1503 its TYPE_CANONICAL (T) will be NULL.
1504 * TYPE_CANONICAL (T) desn't carry type attributes
1505 and loses template parameter names.
1507 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1508 affect type identity, and set the referent to true if any were
1512 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1514 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1516 if (!t
|| t
== error_mark_node
)
1519 if (TREE_CODE (t
) == TREE_LIST
)
1521 bool changed
= false;
1524 for (; t
; t
= TREE_CHAIN (t
))
1526 gcc_assert (!TREE_PURPOSE (t
));
1527 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1528 if (elt
!= TREE_VALUE (t
))
1530 vec_safe_push (vec
, elt
);
1533 r
= build_tree_list_vec (vec
);
1537 gcc_assert (TYPE_P (t
));
1539 if (t
== TYPE_CANONICAL (t
))
1542 if (!(flags
& STF_STRIP_DEPENDENT
)
1543 && dependent_alias_template_spec_p (t
, nt_opaque
))
1544 /* DR 1558: However, if the template-id is dependent, subsequent
1545 template argument substitution still applies to the template-id. */
1548 switch (TREE_CODE (t
))
1551 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1552 result
= build_pointer_type (type
);
1554 case REFERENCE_TYPE
:
1555 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1556 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1559 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1560 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1561 result
= build_offset_type (t0
, type
);
1564 if (TYPE_PTRMEMFUNC_P (t
))
1566 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1567 remove_attributes
, flags
);
1568 result
= build_ptrmemfunc_type (t0
);
1572 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1573 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1574 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t
)
1575 || !dependent_type_p (t
));
1576 result
= build_cplus_array_type (type
, t0
, TYPE_DEPENDENT_P (t
));
1581 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1584 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1585 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1586 can't expect that re-hashing a function type will find a previous
1587 equivalent type, so try to reuse the input type if nothing has
1588 changed. If the type is itself a variant, that will change. */
1589 bool is_variant
= typedef_variant_p (t
);
1590 if (remove_attributes
1591 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1594 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1595 tree canon_spec
= (flag_noexcept_type
1596 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1598 changed
= (type
!= TREE_TYPE (t
) || is_variant
1599 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1601 for (arg_node
= TYPE_ARG_TYPES (t
);
1603 arg_node
= TREE_CHAIN (arg_node
))
1605 if (arg_node
== void_list_node
)
1607 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1608 remove_attributes
, flags
);
1609 gcc_assert (arg_type
);
1610 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1616 for (arg_node2
= TYPE_ARG_TYPES (t
);
1617 arg_node2
!= arg_node
;
1618 arg_node2
= TREE_CHAIN (arg_node2
))
1620 = tree_cons (TREE_PURPOSE (arg_node2
),
1621 TREE_VALUE (arg_node2
), arg_types
);
1625 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1632 arg_types
= nreverse (arg_types
);
1634 /* A list of parameters not ending with an ellipsis
1635 must end with void_list_node. */
1637 arg_types
= chainon (arg_types
, void_list_node
);
1639 if (TREE_CODE (t
) == METHOD_TYPE
)
1641 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1642 gcc_assert (class_type
);
1644 build_method_type_directly (class_type
, type
,
1645 TREE_CHAIN (arg_types
));
1649 result
= build_function_type (type
, arg_types
);
1650 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1653 result
= build_cp_fntype_variant (result
,
1654 type_memfn_rqual (t
), canon_spec
,
1655 TYPE_HAS_LATE_RETURN_TYPE (t
));
1660 bool changed
= false;
1661 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1662 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1663 && TREE_OPERAND (fullname
, 1))
1665 tree args
= TREE_OPERAND (fullname
, 1);
1666 tree new_args
= copy_node (args
);
1667 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1669 tree arg
= TREE_VEC_ELT (args
, i
);
1672 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1674 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1676 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1677 if (strip_arg
!= arg
)
1682 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1683 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1685 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1689 ggc_free (new_args
);
1691 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1692 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1694 tree name
= fullname
;
1695 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1696 name
= TREE_OPERAND (fullname
, 0);
1697 /* Use build_typename_type rather than make_typename_type because we
1698 don't want to resolve it here, just strip typedefs. */
1699 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1703 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1704 remove_attributes
, flags
);
1705 if (result
== DECLTYPE_TYPE_EXPR (t
))
1708 result
= (finish_decltype_type
1710 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1713 case UNDERLYING_TYPE
:
1714 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1715 remove_attributes
, flags
);
1716 result
= finish_underlying_type (type
);
1724 if (typedef_variant_p (t
))
1726 if ((flags
& STF_USER_VISIBLE
)
1727 && !user_facing_original_type_p (t
))
1729 /* If T is a non-template alias or typedef, we can assume that
1730 instantiating its definition will hit any substitution failure,
1731 so we don't need to retain it here as well. */
1732 if (!alias_template_specialization_p (t
, nt_opaque
))
1733 flags
|= STF_STRIP_DEPENDENT
;
1734 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1735 remove_attributes
, flags
);
1738 result
= TYPE_MAIN_VARIANT (t
);
1740 /*gcc_assert (!typedef_variant_p (result)
1741 || dependent_alias_template_spec_p (result, nt_opaque)
1742 || ((flags & STF_USER_VISIBLE)
1743 && !user_facing_original_type_p (result)));*/
1745 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1746 /* If RESULT is complete and T isn't, it's likely the case that T
1747 is a variant of RESULT which hasn't been updated yet. Skip the
1748 attribute handling. */;
1751 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1752 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1754 gcc_assert (TYPE_USER_ALIGN (t
));
1755 if (remove_attributes
)
1756 *remove_attributes
= true;
1759 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1760 result
= build_variant_type_copy (result
);
1762 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1763 TYPE_USER_ALIGN (result
) = true;
1767 if (TYPE_ATTRIBUTES (t
))
1769 if (remove_attributes
)
1770 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1773 result
= cp_build_type_attribute_variant (result
,
1774 TYPE_ATTRIBUTES (t
));
1778 return cp_build_qualified_type (result
, cp_type_quals (t
));
1781 /* Like strip_typedefs above, but works on expressions, so that in
1783 template<class T> struct A
1789 sizeof(TT) is replaced by sizeof(T). */
1792 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1796 enum tree_code code
;
1798 if (t
== NULL_TREE
|| t
== error_mark_node
)
1801 STRIP_ANY_LOCATION_WRAPPER (t
);
1803 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1806 /* Some expressions have type operands, so let's handle types here rather
1807 than check TYPE_P in multiple places below. */
1809 return strip_typedefs (t
, remove_attributes
, flags
);
1811 code
= TREE_CODE (t
);
1814 case IDENTIFIER_NODE
:
1815 case TEMPLATE_PARM_INDEX
:
1818 case ARGUMENT_PACK_SELECT
:
1823 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1824 remove_attributes
, flags
);
1825 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1826 remove_attributes
, flags
);
1827 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1828 && type2
== TRAIT_EXPR_TYPE2 (t
))
1831 TRAIT_EXPR_TYPE1 (r
) = type1
;
1832 TRAIT_EXPR_TYPE2 (r
) = type2
;
1839 bool changed
= false;
1841 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1843 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1844 remove_attributes
, flags
);
1845 vec_safe_push (vec
, val
);
1846 if (val
!= TREE_VALUE (it
))
1848 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1853 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1854 r
= tree_cons (NULL_TREE
, it
, r
);
1863 bool changed
= false;
1865 n
= TREE_VEC_LENGTH (t
);
1866 vec_safe_reserve (vec
, n
);
1867 for (i
= 0; i
< n
; ++i
)
1869 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1870 remove_attributes
, flags
);
1871 vec
->quick_push (op
);
1872 if (op
!= TREE_VEC_ELT (t
, i
))
1878 for (i
= 0; i
< n
; ++i
)
1879 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1880 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1881 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1890 bool changed
= false;
1891 vec
<constructor_elt
, va_gc
> *vec
1892 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1893 n
= CONSTRUCTOR_NELTS (t
);
1894 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1895 for (i
= 0; i
< n
; ++i
)
1897 constructor_elt
*e
= &(*vec
)[i
];
1898 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1905 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1909 if (!changed
&& type
== TREE_TYPE (t
))
1917 TREE_TYPE (r
) = type
;
1918 CONSTRUCTOR_ELTS (r
) = vec
;
1926 case STATEMENT_LIST
:
1927 error ("statement-expression in a constant expression");
1928 return error_mark_node
;
1934 gcc_assert (EXPR_P (t
));
1936 n
= cp_tree_operand_length (t
);
1937 ops
= XALLOCAVEC (tree
, n
);
1938 type
= TREE_TYPE (t
);
1943 case IMPLICIT_CONV_EXPR
:
1944 case DYNAMIC_CAST_EXPR
:
1945 case STATIC_CAST_EXPR
:
1946 case CONST_CAST_EXPR
:
1947 case REINTERPRET_CAST_EXPR
:
1950 type
= strip_typedefs (type
, remove_attributes
, flags
);
1954 for (i
= 0; i
< n
; ++i
)
1955 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1956 remove_attributes
, flags
);
1960 /* If nothing changed, return t. */
1961 for (i
= 0; i
< n
; ++i
)
1962 if (ops
[i
] != TREE_OPERAND (t
, i
))
1964 if (i
== n
&& type
== TREE_TYPE (t
))
1968 TREE_TYPE (r
) = type
;
1969 for (i
= 0; i
< n
; ++i
)
1970 TREE_OPERAND (r
, i
) = ops
[i
];
1974 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1975 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1976 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1977 VIRT indicates whether TYPE is inherited virtually or not.
1978 IGO_PREV points at the previous binfo of the inheritance graph
1979 order chain. The newly copied binfo's TREE_CHAIN forms this
1982 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1983 correct order. That is in the order the bases themselves should be
1986 The BINFO_INHERITANCE of a virtual base class points to the binfo
1987 of the most derived type. ??? We could probably change this so that
1988 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1989 remove a field. They currently can only differ for primary virtual
1993 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1999 /* See if we've already made this virtual base. */
2000 new_binfo
= binfo_for_vbase (type
, t
);
2005 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
2006 BINFO_TYPE (new_binfo
) = type
;
2008 /* Chain it into the inheritance graph. */
2009 TREE_CHAIN (*igo_prev
) = new_binfo
;
2010 *igo_prev
= new_binfo
;
2012 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2017 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2019 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2020 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2022 /* We do not need to copy the accesses, as they are read only. */
2023 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2025 /* Recursively copy base binfos of BINFO. */
2026 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2028 tree new_base_binfo
;
2029 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2031 BINFO_VIRTUAL_P (base_binfo
));
2033 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2034 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2035 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2039 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2043 /* Push it onto the list after any virtual bases it contains
2044 will have been pushed. */
2045 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2046 BINFO_VIRTUAL_P (new_binfo
) = 1;
2047 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2053 /* Hashing of lists so that we don't make duplicates.
2054 The entry point is `list_hash_canon'. */
2063 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2065 typedef list_proxy
*compare_type
;
2067 static hashval_t
hash (tree
);
2068 static bool equal (tree
, list_proxy
*);
2071 /* Now here is the hash table. When recording a list, it is added
2072 to the slot whose index is the hash code mod the table size.
2073 Note that the hash table is used for several kinds of lists.
2074 While all these live in the same table, they are completely independent,
2075 and the hash code is computed differently for each of these. */
2077 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2079 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2080 for a node we are thinking about adding). */
2083 list_hasher::equal (tree t
, list_proxy
*proxy
)
2085 return (TREE_VALUE (t
) == proxy
->value
2086 && TREE_PURPOSE (t
) == proxy
->purpose
2087 && TREE_CHAIN (t
) == proxy
->chain
);
2090 /* Compute a hash code for a list (chain of TREE_LIST nodes
2091 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2092 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2095 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2097 hashval_t hashcode
= 0;
2100 hashcode
+= TREE_HASH (chain
);
2103 hashcode
+= TREE_HASH (value
);
2107 hashcode
+= TREE_HASH (purpose
);
2113 /* Hash an already existing TREE_LIST. */
2116 list_hasher::hash (tree t
)
2118 return list_hash_pieces (TREE_PURPOSE (t
),
2123 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2124 object for an identical list if one already exists. Otherwise, build a
2125 new one, and record it as the canonical object. */
2128 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2132 struct list_proxy proxy
;
2134 /* Hash the list node. */
2135 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2136 /* Create a proxy for the TREE_LIST we would like to create. We
2137 don't actually create it so as to avoid creating garbage. */
2138 proxy
.purpose
= purpose
;
2139 proxy
.value
= value
;
2140 proxy
.chain
= chain
;
2141 /* See if it is already in the table. */
2142 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2143 /* If not, create a new node. */
2145 *slot
= tree_cons (purpose
, value
, chain
);
2146 return (tree
) *slot
;
2149 /* Constructor for hashed lists. */
2152 hash_tree_chain (tree value
, tree chain
)
2154 return hash_tree_cons (NULL_TREE
, value
, chain
);
2158 debug_binfo (tree elem
)
2163 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2165 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2166 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2167 debug_tree (BINFO_TYPE (elem
));
2168 if (BINFO_VTABLE (elem
))
2169 fprintf (stderr
, "vtable decl \"%s\"\n",
2170 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2172 fprintf (stderr
, "no vtable decl yet\n");
2173 fprintf (stderr
, "virtuals:\n");
2174 virtuals
= BINFO_VIRTUALS (elem
);
2179 tree fndecl
= TREE_VALUE (virtuals
);
2180 fprintf (stderr
, "%s [%ld =? %ld]\n",
2181 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2182 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2184 virtuals
= TREE_CHAIN (virtuals
);
2188 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2189 the type of the result expression, if known, or NULL_TREE if the
2190 resulting expression is type-dependent. If TEMPLATE_P is true,
2191 NAME is known to be a template because the user explicitly used the
2192 "template" keyword after the "::".
2194 All SCOPE_REFs should be built by use of this function. */
2197 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2200 if (type
== error_mark_node
2201 || scope
== error_mark_node
2202 || name
== error_mark_node
)
2203 return error_mark_node
;
2204 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2205 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2206 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2207 PTRMEM_OK_P (t
) = true;
2209 t
= convert_from_reference (t
);
2213 /* Like check_qualified_type, but also check ref-qualifier, exception
2214 specification, and whether the return type was specified after the
2218 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2219 cp_ref_qualifier rqual
, tree raises
, bool late
)
2221 return (TYPE_QUALS (cand
) == type_quals
2222 && check_base_type (cand
, base
)
2223 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2225 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2226 && type_memfn_rqual (cand
) == rqual
);
2229 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2232 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2234 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2235 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2236 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2240 make_binding_vec (tree name
, unsigned clusters MEM_STAT_DECL
)
2242 /* Stored in an unsigned short, but we're limited to the number of
2244 gcc_checking_assert (clusters
<= (unsigned short)(~0));
2245 size_t length
= (offsetof (tree_binding_vec
, vec
)
2246 + clusters
* sizeof (binding_cluster
));
2247 tree vec
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2248 TREE_SET_CODE (vec
, BINDING_VECTOR
);
2249 BINDING_VECTOR_NAME (vec
) = name
;
2250 BINDING_VECTOR_ALLOC_CLUSTERS (vec
) = clusters
;
2251 BINDING_VECTOR_NUM_CLUSTERS (vec
) = 0;
2256 /* Make a raw overload node containing FN. */
2259 ovl_make (tree fn
, tree next
)
2261 tree result
= make_node (OVERLOAD
);
2263 if (TREE_CODE (fn
) == OVERLOAD
)
2264 OVL_NESTED_P (result
) = true;
2266 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2267 ? unknown_type_node
: TREE_TYPE (fn
));
2268 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2269 OVL_DEDUP_P (result
) = true;
2270 OVL_FUNCTION (result
) = fn
;
2271 OVL_CHAIN (result
) = next
;
2275 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2276 zero if this is a using-decl. It is > 1 if we're exporting the
2277 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2278 cannot be both using and hidden.) We keep the hidden decls first,
2279 but remaining ones are unordered. */
2282 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2284 tree result
= maybe_ovl
;
2285 tree insert_after
= NULL_TREE
;
2288 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2289 && OVL_HIDDEN_P (maybe_ovl
);
2290 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2292 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2293 insert_after
= maybe_ovl
;
2296 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2298 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2300 if (using_or_hidden
< 0)
2301 OVL_HIDDEN_P (maybe_ovl
) = true;
2302 if (using_or_hidden
> 0)
2304 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2305 if (using_or_hidden
> 1)
2306 OVL_EXPORT_P (maybe_ovl
) = true;
2314 OVL_CHAIN (insert_after
) = maybe_ovl
;
2315 TREE_TYPE (insert_after
) = unknown_type_node
;
2323 /* Skip any hidden names at the beginning of OVL. */
2326 ovl_skip_hidden (tree ovl
)
2328 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2329 ovl
= OVL_CHAIN (ovl
);
2334 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2337 ovl_iterator::reveal_node (tree overload
, tree node
)
2339 /* We cannot have returned NODE as part of a lookup overload, so we
2340 don't have to worry about preserving that. */
2342 OVL_HIDDEN_P (node
) = false;
2343 if (tree chain
= OVL_CHAIN (node
))
2344 if (TREE_CODE (chain
) == OVERLOAD
)
2346 if (OVL_HIDDEN_P (chain
))
2348 /* The node needs moving, and the simplest way is to remove it
2350 overload
= remove_node (overload
, node
);
2351 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2353 else if (OVL_DEDUP_P (chain
))
2354 OVL_DEDUP_P (node
) = true;
2359 /* NODE is on the overloads of OVL. Remove it.
2360 The removed node is unaltered and may continue to be iterated
2361 from (i.e. it is safe to remove a node from an overload one is
2362 currently iterating over). */
2365 ovl_iterator::remove_node (tree overload
, tree node
)
2367 tree
*slot
= &overload
;
2368 while (*slot
!= node
)
2371 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2373 slot
= &OVL_CHAIN (probe
);
2376 /* Stitch out NODE. We don't have to worry about now making a
2377 singleton overload (and consequently maybe setting its type),
2378 because all uses of this function will be followed by inserting a
2379 new node that must follow the place we've cut this out from. */
2380 if (TREE_CODE (node
) != OVERLOAD
)
2381 /* Cloned inherited ctors don't mark themselves as via_using. */
2384 *slot
= OVL_CHAIN (node
);
2389 /* Mark or unmark a lookup set. */
2392 lookup_mark (tree ovl
, bool val
)
2394 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2396 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2397 LOOKUP_SEEN_P (*iter
) = val
;
2401 /* Add a set of new FNS into a lookup. */
2404 lookup_add (tree fns
, tree lookup
)
2406 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2407 return error_mark_node
;
2409 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2411 lookup
= ovl_make (fns
, lookup
);
2412 OVL_LOOKUP_P (lookup
) = true;
2420 /* FNS is a new overload set, add them to LOOKUP, if they are not
2421 already present there. */
2424 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2427 for (tree next
, probe
= fns
; probe
; probe
= next
)
2432 if (TREE_CODE (probe
) == OVERLOAD
)
2434 fn
= OVL_FUNCTION (probe
);
2435 next
= OVL_CHAIN (probe
);
2438 if (!LOOKUP_SEEN_P (fn
))
2439 LOOKUP_SEEN_P (fn
) = true;
2442 /* This function was already seen. Insert all the
2443 predecessors onto the lookup. */
2444 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2446 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2447 /* Propagate OVL_USING, but OVL_HIDDEN &
2448 OVL_DEDUP_P don't matter. */
2449 if (OVL_USING_P (fns
))
2450 OVL_USING_P (lookup
) = true;
2453 /* And now skip this function. */
2459 /* We ended in a set of new functions. Add them all in one go. */
2460 lookup
= lookup_add (fns
, lookup
);
2465 /* Returns nonzero if X is an expression for a (possibly overloaded)
2466 function. If "f" is a function or function template, "f", "c->f",
2467 "c.f", "C::f", and "f<int>" will all be considered possibly
2468 overloaded functions. Returns 2 if the function is actually
2469 overloaded, i.e., if it is impossible to know the type of the
2470 function without performing overload resolution. */
2473 is_overloaded_fn (tree x
)
2475 STRIP_ANY_LOCATION_WRAPPER (x
);
2477 /* A baselink is also considered an overloaded function. */
2478 if (TREE_CODE (x
) == OFFSET_REF
2479 || TREE_CODE (x
) == COMPONENT_REF
)
2480 x
= TREE_OPERAND (x
, 1);
2481 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2482 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2483 x
= TREE_OPERAND (x
, 0);
2485 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2486 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2492 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2493 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2497 dependent_name (tree x
)
2499 /* FIXME a dependent name must be unqualified, but this function doesn't
2500 distinguish between qualified and unqualified identifiers. */
2501 if (identifier_p (x
))
2503 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2504 x
= TREE_OPERAND (x
, 0);
2506 return OVL_NAME (x
);
2510 /* Returns true iff X is an expression for an overloaded function
2511 whose type cannot be known without performing overload
2515 really_overloaded_fn (tree x
)
2517 return is_overloaded_fn (x
) == 2;
2520 /* Get the overload set FROM refers to. Returns NULL if it's not an
2524 maybe_get_fns (tree from
)
2526 STRIP_ANY_LOCATION_WRAPPER (from
);
2528 /* A baselink is also considered an overloaded function. */
2529 if (TREE_CODE (from
) == OFFSET_REF
2530 || TREE_CODE (from
) == COMPONENT_REF
)
2531 from
= TREE_OPERAND (from
, 1);
2532 if (BASELINK_P (from
))
2533 from
= BASELINK_FUNCTIONS (from
);
2534 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2535 from
= TREE_OPERAND (from
, 0);
2543 /* FROM refers to an overload set. Return that set (or die). */
2548 tree res
= maybe_get_fns (from
);
2554 /* Return the first function of the overload set FROM refers to. */
2557 get_first_fn (tree from
)
2559 return OVL_FIRST (get_fns (from
));
2562 /* Return the scope where the overloaded functions OVL were found. */
2565 ovl_scope (tree ovl
)
2567 if (TREE_CODE (ovl
) == OFFSET_REF
2568 || TREE_CODE (ovl
) == COMPONENT_REF
)
2569 ovl
= TREE_OPERAND (ovl
, 1);
2570 if (TREE_CODE (ovl
) == BASELINK
)
2571 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2572 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2573 ovl
= TREE_OPERAND (ovl
, 0);
2574 /* Skip using-declarations. */
2575 lkp_iterator
iter (ovl
);
2578 while (iter
.using_p () && ++iter
);
2580 return CP_DECL_CONTEXT (ovl
);
2583 #define PRINT_RING_SIZE 4
2586 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2588 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2589 static char *print_ring
[PRINT_RING_SIZE
];
2590 static bool trans_ring
[PRINT_RING_SIZE
];
2591 static int ring_counter
;
2594 /* Only cache functions. */
2596 || TREE_CODE (decl
) != FUNCTION_DECL
2597 || DECL_LANG_SPECIFIC (decl
) == 0)
2598 return lang_decl_name (decl
, v
, translate
);
2600 /* See if this print name is lying around. */
2601 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2602 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2603 /* yes, so return it. */
2604 return print_ring
[i
];
2606 if (++ring_counter
== PRINT_RING_SIZE
)
2609 if (current_function_decl
!= NULL_TREE
)
2611 /* There may be both translated and untranslated versions of the
2613 for (i
= 0; i
< 2; i
++)
2615 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2617 if (ring_counter
== PRINT_RING_SIZE
)
2620 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2623 free (print_ring
[ring_counter
]);
2625 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2626 uid_ring
[ring_counter
] = DECL_UID (decl
);
2627 trans_ring
[ring_counter
] = translate
;
2628 return print_ring
[ring_counter
];
2632 cxx_printable_name (tree decl
, int v
)
2634 return cxx_printable_name_internal (decl
, v
, false);
2638 cxx_printable_name_translate (tree decl
, int v
)
2640 return cxx_printable_name_internal (decl
, v
, true);
2643 /* Return the canonical version of exception-specification RAISES for a C++17
2644 function type, for use in type comparison and building TYPE_CANONICAL. */
2647 canonical_eh_spec (tree raises
)
2649 if (raises
== NULL_TREE
)
2651 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2652 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2653 || uses_template_parms (raises
)
2654 || uses_template_parms (TREE_PURPOSE (raises
)))
2655 /* Keep a dependent or deferred exception specification. */
2657 else if (nothrow_spec_p (raises
))
2658 /* throw() -> noexcept. */
2659 return noexcept_true_spec
;
2661 /* For C++17 type matching, anything else -> nothing. */
2666 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2667 tree raises
, bool late
)
2669 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2671 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2674 tree v
= TYPE_MAIN_VARIANT (type
);
2675 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2676 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2679 /* Need to build a new variant. */
2680 v
= build_variant_type_copy (type
);
2681 if (!TYPE_DEPENDENT_P (v
))
2682 /* We no longer know that it's not type-dependent. */
2683 TYPE_DEPENDENT_P_VALID (v
) = false;
2684 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2685 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2688 case REF_QUAL_RVALUE
:
2689 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2690 FUNCTION_REF_QUALIFIED (v
) = 1;
2692 case REF_QUAL_LVALUE
:
2693 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2694 FUNCTION_REF_QUALIFIED (v
) = 1;
2697 FUNCTION_REF_QUALIFIED (v
) = 0;
2701 /* Canonicalize the exception specification. */
2702 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2704 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2705 /* Propagate structural equality. */
2706 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2707 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2708 /* Build the underlying canonical type, since it is different
2710 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2713 /* T is its own canonical type. */
2714 TYPE_CANONICAL (v
) = v
;
2719 /* TYPE is a function or method type with a deferred exception
2720 specification that has been parsed to RAISES. Fixup all the type
2721 variants that are affected in place. Via decltype &| noexcept
2722 tricks, the unparsed spec could have escaped into the type system.
2723 The general case is hard to fixup canonical types for. */
2726 fixup_deferred_exception_variants (tree type
, tree raises
)
2728 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2729 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2731 gcc_checking_assert (TREE_CODE (TREE_PURPOSE (original
))
2734 /* Though sucky, this walk will process the canonical variants
2736 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2737 variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2738 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2740 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2742 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2744 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2745 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2747 tree v
= TYPE_MAIN_VARIANT (type
);
2748 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2749 if (TYPE_CANONICAL (v
) == v
2750 && cp_check_qualified_type (v
, variant
, var_quals
,
2753 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2756 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2758 TYPE_CANONICAL (variant
) = v
;
2761 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2765 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2766 listed in RAISES. */
2769 build_exception_variant (tree type
, tree raises
)
2771 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2772 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2773 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2776 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2777 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2781 bind_template_template_parm (tree t
, tree newargs
)
2783 tree decl
= TYPE_NAME (t
);
2786 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2787 decl
= build_decl (input_location
,
2788 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2789 SET_DECL_TEMPLATE_PARM_P (decl
);
2791 /* These nodes have to be created to reflect new TYPE_DECL and template
2793 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2794 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2795 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2796 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2798 TREE_TYPE (decl
) = t2
;
2799 TYPE_NAME (t2
) = decl
;
2800 TYPE_STUB_DECL (t2
) = decl
;
2802 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2807 /* Called from count_trees via walk_tree. */
2810 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2820 /* Debugging function for measuring the rough complexity of a tree
2824 count_trees (tree t
)
2827 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2831 /* Called from verify_stmt_tree via walk_tree. */
2834 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2837 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2838 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2841 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2844 /* If this statement is already present in the hash table, then
2845 there is a circularity in the statement tree. */
2846 gcc_assert (!statements
->find (t
));
2848 slot
= statements
->find_slot (t
, INSERT
);
2854 /* Debugging function to check that the statement T has not been
2855 corrupted. For now, this function simply checks that T contains no
2859 verify_stmt_tree (tree t
)
2861 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2862 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2865 /* Check if the type T depends on a type with no linkage and if so,
2866 return it. If RELAXED_P then do not consider a class type declared
2867 within a vague-linkage function to have no linkage. Remember:
2868 no-linkage is not the same as internal-linkage*/
2871 no_linkage_check (tree t
, bool relaxed_p
)
2875 /* Lambda types that don't have mangling scope have no linkage. We
2876 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2877 when we get here from pushtag none of the lambda information is
2878 set up yet, so we want to assume that the lambda has linkage and
2879 fix it up later if not. We need to check this even in templates so
2880 that we properly handle a lambda-expression in the signature. */
2881 if (LAMBDA_TYPE_P (t
)
2882 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2884 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2889 /* Otherwise there's no point in checking linkage on template functions; we
2890 can't know their complete types. */
2891 if (processing_template_decl
)
2894 switch (TREE_CODE (t
))
2897 if (TYPE_PTRMEMFUNC_P (t
))
2901 if (!CLASS_TYPE_P (t
))
2905 /* Only treat unnamed types as having no linkage if they're at
2906 namespace scope. This is core issue 966. */
2907 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2910 for (r
= CP_TYPE_CONTEXT (t
); ; )
2912 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2913 have linkage, or we might just be in an anonymous namespace.
2914 If we're in a TREE_PUBLIC class, we have linkage. */
2915 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2916 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2917 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2919 if (!relaxed_p
|| !vague_linkage_p (r
))
2922 r
= CP_DECL_CONTEXT (r
);
2932 case REFERENCE_TYPE
:
2934 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2938 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2942 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2947 tree parm
= TYPE_ARG_TYPES (t
);
2948 if (TREE_CODE (t
) == METHOD_TYPE
)
2949 /* The 'this' pointer isn't interesting; a method has the same
2950 linkage (or lack thereof) as its enclosing class. */
2951 parm
= TREE_CHAIN (parm
);
2953 parm
&& parm
!= void_list_node
;
2954 parm
= TREE_CHAIN (parm
))
2956 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2960 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2968 extern int depth_reached
;
2971 cxx_print_statistics (void)
2973 print_template_statistics ();
2974 if (GATHER_STATISTICS
)
2975 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2979 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2980 (which is an ARRAY_TYPE). This counts only elements of the top
2984 array_type_nelts_top (tree type
)
2986 return fold_build2_loc (input_location
,
2987 PLUS_EXPR
, sizetype
,
2988 array_type_nelts (type
),
2992 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2993 (which is an ARRAY_TYPE). This one is a recursive count of all
2994 ARRAY_TYPEs that are clumped together. */
2997 array_type_nelts_total (tree type
)
2999 tree sz
= array_type_nelts_top (type
);
3000 type
= TREE_TYPE (type
);
3001 while (TREE_CODE (type
) == ARRAY_TYPE
)
3003 tree n
= array_type_nelts_top (type
);
3004 sz
= fold_build2_loc (input_location
,
3005 MULT_EXPR
, sizetype
, sz
, n
);
3006 type
= TREE_TYPE (type
);
3011 /* Return true if FNDECL is std::source_location::current () method. */
3014 source_location_current_p (tree fndecl
)
3016 gcc_checking_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
3017 && DECL_IMMEDIATE_FUNCTION_P (fndecl
));
3018 if (DECL_NAME (fndecl
) == NULL_TREE
3019 || TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
3020 || TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != RECORD_TYPE
3021 || DECL_CONTEXT (fndecl
) != TREE_TYPE (TREE_TYPE (fndecl
))
3022 || !id_equal (DECL_NAME (fndecl
), "current"))
3025 tree source_location
= DECL_CONTEXT (fndecl
);
3026 if (TYPE_NAME (source_location
) == NULL_TREE
3027 || TREE_CODE (TYPE_NAME (source_location
)) != TYPE_DECL
3028 || TYPE_IDENTIFIER (source_location
) == NULL_TREE
3029 || !id_equal (TYPE_IDENTIFIER (source_location
),
3031 || !decl_in_std_namespace_p (TYPE_NAME (source_location
)))
3039 splay_tree target_remap
;
3040 bool clear_location
;
3043 /* Called from break_out_target_exprs via mapcar. */
3046 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
3048 bot_data
&data
= *(bot_data
*)data_
;
3049 splay_tree target_remap
= data
.target_remap
;
3052 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
3054 /* There can't be any TARGET_EXPRs or their slot variables below this
3055 point. But we must make a copy, in case subsequent processing
3056 alters any part of it. For example, during gimplification a cast
3057 of the form (T) &X::f (where "f" is a member function) will lead
3058 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3060 *tp
= unshare_expr (t
);
3063 if (TREE_CODE (t
) == TARGET_EXPR
)
3067 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3069 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3070 tf_warning_or_error
);
3071 if (u
== error_mark_node
)
3073 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3074 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3077 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
3078 tf_warning_or_error
);
3080 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3081 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3082 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3084 /* Map the old variable to the new one. */
3085 splay_tree_insert (target_remap
,
3086 (splay_tree_key
) TREE_OPERAND (t
, 0),
3087 (splay_tree_value
) TREE_OPERAND (u
, 0));
3089 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3090 data
.clear_location
);
3091 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3092 return error_mark_node
;
3094 /* Replace the old expression with the new version. */
3096 /* We don't have to go below this point; the recursive call to
3097 break_out_target_exprs will have handled anything below this
3102 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3105 splay_tree_node n
= splay_tree_lookup (target_remap
,
3106 (splay_tree_key
) t
);
3109 *tp
= (tree
)n
->value
;
3114 copy_tree_r (tp
, walk_subtrees
, NULL
);
3115 splay_tree_insert (target_remap
,
3117 (splay_tree_value
)*tp
);
3118 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3119 splay_tree_insert (target_remap
,
3120 (splay_tree_key
)*tp
,
3121 (splay_tree_value
)*tp
);
3126 /* Make a copy of this node. */
3127 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3128 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3129 if (!processing_template_decl
)
3130 set_flags_from_callee (*tp
);
3131 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3132 SET_EXPR_LOCATION (*tp
, input_location
);
3136 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3137 DATA is really a splay-tree mapping old variables to new
3141 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3143 bot_data
&data
= *(bot_data
*)data_
;
3144 splay_tree target_remap
= data
.target_remap
;
3148 splay_tree_node n
= splay_tree_lookup (target_remap
,
3149 (splay_tree_key
) *t
);
3151 *t
= (tree
) n
->value
;
3153 else if (TREE_CODE (*t
) == PARM_DECL
3154 && DECL_NAME (*t
) == this_identifier
3155 && !DECL_CONTEXT (*t
))
3157 /* In an NSDMI we need to replace the 'this' parameter we used for
3158 parsing with the real one for this function. */
3159 *t
= current_class_ptr
;
3161 else if (TREE_CODE (*t
) == CONVERT_EXPR
3162 && CONVERT_EXPR_VBASE_PATH (*t
))
3164 /* In an NSDMI build_base_path defers building conversions to virtual
3165 bases, and we handle it here. */
3166 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3167 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3169 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3170 if (BINFO_TYPE (binfo
) == basetype
)
3172 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3173 tf_warning_or_error
);
3179 /* When we parse a default argument expression, we may create
3180 temporary variables via TARGET_EXPRs. When we actually use the
3181 default-argument expression, we make a copy of the expression
3182 and replace the temporaries with appropriate local versions.
3184 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3188 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3190 static int target_remap_count
;
3191 static splay_tree target_remap
;
3193 if (!target_remap_count
++)
3194 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3195 /*splay_tree_delete_key_fn=*/NULL
,
3196 /*splay_tree_delete_value_fn=*/NULL
);
3197 bot_data data
= { target_remap
, clear_location
};
3198 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3199 t
= error_mark_node
;
3200 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3202 if (!--target_remap_count
)
3204 splay_tree_delete (target_remap
);
3205 target_remap
= NULL
;
3211 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3212 which we expect to have type TYPE. */
3215 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3217 if (index
== NULL_TREE
)
3218 /* Can't refer to a particular member of a vector. */
3220 else if (TREE_CODE (index
) == INTEGER_CST
)
3221 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3223 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3224 /*reference*/false, tf_none
);
3227 tree objtype
= TREE_TYPE (obj
);
3228 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3230 /* When the destination object refers to a flexible array member
3231 verify that it matches the type of the source object except
3232 for its domain and qualifiers. */
3233 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3234 TYPE_MAIN_VARIANT (objtype
),
3235 COMPARE_REDECLARATION
));
3238 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3244 struct replace_placeholders_t
3246 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3247 tree exp
; /* The outermost exp. */
3248 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3249 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3252 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3253 build up subexpressions as we go deeper. */
3256 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3258 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3261 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3263 *walk_subtrees
= false;
3267 switch (TREE_CODE (*t
))
3269 case PLACEHOLDER_EXPR
:
3272 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3274 x
= TREE_OPERAND (x
, 0))
3275 gcc_assert (handled_component_p (x
));
3276 *t
= unshare_expr (x
);
3277 *walk_subtrees
= false;
3284 constructor_elt
*ce
;
3285 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3286 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3287 other than the d->exp one, those have PLACEHOLDER_EXPRs
3288 related to another object. */
3289 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3291 || d
->pset
->add (*t
))
3293 *walk_subtrees
= false;
3296 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3298 tree
*valp
= &ce
->value
;
3299 tree type
= TREE_TYPE (*valp
);
3302 /* Elements with RANGE_EXPR index shouldn't have any
3303 placeholders in them. */
3304 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3307 if (TREE_CODE (*valp
) == CONSTRUCTOR
3308 && AGGREGATE_TYPE_P (type
))
3310 /* If we're looking at the initializer for OBJ, then build
3311 a sub-object reference. If we're looking at an
3312 initializer for another object, just pass OBJ down. */
3313 if (same_type_ignoring_top_level_qualifiers_p
3314 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3315 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3316 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3317 valp
= &TARGET_EXPR_INITIAL (*valp
);
3320 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3323 *walk_subtrees
= false;
3328 if (d
->pset
->add (*t
))
3329 *walk_subtrees
= false;
3336 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3337 a PLACEHOLDER_EXPR has been encountered. */
3340 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3342 /* This is only relevant for C++14. */
3343 if (cxx_dialect
< cxx14
)
3346 /* If the object isn't a (member of a) class, do nothing. */
3348 while (handled_component_p (op0
))
3349 op0
= TREE_OPERAND (op0
, 0);
3350 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3354 if (TREE_CODE (exp
) == TARGET_EXPR
)
3355 tp
= &TARGET_EXPR_INITIAL (exp
);
3356 hash_set
<tree
> pset
;
3357 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3358 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3360 *seen_p
= data
.seen
;
3364 /* Callback function for find_placeholders. */
3367 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3369 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3371 *walk_subtrees
= false;
3375 switch (TREE_CODE (*t
))
3377 case PLACEHOLDER_EXPR
:
3381 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3382 *walk_subtrees
= false;
3392 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3393 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3396 find_placeholders (tree exp
)
3398 /* This is only relevant for C++14. */
3399 if (cxx_dialect
< cxx14
)
3402 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3405 /* Similar to `build_nt', but for template definitions of dependent
3409 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3416 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3420 t
= make_node (code
);
3421 SET_EXPR_LOCATION (t
, loc
);
3422 length
= TREE_CODE_LENGTH (code
);
3424 for (i
= 0; i
< length
; i
++)
3425 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3431 /* Similar to `build', but for template definitions. */
3434 build_min (enum tree_code code
, tree tt
, ...)
3441 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3445 t
= make_node (code
);
3446 length
= TREE_CODE_LENGTH (code
);
3449 for (i
= 0; i
< length
; i
++)
3451 tree x
= va_arg (p
, tree
);
3452 TREE_OPERAND (t
, i
) = x
;
3453 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3454 TREE_SIDE_EFFECTS (t
) = 1;
3462 /* Similar to `build', but for template definitions of non-dependent
3463 expressions. NON_DEP is the non-dependent expression that has been
3467 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3474 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3476 va_start (p
, non_dep
);
3478 if (REFERENCE_REF_P (non_dep
))
3479 non_dep
= TREE_OPERAND (non_dep
, 0);
3481 t
= make_node (code
);
3482 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3483 length
= TREE_CODE_LENGTH (code
);
3484 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3485 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3487 for (i
= 0; i
< length
; i
++)
3488 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3490 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3491 /* This should not be considered a COMPOUND_EXPR, because it
3492 resolves to an overload. */
3493 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3496 return convert_from_reference (t
);
3499 /* Similar to build_min_nt, but call expressions */
3502 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3507 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3508 CALL_EXPR_FN (ret
) = fn
;
3509 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3510 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3511 CALL_EXPR_ARG (ret
, ix
) = t
;
3516 /* Similar to `build_min_nt_call_vec', but for template definitions of
3517 non-dependent expressions. NON_DEP is the non-dependent expression
3518 that has been built. */
3521 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3523 tree t
= build_min_nt_call_vec (fn
, argvec
);
3524 if (REFERENCE_REF_P (non_dep
))
3525 non_dep
= TREE_OPERAND (non_dep
, 0);
3526 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3527 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3528 return convert_from_reference (t
);
3531 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3532 a call to an operator overload. OP is the operator that has been
3533 overloaded. NON_DEP is the non-dependent expression that's been built,
3534 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3535 the overload that NON_DEP is calling. */
3538 build_min_non_dep_op_overload (enum tree_code op
,
3543 int nargs
, expected_nargs
;
3546 non_dep
= extract_call_expr (non_dep
);
3548 nargs
= call_expr_nargs (non_dep
);
3550 expected_nargs
= cp_tree_code_length (op
);
3551 if ((op
== POSTINCREMENT_EXPR
3552 || op
== POSTDECREMENT_EXPR
)
3553 /* With -fpermissive non_dep could be operator++(). */
3554 && (!flag_permissive
|| nargs
!= expected_nargs
))
3555 expected_nargs
+= 1;
3556 gcc_assert (nargs
== expected_nargs
);
3559 va_start (p
, overload
);
3561 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3564 for (int i
= 0; i
< nargs
; i
++)
3566 tree arg
= va_arg (p
, tree
);
3567 vec_safe_push (args
, arg
);
3570 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3572 tree object
= va_arg (p
, tree
);
3573 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3574 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3575 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3576 object
, method
, NULL_TREE
);
3577 for (int i
= 1; i
< nargs
; i
++)
3579 tree arg
= va_arg (p
, tree
);
3580 vec_safe_push (args
, arg
);
3587 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3589 tree call_expr
= extract_call_expr (call
);
3590 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3591 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3592 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3593 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3598 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3601 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3603 unsigned len
= vec_safe_length (old_vec
);
3604 gcc_assert (idx
<= len
);
3606 vec
<tree
, va_gc
> *new_vec
= NULL
;
3607 vec_alloc (new_vec
, len
+ 1);
3610 for (i
= 0; i
< len
; ++i
)
3613 new_vec
->quick_push (elt
);
3614 new_vec
->quick_push ((*old_vec
)[i
]);
3617 new_vec
->quick_push (elt
);
3623 get_type_decl (tree t
)
3625 if (TREE_CODE (t
) == TYPE_DECL
)
3628 return TYPE_STUB_DECL (t
);
3629 gcc_assert (t
== error_mark_node
);
3633 /* Returns the namespace that contains DECL, whether directly or
3637 decl_namespace_context (tree decl
)
3641 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3643 else if (TYPE_P (decl
))
3644 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3646 decl
= CP_DECL_CONTEXT (decl
);
3650 /* Returns true if decl is within an anonymous namespace, however deeply
3651 nested, or false otherwise. */
3654 decl_anon_ns_mem_p (const_tree decl
)
3656 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3658 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3660 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3662 decl
= CP_DECL_CONTEXT (decl
);
3664 return !TREE_PUBLIC (decl
);
3667 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3668 CALL_EXPRS. Return whether they are equivalent. */
3671 called_fns_equal (tree t1
, tree t2
)
3673 /* Core 1321: dependent names are equivalent even if the overload sets
3674 are different. But do compare explicit template arguments. */
3675 tree name1
= dependent_name (t1
);
3676 tree name2
= dependent_name (t2
);
3679 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3684 /* FIXME dependent_name currently returns an unqualified name regardless
3685 of whether the function was named with a qualified- or unqualified-id.
3686 Until that's fixed, check that we aren't looking at overload sets from
3687 different scopes. */
3688 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3689 && (DECL_CONTEXT (get_first_fn (t1
))
3690 != DECL_CONTEXT (get_first_fn (t2
))))
3693 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3694 targs1
= TREE_OPERAND (t1
, 1);
3695 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3696 targs2
= TREE_OPERAND (t2
, 1);
3697 return cp_tree_equal (targs1
, targs2
);
3700 return cp_tree_equal (t1
, t2
);
3703 /* Return truthvalue of whether T1 is the same tree structure as T2.
3704 Return 1 if they are the same. Return 0 if they are different. */
3707 cp_tree_equal (tree t1
, tree t2
)
3709 enum tree_code code1
, code2
;
3716 code1
= TREE_CODE (t1
);
3717 code2
= TREE_CODE (t2
);
3722 if (CONSTANT_CLASS_P (t1
)
3723 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3729 /* There's only a single VOID_CST node, so we should never reach
3734 return tree_int_cst_equal (t1
, t2
);
3737 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3740 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3741 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3742 TREE_STRING_LENGTH (t1
));
3745 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3746 TREE_FIXED_CST (t2
));
3749 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3750 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3753 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3756 /* We need to do this when determining whether or not two
3757 non-type pointer to member function template arguments
3759 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3760 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3765 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3767 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3768 if (!cp_tree_equal (field
, elt2
->index
)
3769 || !cp_tree_equal (value
, elt2
->value
))
3776 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3778 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3780 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3783 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3787 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
3790 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3793 call_expr_arg_iterator iter1
, iter2
;
3794 init_call_expr_arg_iterator (t1
, &iter1
);
3795 init_call_expr_arg_iterator (t2
, &iter2
);
3796 if (iter1
.n
!= iter2
.n
)
3799 while (more_call_expr_args_p (&iter1
))
3801 tree arg1
= next_call_expr_arg (&iter1
);
3802 tree arg2
= next_call_expr_arg (&iter2
);
3804 gcc_checking_assert (arg1
&& arg2
);
3805 if (!cp_tree_equal (arg1
, arg2
))
3814 tree o1
= TREE_OPERAND (t1
, 0);
3815 tree o2
= TREE_OPERAND (t2
, 0);
3817 /* Special case: if either target is an unallocated VAR_DECL,
3818 it means that it's going to be unified with whatever the
3819 TARGET_EXPR is really supposed to initialize, so treat it
3820 as being equivalent to anything. */
3821 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3822 && !DECL_RTL_SET_P (o1
))
3824 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3825 && !DECL_RTL_SET_P (o2
))
3827 else if (!cp_tree_equal (o1
, o2
))
3830 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3834 /* For comparing uses of parameters in late-specified return types
3835 with an out-of-class definition of the function, but can also come
3836 up for expressions that involve 'this' in a member function
3839 if (comparing_specializations
3840 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
)
3841 /* Module duplicate checking can have t1 = new, t2 =
3842 existing, and they should be considered matching at this
3844 && (DECL_CONTEXT (t1
) != map_context_from
3845 && DECL_CONTEXT (t2
) != map_context_to
))
3846 /* When comparing hash table entries, only an exact match is
3847 good enough; we don't want to replace 'this' with the
3848 version from another function. But be more flexible
3849 with parameters with identical contexts. */
3852 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3854 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3856 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3858 if (DECL_ARTIFICIAL (t1
)
3859 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3860 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3870 case IDENTIFIER_NODE
:
3873 case DEFERRED_PARSE
:
3877 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3878 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3879 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3880 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3881 BASELINK_FUNCTIONS (t2
)));
3883 case TEMPLATE_PARM_INDEX
:
3884 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3885 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3886 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3887 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3888 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3889 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3891 case TEMPLATE_ID_EXPR
:
3892 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3894 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
3898 case CONSTRAINT_INFO
:
3899 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3900 CI_ASSOCIATED_CONSTRAINTS (t2
));
3903 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3904 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3905 CHECK_CONSTR_ARGS (t2
)));
3908 /* These are template args. Really we should be getting the
3909 caller to do this as it knows it to be true. */
3910 if (!comp_template_args (t1
, t2
, NULL
, NULL
, false))
3917 tree o1
= TREE_OPERAND (t1
, 0);
3918 tree o2
= TREE_OPERAND (t2
, 0);
3920 if (code1
== SIZEOF_EXPR
)
3922 if (SIZEOF_EXPR_TYPE_P (t1
))
3923 o1
= TREE_TYPE (o1
);
3924 if (SIZEOF_EXPR_TYPE_P (t2
))
3925 o2
= TREE_TYPE (o2
);
3927 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
3930 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3933 if (ARGUMENT_PACK_P (o1
))
3934 return template_args_equal (o1
, o2
);
3935 else if (TYPE_P (o1
))
3936 return same_type_p (o1
, o2
);
3938 return cp_tree_equal (o1
, o2
);
3943 tree t1_op1
, t2_op1
;
3945 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3948 t1_op1
= TREE_OPERAND (t1
, 1);
3949 t2_op1
= TREE_OPERAND (t2
, 1);
3950 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3953 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3957 /* Two pointer-to-members are the same if they point to the same
3958 field or function in the same class. */
3959 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3962 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3966 /* Two overloads. Must be exactly the same set of decls. */
3967 lkp_iterator
first (t1
);
3968 lkp_iterator
second (t2
);
3970 for (; first
&& second
; ++first
, ++second
)
3971 if (*first
!= *second
)
3973 return !(first
|| second
);
3977 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3979 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3980 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3982 case NON_LVALUE_EXPR
:
3983 case VIEW_CONVERT_EXPR
:
3984 /* Used for location wrappers with possibly NULL types. */
3985 if (!TREE_TYPE (t1
) || !TREE_TYPE (t2
))
3987 if (TREE_TYPE (t1
) || TREE_TYPE (t2
))
3994 case STATIC_CAST_EXPR
:
3995 case REINTERPRET_CAST_EXPR
:
3996 case CONST_CAST_EXPR
:
3997 case DYNAMIC_CAST_EXPR
:
3998 case IMPLICIT_CONV_EXPR
:
4002 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4004 /* Now compare operands as usual. */
4007 case DEFERRED_NOEXCEPT
:
4008 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
4009 DEFERRED_NOEXCEPT_PATTERN (t2
))
4010 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
4011 DEFERRED_NOEXCEPT_ARGS (t2
)));
4014 /* Two lambda-expressions are never considered equivalent. */
4017 case TYPE_ARGUMENT_PACK
:
4018 case NONTYPE_ARGUMENT_PACK
:
4020 tree p1
= ARGUMENT_PACK_ARGS (t1
);
4021 tree p2
= ARGUMENT_PACK_ARGS (t2
);
4022 int len
= TREE_VEC_LENGTH (p1
);
4023 if (TREE_VEC_LENGTH (p2
) != len
)
4026 for (int ix
= 0; ix
!= len
; ix
++)
4027 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
4028 TREE_VEC_ELT (p2
, ix
)))
4033 case EXPR_PACK_EXPANSION
:
4034 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
4035 PACK_EXPANSION_PATTERN (t2
)))
4037 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
4038 PACK_EXPANSION_EXTRA_ARGS (t2
)))
4046 switch (TREE_CODE_CLASS (code1
))
4050 case tcc_comparison
:
4051 case tcc_expression
:
4056 int n
= cp_tree_operand_length (t1
);
4057 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
4058 && n
!= TREE_OPERAND_LENGTH (t2
))
4061 for (int i
= 0; i
< n
; ++i
)
4062 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
4069 return same_type_p (t1
, t2
);
4075 /* We can get here with --disable-checking. */
4079 /* The type of ARG when used as an lvalue. */
4082 lvalue_type (tree arg
)
4084 tree type
= TREE_TYPE (arg
);
4088 /* The type of ARG for printing error messages; denote lvalues with
4092 error_type (tree arg
)
4094 tree type
= TREE_TYPE (arg
);
4096 if (TREE_CODE (type
) == ARRAY_TYPE
)
4098 else if (TREE_CODE (type
) == ERROR_MARK
)
4100 else if (lvalue_p (arg
))
4101 type
= build_reference_type (lvalue_type (arg
));
4102 else if (MAYBE_CLASS_TYPE_P (type
))
4103 type
= lvalue_type (arg
);
4108 /* Does FUNCTION use a variable-length argument list? */
4111 varargs_function_p (const_tree function
)
4113 return stdarg_p (TREE_TYPE (function
));
4116 /* Returns 1 if decl is a member of a class. */
4119 member_p (const_tree decl
)
4121 const_tree
const ctx
= DECL_CONTEXT (decl
);
4122 return (ctx
&& TYPE_P (ctx
));
4125 /* Create a placeholder for member access where we don't actually have an
4126 object that the access is against. */
4129 build_dummy_object (tree type
)
4131 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4132 return cp_build_fold_indirect_ref (decl
);
4135 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4136 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4137 binfo path from current_class_type to TYPE, or 0. */
4140 maybe_dummy_object (tree type
, tree
* binfop
)
4144 tree current
= current_nonlambda_class_type ();
4147 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4148 tf_warning_or_error
)))
4152 /* Reference from a nested class member function. */
4154 binfo
= TYPE_BINFO (type
);
4160 if (current_class_ref
4161 /* current_class_ref might not correspond to current_class_type if
4162 we're in tsubst_default_argument or a lambda-declarator; in either
4163 case, we want to use current_class_ref if it matches CONTEXT. */
4164 && (same_type_ignoring_top_level_qualifiers_p
4165 (TREE_TYPE (current_class_ref
), context
)))
4166 decl
= current_class_ref
;
4168 decl
= build_dummy_object (context
);
4173 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4176 is_dummy_object (const_tree ob
)
4178 if (INDIRECT_REF_P (ob
))
4179 ob
= TREE_OPERAND (ob
, 0);
4180 return (TREE_CODE (ob
) == CONVERT_EXPR
4181 && TREE_OPERAND (ob
, 0) == void_node
);
4184 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4187 is_byte_access_type (tree type
)
4189 type
= TYPE_MAIN_VARIANT (type
);
4190 if (type
== char_type_node
4191 || type
== unsigned_char_type_node
)
4194 return (TREE_CODE (type
) == ENUMERAL_TYPE
4195 && TYPE_CONTEXT (type
) == std_node
4196 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4199 /* Returns 1 iff type T is something we want to treat as a scalar type for
4200 the purpose of deciding whether it is trivial/POD/standard-layout. */
4203 scalarish_type_p (const_tree t
)
4205 if (t
== error_mark_node
)
4208 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4211 /* Returns true iff T requires non-trivial default initialization. */
4214 type_has_nontrivial_default_init (const_tree t
)
4216 t
= strip_array_types (CONST_CAST_TREE (t
));
4218 if (CLASS_TYPE_P (t
))
4219 return TYPE_HAS_COMPLEX_DFLT (t
);
4224 /* Track classes with only deleted copy/move constructors so that we can warn
4225 if they are used in call/return by value. */
4227 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4229 remember_deleted_copy (const_tree t
)
4231 if (!deleted_copy_types
)
4232 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4233 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4236 maybe_warn_parm_abi (tree t
, location_t loc
)
4238 if (!deleted_copy_types
4239 || !deleted_copy_types
->contains (t
))
4242 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4243 && classtype_has_non_deleted_move_ctor (t
))
4246 auto_diagnostic_group d
;
4247 if (flag_abi_version
> 12)
4248 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4249 "the calling convention for %qT, which was "
4250 "accidentally changed in 8.1", t
);
4252 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4253 "ally changes the calling convention for %qT", t
);
4255 inform (location_of (t
), " declared here");
4259 auto_diagnostic_group d
;
4260 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4261 "%<-fabi-version=13%> (GCC 8.2)", t
))
4262 inform (location_of (t
), " because all of its copy and move "
4263 "constructors are deleted");
4266 /* Returns true iff copying an object of type T (including via move
4267 constructor) is non-trivial. That is, T has no non-trivial copy
4268 constructors and no non-trivial move constructors, and not all copy/move
4269 constructors are deleted. This function implements the ABI notion of
4270 non-trivial copy, which has diverged from the one in the standard. */
4273 type_has_nontrivial_copy_init (const_tree type
)
4275 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4277 if (CLASS_TYPE_P (t
))
4279 gcc_assert (COMPLETE_TYPE_P (t
));
4281 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4282 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4286 if (cxx_dialect
< cxx11
)
4287 /* No deleted functions before C++11. */
4290 /* Before ABI v12 we did a bitwise copy of types with only deleted
4291 copy/move constructors. */
4292 if (!abi_version_at_least (12)
4293 && !(warn_abi
&& abi_version_crosses (12)))
4296 bool saw_copy
= false;
4297 bool saw_non_deleted
= false;
4298 bool saw_non_deleted_move
= false;
4300 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4301 saw_copy
= saw_non_deleted
= true;
4302 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4305 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4306 /* [class.copy]/8 If the class definition declares a move
4307 constructor or move assignment operator, the implicitly declared
4308 copy constructor is defined as deleted.... */;
4310 /* Any other reason the implicitly-declared function would be
4311 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4313 saw_non_deleted
= true;
4316 if (!saw_non_deleted
)
4317 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4323 if (!DECL_DELETED_FN (fn
))
4325 /* Not deleted, therefore trivial. */
4326 saw_non_deleted
= true;
4330 else if (move_fn_p (fn
))
4331 if (!DECL_DELETED_FN (fn
))
4332 saw_non_deleted_move
= true;
4335 gcc_assert (saw_copy
);
4337 /* ABI v12 buggily ignored move constructors. */
4338 bool v11nontriv
= false;
4339 bool v12nontriv
= !saw_non_deleted
;
4340 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4341 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4342 : flag_abi_version
== 12 ? v12nontriv
4344 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4345 : warn_abi_version
== 12 ? v12nontriv
4347 if (nontriv
!= warn_nontriv
)
4348 remember_deleted_copy (t
);
4356 /* Returns 1 iff type T is a trivially copyable type, as defined in
4357 [basic.types] and [class]. */
4360 trivially_copyable_p (const_tree t
)
4362 t
= strip_array_types (CONST_CAST_TREE (t
));
4364 if (CLASS_TYPE_P (t
))
4365 return ((!TYPE_HAS_COPY_CTOR (t
)
4366 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4367 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4368 && (!TYPE_HAS_COPY_ASSIGN (t
)
4369 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4370 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4371 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4373 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4374 return scalarish_type_p (t
);
4377 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4381 trivial_type_p (const_tree t
)
4383 t
= strip_array_types (CONST_CAST_TREE (t
));
4385 if (CLASS_TYPE_P (t
))
4386 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4387 && trivially_copyable_p (t
));
4389 return scalarish_type_p (t
);
4392 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4395 pod_type_p (const_tree t
)
4397 /* This CONST_CAST is okay because strip_array_types returns its
4398 argument unmodified and we assign it to a const_tree. */
4399 t
= strip_array_types (CONST_CAST_TREE(t
));
4401 if (!CLASS_TYPE_P (t
))
4402 return scalarish_type_p (t
);
4403 else if (cxx_dialect
> cxx98
)
4404 /* [class]/10: A POD struct is a class that is both a trivial class and a
4405 standard-layout class, and has no non-static data members of type
4406 non-POD struct, non-POD union (or array of such types).
4408 We don't need to check individual members because if a member is
4409 non-std-layout or non-trivial, the class will be too. */
4410 return (std_layout_type_p (t
) && trivial_type_p (t
));
4412 /* The C++98 definition of POD is different. */
4413 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4416 /* Returns true iff T is POD for the purpose of layout, as defined in the
4420 layout_pod_type_p (const_tree t
)
4422 t
= strip_array_types (CONST_CAST_TREE (t
));
4424 if (CLASS_TYPE_P (t
))
4425 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4427 return scalarish_type_p (t
);
4430 /* Returns true iff T is a standard-layout type, as defined in
4434 std_layout_type_p (const_tree t
)
4436 t
= strip_array_types (CONST_CAST_TREE (t
));
4438 if (CLASS_TYPE_P (t
))
4439 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4441 return scalarish_type_p (t
);
4444 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4446 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4447 as defined in [meta.unary.prop]. */
4450 type_has_unique_obj_representations (const_tree t
)
4454 t
= strip_array_types (CONST_CAST_TREE (t
));
4456 if (!trivially_copyable_p (t
))
4459 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4460 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4462 switch (TREE_CODE (t
))
4466 case REFERENCE_TYPE
:
4467 /* If some backend has any paddings in these types, we should add
4468 a target hook for this and handle it there. */
4472 /* For bool values other than 0 and 1 should only appear with
4473 undefined behavior. */
4477 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4480 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4481 when storing long double values, so for that we have to return false.
4482 Other kinds of floating point values are questionable due to +.0/-.0
4483 and NaNs, let's play safe for now. */
4486 case FIXED_POINT_TYPE
:
4494 return type_has_unique_obj_representations (TREE_TYPE (t
));
4497 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4498 if (CLASS_TYPE_P (t
))
4500 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4501 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4509 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4510 if (TREE_CODE (field
) == FIELD_DECL
)
4513 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4514 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4520 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4522 if (CLASS_TYPE_P (t
))
4524 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4525 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4540 /* Helper function for type_has_unique_obj_representations. */
4543 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4545 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4546 if (TREE_CODE (field
) != FIELD_DECL
)
4548 /* For bases, can't use type_has_unique_obj_representations here, as in
4549 struct S { int i : 24; S (); };
4550 struct T : public S { int j : 8; T (); };
4551 S doesn't have unique obj representations, but T does. */
4552 else if (DECL_FIELD_IS_BASE (field
))
4554 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4558 else if (DECL_C_BIT_FIELD (field
))
4560 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4561 if (!type_has_unique_obj_representations (btype
))
4564 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4568 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4569 if (TREE_CODE (field
) == FIELD_DECL
)
4571 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4572 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4573 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4576 if (DECL_SIZE (field
))
4578 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4582 if (cur
!= wi::to_offset (sz
))
4588 /* Nonzero iff type T is a class template implicit specialization. */
4591 class_tmpl_impl_spec_p (const_tree t
)
4593 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4596 /* Returns 1 iff zero initialization of type T means actually storing
4600 zero_init_p (const_tree t
)
4602 /* This CONST_CAST is okay because strip_array_types returns its
4603 argument unmodified and we assign it to a const_tree. */
4604 t
= strip_array_types (CONST_CAST_TREE(t
));
4606 if (t
== error_mark_node
)
4609 /* NULL pointers to data members are initialized with -1. */
4610 if (TYPE_PTRDATAMEM_P (t
))
4613 /* Classes that contain types that can't be zero-initialized, cannot
4614 be zero-initialized themselves. */
4615 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4621 /* Returns true if the expression or initializer T is the result of
4622 zero-initialization for its type, taking pointers to members
4623 into consideration. */
4626 zero_init_expr_p (tree t
)
4628 tree type
= TREE_TYPE (t
);
4629 if (!type
|| uses_template_parms (type
))
4631 if (zero_init_p (type
))
4632 return initializer_zerop (t
);
4633 if (TYPE_PTRMEM_P (type
))
4634 return null_member_pointer_value_p (t
);
4635 if (TREE_CODE (t
) == CONSTRUCTOR
4636 && CP_AGGREGATE_TYPE_P (type
))
4639 unsigned HOST_WIDE_INT i
;
4640 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, elt_init
)
4641 if (!zero_init_expr_p (elt_init
))
4648 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4649 non-type template parameter. If EXPLAIN, explain why not. */
4652 structural_type_p (tree t
, bool explain
)
4654 /* A structural type is one of the following: */
4656 /* a scalar type, or */
4657 if (SCALAR_TYPE_P (t
))
4659 /* an lvalue reference type, or */
4660 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4662 /* a literal class type with the following properties:
4663 - all base classes and non-static data members are public and non-mutable
4665 - the types of all bases classes and non-static data members are
4666 structural types or (possibly multi-dimensional) array thereof. */
4667 if (!CLASS_TYPE_P (t
))
4669 if (!literal_type_p (t
))
4672 explain_non_literal_class (t
);
4675 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4676 m
= next_initializable_field (DECL_CHAIN (m
)))
4678 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4682 if (DECL_FIELD_IS_BASE (m
))
4683 inform (location_of (m
), "base class %qT is not public",
4686 inform (location_of (m
), "%qD is not public", m
);
4690 if (DECL_MUTABLE_P (m
))
4693 inform (location_of (m
), "%qD is mutable", m
);
4696 tree mtype
= strip_array_types (TREE_TYPE (m
));
4697 if (!structural_type_p (mtype
))
4701 inform (location_of (m
), "%qD has a non-structural type", m
);
4702 structural_type_p (mtype
, true);
4710 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4711 warn_unused_result attribute. */
4714 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4715 int /*flags*/, bool *no_add_attrs
)
4717 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4719 error ("%qE attribute argument must be a string constant", name
);
4720 *no_add_attrs
= true;
4722 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4724 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4725 && !DECL_CONSTRUCTOR_P (*node
))
4726 warning_at (DECL_SOURCE_LOCATION (*node
),
4727 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4728 "return type", name
, *node
);
4730 else if (OVERLOAD_TYPE_P (*node
))
4734 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4735 "functions or to class or enumeration types", name
);
4736 *no_add_attrs
= true;
4741 /* Handle a C++20 "no_unique_address" attribute; arguments as in
4742 struct attribute_spec.handler. */
4744 handle_no_unique_addr_attribute (tree
* node
,
4750 if (TREE_CODE (*node
) != FIELD_DECL
)
4752 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4753 "non-static data members", name
);
4754 *no_add_attrs
= true;
4756 else if (DECL_C_BIT_FIELD (*node
))
4758 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4759 "a bit-field", name
);
4760 *no_add_attrs
= true;
4766 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4767 hot/cold attributes. */
4770 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4771 int flags
, bool *no_add_attrs
)
4773 *no_add_attrs
= true;
4774 if (TREE_CODE (*node
) == LABEL_DECL
4775 || TREE_CODE (*node
) == FUNCTION_DECL
)
4778 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4779 tree bname
= (is_attribute_p ("likely", name
)
4780 ? get_identifier ("hot") : get_identifier ("cold"));
4781 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4782 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4783 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4784 tree battr
= build_tree_list (bname
, NULL_TREE
);
4785 decl_attributes (node
, battr
, flags
);
4789 return error_mark_node
;
4792 /* Table of valid C++ attributes. */
4793 const struct attribute_spec cxx_attribute_table
[] =
4795 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4796 affects_type_identity, handler, exclude } */
4797 { "init_priority", 1, 1, true, false, false, false,
4798 handle_init_priority_attribute
, NULL
},
4799 { "abi_tag", 1, -1, false, false, false, true,
4800 handle_abi_tag_attribute
, NULL
},
4801 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4804 /* Table of C++ standard attributes. */
4805 const struct attribute_spec std_attribute_table
[] =
4807 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4808 affects_type_identity, handler, exclude } */
4809 { "maybe_unused", 0, 0, false, false, false, false,
4810 handle_unused_attribute
, NULL
},
4811 { "nodiscard", 0, 1, false, false, false, false,
4812 handle_nodiscard_attribute
, NULL
},
4813 { "no_unique_address", 0, 0, true, false, false, false,
4814 handle_no_unique_addr_attribute
, NULL
},
4815 { "likely", 0, 0, false, false, false, false,
4816 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4817 { "unlikely", 0, 0, false, false, false, false,
4818 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4819 { "noreturn", 0, 0, true, false, false, false,
4820 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4821 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4824 /* Handle an "init_priority" attribute; arguments as in
4825 struct attribute_spec.handler. */
4827 handle_init_priority_attribute (tree
* node
,
4833 tree initp_expr
= TREE_VALUE (args
);
4835 tree type
= TREE_TYPE (decl
);
4838 STRIP_NOPS (initp_expr
);
4839 initp_expr
= default_conversion (initp_expr
);
4841 initp_expr
= maybe_constant_value (initp_expr
);
4843 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4845 error ("requested %<init_priority%> is not an integer constant");
4846 cxx_constant_value (initp_expr
);
4847 *no_add_attrs
= true;
4851 pri
= TREE_INT_CST_LOW (initp_expr
);
4853 type
= strip_array_types (type
);
4855 if (decl
== NULL_TREE
4857 || !TREE_STATIC (decl
)
4858 || DECL_EXTERNAL (decl
)
4859 || (TREE_CODE (type
) != RECORD_TYPE
4860 && TREE_CODE (type
) != UNION_TYPE
)
4861 /* Static objects in functions are initialized the
4862 first time control passes through that
4863 function. This is not precise enough to pin down an
4864 init_priority value, so don't allow it. */
4865 || current_function_decl
)
4867 error ("can only use %qE attribute on file-scope definitions "
4868 "of objects of class type", name
);
4869 *no_add_attrs
= true;
4873 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4875 error ("requested %<init_priority%> %i is out of range [0, %i]",
4876 pri
, MAX_INIT_PRIORITY
);
4877 *no_add_attrs
= true;
4881 /* Check for init_priorities that are reserved for
4882 language and runtime support implementations.*/
4883 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4886 (0, "requested %<init_priority%> %i is reserved for internal use",
4890 if (SUPPORTS_INIT_PRIORITY
)
4892 SET_DECL_INIT_PRIORITY (decl
, pri
);
4893 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4898 error ("%qE attribute is not supported on this platform", name
);
4899 *no_add_attrs
= true;
4904 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4905 and the new one has the tags in NEW_. Give an error if there are tags
4906 in NEW_ that weren't in OLD. */
4909 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4911 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4912 old
= TREE_VALUE (old
);
4913 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4914 new_
= TREE_VALUE (new_
);
4916 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4918 tree str
= TREE_VALUE (t
);
4919 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4921 tree ostr
= TREE_VALUE (in
);
4922 if (cp_tree_equal (str
, ostr
))
4925 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4931 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4937 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4938 ill-formed, give an error and return false; otherwise, return true. */
4941 check_abi_tag_args (tree args
, tree name
)
4945 error ("the %qE attribute requires arguments", name
);
4948 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4950 tree elt
= TREE_VALUE (arg
);
4951 if (TREE_CODE (elt
) != STRING_CST
4952 || (!same_type_ignoring_top_level_qualifiers_p
4953 (strip_array_types (TREE_TYPE (elt
)),
4956 error ("arguments to the %qE attribute must be narrow string "
4960 const char *begin
= TREE_STRING_POINTER (elt
);
4961 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4962 for (const char *p
= begin
; p
!= end
; ++p
)
4967 if (!ISALPHA (c
) && c
!= '_')
4969 error ("arguments to the %qE attribute must contain valid "
4970 "identifiers", name
);
4971 inform (input_location
, "%<%c%> is not a valid first "
4972 "character for an identifier", c
);
4976 else if (p
== end
- 1)
4977 gcc_assert (c
== 0);
4980 if (!ISALNUM (c
) && c
!= '_')
4982 error ("arguments to the %qE attribute must contain valid "
4983 "identifiers", name
);
4984 inform (input_location
, "%<%c%> is not a valid character "
4985 "in an identifier", c
);
4994 /* Handle an "abi_tag" attribute; arguments as in
4995 struct attribute_spec.handler. */
4998 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4999 int flags
, bool* no_add_attrs
)
5001 if (!check_abi_tag_args (args
, name
))
5006 if (!OVERLOAD_TYPE_P (*node
))
5008 error ("%qE attribute applied to non-class, non-enum type %qT",
5012 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
5014 error ("%qE attribute applied to %qT after its definition",
5018 else if (CLASS_TYPE_P (*node
)
5019 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
5021 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5022 "template instantiation %qT", name
, *node
);
5025 else if (CLASS_TYPE_P (*node
)
5026 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
5028 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5029 "template specialization %qT", name
, *node
);
5033 tree attributes
= TYPE_ATTRIBUTES (*node
);
5034 tree decl
= TYPE_NAME (*node
);
5036 /* Make sure all declarations have the same abi tags. */
5037 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
5039 if (!check_abi_tag_redeclaration (decl
,
5040 lookup_attribute ("abi_tag",
5048 if (!VAR_OR_FUNCTION_DECL_P (*node
))
5050 error ("%qE attribute applied to non-function, non-variable %qD",
5054 else if (DECL_LANGUAGE (*node
) == lang_c
)
5056 error ("%qE attribute applied to extern \"C\" declaration %qD",
5065 *no_add_attrs
= true;
5069 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5070 thing pointed to by the constant. */
5073 make_ptrmem_cst (tree type
, tree member
)
5075 tree ptrmem_cst
= make_node (PTRMEM_CST
);
5076 TREE_TYPE (ptrmem_cst
) = type
;
5077 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5081 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5082 return an existing type if an appropriate type already exists. */
5085 cp_build_type_attribute_variant (tree type
, tree attributes
)
5089 new_type
= build_type_attribute_variant (type
, attributes
);
5090 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5091 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5093 /* Making a new main variant of a class type is broken. */
5094 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5099 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5100 Called only after doing all language independent checks. */
5103 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5105 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5107 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5109 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5111 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5112 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5115 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5116 C++, these are the exception-specifier and ref-qualifier. */
5119 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5121 tree type
= CONST_CAST_TREE (typea
);
5122 if (FUNC_OR_METHOD_TYPE_P (type
))
5123 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5124 TYPE_RAISES_EXCEPTIONS (typeb
),
5125 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5129 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5130 traversal. Called from walk_tree. */
5133 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5134 void *data
, hash_set
<tree
> *pset
)
5136 enum tree_code code
= TREE_CODE (*tp
);
5139 #define WALK_SUBTREE(NODE) \
5142 result = cp_walk_tree (&(NODE), func, data, pset); \
5143 if (result) goto out; \
5149 /* Walk into template args without looking through typedefs. */
5150 if (tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (*tp
))
5151 WALK_SUBTREE (TI_ARGS (ti
));
5152 /* Don't look through typedefs; walk_tree_fns that want to look through
5153 typedefs (like min_vis_r) need to do that themselves. */
5154 if (typedef_variant_p (*tp
))
5156 *walk_subtrees_p
= 0;
5161 /* Not one of the easy cases. We must explicitly go through the
5166 case DEFERRED_PARSE
:
5167 case TEMPLATE_TEMPLATE_PARM
:
5168 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5169 case UNBOUND_CLASS_TEMPLATE
:
5170 case TEMPLATE_PARM_INDEX
:
5171 case TEMPLATE_TYPE_PARM
:
5173 case UNDERLYING_TYPE
:
5174 /* None of these have subtrees other than those already walked
5176 *walk_subtrees_p
= 0;
5180 WALK_SUBTREE (TYPE_CONTEXT (*tp
));
5181 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (*tp
));
5182 *walk_subtrees_p
= 0;
5186 if (BASELINK_QUALIFIED_P (*tp
))
5187 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
5188 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
5189 *walk_subtrees_p
= 0;
5193 WALK_SUBTREE (TREE_TYPE (*tp
));
5194 *walk_subtrees_p
= 0;
5198 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5202 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5203 WALK_SUBTREE (OVL_CHAIN (*tp
));
5204 *walk_subtrees_p
= 0;
5208 WALK_SUBTREE (DECL_NAME (*tp
));
5209 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5210 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5211 *walk_subtrees_p
= 0;
5215 if (TYPE_PTRMEMFUNC_P (*tp
))
5216 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5219 case TYPE_ARGUMENT_PACK
:
5220 case NONTYPE_ARGUMENT_PACK
:
5222 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5223 int i
, len
= TREE_VEC_LENGTH (args
);
5224 for (i
= 0; i
< len
; i
++)
5225 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5229 case TYPE_PACK_EXPANSION
:
5230 WALK_SUBTREE (TREE_TYPE (*tp
));
5231 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5232 *walk_subtrees_p
= 0;
5235 case EXPR_PACK_EXPANSION
:
5236 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5237 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5238 *walk_subtrees_p
= 0;
5242 case REINTERPRET_CAST_EXPR
:
5243 case STATIC_CAST_EXPR
:
5244 case CONST_CAST_EXPR
:
5245 case DYNAMIC_CAST_EXPR
:
5246 case IMPLICIT_CONV_EXPR
:
5248 if (TREE_TYPE (*tp
))
5249 WALK_SUBTREE (TREE_TYPE (*tp
));
5253 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
5254 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
5256 *walk_subtrees_p
= 0;
5260 if (COMPOUND_LITERAL_P (*tp
))
5261 WALK_SUBTREE (TREE_TYPE (*tp
));
5265 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5266 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5267 *walk_subtrees_p
= 0;
5271 ++cp_unevaluated_operand
;
5272 /* We can't use WALK_SUBTREE here because of the goto. */
5273 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5274 --cp_unevaluated_operand
;
5275 *walk_subtrees_p
= 0;
5281 ++cp_unevaluated_operand
;
5282 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5283 --cp_unevaluated_operand
;
5284 *walk_subtrees_p
= 0;
5288 // Only recurse through the nested expression. Do not
5289 // walk the parameter list. Doing so causes false
5290 // positives in the pack expansion checker since the
5291 // requires parameters are introduced as pack expansions.
5292 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5293 *walk_subtrees_p
= 0;
5297 /* User variables should be mentioned in BIND_EXPR_VARS
5298 and their initializers and sizes walked when walking
5299 the containing BIND_EXPR. Compiler temporaries are
5300 handled here. And also normal variables in templates,
5301 since do_poplevel doesn't build a BIND_EXPR then. */
5302 if (VAR_P (TREE_OPERAND (*tp
, 0))
5303 && (processing_template_decl
5304 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5305 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5307 tree decl
= TREE_OPERAND (*tp
, 0);
5308 WALK_SUBTREE (DECL_INITIAL (decl
));
5309 WALK_SUBTREE (DECL_SIZE (decl
));
5310 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5315 /* Don't walk into the body of the lambda, but the capture initializers
5316 are part of the enclosing context. */
5317 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5318 cap
= TREE_CHAIN (cap
))
5319 WALK_SUBTREE (TREE_VALUE (cap
));
5323 if (TREE_OPERAND (*tp
, 1))
5324 /* Operand 1 is the tree for the relevant co_await which has any
5325 interesting sub-trees. */
5326 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5330 if (TREE_OPERAND (*tp
, 1))
5331 /* Operand 1 is frame variable. */
5332 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5333 if (TREE_OPERAND (*tp
, 2))
5334 /* Operand 2 has the initialiser, and we need to walk any subtrees
5336 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5339 case CO_RETURN_EXPR
:
5340 if (TREE_OPERAND (*tp
, 0))
5342 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5343 /* For void expressions, operand 1 is a trivial call, and any
5344 interesting subtrees will be part of operand 0. */
5345 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5346 else if (TREE_OPERAND (*tp
, 1))
5347 /* Interesting sub-trees will be in the return_value () call
5349 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5357 /* We didn't find what we were looking for. */
5364 /* Like save_expr, but for C++. */
5367 cp_save_expr (tree expr
)
5369 /* There is no reason to create a SAVE_EXPR within a template; if
5370 needed, we can create the SAVE_EXPR when instantiating the
5371 template. Furthermore, the middle-end cannot handle C++-specific
5373 if (processing_template_decl
)
5376 /* TARGET_EXPRs are only expanded once. */
5377 if (TREE_CODE (expr
) == TARGET_EXPR
)
5380 return save_expr (expr
);
5383 /* Initialize tree.c. */
5388 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5389 register_scoped_attributes (std_attribute_table
, NULL
);
5392 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5393 is. Note that sfk_none is zero, so this function can be used as a
5394 predicate to test whether or not DECL is a special function. */
5396 special_function_kind
5397 special_function_p (const_tree decl
)
5399 /* Rather than doing all this stuff with magic names, we should
5400 probably have a field of type `special_function_kind' in
5401 DECL_LANG_SPECIFIC. */
5402 if (DECL_INHERITED_CTOR (decl
))
5403 return sfk_inheriting_constructor
;
5404 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5405 return sfk_copy_constructor
;
5406 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5407 return sfk_move_constructor
;
5408 if (DECL_CONSTRUCTOR_P (decl
))
5409 return sfk_constructor
;
5410 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5411 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5413 if (copy_fn_p (decl
))
5414 return sfk_copy_assignment
;
5415 if (move_fn_p (decl
))
5416 return sfk_move_assignment
;
5418 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5419 return sfk_destructor
;
5420 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5421 return sfk_complete_destructor
;
5422 if (DECL_BASE_DESTRUCTOR_P (decl
))
5423 return sfk_base_destructor
;
5424 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5425 return sfk_deleting_destructor
;
5426 if (DECL_CONV_FN_P (decl
))
5427 return sfk_conversion
;
5428 if (deduction_guide_p (decl
))
5429 return sfk_deduction_guide
;
5430 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5431 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5432 return sfk_comparison
;
5437 /* As above, but only if DECL is a special member function as per 11.3.3
5438 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5440 special_function_kind
5441 special_memfn_p (const_tree decl
)
5443 switch (special_function_kind sfk
= special_function_p (decl
))
5445 case sfk_constructor
:
5446 if (!default_ctor_p (decl
))
5449 case sfk_copy_constructor
:
5450 case sfk_copy_assignment
:
5451 case sfk_move_assignment
:
5452 case sfk_move_constructor
:
5453 case sfk_destructor
:
5462 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5465 char_type_p (tree type
)
5467 return (same_type_p (type
, char_type_node
)
5468 || same_type_p (type
, unsigned_char_type_node
)
5469 || same_type_p (type
, signed_char_type_node
)
5470 || same_type_p (type
, char8_type_node
)
5471 || same_type_p (type
, char16_type_node
)
5472 || same_type_p (type
, char32_type_node
)
5473 || same_type_p (type
, wchar_type_node
));
5476 /* Returns the kind of linkage associated with the indicated DECL. Th
5477 value returned is as specified by the language standard; it is
5478 independent of implementation details regarding template
5479 instantiation, etc. For example, it is possible that a declaration
5480 to which this function assigns external linkage would not show up
5481 as a global symbol when you run `nm' on the resulting object file. */
5484 decl_linkage (tree decl
)
5486 /* This function doesn't attempt to calculate the linkage from first
5487 principles as given in [basic.link]. Instead, it makes use of
5488 the fact that we have already set TREE_PUBLIC appropriately, and
5489 then handles a few special cases. Ideally, we would calculate
5490 linkage first, and then transform that into a concrete
5493 /* Things that don't have names have no linkage. */
5494 if (!DECL_NAME (decl
))
5497 /* Fields have no linkage. */
5498 if (TREE_CODE (decl
) == FIELD_DECL
)
5501 /* Things in local scope do not have linkage. */
5502 if (decl_function_context (decl
))
5505 /* Things that are TREE_PUBLIC have external linkage. */
5506 if (TREE_PUBLIC (decl
))
5509 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5510 check one of the "clones" for the real linkage. */
5511 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5512 && DECL_CHAIN (decl
)
5513 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5514 return decl_linkage (DECL_CHAIN (decl
));
5516 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5519 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5521 if (TREE_CODE (decl
) == CONST_DECL
)
5522 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5524 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5525 are considered to have external linkage for language purposes, as do
5526 template instantiations on targets without weak symbols. DECLs really
5527 meant to have internal linkage have DECL_THIS_STATIC set. */
5528 if (TREE_CODE (decl
) == TYPE_DECL
)
5530 if (VAR_OR_FUNCTION_DECL_P (decl
))
5532 if (!DECL_THIS_STATIC (decl
))
5535 /* Static data members and static member functions from classes
5536 in anonymous namespace also don't have TREE_PUBLIC set. */
5537 if (DECL_CLASS_CONTEXT (decl
))
5541 /* Everything else has internal linkage. */
5545 /* Returns the storage duration of the object or reference associated with
5546 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5549 decl_storage_duration (tree decl
)
5551 if (TREE_CODE (decl
) == PARM_DECL
)
5553 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5555 gcc_assert (VAR_P (decl
));
5556 if (!TREE_STATIC (decl
)
5557 && !DECL_EXTERNAL (decl
))
5559 if (CP_DECL_THREAD_LOCAL_P (decl
))
5564 /* EXP is an expression that we want to pre-evaluate. Returns (in
5565 *INITP) an expression that will perform the pre-evaluation. The
5566 value returned by this function is a side-effect free expression
5567 equivalent to the pre-evaluated expression. Callers must ensure
5568 that *INITP is evaluated before EXP. */
5571 stabilize_expr (tree exp
, tree
* initp
)
5575 if (!TREE_SIDE_EFFECTS (exp
))
5576 init_expr
= NULL_TREE
;
5577 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5582 /* There are no expressions with REFERENCE_TYPE, but there can be call
5583 arguments with such a type; just treat it as a pointer. */
5584 else if (TYPE_REF_P (TREE_TYPE (exp
))
5585 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5586 || !glvalue_p (exp
))
5588 init_expr
= get_target_expr (exp
);
5589 exp
= TARGET_EXPR_SLOT (init_expr
);
5590 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5597 bool xval
= !lvalue_p (exp
);
5598 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5599 init_expr
= get_target_expr (exp
);
5600 exp
= TARGET_EXPR_SLOT (init_expr
);
5601 exp
= cp_build_fold_indirect_ref (exp
);
5607 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5611 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5612 similar expression ORIG. */
5615 add_stmt_to_compound (tree orig
, tree new_expr
)
5617 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5619 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5621 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5624 /* Like stabilize_expr, but for a call whose arguments we want to
5625 pre-evaluate. CALL is modified in place to use the pre-evaluated
5626 arguments, while, upon return, *INITP contains an expression to
5627 compute the arguments. */
5630 stabilize_call (tree call
, tree
*initp
)
5632 tree inits
= NULL_TREE
;
5634 int nargs
= call_expr_nargs (call
);
5636 if (call
== error_mark_node
|| processing_template_decl
)
5642 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5644 for (i
= 0; i
< nargs
; i
++)
5647 CALL_EXPR_ARG (call
, i
) =
5648 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5649 inits
= add_stmt_to_compound (inits
, init
);
5655 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5656 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5657 arguments, while, upon return, *INITP contains an expression to
5658 compute the arguments. */
5661 stabilize_aggr_init (tree call
, tree
*initp
)
5663 tree inits
= NULL_TREE
;
5665 int nargs
= aggr_init_expr_nargs (call
);
5667 if (call
== error_mark_node
)
5670 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5672 for (i
= 0; i
< nargs
; i
++)
5675 AGGR_INIT_EXPR_ARG (call
, i
) =
5676 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5677 inits
= add_stmt_to_compound (inits
, init
);
5683 /* Like stabilize_expr, but for an initialization.
5685 If the initialization is for an object of class type, this function
5686 takes care not to introduce additional temporaries.
5688 Returns TRUE iff the expression was successfully pre-evaluated,
5689 i.e., if INIT is now side-effect free, except for, possibly, a
5690 single call to a constructor. */
5693 stabilize_init (tree init
, tree
*initp
)
5699 if (t
== error_mark_node
|| processing_template_decl
)
5702 if (TREE_CODE (t
) == INIT_EXPR
)
5703 t
= TREE_OPERAND (t
, 1);
5704 if (TREE_CODE (t
) == TARGET_EXPR
)
5705 t
= TARGET_EXPR_INITIAL (t
);
5707 /* If the RHS can be stabilized without breaking copy elision, stabilize
5708 it. We specifically don't stabilize class prvalues here because that
5709 would mean an extra copy, but they might be stabilized below. */
5710 if (TREE_CODE (init
) == INIT_EXPR
5711 && TREE_CODE (t
) != CONSTRUCTOR
5712 && TREE_CODE (t
) != AGGR_INIT_EXPR
5713 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5716 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5720 if (TREE_CODE (t
) == COMPOUND_EXPR
5721 && TREE_CODE (init
) == INIT_EXPR
)
5723 tree last
= expr_last (t
);
5724 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5725 if (!TREE_SIDE_EFFECTS (last
))
5728 TREE_OPERAND (init
, 1) = last
;
5733 if (TREE_CODE (t
) == CONSTRUCTOR
)
5735 /* Aggregate initialization: stabilize each of the field
5738 constructor_elt
*ce
;
5740 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5741 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5743 tree type
= TREE_TYPE (ce
->value
);
5745 if (TYPE_REF_P (type
)
5746 || SCALAR_TYPE_P (type
))
5747 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5748 else if (!stabilize_init (ce
->value
, &subinit
))
5750 *initp
= add_stmt_to_compound (*initp
, subinit
);
5755 if (TREE_CODE (t
) == CALL_EXPR
)
5757 stabilize_call (t
, initp
);
5761 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5763 stabilize_aggr_init (t
, initp
);
5767 /* The initialization is being performed via a bitwise copy -- and
5768 the item copied may have side effects. */
5769 return !TREE_SIDE_EFFECTS (init
);
5772 /* Returns true if a cast to TYPE may appear in an integral constant
5776 cast_valid_in_integral_constant_expression_p (tree type
)
5778 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5779 || cxx_dialect
>= cxx11
5780 || dependent_type_p (type
)
5781 || type
== error_mark_node
);
5784 /* Return true if we need to fix linkage information of DECL. */
5787 cp_fix_function_decl_p (tree decl
)
5789 /* Skip if DECL is not externally visible. */
5790 if (!TREE_PUBLIC (decl
))
5793 /* We need to fix DECL if it a appears to be exported but with no
5794 function body. Thunks do not have CFGs and we may need to
5795 handle them specially later. */
5796 if (!gimple_has_body_p (decl
)
5797 && !DECL_THUNK_P (decl
)
5798 && !DECL_EXTERNAL (decl
))
5800 struct cgraph_node
*node
= cgraph_node::get (decl
);
5802 /* Don't fix same_body aliases. Although they don't have their own
5803 CFG, they share it with what they alias to. */
5804 if (!node
|| !node
->alias
|| !node
->num_references ())
5811 /* Clean the C++ specific parts of the tree T. */
5814 cp_free_lang_data (tree t
)
5816 if (FUNC_OR_METHOD_TYPE_P (t
))
5818 /* Default args are not interesting anymore. */
5819 tree argtypes
= TYPE_ARG_TYPES (t
);
5822 TREE_PURPOSE (argtypes
) = 0;
5823 argtypes
= TREE_CHAIN (argtypes
);
5826 else if (TREE_CODE (t
) == FUNCTION_DECL
5827 && cp_fix_function_decl_p (t
))
5829 /* If T is used in this translation unit at all, the definition
5830 must exist somewhere else since we have decided to not emit it
5831 in this TU. So make it an external reference. */
5832 DECL_EXTERNAL (t
) = 1;
5833 TREE_STATIC (t
) = 0;
5835 if (TREE_CODE (t
) == FUNCTION_DECL
)
5836 discard_operator_bindings (t
);
5837 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5838 /* We do not need the leftover chaining of namespaces from the
5840 DECL_CHAIN (t
) = NULL_TREE
;
5843 /* Stub for c-common. Please keep in sync with c-decl.c.
5844 FIXME: If address space support is target specific, then this
5845 should be a C target hook. But currently this is not possible,
5846 because this function is called via REGISTER_TARGET_PRAGMAS. */
5848 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5852 /* Return the number of operands in T that we care about for things like
5856 cp_tree_operand_length (const_tree t
)
5858 enum tree_code code
= TREE_CODE (t
);
5860 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5861 return VL_EXP_OPERAND_LENGTH (t
);
5863 return cp_tree_code_length (code
);
5866 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5869 cp_tree_code_length (enum tree_code code
)
5871 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5875 case PREINCREMENT_EXPR
:
5876 case PREDECREMENT_EXPR
:
5877 case POSTINCREMENT_EXPR
:
5878 case POSTDECREMENT_EXPR
:
5884 case EXPR_PACK_EXPANSION
:
5888 return TREE_CODE_LENGTH (code
);
5892 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5896 cp_expr_location (const_tree t_
)
5898 tree t
= CONST_CAST_TREE (t_
);
5900 return UNKNOWN_LOCATION
;
5901 switch (TREE_CODE (t
))
5904 return LAMBDA_EXPR_LOCATION (t
);
5906 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5908 return TRAIT_EXPR_LOCATION (t
);
5910 return EXPR_LOCATION (t
);
5914 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5915 conditions for the warning hold, false otherwise. */
5917 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5919 if (c_inhibit_evaluation_warnings
== 0
5920 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5922 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5923 "zero as null pointer constant");
5929 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5930 /* Complain that some language-specific thing hanging off a tree
5931 node has been accessed improperly. */
5934 lang_check_failed (const char* file
, int line
, const char* function
)
5936 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5937 function
, trim_filename (file
), line
);
5939 #endif /* ENABLE_TREE_CHECKING */
5943 namespace selftest
{
5945 /* Verify that lvalue_kind () works, for various expressions,
5946 and that location wrappers don't affect the results. */
5951 location_t loc
= BUILTINS_LOCATION
;
5953 /* Verify constants and parameters, without and with
5954 location wrappers. */
5955 tree int_cst
= build_int_cst (integer_type_node
, 42);
5956 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5958 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5959 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5960 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5962 tree string_lit
= build_string (4, "foo");
5963 TREE_TYPE (string_lit
) = char_array_type_node
;
5964 string_lit
= fix_string_type (string_lit
);
5965 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5967 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5968 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5969 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5971 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5972 get_identifier ("some_parm"),
5974 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5976 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5977 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5978 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5980 /* Verify that lvalue_kind of std::move on a parm isn't
5981 affected by location wrappers. */
5982 tree rvalue_ref_of_parm
= move (parm
);
5983 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5984 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5985 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5987 /* Verify lvalue_p. */
5988 ASSERT_FALSE (lvalue_p (int_cst
));
5989 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5990 ASSERT_TRUE (lvalue_p (parm
));
5991 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5992 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5993 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5996 /* Run all of the selftests within this file. */
6001 test_lvalue_kind ();
6004 } // namespace selftest
6006 #endif /* #if CHECKING_P */
6009 #include "gt-cp-tree.h"