1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2022 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
77 op1_lvalue_kind
= clk_rvalueref
;
78 if (implicit_rvalue_p (ref
))
79 op1_lvalue_kind
|= clk_implicit_rval
;
80 return op1_lvalue_kind
;
83 /* lvalue references and named rvalue references are lvalues. */
87 if (ref
== current_class_ptr
)
90 /* Expressions with cv void type are prvalues. */
91 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
94 switch (TREE_CODE (ref
))
99 /* preincrements and predecrements are valid lvals, provided
100 what they refer to are valid lvals. */
101 case PREINCREMENT_EXPR
:
102 case PREDECREMENT_EXPR
:
106 case VIEW_CONVERT_EXPR
:
107 return lvalue_kind (TREE_OPERAND (ref
, 0));
111 tree op1
= TREE_OPERAND (ref
, 0);
112 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
114 op1_lvalue_kind
= lvalue_kind (op1
);
115 if (op1_lvalue_kind
== clk_class
)
116 /* in the case of an array operand, the result is an lvalue if
117 that operand is an lvalue and an xvalue otherwise */
118 op1_lvalue_kind
= clk_rvalueref
;
119 return op1_lvalue_kind
;
127 if (TREE_CODE (ref
) == MEMBER_REF
)
128 op1_lvalue_kind
= clk_ordinary
;
130 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
131 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
132 op1_lvalue_kind
= clk_none
;
133 else if (op1_lvalue_kind
== clk_class
)
134 /* The result of a .* expression whose second operand is a pointer to a
135 data member is an lvalue if the first operand is an lvalue and an
137 op1_lvalue_kind
= clk_rvalueref
;
138 return op1_lvalue_kind
;
141 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
143 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
145 /* For static member function recurse on the BASELINK, we can get
146 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
147 OVERLOAD, the overload is resolved first if possible through
148 resolve_address_of_overloaded_function. */
149 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
150 return lvalue_kind (TREE_OPERAND (ref
, 1));
152 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
153 if (op1_lvalue_kind
== clk_class
)
154 /* If E1 is an lvalue, then E1.E2 is an lvalue;
155 otherwise E1.E2 is an xvalue. */
156 op1_lvalue_kind
= clk_rvalueref
;
158 /* Look at the member designator. */
159 if (!op1_lvalue_kind
)
161 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
162 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
163 situations. If we're seeing a COMPONENT_REF, it's a non-static
164 member, so it isn't an lvalue. */
165 op1_lvalue_kind
= clk_none
;
166 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
167 /* This can be IDENTIFIER_NODE in a template. */;
168 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
170 /* Clear the ordinary bit. If this object was a class
171 rvalue we want to preserve that information. */
172 op1_lvalue_kind
&= ~clk_ordinary
;
173 /* The lvalue is for a bitfield. */
174 op1_lvalue_kind
|= clk_bitfield
;
176 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
177 op1_lvalue_kind
|= clk_packed
;
179 return op1_lvalue_kind
;
182 case COMPOUND_LITERAL_EXPR
:
186 /* CONST_DECL without TREE_STATIC are enumeration values and
187 thus not lvalues. With TREE_STATIC they are used by ObjC++
188 in objc_build_string_object and need to be considered as
190 if (! TREE_STATIC (ref
))
194 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
195 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
197 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
198 && DECL_LANG_SPECIFIC (ref
)
199 && DECL_IN_AGGR_P (ref
))
206 case PLACEHOLDER_EXPR
:
209 /* A scope ref in a template, left as SCOPE_REF to support later
212 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
214 tree op
= TREE_OPERAND (ref
, 1);
215 if (TREE_CODE (op
) == FIELD_DECL
)
216 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
218 return lvalue_kind (op
);
223 /* Disallow <? and >? as lvalues if either argument side-effects. */
224 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
225 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
227 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
228 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
232 if (processing_template_decl
)
234 /* Within templates, a REFERENCE_TYPE will indicate whether
235 the COND_EXPR result is an ordinary lvalue or rvalueref.
236 Since REFERENCE_TYPEs are handled above, if we reach this
237 point, we know we got a plain rvalue. Unless we have a
238 type-dependent expr, that is, but we shouldn't be testing
239 lvalueness if we can't even tell the types yet! */
240 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
244 tree op1
= TREE_OPERAND (ref
, 1);
245 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
246 tree op2
= TREE_OPERAND (ref
, 2);
247 op1_lvalue_kind
= lvalue_kind (op1
);
248 op2_lvalue_kind
= lvalue_kind (op2
);
249 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
251 /* The second or the third operand (but not both) is a
252 throw-expression; the result is of the type
253 and value category of the other. */
254 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
255 op2_lvalue_kind
= op1_lvalue_kind
;
256 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
257 op1_lvalue_kind
= op2_lvalue_kind
;
263 /* We expect to see unlowered MODOP_EXPRs only during
264 template processing. */
265 gcc_assert (processing_template_decl
);
273 return lvalue_kind (TREE_OPERAND (ref
, 1));
279 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
282 /* We can see calls outside of TARGET_EXPR in templates. */
283 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
288 /* All functions (except non-static-member functions) are
290 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
291 ? clk_none
: clk_ordinary
);
294 /* We now represent a reference to a single static member function
296 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
297 its argument unmodified and we assign it to a const_tree. */
298 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
300 case NON_DEPENDENT_EXPR
:
302 return lvalue_kind (TREE_OPERAND (ref
, 0));
304 case TEMPLATE_PARM_INDEX
:
305 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
306 /* A template parameter object is an lvalue. */
312 if (!TREE_TYPE (ref
))
314 if (CLASS_TYPE_P (TREE_TYPE (ref
))
315 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
320 /* If one operand is not an lvalue at all, then this expression is
322 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
325 /* Otherwise, it's an lvalue, and it has all the odd properties
326 contributed by either operand. */
327 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
328 /* It's not an ordinary lvalue if it involves any other kind. */
329 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
330 op1_lvalue_kind
&= ~clk_ordinary
;
331 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
332 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
333 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
334 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
335 op1_lvalue_kind
= clk_none
;
336 return op1_lvalue_kind
;
339 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
342 real_lvalue_p (const_tree ref
)
344 cp_lvalue_kind kind
= lvalue_kind (ref
);
345 if (kind
& (clk_rvalueref
|clk_class
))
351 /* c-common wants us to return bool. */
354 lvalue_p (const_tree t
)
356 return real_lvalue_p (t
);
359 /* This differs from lvalue_p in that xvalues are included. */
362 glvalue_p (const_tree ref
)
364 cp_lvalue_kind kind
= lvalue_kind (ref
);
365 if (kind
& clk_class
)
368 return (kind
!= clk_none
);
371 /* This differs from glvalue_p in that class prvalues are included. */
374 obvalue_p (const_tree ref
)
376 return (lvalue_kind (ref
) != clk_none
);
379 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
380 reference), false otherwise. */
383 xvalue_p (const_tree ref
)
385 return (lvalue_kind (ref
) == clk_rvalueref
);
388 /* True if REF is a bit-field. */
391 bitfield_p (const_tree ref
)
393 return (lvalue_kind (ref
) & clk_bitfield
);
396 /* C++-specific version of stabilize_reference. */
399 cp_stabilize_reference (tree ref
)
401 STRIP_ANY_LOCATION_WRAPPER (ref
);
402 switch (TREE_CODE (ref
))
404 case NON_DEPENDENT_EXPR
:
405 /* We aren't actually evaluating this. */
408 /* We need to treat specially anything stabilize_reference doesn't
409 handle specifically. */
420 case ARRAY_RANGE_REF
:
424 cp_lvalue_kind kind
= lvalue_kind (ref
);
425 if ((kind
& ~clk_class
) != clk_none
)
427 tree type
= unlowered_expr_type (ref
);
428 bool rval
= !!(kind
& clk_rvalueref
);
429 type
= cp_build_reference_type (type
, rval
);
430 /* This inhibits warnings in, eg, cxx_mark_addressable
432 warning_sentinel
s (extra_warnings
);
433 ref
= build_static_cast (input_location
, type
, ref
,
438 return stabilize_reference (ref
);
441 /* Test whether DECL is a builtin that may appear in a
442 constant-expression. */
445 builtin_valid_in_constant_expr_p (const_tree decl
)
447 STRIP_ANY_LOCATION_WRAPPER (decl
);
448 if (TREE_CODE (decl
) != FUNCTION_DECL
)
449 /* Not a function. */
451 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
453 if (fndecl_built_in_p (decl
, BUILT_IN_FRONTEND
))
454 switch (DECL_FE_FUNCTION_CODE (decl
))
456 case CP_BUILT_IN_IS_CONSTANT_EVALUATED
:
457 case CP_BUILT_IN_SOURCE_LOCATION
:
458 case CP_BUILT_IN_IS_CORRESPONDING_MEMBER
:
459 case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS
:
464 /* Not a built-in. */
467 switch (DECL_FUNCTION_CODE (decl
))
469 /* These always have constant results like the corresponding
472 case BUILT_IN_FUNCTION
:
475 /* The following built-ins are valid in constant expressions
476 when their arguments are. */
477 case BUILT_IN_ADD_OVERFLOW_P
:
478 case BUILT_IN_SUB_OVERFLOW_P
:
479 case BUILT_IN_MUL_OVERFLOW_P
:
481 /* These have constant results even if their operands are
483 case BUILT_IN_CONSTANT_P
:
484 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
491 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
494 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
497 tree type
= TREE_TYPE (decl
);
499 value
= mark_rvalue_use (value
);
501 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
502 || TREE_TYPE (decl
) == TREE_TYPE (value
)
503 /* On ARM ctors return 'this'. */
504 || (TYPE_PTR_P (TREE_TYPE (value
))
505 && TREE_CODE (value
) == CALL_EXPR
)
506 || useless_type_conversion_p (TREE_TYPE (decl
),
509 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
510 moving a constant aggregate into .rodata. */
511 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
512 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
513 && !VOID_TYPE_P (TREE_TYPE (value
))
514 && reduced_constant_expression_p (value
))
515 TREE_READONLY (decl
) = true;
517 if (complain
& tf_no_cleanup
)
518 /* The caller is building a new-expr and does not need a cleanup. */
522 t
= cxx_maybe_build_cleanup (decl
, complain
);
523 if (t
== error_mark_node
)
524 return error_mark_node
;
526 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
527 if (location_t eloc
= cp_expr_location (value
))
528 SET_EXPR_LOCATION (t
, eloc
);
529 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
530 ignore the TARGET_EXPR. If there really turn out to be no
531 side-effects, then the optimizer should be able to get rid of
532 whatever code is generated anyhow. */
533 TREE_SIDE_EFFECTS (t
) = 1;
538 /* Return an undeclared local temporary of type TYPE for use in building a
542 build_local_temp (tree type
)
544 tree slot
= build_decl (input_location
,
545 VAR_DECL
, NULL_TREE
, type
);
546 DECL_ARTIFICIAL (slot
) = 1;
547 DECL_IGNORED_P (slot
) = 1;
548 DECL_CONTEXT (slot
) = current_function_decl
;
549 layout_decl (slot
, 0);
553 /* Return whether DECL is such a local temporary (or one from
554 create_tmp_var_raw). */
557 is_local_temp (tree decl
)
559 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
560 && !TREE_STATIC (decl
)
561 && DECL_FUNCTION_SCOPE_P (decl
));
564 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
567 process_aggr_init_operands (tree t
)
571 side_effects
= TREE_SIDE_EFFECTS (t
);
575 n
= TREE_OPERAND_LENGTH (t
);
576 for (i
= 1; i
< n
; i
++)
578 tree op
= TREE_OPERAND (t
, i
);
579 if (op
&& TREE_SIDE_EFFECTS (op
))
586 TREE_SIDE_EFFECTS (t
) = side_effects
;
589 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
590 FN, and SLOT. NARGS is the number of call arguments which are specified
591 as a tree array ARGS. */
594 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
600 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
601 TREE_TYPE (t
) = return_type
;
602 AGGR_INIT_EXPR_FN (t
) = fn
;
603 AGGR_INIT_EXPR_SLOT (t
) = slot
;
604 for (i
= 0; i
< nargs
; i
++)
605 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
606 process_aggr_init_operands (t
);
610 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
611 target. TYPE is the type to be initialized.
613 Build an AGGR_INIT_EXPR to represent the initialization. This function
614 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
615 to initialize another object, whereas a TARGET_EXPR can either
616 initialize another object or create its own temporary object, and as a
617 result building up a TARGET_EXPR requires that the type's destructor be
621 build_aggr_init_expr (tree type
, tree init
)
628 gcc_assert (!VOID_TYPE_P (type
));
630 /* Don't build AGGR_INIT_EXPR in a template. */
631 if (processing_template_decl
)
634 fn
= cp_get_callee (init
);
636 return convert (type
, init
);
638 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
639 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
640 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
642 /* We split the CALL_EXPR into its function and its arguments here.
643 Then, in expand_expr, we put them back together. The reason for
644 this is that this expression might be a default argument
645 expression. In that case, we need a new temporary every time the
646 expression is used. That's what break_out_target_exprs does; it
647 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
648 temporary slot. Then, expand_expr builds up a call-expression
649 using the new slot. */
651 /* If we don't need to use a constructor to create an object of this
652 type, don't mess with AGGR_INIT_EXPR. */
653 if (is_ctor
|| TREE_ADDRESSABLE (type
))
655 slot
= build_local_temp (type
);
657 if (TREE_CODE (init
) == CALL_EXPR
)
659 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
660 call_expr_nargs (init
),
661 CALL_EXPR_ARGP (init
));
662 AGGR_INIT_FROM_THUNK_P (rval
)
663 = CALL_FROM_THUNK_P (init
);
667 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
668 aggr_init_expr_nargs (init
),
669 AGGR_INIT_EXPR_ARGP (init
));
670 AGGR_INIT_FROM_THUNK_P (rval
)
671 = AGGR_INIT_FROM_THUNK_P (init
);
673 TREE_SIDE_EFFECTS (rval
) = 1;
674 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
675 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
676 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
677 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
678 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
686 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
687 target. TYPE is the type that this initialization should appear to
690 Build an encapsulation of the initialization to perform
691 and return it so that it can be processed by language-independent
692 and language-specific expression expanders. */
695 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
697 /* This function should cope with what build_special_member_call
698 can produce. When performing parenthesized aggregate initialization,
699 it can produce a { }. */
700 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
702 gcc_assert (cxx_dialect
>= cxx20
);
703 return finish_compound_literal (type
, init
, complain
);
706 tree rval
= build_aggr_init_expr (type
, init
);
709 if (init
== error_mark_node
)
710 return error_mark_node
;
712 if (!complete_type_or_maybe_complain (type
, init
, complain
))
713 return error_mark_node
;
715 /* Make sure that we're not trying to create an instance of an
717 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
718 return error_mark_node
;
720 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
721 slot
= AGGR_INIT_EXPR_SLOT (rval
);
722 else if (TREE_CODE (rval
) == CALL_EXPR
723 || TREE_CODE (rval
) == CONSTRUCTOR
)
724 slot
= build_local_temp (type
);
728 rval
= build_target_expr (slot
, rval
, complain
);
730 if (rval
!= error_mark_node
)
731 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
736 /* Subroutine of build_vec_init_expr: Build up a single element
737 intialization as a proxy for the full array initialization to get things
738 marked as used and any appropriate diagnostics.
740 Since we're deferring building the actual constructor calls until
741 gimplification time, we need to build one now and throw it away so
742 that the relevant constructor gets mark_used before cgraph decides
743 what functions are needed. Here we assume that init is either
744 NULL_TREE, void_type_node (indicating value-initialization), or
745 another array to copy. */
748 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
750 tree inner_type
= strip_array_types (type
);
752 if (integer_zerop (array_type_nelts_total (type
))
753 || !CLASS_TYPE_P (inner_type
))
754 /* No interesting initialization to do. */
755 return integer_zero_node
;
756 else if (init
== void_type_node
)
757 return build_value_init (inner_type
, complain
);
759 gcc_assert (init
== NULL_TREE
760 || (same_type_ignoring_top_level_qualifiers_p
761 (type
, TREE_TYPE (init
))));
763 releasing_vec argvec
;
766 tree init_type
= strip_array_types (TREE_TYPE (init
));
767 tree dummy
= build_dummy_object (init_type
);
768 if (!lvalue_p (init
))
769 dummy
= move (dummy
);
770 argvec
->quick_push (dummy
);
772 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
773 &argvec
, inner_type
, LOOKUP_NORMAL
,
776 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
777 we don't want one here because we aren't creating a temporary. */
778 if (TREE_CODE (init
) == TARGET_EXPR
)
779 init
= TARGET_EXPR_INITIAL (init
);
784 /* Return a TARGET_EXPR which expresses the initialization of an array to
785 be named later, either default-initialization or copy-initialization
786 from another array of the same type. */
789 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
792 bool value_init
= false;
794 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
796 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
797 /* We built any needed constructor calls in digest_init. */
801 elt_init
= build_vec_init_elt (type
, init
, complain
);
803 if (init
== void_type_node
)
809 slot
= build_local_temp (type
);
810 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
811 TREE_SIDE_EFFECTS (init
) = true;
812 SET_EXPR_LOCATION (init
, input_location
);
814 if (cxx_dialect
>= cxx11
815 && potential_constant_expression (elt_init
))
816 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
817 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
822 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
823 that requires a constant expression. */
826 diagnose_non_constexpr_vec_init (tree expr
)
828 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
830 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
831 init
= void_type_node
;
833 init
= VEC_INIT_EXPR_INIT (expr
);
835 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
836 require_potential_constant_expression (elt_init
);
840 build_array_copy (tree init
)
842 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
845 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
849 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
851 gcc_assert (!VOID_TYPE_P (type
));
852 gcc_assert (!VOID_TYPE_P (TREE_TYPE (init
)));
854 if (TREE_CODE (init
) == TARGET_EXPR
855 || init
== error_mark_node
)
857 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
858 && TREE_CODE (init
) != COND_EXPR
859 && TREE_CODE (init
) != CONSTRUCTOR
860 && TREE_CODE (init
) != VA_ARG_EXPR
861 && TREE_CODE (init
) != CALL_EXPR
)
862 /* We need to build up a copy constructor call. COND_EXPR is a special
863 case because we already have copies on the arms and we don't want
864 another one here. A CONSTRUCTOR is aggregate initialization, which
865 is handled separately. A VA_ARG_EXPR is magic creation of an
866 aggregate; there's no additional work to be done. A CALL_EXPR
867 already creates a prvalue. */
868 return force_rvalue (init
, complain
);
870 return force_target_expr (type
, init
, complain
);
873 /* Like the above function, but without the checking. This function should
874 only be used by code which is deliberately trying to subvert the type
875 system, such as call_builtin_trap. Or build_over_call, to avoid
876 infinite recursion. */
879 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
883 gcc_assert (!VOID_TYPE_P (type
));
885 slot
= build_local_temp (type
);
886 return build_target_expr (slot
, init
, complain
);
889 /* Like build_target_expr_with_type, but use the type of INIT. */
892 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
894 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
895 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
896 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
897 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
900 init
= convert_bitfield_to_declared_type (init
);
901 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
906 get_target_expr (tree init
)
908 return get_target_expr_sfinae (init
, tf_warning_or_error
);
911 /* If EXPR is a bitfield reference, convert it to the declared type of
912 the bitfield, and return the resulting expression. Otherwise,
913 return EXPR itself. */
916 convert_bitfield_to_declared_type (tree expr
)
920 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
922 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
927 /* EXPR is being used in an rvalue context. Return a version of EXPR
928 that is marked as an rvalue. */
935 if (error_operand_p (expr
))
938 expr
= mark_rvalue_use (expr
);
942 Non-class rvalues always have cv-unqualified types. */
943 type
= TREE_TYPE (expr
);
944 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
945 type
= cv_unqualified (type
);
947 /* We need to do this for rvalue refs as well to get the right answer
948 from decltype; see c++/36628. */
949 if (!processing_template_decl
&& glvalue_p (expr
))
951 /* But don't use this function for class lvalues; use move (to treat an
952 lvalue as an xvalue) or force_rvalue (to make a prvalue copy). */
953 gcc_checking_assert (!CLASS_TYPE_P (type
));
954 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
956 else if (type
!= TREE_TYPE (expr
))
957 expr
= build_nop (type
, expr
);
963 struct cplus_array_info
969 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
971 typedef cplus_array_info
*compare_type
;
973 static hashval_t
hash (tree t
);
974 static bool equal (tree
, cplus_array_info
*);
977 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
980 cplus_array_hasher::hash (tree t
)
984 hash
= TYPE_UID (TREE_TYPE (t
));
986 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
990 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
991 of type `cplus_array_info*'. */
994 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
996 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
999 /* Hash table containing dependent array types, which are unsuitable for
1000 the language-independent type hash table. */
1001 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
1003 /* Build an ARRAY_TYPE without laying it out. */
1006 build_min_array_type (tree elt_type
, tree index_type
)
1008 tree t
= cxx_make_type (ARRAY_TYPE
);
1009 TREE_TYPE (t
) = elt_type
;
1010 TYPE_DOMAIN (t
) = index_type
;
1014 /* Set TYPE_CANONICAL like build_array_type_1, but using
1015 build_cplus_array_type. */
1018 set_array_type_canon (tree t
, tree elt_type
, tree index_type
, bool dep
)
1020 /* Set the canonical type for this new node. */
1021 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1022 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1023 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1024 else if (TYPE_CANONICAL (elt_type
) != elt_type
1025 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1027 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1029 ? TYPE_CANONICAL (index_type
) : index_type
,
1032 TYPE_CANONICAL (t
) = t
;
1035 /* Like build_array_type, but handle special C++ semantics: an array of a
1036 variant element type is a variant of the array of the main variant of
1037 the element type. IS_DEPENDENT is -ve if we should determine the
1038 dependency. Otherwise its bool value indicates dependency. */
1041 build_cplus_array_type (tree elt_type
, tree index_type
, int dependent
)
1045 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1046 return error_mark_node
;
1049 dependent
= (uses_template_parms (elt_type
)
1050 || (index_type
&& uses_template_parms (index_type
)));
1052 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1053 /* Start with an array of the TYPE_MAIN_VARIANT. */
1054 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1055 index_type
, dependent
);
1058 /* Since type_hash_canon calls layout_type, we need to use our own
1060 cplus_array_info cai
;
1063 if (cplus_array_htab
== NULL
)
1064 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1066 hash
= TYPE_UID (elt_type
);
1068 hash
^= TYPE_UID (index_type
);
1069 cai
.type
= elt_type
;
1070 cai
.domain
= index_type
;
1072 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1074 /* We have found the type: we're done. */
1078 /* Build a new array type. */
1079 t
= build_min_array_type (elt_type
, index_type
);
1081 /* Store it in the hash table. */
1084 /* Set the canonical type for this new node. */
1085 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1087 /* Mark it as dependent now, this saves time later. */
1088 TYPE_DEPENDENT_P_VALID (t
) = true;
1089 TYPE_DEPENDENT_P (t
) = true;
1094 bool typeless_storage
= is_byte_access_type (elt_type
);
1095 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1097 /* Mark as non-dependenty now, this will save time later. */
1098 TYPE_DEPENDENT_P_VALID (t
) = true;
1101 /* Now check whether we already have this array variant. */
1102 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1105 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1106 if (TREE_TYPE (t
) == elt_type
1107 && TYPE_NAME (t
) == NULL_TREE
1108 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1112 t
= build_min_array_type (elt_type
, index_type
);
1113 /* Mark dependency now, this saves time later. */
1114 TYPE_DEPENDENT_P_VALID (t
) = true;
1115 TYPE_DEPENDENT_P (t
) = dependent
;
1116 set_array_type_canon (t
, elt_type
, index_type
, dependent
);
1120 /* Make sure sizes are shared with the main variant.
1121 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1122 as it will overwrite alignment etc. of all variants. */
1123 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1124 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1125 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1128 TYPE_MAIN_VARIANT (t
) = m
;
1129 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1130 TYPE_NEXT_VARIANT (m
) = t
;
1134 /* Avoid spurious warnings with VLAs (c++/54583). */
1135 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1136 suppress_warning (TYPE_SIZE (t
), OPT_Wunused
);
1138 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1139 place more easily. */
1140 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1141 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1142 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1143 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1145 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1146 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1148 /* The element type has been completed since the last time we saw
1149 this array type; update the layout and 'tor flags for any variants
1152 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1154 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1155 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1162 /* Return an ARRAY_TYPE with element type ELT and length N. */
1165 build_array_of_n_type (tree elt
, int n
)
1167 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1170 /* True iff T is an array of unknown bound. */
1173 array_of_unknown_bound_p (const_tree t
)
1175 return (TREE_CODE (t
) == ARRAY_TYPE
1176 && !TYPE_DOMAIN (t
));
1179 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1180 for C++14 but then removed. This should only be used for N3639
1181 specifically; code wondering more generally if something is a VLA should use
1185 array_of_runtime_bound_p (tree t
)
1187 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1189 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1191 tree dom
= TYPE_DOMAIN (t
);
1194 tree max
= TYPE_MAX_VALUE (dom
);
1195 return (!potential_rvalue_constant_expression (max
)
1196 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1199 /* True iff T is a variable length array. */
1204 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1206 if (tree dom
= TYPE_DOMAIN (t
))
1208 tree max
= TYPE_MAX_VALUE (dom
);
1209 if (!potential_rvalue_constant_expression (max
)
1210 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1217 /* Return a reference type node of MODE referring to TO_TYPE. If MODE
1218 is VOIDmode the standard pointer mode will be picked. If RVAL is
1219 true, return an rvalue reference type, otherwise return an lvalue
1220 reference type. If a type node exists, reuse it, otherwise create
1223 cp_build_reference_type_for_mode (tree to_type
, machine_mode mode
, bool rval
)
1227 if (to_type
== error_mark_node
)
1228 return error_mark_node
;
1230 if (TYPE_REF_P (to_type
))
1232 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1233 to_type
= TREE_TYPE (to_type
);
1236 lvalue_ref
= build_reference_type_for_mode (to_type
, mode
, false);
1241 /* This code to create rvalue reference types is based on and tied
1242 to the code creating lvalue reference types in the middle-end
1243 functions build_reference_type_for_mode and build_reference_type.
1245 It works by putting the rvalue reference type nodes after the
1246 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1247 they will effectively be ignored by the middle end. */
1249 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1250 if (TYPE_REF_IS_RVALUE (t
))
1253 t
= build_distinct_type_copy (lvalue_ref
);
1255 TYPE_REF_IS_RVALUE (t
) = true;
1256 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1257 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1259 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1260 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1261 else if (TYPE_CANONICAL (to_type
) != to_type
)
1263 = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type
), mode
, rval
);
1265 TYPE_CANONICAL (t
) = t
;
1273 /* Return a reference type node referring to TO_TYPE. If RVAL is
1274 true, return an rvalue reference type, otherwise return an lvalue
1275 reference type. If a type node exists, reuse it, otherwise create
1278 cp_build_reference_type (tree to_type
, bool rval
)
1280 return cp_build_reference_type_for_mode (to_type
, VOIDmode
, rval
);
1283 /* Returns EXPR cast to rvalue reference type, like std::move. */
1288 tree type
= TREE_TYPE (expr
);
1289 gcc_assert (!TYPE_REF_P (type
));
1290 type
= cp_build_reference_type (type
, /*rval*/true);
1291 return build_static_cast (input_location
, type
, expr
,
1292 tf_warning_or_error
);
1295 /* Used by the C++ front end to build qualified array types. However,
1296 the C version of this function does not properly maintain canonical
1297 types (which are not used in C). */
1299 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1300 size_t /* orig_qual_indirect */)
1302 return cp_build_qualified_type (type
, type_quals
);
1306 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1307 arrays correctly. In particular, if TYPE is an array of T's, and
1308 TYPE_QUALS is non-empty, returns an array of qualified T's.
1310 FLAGS determines how to deal with ill-formed qualifications. If
1311 tf_ignore_bad_quals is set, then bad qualifications are dropped
1312 (this is permitted if TYPE was introduced via a typedef or template
1313 type parameter). If bad qualifications are dropped and tf_warning
1314 is set, then a warning is issued for non-const qualifications. If
1315 tf_ignore_bad_quals is not set and tf_error is not set, we
1316 return error_mark_node. Otherwise, we issue an error, and ignore
1319 Qualification of a reference type is valid when the reference came
1320 via a typedef or template type argument. [dcl.ref] No such
1321 dispensation is provided for qualifying a function type. [dcl.fct]
1322 DR 295 queries this and the proposed resolution brings it into line
1323 with qualifying a reference. We implement the DR. We also behave
1324 in a similar manner for restricting non-pointer types. */
1327 cp_build_qualified_type_real (tree type
,
1329 tsubst_flags_t complain
)
1332 int bad_quals
= TYPE_UNQUALIFIED
;
1334 if (type
== error_mark_node
)
1337 if (type_quals
== cp_type_quals (type
))
1340 if (TREE_CODE (type
) == ARRAY_TYPE
)
1342 /* In C++, the qualification really applies to the array element
1343 type. Obtain the appropriately qualified element type. */
1346 = cp_build_qualified_type_real (TREE_TYPE (type
),
1350 if (element_type
== error_mark_node
)
1351 return error_mark_node
;
1353 /* See if we already have an identically qualified type. Tests
1354 should be equivalent to those in check_qualified_type. */
1355 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1356 if (TREE_TYPE (t
) == element_type
1357 && TYPE_NAME (t
) == TYPE_NAME (type
)
1358 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1359 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1360 TYPE_ATTRIBUTES (type
)))
1365 /* If we already know the dependentness, tell the array type
1366 constructor. This is important for module streaming, as we cannot
1367 dynamically determine that on read in. */
1368 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
),
1369 TYPE_DEPENDENT_P_VALID (type
)
1370 ? int (TYPE_DEPENDENT_P (type
)) : -1);
1372 /* Keep the typedef name. */
1373 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1375 t
= build_variant_type_copy (t
);
1376 TYPE_NAME (t
) = TYPE_NAME (type
);
1377 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1378 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1382 /* Even if we already had this variant, we update
1383 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1384 they changed since the variant was originally created.
1386 This seems hokey; if there is some way to use a previous
1387 variant *without* coming through here,
1388 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1389 TYPE_NEEDS_CONSTRUCTING (t
)
1390 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1391 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1392 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1395 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1397 tree t
= PACK_EXPANSION_PATTERN (type
);
1399 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1400 return make_pack_expansion (t
, complain
);
1403 /* A reference or method type shall not be cv-qualified.
1404 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1405 (in CD1) we always ignore extra cv-quals on functions. */
1407 /* [dcl.ref/1] Cv-qualified references are ill-formed except when
1408 the cv-qualifiers are introduced through the use of a typedef-name
1409 ([dcl.typedef], [temp.param]) or decltype-specifier
1410 ([dcl.type.decltype]),in which case the cv-qualifiers are
1412 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1413 && (TYPE_REF_P (type
)
1414 || FUNC_OR_METHOD_TYPE_P (type
)))
1416 if (TYPE_REF_P (type
)
1417 && (!typedef_variant_p (type
) || FUNC_OR_METHOD_TYPE_P (type
)))
1418 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1419 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1422 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1423 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1424 type_quals
|= type_memfn_quals (type
);
1426 /* A restrict-qualified type must be a pointer (or reference)
1427 to object or incomplete type. */
1428 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1429 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1430 && TREE_CODE (type
) != TYPENAME_TYPE
1431 && !INDIRECT_TYPE_P (type
))
1433 bad_quals
|= TYPE_QUAL_RESTRICT
;
1434 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1437 if (bad_quals
== TYPE_UNQUALIFIED
1438 || (complain
& tf_ignore_bad_quals
))
1440 else if (!(complain
& tf_error
))
1441 return error_mark_node
;
1444 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1445 error ("%qV qualifiers cannot be applied to %qT",
1449 /* Retrieve (or create) the appropriately qualified variant. */
1450 result
= build_qualified_type (type
, type_quals
);
1455 /* Return TYPE with const and volatile removed. */
1458 cv_unqualified (tree type
)
1462 if (type
== error_mark_node
)
1465 quals
= cp_type_quals (type
);
1466 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1467 return cp_build_qualified_type (type
, quals
);
1470 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1471 from ATTRIBS that affect type identity, and no others. If any are not
1472 applied, set *remove_attributes to true. */
1475 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1477 tree first_ident
= NULL_TREE
;
1478 tree new_attribs
= NULL_TREE
;
1479 tree
*p
= &new_attribs
;
1481 if (OVERLOAD_TYPE_P (result
))
1483 /* On classes and enums all attributes are ingrained. */
1484 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1488 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1490 const attribute_spec
*as
1491 = lookup_attribute_spec (get_attribute_name (a
));
1492 if (as
&& as
->affects_type_identity
)
1496 else if (first_ident
== error_mark_node
)
1498 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1499 p
= &TREE_CHAIN (*p
);
1502 else if (first_ident
&& first_ident
!= error_mark_node
)
1504 for (tree a2
= first_ident
; a2
!= a
; a2
= TREE_CHAIN (a2
))
1506 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1507 p
= &TREE_CHAIN (*p
);
1509 first_ident
= error_mark_node
;
1512 if (first_ident
!= error_mark_node
)
1513 new_attribs
= first_ident
;
1515 if (first_ident
== attribs
)
1516 /* All attributes affected type identity. */;
1518 *remove_attributes
= true;
1520 return cp_build_type_attribute_variant (result
, new_attribs
);
1523 /* Builds a qualified variant of T that is either not a typedef variant
1524 (the default behavior) or not a typedef variant of a user-facing type
1525 (if FLAGS contains STF_USER_FACING).
1527 E.g. consider the following declarations:
1528 typedef const int ConstInt;
1529 typedef ConstInt* PtrConstInt;
1530 If T is PtrConstInt, this function returns a type representing
1532 In other words, if T is a typedef, the function returns the underlying type.
1533 The cv-qualification and attributes of the type returned match the
1535 They will always be compatible types.
1536 The returned type is built so that all of its subtypes
1537 recursively have their typedefs stripped as well.
1539 This is different from just returning TYPE_CANONICAL (T)
1540 Because of several reasons:
1541 * If T is a type that needs structural equality
1542 its TYPE_CANONICAL (T) will be NULL.
1543 * TYPE_CANONICAL (T) desn't carry type attributes
1544 and loses template parameter names.
1546 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1547 affect type identity, and set the referent to true if any were
1551 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1553 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1555 if (!t
|| t
== error_mark_node
)
1558 if (TREE_CODE (t
) == TREE_LIST
)
1560 bool changed
= false;
1563 for (; t
; t
= TREE_CHAIN (t
))
1565 gcc_assert (!TREE_PURPOSE (t
));
1566 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1567 if (elt
!= TREE_VALUE (t
))
1569 vec_safe_push (vec
, elt
);
1572 r
= build_tree_list_vec (vec
);
1576 gcc_assert (TYPE_P (t
));
1578 if (t
== TYPE_CANONICAL (t
))
1581 if (!(flags
& STF_STRIP_DEPENDENT
)
1582 && dependent_alias_template_spec_p (t
, nt_opaque
))
1583 /* DR 1558: However, if the template-id is dependent, subsequent
1584 template argument substitution still applies to the template-id. */
1587 switch (TREE_CODE (t
))
1590 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1591 result
= build_pointer_type_for_mode (type
, TYPE_MODE (t
), false);
1593 case REFERENCE_TYPE
:
1594 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1595 result
= cp_build_reference_type_for_mode (type
, TYPE_MODE (t
), TYPE_REF_IS_RVALUE (t
));
1598 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1599 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1600 result
= build_offset_type (t0
, type
);
1603 if (TYPE_PTRMEMFUNC_P (t
))
1605 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1606 remove_attributes
, flags
);
1607 result
= build_ptrmemfunc_type (t0
);
1611 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1612 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1613 gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t
)
1614 || !dependent_type_p (t
));
1615 result
= build_cplus_array_type (type
, t0
, TYPE_DEPENDENT_P (t
));
1620 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1623 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1624 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1625 can't expect that re-hashing a function type will find a previous
1626 equivalent type, so try to reuse the input type if nothing has
1627 changed. If the type is itself a variant, that will change. */
1628 bool is_variant
= typedef_variant_p (t
);
1629 if (remove_attributes
1630 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1633 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1634 tree canon_spec
= (flag_noexcept_type
1635 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1637 changed
= (type
!= TREE_TYPE (t
) || is_variant
1638 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1640 for (arg_node
= TYPE_ARG_TYPES (t
);
1642 arg_node
= TREE_CHAIN (arg_node
))
1644 if (arg_node
== void_list_node
)
1646 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1647 remove_attributes
, flags
);
1648 gcc_assert (arg_type
);
1649 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1655 for (arg_node2
= TYPE_ARG_TYPES (t
);
1656 arg_node2
!= arg_node
;
1657 arg_node2
= TREE_CHAIN (arg_node2
))
1659 = tree_cons (TREE_PURPOSE (arg_node2
),
1660 TREE_VALUE (arg_node2
), arg_types
);
1664 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1671 arg_types
= nreverse (arg_types
);
1673 /* A list of parameters not ending with an ellipsis
1674 must end with void_list_node. */
1676 arg_types
= chainon (arg_types
, void_list_node
);
1678 if (TREE_CODE (t
) == METHOD_TYPE
)
1680 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1681 gcc_assert (class_type
);
1683 build_method_type_directly (class_type
, type
,
1684 TREE_CHAIN (arg_types
));
1688 result
= build_function_type (type
, arg_types
);
1689 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1692 result
= build_cp_fntype_variant (result
,
1693 type_memfn_rqual (t
), canon_spec
,
1694 TYPE_HAS_LATE_RETURN_TYPE (t
));
1699 bool changed
= false;
1700 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1701 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1702 && TREE_OPERAND (fullname
, 1))
1704 tree args
= TREE_OPERAND (fullname
, 1);
1705 tree new_args
= copy_node (args
);
1706 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1708 tree arg
= TREE_VEC_ELT (args
, i
);
1711 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1713 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1715 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1716 if (strip_arg
!= arg
)
1721 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1722 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1724 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1728 ggc_free (new_args
);
1730 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1731 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1733 tree name
= fullname
;
1734 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1735 name
= TREE_OPERAND (fullname
, 0);
1736 /* Use build_typename_type rather than make_typename_type because we
1737 don't want to resolve it here, just strip typedefs. */
1738 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1742 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1743 remove_attributes
, flags
);
1744 if (result
== DECLTYPE_TYPE_EXPR (t
))
1747 result
= (finish_decltype_type
1749 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1752 case UNDERLYING_TYPE
:
1753 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1754 remove_attributes
, flags
);
1755 result
= finish_underlying_type (type
);
1757 case TYPE_PACK_EXPANSION
:
1759 tree pat
= PACK_EXPANSION_PATTERN (t
);
1762 type
= strip_typedefs (pat
, remove_attributes
, flags
);
1765 result
= copy_node (t
);
1766 PACK_EXPANSION_PATTERN (result
) = type
;
1777 if (typedef_variant_p (t
))
1779 if ((flags
& STF_USER_VISIBLE
)
1780 && !user_facing_original_type_p (t
))
1782 /* If T is a non-template alias or typedef, we can assume that
1783 instantiating its definition will hit any substitution failure,
1784 so we don't need to retain it here as well. */
1785 if (!alias_template_specialization_p (t
, nt_opaque
))
1786 flags
|= STF_STRIP_DEPENDENT
;
1787 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1788 remove_attributes
, flags
);
1791 result
= TYPE_MAIN_VARIANT (t
);
1793 /*gcc_assert (!typedef_variant_p (result)
1794 || dependent_alias_template_spec_p (result, nt_opaque)
1795 || ((flags & STF_USER_VISIBLE)
1796 && !user_facing_original_type_p (result)));*/
1798 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1799 /* If RESULT is complete and T isn't, it's likely the case that T
1800 is a variant of RESULT which hasn't been updated yet. Skip the
1801 attribute handling. */;
1804 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1805 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1807 gcc_assert (TYPE_USER_ALIGN (t
));
1808 if (remove_attributes
)
1809 *remove_attributes
= true;
1812 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1813 result
= build_variant_type_copy (result
);
1815 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1816 TYPE_USER_ALIGN (result
) = true;
1820 if (TYPE_ATTRIBUTES (t
))
1822 if (remove_attributes
)
1823 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1826 result
= cp_build_type_attribute_variant (result
,
1827 TYPE_ATTRIBUTES (t
));
1831 return cp_build_qualified_type (result
, cp_type_quals (t
));
1834 /* Like strip_typedefs above, but works on expressions, so that in
1836 template<class T> struct A
1842 sizeof(TT) is replaced by sizeof(T). */
1845 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1849 enum tree_code code
;
1851 if (t
== NULL_TREE
|| t
== error_mark_node
)
1854 STRIP_ANY_LOCATION_WRAPPER (t
);
1856 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1859 /* Some expressions have type operands, so let's handle types here rather
1860 than check TYPE_P in multiple places below. */
1862 return strip_typedefs (t
, remove_attributes
, flags
);
1864 code
= TREE_CODE (t
);
1867 case IDENTIFIER_NODE
:
1868 case TEMPLATE_PARM_INDEX
:
1871 case ARGUMENT_PACK_SELECT
:
1876 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1877 remove_attributes
, flags
);
1878 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1879 remove_attributes
, flags
);
1880 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1881 && type2
== TRAIT_EXPR_TYPE2 (t
))
1884 TRAIT_EXPR_TYPE1 (r
) = type1
;
1885 TRAIT_EXPR_TYPE2 (r
) = type2
;
1892 bool changed
= false;
1894 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1896 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1897 remove_attributes
, flags
);
1898 vec_safe_push (vec
, val
);
1899 if (val
!= TREE_VALUE (it
))
1901 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1906 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1907 r
= tree_cons (NULL_TREE
, it
, r
);
1916 bool changed
= false;
1918 n
= TREE_VEC_LENGTH (t
);
1919 vec_safe_reserve (vec
, n
);
1920 for (i
= 0; i
< n
; ++i
)
1922 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1923 remove_attributes
, flags
);
1924 vec
->quick_push (op
);
1925 if (op
!= TREE_VEC_ELT (t
, i
))
1931 for (i
= 0; i
< n
; ++i
)
1932 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1933 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1934 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1943 bool changed
= false;
1944 vec
<constructor_elt
, va_gc
> *vec
1945 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1946 n
= CONSTRUCTOR_NELTS (t
);
1947 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1948 for (i
= 0; i
< n
; ++i
)
1950 constructor_elt
*e
= &(*vec
)[i
];
1951 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1958 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1962 if (!changed
&& type
== TREE_TYPE (t
))
1970 TREE_TYPE (r
) = type
;
1971 CONSTRUCTOR_ELTS (r
) = vec
;
1979 case STATEMENT_LIST
:
1980 error ("statement-expression in a constant expression");
1981 return error_mark_node
;
1987 gcc_assert (EXPR_P (t
));
1989 n
= cp_tree_operand_length (t
);
1990 ops
= XALLOCAVEC (tree
, n
);
1991 type
= TREE_TYPE (t
);
1996 case IMPLICIT_CONV_EXPR
:
1997 case DYNAMIC_CAST_EXPR
:
1998 case STATIC_CAST_EXPR
:
1999 case CONST_CAST_EXPR
:
2000 case REINTERPRET_CAST_EXPR
:
2003 type
= strip_typedefs (type
, remove_attributes
, flags
);
2007 for (i
= 0; i
< n
; ++i
)
2008 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
2009 remove_attributes
, flags
);
2013 /* If nothing changed, return t. */
2014 for (i
= 0; i
< n
; ++i
)
2015 if (ops
[i
] != TREE_OPERAND (t
, i
))
2017 if (i
== n
&& type
== TREE_TYPE (t
))
2021 TREE_TYPE (r
) = type
;
2022 for (i
= 0; i
< n
; ++i
)
2023 TREE_OPERAND (r
, i
) = ops
[i
];
2027 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
2028 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2029 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2030 VIRT indicates whether TYPE is inherited virtually or not.
2031 IGO_PREV points at the previous binfo of the inheritance graph
2032 order chain. The newly copied binfo's TREE_CHAIN forms this
2035 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2036 correct order. That is in the order the bases themselves should be
2039 The BINFO_INHERITANCE of a virtual base class points to the binfo
2040 of the most derived type. ??? We could probably change this so that
2041 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2042 remove a field. They currently can only differ for primary virtual
2046 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
2052 /* See if we've already made this virtual base. */
2053 new_binfo
= binfo_for_vbase (type
, t
);
2058 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
2059 BINFO_TYPE (new_binfo
) = type
;
2061 /* Chain it into the inheritance graph. */
2062 TREE_CHAIN (*igo_prev
) = new_binfo
;
2063 *igo_prev
= new_binfo
;
2065 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2070 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2072 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2073 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2075 /* We do not need to copy the accesses, as they are read only. */
2076 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2078 /* Recursively copy base binfos of BINFO. */
2079 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2081 tree new_base_binfo
;
2082 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2084 BINFO_VIRTUAL_P (base_binfo
));
2086 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2087 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2088 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2092 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2096 /* Push it onto the list after any virtual bases it contains
2097 will have been pushed. */
2098 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2099 BINFO_VIRTUAL_P (new_binfo
) = 1;
2100 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2106 /* Hashing of lists so that we don't make duplicates.
2107 The entry point is `list_hash_canon'. */
2116 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2118 typedef list_proxy
*compare_type
;
2120 static hashval_t
hash (tree
);
2121 static bool equal (tree
, list_proxy
*);
2124 /* Now here is the hash table. When recording a list, it is added
2125 to the slot whose index is the hash code mod the table size.
2126 Note that the hash table is used for several kinds of lists.
2127 While all these live in the same table, they are completely independent,
2128 and the hash code is computed differently for each of these. */
2130 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2132 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2133 for a node we are thinking about adding). */
2136 list_hasher::equal (tree t
, list_proxy
*proxy
)
2138 return (TREE_VALUE (t
) == proxy
->value
2139 && TREE_PURPOSE (t
) == proxy
->purpose
2140 && TREE_CHAIN (t
) == proxy
->chain
);
2143 /* Compute a hash code for a list (chain of TREE_LIST nodes
2144 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2145 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2148 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2150 hashval_t hashcode
= 0;
2153 hashcode
+= TREE_HASH (chain
);
2156 hashcode
+= TREE_HASH (value
);
2160 hashcode
+= TREE_HASH (purpose
);
2166 /* Hash an already existing TREE_LIST. */
2169 list_hasher::hash (tree t
)
2171 return list_hash_pieces (TREE_PURPOSE (t
),
2176 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2177 object for an identical list if one already exists. Otherwise, build a
2178 new one, and record it as the canonical object. */
2181 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2185 struct list_proxy proxy
;
2187 /* Hash the list node. */
2188 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2189 /* Create a proxy for the TREE_LIST we would like to create. We
2190 don't actually create it so as to avoid creating garbage. */
2191 proxy
.purpose
= purpose
;
2192 proxy
.value
= value
;
2193 proxy
.chain
= chain
;
2194 /* See if it is already in the table. */
2195 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2196 /* If not, create a new node. */
2198 *slot
= tree_cons (purpose
, value
, chain
);
2199 return (tree
) *slot
;
2202 /* Constructor for hashed lists. */
2205 hash_tree_chain (tree value
, tree chain
)
2207 return hash_tree_cons (NULL_TREE
, value
, chain
);
2211 debug_binfo (tree elem
)
2216 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2218 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2219 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2220 debug_tree (BINFO_TYPE (elem
));
2221 if (BINFO_VTABLE (elem
))
2222 fprintf (stderr
, "vtable decl \"%s\"\n",
2223 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2225 fprintf (stderr
, "no vtable decl yet\n");
2226 fprintf (stderr
, "virtuals:\n");
2227 virtuals
= BINFO_VIRTUALS (elem
);
2232 tree fndecl
= TREE_VALUE (virtuals
);
2233 fprintf (stderr
, "%s [%ld =? %ld]\n",
2234 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2235 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2237 virtuals
= TREE_CHAIN (virtuals
);
2241 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2242 the type of the result expression, if known, or NULL_TREE if the
2243 resulting expression is type-dependent. If TEMPLATE_P is true,
2244 NAME is known to be a template because the user explicitly used the
2245 "template" keyword after the "::".
2247 All SCOPE_REFs should be built by use of this function. */
2250 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2253 if (type
== error_mark_node
2254 || scope
== error_mark_node
2255 || name
== error_mark_node
)
2256 return error_mark_node
;
2257 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2258 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2259 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2260 PTRMEM_OK_P (t
) = true;
2262 t
= convert_from_reference (t
);
2266 /* Like check_qualified_type, but also check ref-qualifier, exception
2267 specification, and whether the return type was specified after the
2271 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2272 cp_ref_qualifier rqual
, tree raises
, bool late
)
2274 return (TYPE_QUALS (cand
) == type_quals
2275 && check_base_type (cand
, base
)
2276 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2278 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2279 && type_memfn_rqual (cand
) == rqual
);
2282 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2285 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2287 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2288 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2289 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2293 make_binding_vec (tree name
, unsigned clusters MEM_STAT_DECL
)
2295 /* Stored in an unsigned short, but we're limited to the number of
2297 gcc_checking_assert (clusters
<= (unsigned short)(~0));
2298 size_t length
= (offsetof (tree_binding_vec
, vec
)
2299 + clusters
* sizeof (binding_cluster
));
2300 tree vec
= ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT
);
2301 TREE_SET_CODE (vec
, BINDING_VECTOR
);
2302 BINDING_VECTOR_NAME (vec
) = name
;
2303 BINDING_VECTOR_ALLOC_CLUSTERS (vec
) = clusters
;
2304 BINDING_VECTOR_NUM_CLUSTERS (vec
) = 0;
2309 /* Make a raw overload node containing FN. */
2312 ovl_make (tree fn
, tree next
)
2314 tree result
= make_node (OVERLOAD
);
2316 if (TREE_CODE (fn
) == OVERLOAD
)
2317 OVL_NESTED_P (result
) = true;
2319 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2320 ? unknown_type_node
: TREE_TYPE (fn
));
2321 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2322 OVL_DEDUP_P (result
) = true;
2323 OVL_FUNCTION (result
) = fn
;
2324 OVL_CHAIN (result
) = next
;
2328 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is >
2329 zero if this is a using-decl. It is > 1 if we're exporting the
2330 using decl. USING_OR_HIDDEN is < 0, if FN is hidden. (A decl
2331 cannot be both using and hidden.) We keep the hidden decls first,
2332 but remaining ones are unordered. */
2335 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2337 tree result
= maybe_ovl
;
2338 tree insert_after
= NULL_TREE
;
2341 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2342 && OVL_HIDDEN_P (maybe_ovl
);
2343 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2345 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2346 insert_after
= maybe_ovl
;
2349 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2351 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2353 if (using_or_hidden
< 0)
2354 OVL_HIDDEN_P (maybe_ovl
) = true;
2355 if (using_or_hidden
> 0)
2357 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2358 if (using_or_hidden
> 1)
2359 OVL_EXPORT_P (maybe_ovl
) = true;
2367 OVL_CHAIN (insert_after
) = maybe_ovl
;
2368 TREE_TYPE (insert_after
) = unknown_type_node
;
2376 /* Skip any hidden names at the beginning of OVL. */
2379 ovl_skip_hidden (tree ovl
)
2381 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2382 ovl
= OVL_CHAIN (ovl
);
2387 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2390 ovl_iterator::reveal_node (tree overload
, tree node
)
2392 /* We cannot have returned NODE as part of a lookup overload, so we
2393 don't have to worry about preserving that. */
2395 OVL_HIDDEN_P (node
) = false;
2396 if (tree chain
= OVL_CHAIN (node
))
2397 if (TREE_CODE (chain
) == OVERLOAD
)
2399 if (OVL_HIDDEN_P (chain
))
2401 /* The node needs moving, and the simplest way is to remove it
2403 overload
= remove_node (overload
, node
);
2404 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2406 else if (OVL_DEDUP_P (chain
))
2407 OVL_DEDUP_P (node
) = true;
2412 /* NODE is on the overloads of OVL. Remove it.
2413 The removed node is unaltered and may continue to be iterated
2414 from (i.e. it is safe to remove a node from an overload one is
2415 currently iterating over). */
2418 ovl_iterator::remove_node (tree overload
, tree node
)
2420 tree
*slot
= &overload
;
2421 while (*slot
!= node
)
2424 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2426 slot
= &OVL_CHAIN (probe
);
2429 /* Stitch out NODE. We don't have to worry about now making a
2430 singleton overload (and consequently maybe setting its type),
2431 because all uses of this function will be followed by inserting a
2432 new node that must follow the place we've cut this out from. */
2433 if (TREE_CODE (node
) != OVERLOAD
)
2434 /* Cloned inherited ctors don't mark themselves as via_using. */
2437 *slot
= OVL_CHAIN (node
);
2442 /* Mark or unmark a lookup set. */
2445 lookup_mark (tree ovl
, bool val
)
2447 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2449 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2450 LOOKUP_SEEN_P (*iter
) = val
;
2454 /* Add a set of new FNS into a lookup. */
2457 lookup_add (tree fns
, tree lookup
)
2459 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2460 return error_mark_node
;
2462 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2464 lookup
= ovl_make (fns
, lookup
);
2465 OVL_LOOKUP_P (lookup
) = true;
2473 /* FNS is a new overload set, add them to LOOKUP, if they are not
2474 already present there. */
2477 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2480 for (tree next
, probe
= fns
; probe
; probe
= next
)
2485 if (TREE_CODE (probe
) == OVERLOAD
)
2487 fn
= OVL_FUNCTION (probe
);
2488 next
= OVL_CHAIN (probe
);
2491 if (!LOOKUP_SEEN_P (fn
))
2492 LOOKUP_SEEN_P (fn
) = true;
2495 /* This function was already seen. Insert all the
2496 predecessors onto the lookup. */
2497 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2499 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2500 /* Propagate OVL_USING, but OVL_HIDDEN &
2501 OVL_DEDUP_P don't matter. */
2502 if (OVL_USING_P (fns
))
2503 OVL_USING_P (lookup
) = true;
2506 /* And now skip this function. */
2512 /* We ended in a set of new functions. Add them all in one go. */
2513 lookup
= lookup_add (fns
, lookup
);
2518 /* Returns nonzero if X is an expression for a (possibly overloaded)
2519 function. If "f" is a function or function template, "f", "c->f",
2520 "c.f", "C::f", and "f<int>" will all be considered possibly
2521 overloaded functions. Returns 2 if the function is actually
2522 overloaded, i.e., if it is impossible to know the type of the
2523 function without performing overload resolution. */
2526 is_overloaded_fn (tree x
)
2528 STRIP_ANY_LOCATION_WRAPPER (x
);
2530 /* A baselink is also considered an overloaded function. */
2531 if (TREE_CODE (x
) == OFFSET_REF
2532 || TREE_CODE (x
) == COMPONENT_REF
)
2533 x
= TREE_OPERAND (x
, 1);
2534 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2535 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2536 x
= TREE_OPERAND (x
, 0);
2538 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2539 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2545 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2546 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2550 dependent_name (tree x
)
2552 /* FIXME a dependent name must be unqualified, but this function doesn't
2553 distinguish between qualified and unqualified identifiers. */
2554 if (identifier_p (x
))
2556 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2557 x
= TREE_OPERAND (x
, 0);
2559 return OVL_NAME (x
);
2563 /* Returns true iff X is an expression for an overloaded function
2564 whose type cannot be known without performing overload
2568 really_overloaded_fn (tree x
)
2570 return is_overloaded_fn (x
) == 2;
2573 /* Get the overload set FROM refers to. Returns NULL if it's not an
2577 maybe_get_fns (tree from
)
2579 STRIP_ANY_LOCATION_WRAPPER (from
);
2581 /* A baselink is also considered an overloaded function. */
2582 if (TREE_CODE (from
) == OFFSET_REF
2583 || TREE_CODE (from
) == COMPONENT_REF
)
2584 from
= TREE_OPERAND (from
, 1);
2585 if (BASELINK_P (from
))
2586 from
= BASELINK_FUNCTIONS (from
);
2587 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2588 from
= TREE_OPERAND (from
, 0);
2596 /* FROM refers to an overload set. Return that set (or die). */
2601 tree res
= maybe_get_fns (from
);
2607 /* Return the first function of the overload set FROM refers to. */
2610 get_first_fn (tree from
)
2612 return OVL_FIRST (get_fns (from
));
2615 /* Return the scope where the overloaded functions OVL were found. */
2618 ovl_scope (tree ovl
)
2620 if (TREE_CODE (ovl
) == OFFSET_REF
2621 || TREE_CODE (ovl
) == COMPONENT_REF
)
2622 ovl
= TREE_OPERAND (ovl
, 1);
2623 if (TREE_CODE (ovl
) == BASELINK
)
2624 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2625 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2626 ovl
= TREE_OPERAND (ovl
, 0);
2627 /* Skip using-declarations. */
2628 lkp_iterator
iter (ovl
);
2631 while (iter
.using_p () && ++iter
);
2633 return CP_DECL_CONTEXT (ovl
);
2636 #define PRINT_RING_SIZE 4
2639 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2641 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2642 static char *print_ring
[PRINT_RING_SIZE
];
2643 static bool trans_ring
[PRINT_RING_SIZE
];
2644 static int ring_counter
;
2647 /* Only cache functions. */
2649 || TREE_CODE (decl
) != FUNCTION_DECL
2650 || DECL_LANG_SPECIFIC (decl
) == 0)
2651 return lang_decl_name (decl
, v
, translate
);
2653 /* See if this print name is lying around. */
2654 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2655 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2656 /* yes, so return it. */
2657 return print_ring
[i
];
2659 if (++ring_counter
== PRINT_RING_SIZE
)
2662 if (current_function_decl
!= NULL_TREE
)
2664 /* There may be both translated and untranslated versions of the
2666 for (i
= 0; i
< 2; i
++)
2668 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2670 if (ring_counter
== PRINT_RING_SIZE
)
2673 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2676 free (print_ring
[ring_counter
]);
2678 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2679 uid_ring
[ring_counter
] = DECL_UID (decl
);
2680 trans_ring
[ring_counter
] = translate
;
2681 return print_ring
[ring_counter
];
2685 cxx_printable_name (tree decl
, int v
)
2687 return cxx_printable_name_internal (decl
, v
, false);
2691 cxx_printable_name_translate (tree decl
, int v
)
2693 return cxx_printable_name_internal (decl
, v
, true);
2696 /* Return the canonical version of exception-specification RAISES for a C++17
2697 function type, for use in type comparison and building TYPE_CANONICAL. */
2700 canonical_eh_spec (tree raises
)
2702 if (raises
== NULL_TREE
)
2704 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2705 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2706 || uses_template_parms (raises
)
2707 || uses_template_parms (TREE_PURPOSE (raises
)))
2708 /* Keep a dependent or deferred exception specification. */
2710 else if (nothrow_spec_p (raises
))
2711 /* throw() -> noexcept. */
2712 return noexcept_true_spec
;
2714 /* For C++17 type matching, anything else -> nothing. */
2719 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2720 tree raises
, bool late
)
2722 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2724 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2727 tree v
= TYPE_MAIN_VARIANT (type
);
2728 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2729 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2732 /* Need to build a new variant. */
2733 v
= build_variant_type_copy (type
);
2734 if (!TYPE_DEPENDENT_P (v
))
2735 /* We no longer know that it's not type-dependent. */
2736 TYPE_DEPENDENT_P_VALID (v
) = false;
2737 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2738 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2741 case REF_QUAL_RVALUE
:
2742 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2743 FUNCTION_REF_QUALIFIED (v
) = 1;
2745 case REF_QUAL_LVALUE
:
2746 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2747 FUNCTION_REF_QUALIFIED (v
) = 1;
2750 FUNCTION_REF_QUALIFIED (v
) = 0;
2754 /* Canonicalize the exception specification. */
2755 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2757 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2758 /* Propagate structural equality. */
2759 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2760 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2761 /* Build the underlying canonical type, since it is different
2763 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2766 /* T is its own canonical type. */
2767 TYPE_CANONICAL (v
) = v
;
2772 /* TYPE is a function or method type with a deferred exception
2773 specification that has been parsed to RAISES. Fixup all the type
2774 variants that are affected in place. Via decltype &| noexcept
2775 tricks, the unparsed spec could have escaped into the type system.
2776 The general case is hard to fixup canonical types for. */
2779 fixup_deferred_exception_variants (tree type
, tree raises
)
2781 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2782 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2784 gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original
));
2786 /* Though sucky, this walk will process the canonical variants
2788 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2789 variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2790 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2792 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2794 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2796 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2797 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2799 tree v
= TYPE_MAIN_VARIANT (type
);
2800 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2801 if (TYPE_CANONICAL (v
) == v
2802 && cp_check_qualified_type (v
, variant
, var_quals
,
2805 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2808 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2810 TYPE_CANONICAL (variant
) = v
;
2813 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2817 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2818 listed in RAISES. */
2821 build_exception_variant (tree type
, tree raises
)
2823 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2824 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2825 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2828 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2829 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2833 bind_template_template_parm (tree t
, tree newargs
)
2835 tree decl
= TYPE_NAME (t
);
2838 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2839 decl
= build_decl (input_location
,
2840 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2841 SET_DECL_TEMPLATE_PARM_P (decl
);
2843 /* These nodes have to be created to reflect new TYPE_DECL and template
2845 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2846 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2847 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2848 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2850 TREE_TYPE (decl
) = t2
;
2851 TYPE_NAME (t2
) = decl
;
2852 TYPE_STUB_DECL (t2
) = decl
;
2854 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2859 /* Called from count_trees via walk_tree. */
2862 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2872 /* Debugging function for measuring the rough complexity of a tree
2876 count_trees (tree t
)
2879 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2883 /* Called from verify_stmt_tree via walk_tree. */
2886 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2889 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2890 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2893 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2896 /* If this statement is already present in the hash table, then
2897 there is a circularity in the statement tree. */
2898 gcc_assert (!statements
->find (t
));
2900 slot
= statements
->find_slot (t
, INSERT
);
2906 /* Debugging function to check that the statement T has not been
2907 corrupted. For now, this function simply checks that T contains no
2911 verify_stmt_tree (tree t
)
2913 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2914 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2917 /* Check if the type T depends on a type with no linkage and if so,
2918 return it. If RELAXED_P then do not consider a class type declared
2919 within a vague-linkage function to have no linkage. Remember:
2920 no-linkage is not the same as internal-linkage*/
2923 no_linkage_check (tree t
, bool relaxed_p
)
2927 /* Lambda types that don't have mangling scope have no linkage. We
2928 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2929 when we get here from pushtag none of the lambda information is
2930 set up yet, so we want to assume that the lambda has linkage and
2931 fix it up later if not. We need to check this even in templates so
2932 that we properly handle a lambda-expression in the signature. */
2933 if (LAMBDA_TYPE_P (t
)
2934 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2936 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2941 /* Otherwise there's no point in checking linkage on template functions; we
2942 can't know their complete types. */
2943 if (processing_template_decl
)
2946 switch (TREE_CODE (t
))
2949 if (TYPE_PTRMEMFUNC_P (t
))
2953 if (!CLASS_TYPE_P (t
))
2957 /* Only treat unnamed types as having no linkage if they're at
2958 namespace scope. This is core issue 966. */
2959 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2962 for (r
= CP_TYPE_CONTEXT (t
); ; )
2964 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2965 have linkage, or we might just be in an anonymous namespace.
2966 If we're in a TREE_PUBLIC class, we have linkage. */
2967 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2968 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2969 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2971 if (!relaxed_p
|| !vague_linkage_p (r
))
2974 r
= CP_DECL_CONTEXT (r
);
2984 case REFERENCE_TYPE
:
2986 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2990 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2994 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2999 tree parm
= TYPE_ARG_TYPES (t
);
3000 if (TREE_CODE (t
) == METHOD_TYPE
)
3001 /* The 'this' pointer isn't interesting; a method has the same
3002 linkage (or lack thereof) as its enclosing class. */
3003 parm
= TREE_CHAIN (parm
);
3005 parm
&& parm
!= void_list_node
;
3006 parm
= TREE_CHAIN (parm
))
3008 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
3012 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
3020 extern int depth_reached
;
3023 cxx_print_statistics (void)
3025 print_template_statistics ();
3026 if (GATHER_STATISTICS
)
3027 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
3031 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3032 (which is an ARRAY_TYPE). This counts only elements of the top
3036 array_type_nelts_top (tree type
)
3038 return fold_build2_loc (input_location
,
3039 PLUS_EXPR
, sizetype
,
3040 array_type_nelts (type
),
3044 /* Return, as an INTEGER_CST node, the number of elements for TYPE
3045 (which is an ARRAY_TYPE). This one is a recursive count of all
3046 ARRAY_TYPEs that are clumped together. */
3049 array_type_nelts_total (tree type
)
3051 tree sz
= array_type_nelts_top (type
);
3052 type
= TREE_TYPE (type
);
3053 while (TREE_CODE (type
) == ARRAY_TYPE
)
3055 tree n
= array_type_nelts_top (type
);
3056 sz
= fold_build2_loc (input_location
,
3057 MULT_EXPR
, sizetype
, sz
, n
);
3058 type
= TREE_TYPE (type
);
3063 /* Return true if FNDECL is std::source_location::current () method. */
3066 source_location_current_p (tree fndecl
)
3068 gcc_checking_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
3069 && DECL_IMMEDIATE_FUNCTION_P (fndecl
));
3070 if (DECL_NAME (fndecl
) == NULL_TREE
3071 || TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
3072 || TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != RECORD_TYPE
3073 || DECL_CONTEXT (fndecl
) != TREE_TYPE (TREE_TYPE (fndecl
))
3074 || !id_equal (DECL_NAME (fndecl
), "current"))
3077 tree source_location
= DECL_CONTEXT (fndecl
);
3078 if (TYPE_NAME (source_location
) == NULL_TREE
3079 || TREE_CODE (TYPE_NAME (source_location
)) != TYPE_DECL
3080 || TYPE_IDENTIFIER (source_location
) == NULL_TREE
3081 || !id_equal (TYPE_IDENTIFIER (source_location
),
3083 || !decl_in_std_namespace_p (TYPE_NAME (source_location
)))
3091 splay_tree target_remap
;
3092 bool clear_location
;
3095 /* Called from break_out_target_exprs via mapcar. */
3098 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
3100 bot_data
&data
= *(bot_data
*)data_
;
3101 splay_tree target_remap
= data
.target_remap
;
3104 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
3106 /* There can't be any TARGET_EXPRs or their slot variables below this
3107 point. But we must make a copy, in case subsequent processing
3108 alters any part of it. For example, during gimplification a cast
3109 of the form (T) &X::f (where "f" is a member function) will lead
3110 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3112 *tp
= unshare_expr (t
);
3115 if (TREE_CODE (t
) == TARGET_EXPR
)
3119 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3121 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3122 tf_warning_or_error
);
3123 if (u
== error_mark_node
)
3125 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3126 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3129 u
= force_target_expr (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3130 tf_warning_or_error
);
3132 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3133 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3134 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3136 /* Map the old variable to the new one. */
3137 splay_tree_insert (target_remap
,
3138 (splay_tree_key
) TREE_OPERAND (t
, 0),
3139 (splay_tree_value
) TREE_OPERAND (u
, 0));
3141 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3142 data
.clear_location
);
3143 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3144 return error_mark_node
;
3146 /* Replace the old expression with the new version. */
3148 /* We don't have to go below this point; the recursive call to
3149 break_out_target_exprs will have handled anything below this
3154 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3157 splay_tree_node n
= splay_tree_lookup (target_remap
,
3158 (splay_tree_key
) t
);
3161 *tp
= (tree
)n
->value
;
3166 copy_tree_r (tp
, walk_subtrees
, NULL
);
3167 splay_tree_insert (target_remap
,
3169 (splay_tree_value
)*tp
);
3170 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3171 splay_tree_insert (target_remap
,
3172 (splay_tree_key
)*tp
,
3173 (splay_tree_value
)*tp
);
3177 if (TREE_CODE (*tp
) == DECL_EXPR
3178 && VAR_P (DECL_EXPR_DECL (*tp
))
3179 && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp
))
3180 && !TREE_STATIC (DECL_EXPR_DECL (*tp
)))
3184 = splay_tree_lookup (target_remap
,
3185 (splay_tree_key
) DECL_EXPR_DECL (*tp
));
3187 t
= (tree
) n
->value
;
3190 t
= create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp
)));
3191 DECL_INITIAL (t
) = DECL_INITIAL (DECL_EXPR_DECL (*tp
));
3192 splay_tree_insert (target_remap
,
3193 (splay_tree_key
) DECL_EXPR_DECL (*tp
),
3194 (splay_tree_value
) t
);
3196 copy_tree_r (tp
, walk_subtrees
, NULL
);
3197 DECL_EXPR_DECL (*tp
) = t
;
3198 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3199 SET_EXPR_LOCATION (*tp
, input_location
);
3202 if (TREE_CODE (*tp
) == BIND_EXPR
&& BIND_EXPR_VARS (*tp
))
3204 copy_tree_r (tp
, walk_subtrees
, NULL
);
3205 for (tree
*p
= &BIND_EXPR_VARS (*tp
); *p
; p
= &DECL_CHAIN (*p
))
3207 gcc_assert (VAR_P (*p
) && DECL_ARTIFICIAL (*p
) && !TREE_STATIC (*p
));
3208 tree t
= create_temporary_var (TREE_TYPE (*p
));
3209 DECL_INITIAL (t
) = DECL_INITIAL (*p
);
3210 DECL_CHAIN (t
) = DECL_CHAIN (*p
);
3211 splay_tree_insert (target_remap
, (splay_tree_key
) *p
,
3212 (splay_tree_value
) t
);
3215 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3216 SET_EXPR_LOCATION (*tp
, input_location
);
3220 /* Make a copy of this node. */
3221 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3222 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3223 if (!processing_template_decl
)
3224 set_flags_from_callee (*tp
);
3225 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3226 SET_EXPR_LOCATION (*tp
, input_location
);
3230 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3231 DATA is really a splay-tree mapping old variables to new
3235 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3237 bot_data
&data
= *(bot_data
*)data_
;
3238 splay_tree target_remap
= data
.target_remap
;
3242 splay_tree_node n
= splay_tree_lookup (target_remap
,
3243 (splay_tree_key
) *t
);
3245 *t
= (tree
) n
->value
;
3247 else if (TREE_CODE (*t
) == PARM_DECL
3248 && DECL_NAME (*t
) == this_identifier
3249 && !DECL_CONTEXT (*t
))
3251 /* In an NSDMI we need to replace the 'this' parameter we used for
3252 parsing with the real one for this function. */
3253 *t
= current_class_ptr
;
3255 else if (TREE_CODE (*t
) == CONVERT_EXPR
3256 && CONVERT_EXPR_VBASE_PATH (*t
))
3258 /* In an NSDMI build_base_path defers building conversions to morally
3259 virtual bases, and we handle it here. */
3260 tree basetype
= TREE_TYPE (*t
);
3261 *t
= convert_to_base (TREE_OPERAND (*t
, 0), basetype
,
3262 /*check_access=*/false, /*nonnull=*/true,
3263 tf_warning_or_error
);
3269 /* When we parse a default argument expression, we may create
3270 temporary variables via TARGET_EXPRs. When we actually use the
3271 default-argument expression, we make a copy of the expression
3272 and replace the temporaries with appropriate local versions.
3274 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3278 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3280 static int target_remap_count
;
3281 static splay_tree target_remap
;
3283 if (!target_remap_count
++)
3284 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3285 /*splay_tree_delete_key_fn=*/NULL
,
3286 /*splay_tree_delete_value_fn=*/NULL
);
3287 bot_data data
= { target_remap
, clear_location
};
3288 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3289 t
= error_mark_node
;
3290 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3292 if (!--target_remap_count
)
3294 splay_tree_delete (target_remap
);
3295 target_remap
= NULL
;
3301 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3302 which we expect to have type TYPE. */
3305 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3307 if (index
== NULL_TREE
)
3308 /* Can't refer to a particular member of a vector. */
3310 else if (TREE_CODE (index
) == INTEGER_CST
)
3311 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3313 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3314 /*reference*/false, tf_none
);
3317 tree objtype
= TREE_TYPE (obj
);
3318 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3320 /* When the destination object refers to a flexible array member
3321 verify that it matches the type of the source object except
3322 for its domain and qualifiers. */
3323 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3324 TYPE_MAIN_VARIANT (objtype
),
3325 COMPARE_REDECLARATION
));
3328 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3334 struct replace_placeholders_t
3336 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3337 tree exp
; /* The outermost exp. */
3338 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3339 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3342 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3343 build up subexpressions as we go deeper. */
3346 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3348 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3351 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3353 *walk_subtrees
= false;
3357 switch (TREE_CODE (*t
))
3359 case PLACEHOLDER_EXPR
:
3362 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3364 x
= TREE_OPERAND (x
, 0))
3365 gcc_assert (handled_component_p (x
));
3366 *t
= unshare_expr (x
);
3367 *walk_subtrees
= false;
3374 constructor_elt
*ce
;
3375 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3376 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3377 other than the d->exp one, those have PLACEHOLDER_EXPRs
3378 related to another object. */
3379 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3381 || d
->pset
->add (*t
))
3383 *walk_subtrees
= false;
3386 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3388 tree
*valp
= &ce
->value
;
3389 tree type
= TREE_TYPE (*valp
);
3392 /* Elements with RANGE_EXPR index shouldn't have any
3393 placeholders in them. */
3394 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3397 if (TREE_CODE (*valp
) == CONSTRUCTOR
3398 && AGGREGATE_TYPE_P (type
))
3400 /* If we're looking at the initializer for OBJ, then build
3401 a sub-object reference. If we're looking at an
3402 initializer for another object, just pass OBJ down. */
3403 if (same_type_ignoring_top_level_qualifiers_p
3404 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3405 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3406 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3407 valp
= &TARGET_EXPR_INITIAL (*valp
);
3410 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3413 *walk_subtrees
= false;
3418 if (d
->pset
->add (*t
))
3419 *walk_subtrees
= false;
3426 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3427 a PLACEHOLDER_EXPR has been encountered. */
3430 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3432 /* This is only relevant for C++14. */
3433 if (cxx_dialect
< cxx14
)
3436 /* If the object isn't a (member of a) class, do nothing. */
3438 while (handled_component_p (op0
))
3439 op0
= TREE_OPERAND (op0
, 0);
3440 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3444 if (TREE_CODE (exp
) == TARGET_EXPR
)
3445 tp
= &TARGET_EXPR_INITIAL (exp
);
3446 hash_set
<tree
> pset
;
3447 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3448 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3450 *seen_p
= data
.seen
;
3454 /* Callback function for find_placeholders. */
3457 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3459 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3461 *walk_subtrees
= false;
3465 switch (TREE_CODE (*t
))
3467 case PLACEHOLDER_EXPR
:
3471 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3472 *walk_subtrees
= false;
3482 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3483 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3486 find_placeholders (tree exp
)
3488 /* This is only relevant for C++14. */
3489 if (cxx_dialect
< cxx14
)
3492 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3495 /* Similar to `build_nt', but for template definitions of dependent
3499 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3506 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3510 t
= make_node (code
);
3511 SET_EXPR_LOCATION (t
, loc
);
3512 length
= TREE_CODE_LENGTH (code
);
3514 for (i
= 0; i
< length
; i
++)
3515 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3521 /* Similar to `build', but for template definitions. */
3524 build_min (enum tree_code code
, tree tt
, ...)
3531 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3535 t
= make_node (code
);
3536 length
= TREE_CODE_LENGTH (code
);
3539 for (i
= 0; i
< length
; i
++)
3541 tree x
= va_arg (p
, tree
);
3542 TREE_OPERAND (t
, i
) = x
;
3543 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3544 TREE_SIDE_EFFECTS (t
) = 1;
3552 /* Similar to `build', but for template definitions of non-dependent
3553 expressions. NON_DEP is the non-dependent expression that has been
3557 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3564 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3566 va_start (p
, non_dep
);
3568 if (REFERENCE_REF_P (non_dep
))
3569 non_dep
= TREE_OPERAND (non_dep
, 0);
3571 t
= make_node (code
);
3572 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3573 length
= TREE_CODE_LENGTH (code
);
3574 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3575 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3577 for (i
= 0; i
< length
; i
++)
3578 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3581 return convert_from_reference (t
);
3584 /* Similar to build_min_nt, but call expressions */
3587 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3592 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3593 CALL_EXPR_FN (ret
) = fn
;
3594 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3595 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3596 CALL_EXPR_ARG (ret
, ix
) = t
;
3601 /* Similar to `build_min_nt_call_vec', but for template definitions of
3602 non-dependent expressions. NON_DEP is the non-dependent expression
3603 that has been built. */
3606 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3608 tree t
= build_min_nt_call_vec (fn
, argvec
);
3609 if (REFERENCE_REF_P (non_dep
))
3610 non_dep
= TREE_OPERAND (non_dep
, 0);
3611 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3612 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3613 return convert_from_reference (t
);
3616 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3617 a call to an operator overload. OP is the operator that has been
3618 overloaded. NON_DEP is the non-dependent expression that's been built,
3619 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3620 the overload that NON_DEP is calling. */
3623 build_min_non_dep_op_overload (enum tree_code op
,
3628 int nargs
, expected_nargs
;
3631 non_dep
= extract_call_expr (non_dep
);
3633 nargs
= call_expr_nargs (non_dep
);
3635 expected_nargs
= cp_tree_code_length (op
);
3636 if ((op
== POSTINCREMENT_EXPR
3637 || op
== POSTDECREMENT_EXPR
)
3638 /* With -fpermissive non_dep could be operator++(). */
3639 && (!flag_permissive
|| nargs
!= expected_nargs
))
3640 expected_nargs
+= 1;
3641 gcc_assert (nargs
== expected_nargs
);
3644 va_start (p
, overload
);
3646 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3649 for (int i
= 0; i
< nargs
; i
++)
3651 tree arg
= va_arg (p
, tree
);
3652 vec_safe_push (args
, arg
);
3655 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3657 tree object
= va_arg (p
, tree
);
3658 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3659 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3660 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3661 object
, method
, NULL_TREE
);
3662 for (int i
= 1; i
< nargs
; i
++)
3664 tree arg
= va_arg (p
, tree
);
3665 vec_safe_push (args
, arg
);
3672 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3674 tree call_expr
= extract_call_expr (call
);
3675 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3676 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3677 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3678 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3683 /* Similar to above build_min_non_dep_op_overload, but arguments
3684 are taken from ARGS vector. */
3687 build_min_non_dep_op_overload (tree non_dep
, tree overload
, tree object
,
3688 vec
<tree
, va_gc
> *args
)
3690 non_dep
= extract_call_expr (non_dep
);
3692 unsigned int nargs
= call_expr_nargs (non_dep
);
3693 gcc_assert (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
);
3694 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3695 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3696 tree fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3697 object
, method
, NULL_TREE
);
3699 gcc_assert (vec_safe_length (args
) == nargs
);
3701 tree call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3703 tree call_expr
= extract_call_expr (call
);
3704 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3705 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3706 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3707 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3712 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3715 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3717 unsigned len
= vec_safe_length (old_vec
);
3718 gcc_assert (idx
<= len
);
3720 vec
<tree
, va_gc
> *new_vec
= NULL
;
3721 vec_alloc (new_vec
, len
+ 1);
3724 for (i
= 0; i
< len
; ++i
)
3727 new_vec
->quick_push (elt
);
3728 new_vec
->quick_push ((*old_vec
)[i
]);
3731 new_vec
->quick_push (elt
);
3737 get_type_decl (tree t
)
3739 if (TREE_CODE (t
) == TYPE_DECL
)
3742 return TYPE_STUB_DECL (t
);
3743 gcc_assert (t
== error_mark_node
);
3747 /* Returns the namespace that contains DECL, whether directly or
3751 decl_namespace_context (tree decl
)
3755 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3757 else if (TYPE_P (decl
))
3758 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3760 decl
= CP_DECL_CONTEXT (decl
);
3764 /* Returns true if decl is within an anonymous namespace, however deeply
3765 nested, or false otherwise. */
3768 decl_anon_ns_mem_p (const_tree decl
)
3770 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3772 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3774 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3776 decl
= CP_DECL_CONTEXT (decl
);
3778 return !TREE_PUBLIC (decl
);
3781 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3782 CALL_EXPRS. Return whether they are equivalent. */
3785 called_fns_equal (tree t1
, tree t2
)
3787 /* Core 1321: dependent names are equivalent even if the overload sets
3788 are different. But do compare explicit template arguments. */
3789 tree name1
= dependent_name (t1
);
3790 tree name2
= dependent_name (t2
);
3793 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3798 /* FIXME dependent_name currently returns an unqualified name regardless
3799 of whether the function was named with a qualified- or unqualified-id.
3800 Until that's fixed, check that we aren't looking at overload sets from
3801 different scopes. */
3802 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3803 && (DECL_CONTEXT (get_first_fn (t1
))
3804 != DECL_CONTEXT (get_first_fn (t2
))))
3807 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3808 targs1
= TREE_OPERAND (t1
, 1);
3809 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3810 targs2
= TREE_OPERAND (t2
, 1);
3811 return cp_tree_equal (targs1
, targs2
);
3814 return cp_tree_equal (t1
, t2
);
3817 /* Return truthvalue of whether T1 is the same tree structure as T2.
3818 Return 1 if they are the same. Return 0 if they are different. */
3821 cp_tree_equal (tree t1
, tree t2
)
3823 enum tree_code code1
, code2
;
3830 code1
= TREE_CODE (t1
);
3831 code2
= TREE_CODE (t2
);
3836 if (CONSTANT_CLASS_P (t1
)
3837 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3843 /* There's only a single VOID_CST node, so we should never reach
3848 return tree_int_cst_equal (t1
, t2
);
3851 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3854 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3855 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3856 TREE_STRING_LENGTH (t1
));
3859 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3860 TREE_FIXED_CST (t2
));
3863 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3864 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3867 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3870 /* We need to do this when determining whether or not two
3871 non-type pointer to member function template arguments
3873 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3874 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3879 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3881 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3882 if (!cp_tree_equal (field
, elt2
->index
)
3883 || !cp_tree_equal (value
, elt2
->value
))
3890 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3892 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3894 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3897 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3901 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
3904 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3907 call_expr_arg_iterator iter1
, iter2
;
3908 init_call_expr_arg_iterator (t1
, &iter1
);
3909 init_call_expr_arg_iterator (t2
, &iter2
);
3910 if (iter1
.n
!= iter2
.n
)
3913 while (more_call_expr_args_p (&iter1
))
3915 tree arg1
= next_call_expr_arg (&iter1
);
3916 tree arg2
= next_call_expr_arg (&iter2
);
3918 gcc_checking_assert (arg1
&& arg2
);
3919 if (!cp_tree_equal (arg1
, arg2
))
3928 tree o1
= TREE_OPERAND (t1
, 0);
3929 tree o2
= TREE_OPERAND (t2
, 0);
3931 /* Special case: if either target is an unallocated VAR_DECL,
3932 it means that it's going to be unified with whatever the
3933 TARGET_EXPR is really supposed to initialize, so treat it
3934 as being equivalent to anything. */
3935 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3936 && !DECL_RTL_SET_P (o1
))
3938 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3939 && !DECL_RTL_SET_P (o2
))
3941 else if (!cp_tree_equal (o1
, o2
))
3944 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3948 /* For comparing uses of parameters in late-specified return types
3949 with an out-of-class definition of the function, but can also come
3950 up for expressions that involve 'this' in a member function
3953 if (comparing_specializations
3954 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
3955 /* When comparing hash table entries, only an exact match is
3956 good enough; we don't want to replace 'this' with the
3957 version from another function. But be more flexible
3958 with parameters with identical contexts. */
3961 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3963 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3965 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3967 if (DECL_ARTIFICIAL (t1
)
3968 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3969 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3979 case IDENTIFIER_NODE
:
3982 case DEFERRED_PARSE
:
3986 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3987 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3988 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3989 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3990 BASELINK_FUNCTIONS (t2
)));
3992 case TEMPLATE_PARM_INDEX
:
3993 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3994 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3995 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3996 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3997 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3998 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
4000 case TEMPLATE_ID_EXPR
:
4001 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4003 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
4007 case CONSTRAINT_INFO
:
4008 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
4009 CI_ASSOCIATED_CONSTRAINTS (t2
));
4012 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
4013 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
4014 CHECK_CONSTR_ARGS (t2
)));
4017 /* These are template args. Really we should be getting the
4018 caller to do this as it knows it to be true. */
4019 if (!comp_template_args (t1
, t2
, NULL
, NULL
, false))
4026 tree o1
= TREE_OPERAND (t1
, 0);
4027 tree o2
= TREE_OPERAND (t2
, 0);
4029 if (code1
== SIZEOF_EXPR
)
4031 if (SIZEOF_EXPR_TYPE_P (t1
))
4032 o1
= TREE_TYPE (o1
);
4033 if (SIZEOF_EXPR_TYPE_P (t2
))
4034 o2
= TREE_TYPE (o2
);
4036 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
4039 if (TREE_CODE (o1
) != TREE_CODE (o2
))
4042 if (ARGUMENT_PACK_P (o1
))
4043 return template_args_equal (o1
, o2
);
4044 else if (TYPE_P (o1
))
4045 return same_type_p (o1
, o2
);
4047 return cp_tree_equal (o1
, o2
);
4052 tree t1_op1
, t2_op1
;
4054 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
4057 t1_op1
= TREE_OPERAND (t1
, 1);
4058 t2_op1
= TREE_OPERAND (t2
, 1);
4059 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
4062 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
4066 /* Two pointer-to-members are the same if they point to the same
4067 field or function in the same class. */
4068 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
4071 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
4075 /* Two overloads. Must be exactly the same set of decls. */
4076 lkp_iterator
first (t1
);
4077 lkp_iterator
second (t2
);
4079 for (; first
&& second
; ++first
, ++second
)
4080 if (*first
!= *second
)
4082 return !(first
|| second
);
4086 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
4088 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
4089 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
4091 case NON_LVALUE_EXPR
:
4092 case VIEW_CONVERT_EXPR
:
4093 /* Used for location wrappers with possibly NULL types. */
4094 if (!TREE_TYPE (t1
) || !TREE_TYPE (t2
))
4096 if (TREE_TYPE (t1
) || TREE_TYPE (t2
))
4103 case STATIC_CAST_EXPR
:
4104 case REINTERPRET_CAST_EXPR
:
4105 case CONST_CAST_EXPR
:
4106 case DYNAMIC_CAST_EXPR
:
4107 case IMPLICIT_CONV_EXPR
:
4111 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
4113 /* Now compare operands as usual. */
4116 case DEFERRED_NOEXCEPT
:
4117 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
4118 DEFERRED_NOEXCEPT_PATTERN (t2
))
4119 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
4120 DEFERRED_NOEXCEPT_ARGS (t2
)));
4123 /* Two lambda-expressions are never considered equivalent. */
4126 case TYPE_ARGUMENT_PACK
:
4127 case NONTYPE_ARGUMENT_PACK
:
4129 tree p1
= ARGUMENT_PACK_ARGS (t1
);
4130 tree p2
= ARGUMENT_PACK_ARGS (t2
);
4131 int len
= TREE_VEC_LENGTH (p1
);
4132 if (TREE_VEC_LENGTH (p2
) != len
)
4135 for (int ix
= 0; ix
!= len
; ix
++)
4136 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
4137 TREE_VEC_ELT (p2
, ix
)))
4142 case EXPR_PACK_EXPANSION
:
4143 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
4144 PACK_EXPANSION_PATTERN (t2
)))
4146 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
4147 PACK_EXPANSION_EXTRA_ARGS (t2
)))
4155 switch (TREE_CODE_CLASS (code1
))
4159 case tcc_comparison
:
4160 case tcc_expression
:
4165 int n
= cp_tree_operand_length (t1
);
4166 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
4167 && n
!= TREE_OPERAND_LENGTH (t2
))
4170 for (int i
= 0; i
< n
; ++i
)
4171 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
4178 return same_type_p (t1
, t2
);
4184 /* We can get here with --disable-checking. */
4188 /* The type of ARG when used as an lvalue. */
4191 lvalue_type (tree arg
)
4193 tree type
= TREE_TYPE (arg
);
4197 /* The type of ARG for printing error messages; denote lvalues with
4201 error_type (tree arg
)
4203 tree type
= TREE_TYPE (arg
);
4205 if (TREE_CODE (type
) == ARRAY_TYPE
)
4207 else if (TREE_CODE (type
) == ERROR_MARK
)
4209 else if (lvalue_p (arg
))
4210 type
= build_reference_type (lvalue_type (arg
));
4211 else if (MAYBE_CLASS_TYPE_P (type
))
4212 type
= lvalue_type (arg
);
4217 /* Does FUNCTION use a variable-length argument list? */
4220 varargs_function_p (const_tree function
)
4222 return stdarg_p (TREE_TYPE (function
));
4225 /* Returns 1 if decl is a member of a class. */
4228 member_p (const_tree decl
)
4230 const_tree
const ctx
= DECL_CONTEXT (decl
);
4231 return (ctx
&& TYPE_P (ctx
));
4234 /* Create a placeholder for member access where we don't actually have an
4235 object that the access is against. For a general declval<T> equivalent,
4236 use build_stub_object instead. */
4239 build_dummy_object (tree type
)
4241 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4242 return cp_build_fold_indirect_ref (decl
);
4245 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4246 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4247 binfo path from current_class_type to TYPE, or 0. */
4250 maybe_dummy_object (tree type
, tree
* binfop
)
4254 tree current
= current_nonlambda_class_type ();
4257 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4258 tf_warning_or_error
)))
4262 /* Reference from a nested class member function. */
4264 binfo
= TYPE_BINFO (type
);
4270 if (current_class_ref
4271 /* current_class_ref might not correspond to current_class_type if
4272 we're in tsubst_default_argument or a lambda-declarator; in either
4273 case, we want to use current_class_ref if it matches CONTEXT. */
4274 && (same_type_ignoring_top_level_qualifiers_p
4275 (TREE_TYPE (current_class_ref
), context
)))
4276 decl
= current_class_ref
;
4278 decl
= build_dummy_object (context
);
4283 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4286 is_dummy_object (const_tree ob
)
4288 if (INDIRECT_REF_P (ob
))
4289 ob
= TREE_OPERAND (ob
, 0);
4290 return (TREE_CODE (ob
) == CONVERT_EXPR
4291 && TREE_OPERAND (ob
, 0) == void_node
);
4294 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4297 is_byte_access_type (tree type
)
4299 type
= TYPE_MAIN_VARIANT (type
);
4300 if (type
== char_type_node
4301 || type
== unsigned_char_type_node
)
4304 return (TREE_CODE (type
) == ENUMERAL_TYPE
4305 && TYPE_CONTEXT (type
) == std_node
4306 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4309 /* Returns true if TYPE is unsigned char or std::byte. */
4312 is_byte_access_type_not_plain_char (tree type
)
4314 type
= TYPE_MAIN_VARIANT (type
);
4315 if (type
== char_type_node
)
4318 return is_byte_access_type (type
);
4321 /* Returns 1 iff type T is something we want to treat as a scalar type for
4322 the purpose of deciding whether it is trivial/POD/standard-layout. */
4325 scalarish_type_p (const_tree t
)
4327 if (t
== error_mark_node
)
4330 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4333 /* Returns true iff T requires non-trivial default initialization. */
4336 type_has_nontrivial_default_init (const_tree t
)
4338 t
= strip_array_types (CONST_CAST_TREE (t
));
4340 if (CLASS_TYPE_P (t
))
4341 return TYPE_HAS_COMPLEX_DFLT (t
);
4346 /* Track classes with only deleted copy/move constructors so that we can warn
4347 if they are used in call/return by value. */
4349 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4351 remember_deleted_copy (const_tree t
)
4353 if (!deleted_copy_types
)
4354 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4355 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4358 maybe_warn_parm_abi (tree t
, location_t loc
)
4360 if (!deleted_copy_types
4361 || !deleted_copy_types
->contains (t
))
4364 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4365 && classtype_has_non_deleted_move_ctor (t
))
4368 auto_diagnostic_group d
;
4369 if (flag_abi_version
> 12)
4370 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4371 "the calling convention for %qT, which was "
4372 "accidentally changed in 8.1", t
);
4374 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) "
4375 "accidentally changes the calling convention for %qT",
4378 inform (location_of (t
), " declared here");
4382 auto_diagnostic_group d
;
4383 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4384 "%<-fabi-version=13%> (GCC 8.2)", t
))
4385 inform (location_of (t
), " because all of its copy and move "
4386 "constructors are deleted");
4389 /* Returns true iff copying an object of type T (including via move
4390 constructor) is non-trivial. That is, T has no non-trivial copy
4391 constructors and no non-trivial move constructors, and not all copy/move
4392 constructors are deleted. This function implements the ABI notion of
4393 non-trivial copy, which has diverged from the one in the standard. */
4396 type_has_nontrivial_copy_init (const_tree type
)
4398 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4400 if (CLASS_TYPE_P (t
))
4402 gcc_assert (COMPLETE_TYPE_P (t
));
4404 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4405 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4409 if (cxx_dialect
< cxx11
)
4410 /* No deleted functions before C++11. */
4413 /* Before ABI v12 we did a bitwise copy of types with only deleted
4414 copy/move constructors. */
4415 if (!abi_version_at_least (12)
4416 && !(warn_abi
&& abi_version_crosses (12)))
4419 bool saw_copy
= false;
4420 bool saw_non_deleted
= false;
4421 bool saw_non_deleted_move
= false;
4423 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4424 saw_copy
= saw_non_deleted
= true;
4425 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4428 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4429 /* [class.copy]/8 If the class definition declares a move
4430 constructor or move assignment operator, the implicitly declared
4431 copy constructor is defined as deleted.... */;
4433 /* Any other reason the implicitly-declared function would be
4434 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4436 saw_non_deleted
= true;
4439 if (!saw_non_deleted
)
4440 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4446 if (!DECL_DELETED_FN (fn
))
4448 /* Not deleted, therefore trivial. */
4449 saw_non_deleted
= true;
4453 else if (move_fn_p (fn
))
4454 if (!DECL_DELETED_FN (fn
))
4455 saw_non_deleted_move
= true;
4458 gcc_assert (saw_copy
);
4460 /* ABI v12 buggily ignored move constructors. */
4461 bool v11nontriv
= false;
4462 bool v12nontriv
= !saw_non_deleted
;
4463 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4464 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4465 : flag_abi_version
== 12 ? v12nontriv
4467 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4468 : warn_abi_version
== 12 ? v12nontriv
4470 if (nontriv
!= warn_nontriv
)
4471 remember_deleted_copy (t
);
4479 /* Returns 1 iff type T is a trivially copyable type, as defined in
4480 [basic.types] and [class]. */
4483 trivially_copyable_p (const_tree t
)
4485 t
= strip_array_types (CONST_CAST_TREE (t
));
4487 if (CLASS_TYPE_P (t
))
4488 return ((!TYPE_HAS_COPY_CTOR (t
)
4489 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4490 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4491 && (!TYPE_HAS_COPY_ASSIGN (t
)
4492 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4493 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4494 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4496 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4497 return scalarish_type_p (t
);
4500 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4504 trivial_type_p (const_tree t
)
4506 t
= strip_array_types (CONST_CAST_TREE (t
));
4508 if (CLASS_TYPE_P (t
))
4509 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4510 && trivially_copyable_p (t
));
4512 return scalarish_type_p (t
);
4515 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4518 pod_type_p (const_tree t
)
4520 /* This CONST_CAST is okay because strip_array_types returns its
4521 argument unmodified and we assign it to a const_tree. */
4522 t
= strip_array_types (CONST_CAST_TREE(t
));
4524 if (!CLASS_TYPE_P (t
))
4525 return scalarish_type_p (t
);
4526 else if (cxx_dialect
> cxx98
)
4527 /* [class]/10: A POD struct is a class that is both a trivial class and a
4528 standard-layout class, and has no non-static data members of type
4529 non-POD struct, non-POD union (or array of such types).
4531 We don't need to check individual members because if a member is
4532 non-std-layout or non-trivial, the class will be too. */
4533 return (std_layout_type_p (t
) && trivial_type_p (t
));
4535 /* The C++98 definition of POD is different. */
4536 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4539 /* Returns true iff T is POD for the purpose of layout, as defined in the
4543 layout_pod_type_p (const_tree t
)
4545 t
= strip_array_types (CONST_CAST_TREE (t
));
4547 if (CLASS_TYPE_P (t
))
4548 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4550 return scalarish_type_p (t
);
4553 /* Returns true iff T is a standard-layout type, as defined in
4557 std_layout_type_p (const_tree t
)
4559 t
= strip_array_types (CONST_CAST_TREE (t
));
4561 if (CLASS_TYPE_P (t
))
4562 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4564 return scalarish_type_p (t
);
4567 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4569 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4570 as defined in [meta.unary.prop]. */
4573 type_has_unique_obj_representations (const_tree t
)
4577 t
= strip_array_types (CONST_CAST_TREE (t
));
4579 if (!trivially_copyable_p (t
))
4582 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4583 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4585 switch (TREE_CODE (t
))
4589 case REFERENCE_TYPE
:
4590 /* If some backend has any paddings in these types, we should add
4591 a target hook for this and handle it there. */
4595 /* For bool values other than 0 and 1 should only appear with
4596 undefined behavior. */
4600 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4603 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4604 when storing long double values, so for that we have to return false.
4605 Other kinds of floating point values are questionable due to +.0/-.0
4606 and NaNs, let's play safe for now. */
4609 case FIXED_POINT_TYPE
:
4617 return type_has_unique_obj_representations (TREE_TYPE (t
));
4620 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4621 if (CLASS_TYPE_P (t
))
4623 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4624 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4632 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4633 if (TREE_CODE (field
) == FIELD_DECL
)
4636 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4637 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4643 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4645 if (CLASS_TYPE_P (t
))
4647 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4648 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4663 /* Helper function for type_has_unique_obj_representations. */
4666 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4668 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4669 if (TREE_CODE (field
) != FIELD_DECL
)
4671 /* For bases, can't use type_has_unique_obj_representations here, as in
4672 struct S { int i : 24; S (); };
4673 struct T : public S { int j : 8; T (); };
4674 S doesn't have unique obj representations, but T does. */
4675 else if (DECL_FIELD_IS_BASE (field
))
4677 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4681 else if (DECL_C_BIT_FIELD (field
))
4683 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4684 if (!type_has_unique_obj_representations (btype
))
4687 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4691 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4692 if (TREE_CODE (field
) == FIELD_DECL
)
4694 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4695 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4696 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4699 if (DECL_SIZE (field
))
4701 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4705 if (cur
!= wi::to_offset (sz
))
4711 /* Nonzero iff type T is a class template implicit specialization. */
4714 class_tmpl_impl_spec_p (const_tree t
)
4716 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4719 /* Returns 1 iff zero initialization of type T means actually storing
4723 zero_init_p (const_tree t
)
4725 /* This CONST_CAST is okay because strip_array_types returns its
4726 argument unmodified and we assign it to a const_tree. */
4727 t
= strip_array_types (CONST_CAST_TREE(t
));
4729 if (t
== error_mark_node
)
4732 /* NULL pointers to data members are initialized with -1. */
4733 if (TYPE_PTRDATAMEM_P (t
))
4736 /* Classes that contain types that can't be zero-initialized, cannot
4737 be zero-initialized themselves. */
4738 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4744 /* Returns true if the expression or initializer T is the result of
4745 zero-initialization for its type, taking pointers to members
4746 into consideration. */
4749 zero_init_expr_p (tree t
)
4751 tree type
= TREE_TYPE (t
);
4752 if (!type
|| uses_template_parms (type
))
4754 if (TYPE_PTRMEM_P (type
))
4755 return null_member_pointer_value_p (t
);
4756 if (TREE_CODE (t
) == CONSTRUCTOR
)
4758 if (COMPOUND_LITERAL_P (t
)
4759 || BRACE_ENCLOSED_INITIALIZER_P (t
))
4760 /* Undigested, conversions might change the zeroness. */
4762 for (constructor_elt
&elt
: CONSTRUCTOR_ELTS (t
))
4764 if (TREE_CODE (type
) == UNION_TYPE
4765 && elt
.index
!= first_field (type
))
4767 if (!zero_init_expr_p (elt
.value
))
4772 if (zero_init_p (type
))
4773 return initializer_zerop (t
);
4777 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4778 non-type template parameter. If EXPLAIN, explain why not. */
4781 structural_type_p (tree t
, bool explain
)
4783 /* A structural type is one of the following: */
4785 /* a scalar type, or */
4786 if (SCALAR_TYPE_P (t
))
4788 /* an lvalue reference type, or */
4789 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4791 /* a literal class type with the following properties:
4792 - all base classes and non-static data members are public and non-mutable
4794 - the types of all bases classes and non-static data members are
4795 structural types or (possibly multi-dimensional) array thereof. */
4796 if (!CLASS_TYPE_P (t
))
4798 if (!literal_type_p (t
))
4801 explain_non_literal_class (t
);
4804 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4805 m
= next_initializable_field (DECL_CHAIN (m
)))
4807 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4811 if (DECL_FIELD_IS_BASE (m
))
4812 inform (location_of (m
), "base class %qT is not public",
4815 inform (location_of (m
), "%qD is not public", m
);
4819 if (DECL_MUTABLE_P (m
))
4822 inform (location_of (m
), "%qD is mutable", m
);
4825 tree mtype
= strip_array_types (TREE_TYPE (m
));
4826 if (!structural_type_p (mtype
))
4830 inform (location_of (m
), "%qD has a non-structural type", m
);
4831 structural_type_p (mtype
, true);
4839 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4840 warn_unused_result attribute. */
4843 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4844 int /*flags*/, bool *no_add_attrs
)
4846 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4848 error ("%qE attribute argument must be a string constant", name
);
4849 *no_add_attrs
= true;
4851 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4853 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4854 && !DECL_CONSTRUCTOR_P (*node
))
4855 warning_at (DECL_SOURCE_LOCATION (*node
),
4856 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4857 "return type", name
, *node
);
4859 else if (OVERLOAD_TYPE_P (*node
))
4863 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4864 "functions or to class or enumeration types", name
);
4865 *no_add_attrs
= true;
4870 /* Handle a C++20 "no_unique_address" attribute; arguments as in
4871 struct attribute_spec.handler. */
4873 handle_no_unique_addr_attribute (tree
* node
,
4879 if (TREE_CODE (*node
) != FIELD_DECL
)
4881 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4882 "non-static data members", name
);
4883 *no_add_attrs
= true;
4885 else if (DECL_C_BIT_FIELD (*node
))
4887 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4888 "a bit-field", name
);
4889 *no_add_attrs
= true;
4895 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4896 hot/cold attributes. */
4899 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4900 int flags
, bool *no_add_attrs
)
4902 *no_add_attrs
= true;
4903 if (TREE_CODE (*node
) == LABEL_DECL
4904 || TREE_CODE (*node
) == FUNCTION_DECL
)
4907 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4908 tree bname
= (is_attribute_p ("likely", name
)
4909 ? get_identifier ("hot") : get_identifier ("cold"));
4910 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4911 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4912 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4913 tree battr
= build_tree_list (bname
, NULL_TREE
);
4914 decl_attributes (node
, battr
, flags
);
4918 return error_mark_node
;
4921 /* Table of valid C++ attributes. */
4922 const struct attribute_spec cxx_attribute_table
[] =
4924 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4925 affects_type_identity, handler, exclude } */
4926 { "init_priority", 1, 1, true, false, false, false,
4927 handle_init_priority_attribute
, NULL
},
4928 { "abi_tag", 1, -1, false, false, false, true,
4929 handle_abi_tag_attribute
, NULL
},
4930 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4933 /* Table of C++ standard attributes. */
4934 const struct attribute_spec std_attribute_table
[] =
4936 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4937 affects_type_identity, handler, exclude } */
4938 { "maybe_unused", 0, 0, false, false, false, false,
4939 handle_unused_attribute
, NULL
},
4940 { "nodiscard", 0, 1, false, false, false, false,
4941 handle_nodiscard_attribute
, NULL
},
4942 { "no_unique_address", 0, 0, true, false, false, false,
4943 handle_no_unique_addr_attribute
, NULL
},
4944 { "likely", 0, 0, false, false, false, false,
4945 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4946 { "unlikely", 0, 0, false, false, false, false,
4947 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4948 { "noreturn", 0, 0, true, false, false, false,
4949 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4950 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4953 /* Handle an "init_priority" attribute; arguments as in
4954 struct attribute_spec.handler. */
4956 handle_init_priority_attribute (tree
* node
,
4962 tree initp_expr
= TREE_VALUE (args
);
4964 tree type
= TREE_TYPE (decl
);
4967 STRIP_NOPS (initp_expr
);
4968 initp_expr
= default_conversion (initp_expr
);
4970 initp_expr
= maybe_constant_value (initp_expr
);
4972 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4974 error ("requested %<init_priority%> is not an integer constant");
4975 cxx_constant_value (initp_expr
);
4976 *no_add_attrs
= true;
4980 pri
= TREE_INT_CST_LOW (initp_expr
);
4982 type
= strip_array_types (type
);
4984 if (decl
== NULL_TREE
4986 || !TREE_STATIC (decl
)
4987 || DECL_EXTERNAL (decl
)
4988 || (TREE_CODE (type
) != RECORD_TYPE
4989 && TREE_CODE (type
) != UNION_TYPE
)
4990 /* Static objects in functions are initialized the
4991 first time control passes through that
4992 function. This is not precise enough to pin down an
4993 init_priority value, so don't allow it. */
4994 || current_function_decl
)
4996 error ("can only use %qE attribute on file-scope definitions "
4997 "of objects of class type", name
);
4998 *no_add_attrs
= true;
5002 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
5004 error ("requested %<init_priority%> %i is out of range [0, %i]",
5005 pri
, MAX_INIT_PRIORITY
);
5006 *no_add_attrs
= true;
5010 /* Check for init_priorities that are reserved for
5011 language and runtime support implementations.*/
5012 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5015 (0, "requested %<init_priority%> %i is reserved for internal use",
5019 if (SUPPORTS_INIT_PRIORITY
)
5021 SET_DECL_INIT_PRIORITY (decl
, pri
);
5022 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
5027 error ("%qE attribute is not supported on this platform", name
);
5028 *no_add_attrs
= true;
5033 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
5034 and the new one has the tags in NEW_. Give an error if there are tags
5035 in NEW_ that weren't in OLD. */
5038 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
5040 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
5041 old
= TREE_VALUE (old
);
5042 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
5043 new_
= TREE_VALUE (new_
);
5045 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
5047 tree str
= TREE_VALUE (t
);
5048 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
5050 tree ostr
= TREE_VALUE (in
);
5051 if (cp_tree_equal (str
, ostr
))
5054 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
5060 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
5066 /* The abi_tag attribute with the name NAME was given ARGS. If they are
5067 ill-formed, give an error and return false; otherwise, return true. */
5070 check_abi_tag_args (tree args
, tree name
)
5074 error ("the %qE attribute requires arguments", name
);
5077 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
5079 tree elt
= TREE_VALUE (arg
);
5080 if (TREE_CODE (elt
) != STRING_CST
5081 || (!same_type_ignoring_top_level_qualifiers_p
5082 (strip_array_types (TREE_TYPE (elt
)),
5085 error ("arguments to the %qE attribute must be narrow string "
5089 const char *begin
= TREE_STRING_POINTER (elt
);
5090 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
5091 for (const char *p
= begin
; p
!= end
; ++p
)
5096 if (!ISALPHA (c
) && c
!= '_')
5098 error ("arguments to the %qE attribute must contain valid "
5099 "identifiers", name
);
5100 inform (input_location
, "%<%c%> is not a valid first "
5101 "character for an identifier", c
);
5105 else if (p
== end
- 1)
5106 gcc_assert (c
== 0);
5109 if (!ISALNUM (c
) && c
!= '_')
5111 error ("arguments to the %qE attribute must contain valid "
5112 "identifiers", name
);
5113 inform (input_location
, "%<%c%> is not a valid character "
5114 "in an identifier", c
);
5123 /* Handle an "abi_tag" attribute; arguments as in
5124 struct attribute_spec.handler. */
5127 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
5128 int flags
, bool* no_add_attrs
)
5130 if (!check_abi_tag_args (args
, name
))
5135 if (!OVERLOAD_TYPE_P (*node
))
5137 error ("%qE attribute applied to non-class, non-enum type %qT",
5141 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
5143 error ("%qE attribute applied to %qT after its definition",
5147 else if (CLASS_TYPE_P (*node
)
5148 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
5150 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5151 "template instantiation %qT", name
, *node
);
5154 else if (CLASS_TYPE_P (*node
)
5155 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
5157 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
5158 "template specialization %qT", name
, *node
);
5162 tree attributes
= TYPE_ATTRIBUTES (*node
);
5163 tree decl
= TYPE_NAME (*node
);
5165 /* Make sure all declarations have the same abi tags. */
5166 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
5168 if (!check_abi_tag_redeclaration (decl
,
5169 lookup_attribute ("abi_tag",
5177 if (!VAR_OR_FUNCTION_DECL_P (*node
))
5179 error ("%qE attribute applied to non-function, non-variable %qD",
5183 else if (DECL_LANGUAGE (*node
) == lang_c
)
5185 error ("%qE attribute applied to extern \"C\" declaration %qD",
5194 *no_add_attrs
= true;
5198 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5199 thing pointed to by the constant. */
5202 make_ptrmem_cst (tree type
, tree member
)
5204 tree ptrmem_cst
= make_node (PTRMEM_CST
);
5205 TREE_TYPE (ptrmem_cst
) = type
;
5206 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5207 PTRMEM_CST_LOCATION (ptrmem_cst
) = input_location
;
5211 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5212 return an existing type if an appropriate type already exists. */
5215 cp_build_type_attribute_variant (tree type
, tree attributes
)
5219 new_type
= build_type_attribute_variant (type
, attributes
);
5220 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5221 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5223 /* Making a new main variant of a class type is broken. */
5224 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5229 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5230 Called only after doing all language independent checks. */
5233 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5235 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5237 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5239 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5241 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5242 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5245 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5246 C++, these are the exception-specifier and ref-qualifier. */
5249 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5251 tree type
= CONST_CAST_TREE (typea
);
5252 if (FUNC_OR_METHOD_TYPE_P (type
))
5253 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5254 TYPE_RAISES_EXCEPTIONS (typeb
),
5255 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5259 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5260 traversal. Called from walk_tree. */
5263 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5264 void *data
, hash_set
<tree
> *pset
)
5266 enum tree_code code
= TREE_CODE (*tp
);
5269 #define WALK_SUBTREE(NODE) \
5272 result = cp_walk_tree (&(NODE), func, data, pset); \
5273 if (result) goto out; \
5279 /* If *WALK_SUBTREES_P is 1, we're interested in the syntactic form of
5280 the argument, so don't look through typedefs, but do walk into
5281 template arguments for alias templates (and non-typedefed classes).
5283 If *WALK_SUBTREES_P > 1, we're interested in type identity or
5284 equivalence, so look through typedefs, ignoring template arguments for
5285 alias templates, and walk into template args of classes.
5287 See find_abi_tags_r for an example of setting *WALK_SUBTREES_P to 2
5288 when that's the behavior the walk_tree_fn wants. */
5289 if (*walk_subtrees_p
== 1 && typedef_variant_p (*tp
))
5291 if (tree ti
= TYPE_ALIAS_TEMPLATE_INFO (*tp
))
5292 WALK_SUBTREE (TI_ARGS (ti
));
5293 *walk_subtrees_p
= 0;
5297 if (tree ti
= TYPE_TEMPLATE_INFO (*tp
))
5298 WALK_SUBTREE (TI_ARGS (ti
));
5301 /* Not one of the easy cases. We must explicitly go through the
5306 case TEMPLATE_TYPE_PARM
:
5307 if (template_placeholder_p (*tp
))
5308 WALK_SUBTREE (CLASS_PLACEHOLDER_TEMPLATE (*tp
));
5310 case DEFERRED_PARSE
:
5311 case TEMPLATE_TEMPLATE_PARM
:
5312 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5313 case UNBOUND_CLASS_TEMPLATE
:
5314 case TEMPLATE_PARM_INDEX
:
5316 case UNDERLYING_TYPE
:
5317 /* None of these have subtrees other than those already walked
5319 *walk_subtrees_p
= 0;
5323 WALK_SUBTREE (TYPE_CONTEXT (*tp
));
5324 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (*tp
));
5325 *walk_subtrees_p
= 0;
5329 if (BASELINK_QUALIFIED_P (*tp
))
5330 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
5331 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
5332 *walk_subtrees_p
= 0;
5336 WALK_SUBTREE (TREE_TYPE (*tp
));
5337 *walk_subtrees_p
= 0;
5341 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5345 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5346 WALK_SUBTREE (OVL_CHAIN (*tp
));
5347 *walk_subtrees_p
= 0;
5351 WALK_SUBTREE (DECL_NAME (*tp
));
5352 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5353 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5354 *walk_subtrees_p
= 0;
5358 if (TYPE_PTRMEMFUNC_P (*tp
))
5359 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5362 case TYPE_ARGUMENT_PACK
:
5363 case NONTYPE_ARGUMENT_PACK
:
5365 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5366 int i
, len
= TREE_VEC_LENGTH (args
);
5367 for (i
= 0; i
< len
; i
++)
5368 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5372 case TYPE_PACK_EXPANSION
:
5373 WALK_SUBTREE (TREE_TYPE (*tp
));
5374 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5375 *walk_subtrees_p
= 0;
5378 case EXPR_PACK_EXPANSION
:
5379 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5380 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5381 *walk_subtrees_p
= 0;
5385 case REINTERPRET_CAST_EXPR
:
5386 case STATIC_CAST_EXPR
:
5387 case CONST_CAST_EXPR
:
5388 case DYNAMIC_CAST_EXPR
:
5389 case IMPLICIT_CONV_EXPR
:
5391 if (TREE_TYPE (*tp
))
5392 WALK_SUBTREE (TREE_TYPE (*tp
));
5396 if (COMPOUND_LITERAL_P (*tp
))
5397 WALK_SUBTREE (TREE_TYPE (*tp
));
5401 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5402 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5403 *walk_subtrees_p
= 0;
5407 ++cp_unevaluated_operand
;
5408 /* We can't use WALK_SUBTREE here because of the goto. */
5409 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5410 --cp_unevaluated_operand
;
5411 *walk_subtrees_p
= 0;
5417 ++cp_unevaluated_operand
;
5418 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5419 --cp_unevaluated_operand
;
5420 *walk_subtrees_p
= 0;
5424 // Only recurse through the nested expression. Do not
5425 // walk the parameter list. Doing so causes false
5426 // positives in the pack expansion checker since the
5427 // requires parameters are introduced as pack expansions.
5428 ++cp_unevaluated_operand
;
5429 result
= cp_walk_tree (&REQUIRES_EXPR_REQS (*tp
), func
, data
, pset
);
5430 --cp_unevaluated_operand
;
5431 *walk_subtrees_p
= 0;
5435 /* User variables should be mentioned in BIND_EXPR_VARS
5436 and their initializers and sizes walked when walking
5437 the containing BIND_EXPR. Compiler temporaries are
5438 handled here. And also normal variables in templates,
5439 since do_poplevel doesn't build a BIND_EXPR then. */
5440 if (VAR_P (TREE_OPERAND (*tp
, 0))
5441 && (processing_template_decl
5442 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5443 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5445 tree decl
= TREE_OPERAND (*tp
, 0);
5446 WALK_SUBTREE (DECL_INITIAL (decl
));
5447 WALK_SUBTREE (DECL_SIZE (decl
));
5448 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5453 /* Don't walk into the body of the lambda, but the capture initializers
5454 are part of the enclosing context. */
5455 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5456 cap
= TREE_CHAIN (cap
))
5457 WALK_SUBTREE (TREE_VALUE (cap
));
5461 if (TREE_OPERAND (*tp
, 1))
5462 /* Operand 1 is the tree for the relevant co_await which has any
5463 interesting sub-trees. */
5464 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5468 if (TREE_OPERAND (*tp
, 1))
5469 /* Operand 1 is frame variable. */
5470 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5471 if (TREE_OPERAND (*tp
, 2))
5472 /* Operand 2 has the initialiser, and we need to walk any subtrees
5474 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5477 case CO_RETURN_EXPR
:
5478 if (TREE_OPERAND (*tp
, 0))
5480 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5481 /* For void expressions, operand 1 is a trivial call, and any
5482 interesting subtrees will be part of operand 0. */
5483 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5484 else if (TREE_OPERAND (*tp
, 1))
5485 /* Interesting sub-trees will be in the return_value () call
5487 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5492 WALK_SUBTREE (STATIC_ASSERT_CONDITION (*tp
));
5493 WALK_SUBTREE (STATIC_ASSERT_MESSAGE (*tp
));
5500 /* We didn't find what we were looking for. */
5507 /* Like save_expr, but for C++. */
5510 cp_save_expr (tree expr
)
5512 /* There is no reason to create a SAVE_EXPR within a template; if
5513 needed, we can create the SAVE_EXPR when instantiating the
5514 template. Furthermore, the middle-end cannot handle C++-specific
5516 if (processing_template_decl
)
5519 /* TARGET_EXPRs are only expanded once. */
5520 if (TREE_CODE (expr
) == TARGET_EXPR
)
5523 return save_expr (expr
);
5526 /* Initialize tree.c. */
5531 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5532 register_scoped_attributes (std_attribute_table
, NULL
);
5535 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5536 is. Note that sfk_none is zero, so this function can be used as a
5537 predicate to test whether or not DECL is a special function. */
5539 special_function_kind
5540 special_function_p (const_tree decl
)
5542 /* Rather than doing all this stuff with magic names, we should
5543 probably have a field of type `special_function_kind' in
5544 DECL_LANG_SPECIFIC. */
5545 if (DECL_INHERITED_CTOR (decl
))
5546 return sfk_inheriting_constructor
;
5547 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5548 return sfk_copy_constructor
;
5549 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5550 return sfk_move_constructor
;
5551 if (DECL_CONSTRUCTOR_P (decl
))
5552 return sfk_constructor
;
5553 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5554 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5556 if (copy_fn_p (decl
))
5557 return sfk_copy_assignment
;
5558 if (move_fn_p (decl
))
5559 return sfk_move_assignment
;
5561 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5562 return sfk_destructor
;
5563 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5564 return sfk_complete_destructor
;
5565 if (DECL_BASE_DESTRUCTOR_P (decl
))
5566 return sfk_base_destructor
;
5567 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5568 return sfk_deleting_destructor
;
5569 if (DECL_CONV_FN_P (decl
))
5570 return sfk_conversion
;
5571 if (deduction_guide_p (decl
))
5572 return sfk_deduction_guide
;
5573 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5574 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5575 return sfk_comparison
;
5580 /* As above, but only if DECL is a special member function as per 11.3.3
5581 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5583 special_function_kind
5584 special_memfn_p (const_tree decl
)
5586 switch (special_function_kind sfk
= special_function_p (decl
))
5588 case sfk_constructor
:
5589 if (!default_ctor_p (decl
))
5592 case sfk_copy_constructor
:
5593 case sfk_copy_assignment
:
5594 case sfk_move_assignment
:
5595 case sfk_move_constructor
:
5596 case sfk_destructor
:
5605 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5608 char_type_p (tree type
)
5610 return (same_type_p (type
, char_type_node
)
5611 || same_type_p (type
, unsigned_char_type_node
)
5612 || same_type_p (type
, signed_char_type_node
)
5613 || same_type_p (type
, char8_type_node
)
5614 || same_type_p (type
, char16_type_node
)
5615 || same_type_p (type
, char32_type_node
)
5616 || same_type_p (type
, wchar_type_node
));
5619 /* Returns the kind of linkage associated with the indicated DECL. Th
5620 value returned is as specified by the language standard; it is
5621 independent of implementation details regarding template
5622 instantiation, etc. For example, it is possible that a declaration
5623 to which this function assigns external linkage would not show up
5624 as a global symbol when you run `nm' on the resulting object file. */
5627 decl_linkage (tree decl
)
5629 /* This function doesn't attempt to calculate the linkage from first
5630 principles as given in [basic.link]. Instead, it makes use of
5631 the fact that we have already set TREE_PUBLIC appropriately, and
5632 then handles a few special cases. Ideally, we would calculate
5633 linkage first, and then transform that into a concrete
5636 /* Things that don't have names have no linkage. */
5637 if (!DECL_NAME (decl
))
5640 /* Fields have no linkage. */
5641 if (TREE_CODE (decl
) == FIELD_DECL
)
5644 /* Things in local scope do not have linkage. */
5645 if (decl_function_context (decl
))
5648 /* Things that are TREE_PUBLIC have external linkage. */
5649 if (TREE_PUBLIC (decl
))
5652 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5653 check one of the "clones" for the real linkage. */
5654 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5655 && DECL_CHAIN (decl
)
5656 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5657 return decl_linkage (DECL_CHAIN (decl
));
5659 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5662 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5664 if (TREE_CODE (decl
) == CONST_DECL
)
5665 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5667 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5668 are considered to have external linkage for language purposes, as do
5669 template instantiations on targets without weak symbols. DECLs really
5670 meant to have internal linkage have DECL_THIS_STATIC set. */
5671 if (TREE_CODE (decl
) == TYPE_DECL
)
5673 if (VAR_OR_FUNCTION_DECL_P (decl
))
5675 if (!DECL_THIS_STATIC (decl
))
5678 /* Static data members and static member functions from classes
5679 in anonymous namespace also don't have TREE_PUBLIC set. */
5680 if (DECL_CLASS_CONTEXT (decl
))
5684 /* Everything else has internal linkage. */
5688 /* Returns the storage duration of the object or reference associated with
5689 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5692 decl_storage_duration (tree decl
)
5694 if (TREE_CODE (decl
) == PARM_DECL
)
5696 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5698 gcc_assert (VAR_P (decl
));
5699 if (!TREE_STATIC (decl
)
5700 && !DECL_EXTERNAL (decl
))
5702 if (CP_DECL_THREAD_LOCAL_P (decl
))
5707 /* EXP is an expression that we want to pre-evaluate. Returns (in
5708 *INITP) an expression that will perform the pre-evaluation. The
5709 value returned by this function is a side-effect free expression
5710 equivalent to the pre-evaluated expression. Callers must ensure
5711 that *INITP is evaluated before EXP. */
5714 stabilize_expr (tree exp
, tree
* initp
)
5718 if (!TREE_SIDE_EFFECTS (exp
))
5719 init_expr
= NULL_TREE
;
5720 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5725 /* There are no expressions with REFERENCE_TYPE, but there can be call
5726 arguments with such a type; just treat it as a pointer. */
5727 else if (TYPE_REF_P (TREE_TYPE (exp
))
5728 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5729 || !glvalue_p (exp
))
5731 init_expr
= get_target_expr (exp
);
5732 exp
= TARGET_EXPR_SLOT (init_expr
);
5733 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5740 bool xval
= !lvalue_p (exp
);
5741 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5742 init_expr
= get_target_expr (exp
);
5743 exp
= TARGET_EXPR_SLOT (init_expr
);
5744 exp
= cp_build_fold_indirect_ref (exp
);
5750 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5754 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5755 similar expression ORIG. */
5758 add_stmt_to_compound (tree orig
, tree new_expr
)
5760 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5762 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5764 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5767 /* Like stabilize_expr, but for a call whose arguments we want to
5768 pre-evaluate. CALL is modified in place to use the pre-evaluated
5769 arguments, while, upon return, *INITP contains an expression to
5770 compute the arguments. */
5773 stabilize_call (tree call
, tree
*initp
)
5775 tree inits
= NULL_TREE
;
5777 int nargs
= call_expr_nargs (call
);
5779 if (call
== error_mark_node
|| processing_template_decl
)
5785 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5787 for (i
= 0; i
< nargs
; i
++)
5790 CALL_EXPR_ARG (call
, i
) =
5791 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5792 inits
= add_stmt_to_compound (inits
, init
);
5798 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5799 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5800 arguments, while, upon return, *INITP contains an expression to
5801 compute the arguments. */
5804 stabilize_aggr_init (tree call
, tree
*initp
)
5806 tree inits
= NULL_TREE
;
5808 int nargs
= aggr_init_expr_nargs (call
);
5810 if (call
== error_mark_node
)
5813 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5815 for (i
= 0; i
< nargs
; i
++)
5818 AGGR_INIT_EXPR_ARG (call
, i
) =
5819 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5820 inits
= add_stmt_to_compound (inits
, init
);
5826 /* Like stabilize_expr, but for an initialization.
5828 If the initialization is for an object of class type, this function
5829 takes care not to introduce additional temporaries.
5831 Returns TRUE iff the expression was successfully pre-evaluated,
5832 i.e., if INIT is now side-effect free, except for, possibly, a
5833 single call to a constructor. */
5836 stabilize_init (tree init
, tree
*initp
)
5842 if (t
== error_mark_node
|| processing_template_decl
)
5845 if (TREE_CODE (t
) == INIT_EXPR
)
5846 t
= TREE_OPERAND (t
, 1);
5847 if (TREE_CODE (t
) == TARGET_EXPR
)
5848 t
= TARGET_EXPR_INITIAL (t
);
5850 /* If the RHS can be stabilized without breaking copy elision, stabilize
5851 it. We specifically don't stabilize class prvalues here because that
5852 would mean an extra copy, but they might be stabilized below. */
5853 if (TREE_CODE (init
) == INIT_EXPR
5854 && TREE_CODE (t
) != CONSTRUCTOR
5855 && TREE_CODE (t
) != AGGR_INIT_EXPR
5856 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5859 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5863 if (TREE_CODE (t
) == COMPOUND_EXPR
5864 && TREE_CODE (init
) == INIT_EXPR
)
5866 tree last
= expr_last (t
);
5867 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5868 if (!TREE_SIDE_EFFECTS (last
))
5871 TREE_OPERAND (init
, 1) = last
;
5876 if (TREE_CODE (t
) == CONSTRUCTOR
)
5878 /* Aggregate initialization: stabilize each of the field
5881 constructor_elt
*ce
;
5883 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5884 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5886 tree type
= TREE_TYPE (ce
->value
);
5888 if (TYPE_REF_P (type
)
5889 || SCALAR_TYPE_P (type
))
5890 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5891 else if (!stabilize_init (ce
->value
, &subinit
))
5893 *initp
= add_stmt_to_compound (*initp
, subinit
);
5898 if (TREE_CODE (t
) == CALL_EXPR
)
5900 stabilize_call (t
, initp
);
5904 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5906 stabilize_aggr_init (t
, initp
);
5910 /* The initialization is being performed via a bitwise copy -- and
5911 the item copied may have side effects. */
5912 return !TREE_SIDE_EFFECTS (init
);
5915 /* Returns true if a cast to TYPE may appear in an integral constant
5919 cast_valid_in_integral_constant_expression_p (tree type
)
5921 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5922 || cxx_dialect
>= cxx11
5923 || dependent_type_p (type
)
5924 || type
== error_mark_node
);
5927 /* Return true if we need to fix linkage information of DECL. */
5930 cp_fix_function_decl_p (tree decl
)
5932 /* Skip if DECL is not externally visible. */
5933 if (!TREE_PUBLIC (decl
))
5936 /* We need to fix DECL if it a appears to be exported but with no
5937 function body. Thunks do not have CFGs and we may need to
5938 handle them specially later. */
5939 if (!gimple_has_body_p (decl
)
5940 && !DECL_THUNK_P (decl
)
5941 && !DECL_EXTERNAL (decl
))
5943 struct cgraph_node
*node
= cgraph_node::get (decl
);
5945 /* Don't fix same_body aliases. Although they don't have their own
5946 CFG, they share it with what they alias to. */
5947 if (!node
|| !node
->alias
|| !node
->num_references ())
5954 /* Clean the C++ specific parts of the tree T. */
5957 cp_free_lang_data (tree t
)
5959 if (FUNC_OR_METHOD_TYPE_P (t
))
5961 /* Default args are not interesting anymore. */
5962 tree argtypes
= TYPE_ARG_TYPES (t
);
5965 TREE_PURPOSE (argtypes
) = 0;
5966 argtypes
= TREE_CHAIN (argtypes
);
5969 else if (TREE_CODE (t
) == FUNCTION_DECL
5970 && cp_fix_function_decl_p (t
))
5972 /* If T is used in this translation unit at all, the definition
5973 must exist somewhere else since we have decided to not emit it
5974 in this TU. So make it an external reference. */
5975 DECL_EXTERNAL (t
) = 1;
5976 TREE_STATIC (t
) = 0;
5978 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5979 /* We do not need the leftover chaining of namespaces from the
5981 DECL_CHAIN (t
) = NULL_TREE
;
5984 /* Stub for c-common. Please keep in sync with c-decl.c.
5985 FIXME: If address space support is target specific, then this
5986 should be a C target hook. But currently this is not possible,
5987 because this function is called via REGISTER_TARGET_PRAGMAS. */
5989 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5993 /* Return the number of operands in T that we care about for things like
5997 cp_tree_operand_length (const_tree t
)
5999 enum tree_code code
= TREE_CODE (t
);
6001 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
6002 return VL_EXP_OPERAND_LENGTH (t
);
6004 return cp_tree_code_length (code
);
6007 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
6010 cp_tree_code_length (enum tree_code code
)
6012 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
6016 case PREINCREMENT_EXPR
:
6017 case PREDECREMENT_EXPR
:
6018 case POSTINCREMENT_EXPR
:
6019 case POSTDECREMENT_EXPR
:
6025 case EXPR_PACK_EXPANSION
:
6029 return TREE_CODE_LENGTH (code
);
6033 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
6037 cp_expr_location (const_tree t_
)
6039 tree t
= CONST_CAST_TREE (t_
);
6041 return UNKNOWN_LOCATION
;
6042 switch (TREE_CODE (t
))
6045 return LAMBDA_EXPR_LOCATION (t
);
6047 return STATIC_ASSERT_SOURCE_LOCATION (t
);
6049 return TRAIT_EXPR_LOCATION (t
);
6051 return PTRMEM_CST_LOCATION (t
);
6053 return EXPR_LOCATION (t
);
6057 /* Implement -Wzero_as_null_pointer_constant. Return true if the
6058 conditions for the warning hold, false otherwise. */
6060 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
6062 if (c_inhibit_evaluation_warnings
== 0
6063 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6065 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
6066 "zero as null pointer constant");
6072 /* Release memory we no longer need after parsing. */
6074 cp_tree_c_finish_parsing ()
6076 if (previous_class_level
)
6077 invalidate_class_lookup_cache ();
6078 deleted_copy_types
= NULL
;
6081 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6082 /* Complain that some language-specific thing hanging off a tree
6083 node has been accessed improperly. */
6086 lang_check_failed (const char* file
, int line
, const char* function
)
6088 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
6089 function
, trim_filename (file
), line
);
6091 #endif /* ENABLE_TREE_CHECKING */
6095 namespace selftest
{
6097 /* Verify that lvalue_kind () works, for various expressions,
6098 and that location wrappers don't affect the results. */
6103 location_t loc
= BUILTINS_LOCATION
;
6105 /* Verify constants and parameters, without and with
6106 location wrappers. */
6107 tree int_cst
= build_int_cst (integer_type_node
, 42);
6108 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
6110 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
6111 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
6112 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
6114 tree string_lit
= build_string (4, "foo");
6115 TREE_TYPE (string_lit
) = char_array_type_node
;
6116 string_lit
= fix_string_type (string_lit
);
6117 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
6119 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
6120 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
6121 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
6123 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
6124 get_identifier ("some_parm"),
6126 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
6128 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
6129 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
6130 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
6132 /* Verify that lvalue_kind of std::move on a parm isn't
6133 affected by location wrappers. */
6134 tree rvalue_ref_of_parm
= move (parm
);
6135 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
6136 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
6137 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
6139 /* Verify lvalue_p. */
6140 ASSERT_FALSE (lvalue_p (int_cst
));
6141 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
6142 ASSERT_TRUE (lvalue_p (parm
));
6143 ASSERT_TRUE (lvalue_p (wrapped_parm
));
6144 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
6145 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
6148 /* Run all of the selftests within this file. */
6153 test_lvalue_kind ();
6156 } // namespace selftest
6158 #endif /* #if CHECKING_P */
6161 #include "gt-cp-tree.h"