1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 /* Expressions with cv void type are prvalues. */
86 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
89 switch (TREE_CODE (ref
))
94 /* preincrements and predecrements are valid lvals, provided
95 what they refer to are valid lvals. */
96 case PREINCREMENT_EXPR
:
97 case PREDECREMENT_EXPR
:
101 case VIEW_CONVERT_EXPR
:
102 return lvalue_kind (TREE_OPERAND (ref
, 0));
106 tree op1
= TREE_OPERAND (ref
, 0);
107 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
109 op1_lvalue_kind
= lvalue_kind (op1
);
110 if (op1_lvalue_kind
== clk_class
)
111 /* in the case of an array operand, the result is an lvalue if
112 that operand is an lvalue and an xvalue otherwise */
113 op1_lvalue_kind
= clk_rvalueref
;
114 return op1_lvalue_kind
;
122 if (TREE_CODE (ref
) == MEMBER_REF
)
123 op1_lvalue_kind
= clk_ordinary
;
125 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
126 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
127 op1_lvalue_kind
= clk_none
;
128 else if (op1_lvalue_kind
== clk_class
)
129 /* The result of a .* expression whose second operand is a pointer to a
130 data member is an lvalue if the first operand is an lvalue and an
132 op1_lvalue_kind
= clk_rvalueref
;
133 return op1_lvalue_kind
;
136 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
138 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
140 /* For static member function recurse on the BASELINK, we can get
141 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
142 OVERLOAD, the overload is resolved first if possible through
143 resolve_address_of_overloaded_function. */
144 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
145 return lvalue_kind (TREE_OPERAND (ref
, 1));
147 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
148 if (op1_lvalue_kind
== clk_class
)
149 /* If E1 is an lvalue, then E1.E2 is an lvalue;
150 otherwise E1.E2 is an xvalue. */
151 op1_lvalue_kind
= clk_rvalueref
;
153 /* Look at the member designator. */
154 if (!op1_lvalue_kind
)
156 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
157 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
158 situations. If we're seeing a COMPONENT_REF, it's a non-static
159 member, so it isn't an lvalue. */
160 op1_lvalue_kind
= clk_none
;
161 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
162 /* This can be IDENTIFIER_NODE in a template. */;
163 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
165 /* Clear the ordinary bit. If this object was a class
166 rvalue we want to preserve that information. */
167 op1_lvalue_kind
&= ~clk_ordinary
;
168 /* The lvalue is for a bitfield. */
169 op1_lvalue_kind
|= clk_bitfield
;
171 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
172 op1_lvalue_kind
|= clk_packed
;
174 return op1_lvalue_kind
;
177 case COMPOUND_LITERAL_EXPR
:
181 /* CONST_DECL without TREE_STATIC are enumeration values and
182 thus not lvalues. With TREE_STATIC they are used by ObjC++
183 in objc_build_string_object and need to be considered as
185 if (! TREE_STATIC (ref
))
189 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
190 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
192 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
193 && DECL_LANG_SPECIFIC (ref
)
194 && DECL_IN_AGGR_P (ref
))
201 case PLACEHOLDER_EXPR
:
204 /* A scope ref in a template, left as SCOPE_REF to support later
207 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
209 tree op
= TREE_OPERAND (ref
, 1);
210 if (TREE_CODE (op
) == FIELD_DECL
)
211 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
213 return lvalue_kind (op
);
218 /* Disallow <? and >? as lvalues if either argument side-effects. */
219 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
220 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
222 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
223 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
227 if (processing_template_decl
)
229 /* Within templates, a REFERENCE_TYPE will indicate whether
230 the COND_EXPR result is an ordinary lvalue or rvalueref.
231 Since REFERENCE_TYPEs are handled above, if we reach this
232 point, we know we got a plain rvalue. Unless we have a
233 type-dependent expr, that is, but we shouldn't be testing
234 lvalueness if we can't even tell the types yet! */
235 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
239 tree op1
= TREE_OPERAND (ref
, 1);
240 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
241 tree op2
= TREE_OPERAND (ref
, 2);
242 op1_lvalue_kind
= lvalue_kind (op1
);
243 op2_lvalue_kind
= lvalue_kind (op2
);
244 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
246 /* The second or the third operand (but not both) is a
247 throw-expression; the result is of the type
248 and value category of the other. */
249 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
250 op2_lvalue_kind
= op1_lvalue_kind
;
251 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
252 op1_lvalue_kind
= op2_lvalue_kind
;
258 /* We expect to see unlowered MODOP_EXPRs only during
259 template processing. */
260 gcc_assert (processing_template_decl
);
268 return lvalue_kind (TREE_OPERAND (ref
, 1));
274 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
277 /* We can see calls outside of TARGET_EXPR in templates. */
278 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
283 /* All functions (except non-static-member functions) are
285 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
286 ? clk_none
: clk_ordinary
);
289 /* We now represent a reference to a single static member function
291 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
292 its argument unmodified and we assign it to a const_tree. */
293 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
295 case NON_DEPENDENT_EXPR
:
297 return lvalue_kind (TREE_OPERAND (ref
, 0));
299 case TEMPLATE_PARM_INDEX
:
300 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
301 /* A template parameter object is an lvalue. */
307 if (!TREE_TYPE (ref
))
309 if (CLASS_TYPE_P (TREE_TYPE (ref
))
310 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
315 /* If one operand is not an lvalue at all, then this expression is
317 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
320 /* Otherwise, it's an lvalue, and it has all the odd properties
321 contributed by either operand. */
322 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
323 /* It's not an ordinary lvalue if it involves any other kind. */
324 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
325 op1_lvalue_kind
&= ~clk_ordinary
;
326 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
327 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
328 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
329 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
330 op1_lvalue_kind
= clk_none
;
331 return op1_lvalue_kind
;
334 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
337 real_lvalue_p (const_tree ref
)
339 cp_lvalue_kind kind
= lvalue_kind (ref
);
340 if (kind
& (clk_rvalueref
|clk_class
))
346 /* c-common wants us to return bool. */
349 lvalue_p (const_tree t
)
351 return real_lvalue_p (t
);
354 /* This differs from lvalue_p in that xvalues are included. */
357 glvalue_p (const_tree ref
)
359 cp_lvalue_kind kind
= lvalue_kind (ref
);
360 if (kind
& clk_class
)
363 return (kind
!= clk_none
);
366 /* This differs from glvalue_p in that class prvalues are included. */
369 obvalue_p (const_tree ref
)
371 return (lvalue_kind (ref
) != clk_none
);
374 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
375 reference), false otherwise. */
378 xvalue_p (const_tree ref
)
380 return (lvalue_kind (ref
) == clk_rvalueref
);
383 /* True if REF is a bit-field. */
386 bitfield_p (const_tree ref
)
388 return (lvalue_kind (ref
) & clk_bitfield
);
391 /* C++-specific version of stabilize_reference. */
394 cp_stabilize_reference (tree ref
)
396 STRIP_ANY_LOCATION_WRAPPER (ref
);
397 switch (TREE_CODE (ref
))
399 case NON_DEPENDENT_EXPR
:
400 /* We aren't actually evaluating this. */
403 /* We need to treat specially anything stabilize_reference doesn't
404 handle specifically. */
415 case ARRAY_RANGE_REF
:
419 cp_lvalue_kind kind
= lvalue_kind (ref
);
420 if ((kind
& ~clk_class
) != clk_none
)
422 tree type
= unlowered_expr_type (ref
);
423 bool rval
= !!(kind
& clk_rvalueref
);
424 type
= cp_build_reference_type (type
, rval
);
425 /* This inhibits warnings in, eg, cxx_mark_addressable
427 warning_sentinel
s (extra_warnings
);
428 ref
= build_static_cast (input_location
, type
, ref
,
433 return stabilize_reference (ref
);
436 /* Test whether DECL is a builtin that may appear in a
437 constant-expression. */
440 builtin_valid_in_constant_expr_p (const_tree decl
)
442 STRIP_ANY_LOCATION_WRAPPER (decl
);
443 if (TREE_CODE (decl
) != FUNCTION_DECL
)
444 /* Not a function. */
446 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
448 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
450 || fndecl_built_in_p (decl
, CP_BUILT_IN_SOURCE_LOCATION
,
453 /* Not a built-in. */
456 switch (DECL_FUNCTION_CODE (decl
))
458 /* These always have constant results like the corresponding
461 case BUILT_IN_FUNCTION
:
464 /* The following built-ins are valid in constant expressions
465 when their arguments are. */
466 case BUILT_IN_ADD_OVERFLOW_P
:
467 case BUILT_IN_SUB_OVERFLOW_P
:
468 case BUILT_IN_MUL_OVERFLOW_P
:
470 /* These have constant results even if their operands are
472 case BUILT_IN_CONSTANT_P
:
473 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
480 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
483 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
486 tree type
= TREE_TYPE (decl
);
488 value
= mark_rvalue_use (value
);
490 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
491 || TREE_TYPE (decl
) == TREE_TYPE (value
)
492 /* On ARM ctors return 'this'. */
493 || (TYPE_PTR_P (TREE_TYPE (value
))
494 && TREE_CODE (value
) == CALL_EXPR
)
495 || useless_type_conversion_p (TREE_TYPE (decl
),
498 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
499 moving a constant aggregate into .rodata. */
500 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
501 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
502 && !VOID_TYPE_P (TREE_TYPE (value
))
503 && reduced_constant_expression_p (value
))
504 TREE_READONLY (decl
) = true;
506 if (complain
& tf_no_cleanup
)
507 /* The caller is building a new-expr and does not need a cleanup. */
511 t
= cxx_maybe_build_cleanup (decl
, complain
);
512 if (t
== error_mark_node
)
513 return error_mark_node
;
515 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
516 if (location_t eloc
= cp_expr_location (value
))
517 SET_EXPR_LOCATION (t
, eloc
);
518 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
519 ignore the TARGET_EXPR. If there really turn out to be no
520 side-effects, then the optimizer should be able to get rid of
521 whatever code is generated anyhow. */
522 TREE_SIDE_EFFECTS (t
) = 1;
527 /* Return an undeclared local temporary of type TYPE for use in building a
531 build_local_temp (tree type
)
533 tree slot
= build_decl (input_location
,
534 VAR_DECL
, NULL_TREE
, type
);
535 DECL_ARTIFICIAL (slot
) = 1;
536 DECL_IGNORED_P (slot
) = 1;
537 DECL_CONTEXT (slot
) = current_function_decl
;
538 layout_decl (slot
, 0);
542 /* Return whether DECL is such a local temporary (or one from
543 create_tmp_var_raw). */
546 is_local_temp (tree decl
)
548 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
549 && !TREE_STATIC (decl
)
550 && DECL_FUNCTION_SCOPE_P (decl
));
553 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
556 process_aggr_init_operands (tree t
)
560 side_effects
= TREE_SIDE_EFFECTS (t
);
564 n
= TREE_OPERAND_LENGTH (t
);
565 for (i
= 1; i
< n
; i
++)
567 tree op
= TREE_OPERAND (t
, i
);
568 if (op
&& TREE_SIDE_EFFECTS (op
))
575 TREE_SIDE_EFFECTS (t
) = side_effects
;
578 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
579 FN, and SLOT. NARGS is the number of call arguments which are specified
580 as a tree array ARGS. */
583 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
589 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
590 TREE_TYPE (t
) = return_type
;
591 AGGR_INIT_EXPR_FN (t
) = fn
;
592 AGGR_INIT_EXPR_SLOT (t
) = slot
;
593 for (i
= 0; i
< nargs
; i
++)
594 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
595 process_aggr_init_operands (t
);
599 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
600 target. TYPE is the type to be initialized.
602 Build an AGGR_INIT_EXPR to represent the initialization. This function
603 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
604 to initialize another object, whereas a TARGET_EXPR can either
605 initialize another object or create its own temporary object, and as a
606 result building up a TARGET_EXPR requires that the type's destructor be
610 build_aggr_init_expr (tree type
, tree init
)
617 gcc_assert (!VOID_TYPE_P (type
));
619 /* Don't build AGGR_INIT_EXPR in a template. */
620 if (processing_template_decl
)
623 fn
= cp_get_callee (init
);
625 return convert (type
, init
);
627 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
628 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
629 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
631 /* We split the CALL_EXPR into its function and its arguments here.
632 Then, in expand_expr, we put them back together. The reason for
633 this is that this expression might be a default argument
634 expression. In that case, we need a new temporary every time the
635 expression is used. That's what break_out_target_exprs does; it
636 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
637 temporary slot. Then, expand_expr builds up a call-expression
638 using the new slot. */
640 /* If we don't need to use a constructor to create an object of this
641 type, don't mess with AGGR_INIT_EXPR. */
642 if (is_ctor
|| TREE_ADDRESSABLE (type
))
644 slot
= build_local_temp (type
);
646 if (TREE_CODE (init
) == CALL_EXPR
)
648 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
649 call_expr_nargs (init
),
650 CALL_EXPR_ARGP (init
));
651 AGGR_INIT_FROM_THUNK_P (rval
)
652 = CALL_FROM_THUNK_P (init
);
656 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
657 aggr_init_expr_nargs (init
),
658 AGGR_INIT_EXPR_ARGP (init
));
659 AGGR_INIT_FROM_THUNK_P (rval
)
660 = AGGR_INIT_FROM_THUNK_P (init
);
662 TREE_SIDE_EFFECTS (rval
) = 1;
663 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
664 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
665 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
666 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
667 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
675 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
676 target. TYPE is the type that this initialization should appear to
679 Build an encapsulation of the initialization to perform
680 and return it so that it can be processed by language-independent
681 and language-specific expression expanders. */
684 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
686 /* This function should cope with what build_special_member_call
687 can produce. When performing parenthesized aggregate initialization,
688 it can produce a { }. */
689 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
691 gcc_assert (cxx_dialect
>= cxx2a
);
692 return finish_compound_literal (type
, init
, complain
);
695 tree rval
= build_aggr_init_expr (type
, init
);
698 if (init
== error_mark_node
)
699 return error_mark_node
;
701 if (!complete_type_or_maybe_complain (type
, init
, complain
))
702 return error_mark_node
;
704 /* Make sure that we're not trying to create an instance of an
706 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
707 return error_mark_node
;
709 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
710 slot
= AGGR_INIT_EXPR_SLOT (rval
);
711 else if (TREE_CODE (rval
) == CALL_EXPR
712 || TREE_CODE (rval
) == CONSTRUCTOR
)
713 slot
= build_local_temp (type
);
717 rval
= build_target_expr (slot
, rval
, complain
);
719 if (rval
!= error_mark_node
)
720 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
725 /* Subroutine of build_vec_init_expr: Build up a single element
726 intialization as a proxy for the full array initialization to get things
727 marked as used and any appropriate diagnostics.
729 Since we're deferring building the actual constructor calls until
730 gimplification time, we need to build one now and throw it away so
731 that the relevant constructor gets mark_used before cgraph decides
732 what functions are needed. Here we assume that init is either
733 NULL_TREE, void_type_node (indicating value-initialization), or
734 another array to copy. */
737 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
739 tree inner_type
= strip_array_types (type
);
741 if (integer_zerop (array_type_nelts_total (type
))
742 || !CLASS_TYPE_P (inner_type
))
743 /* No interesting initialization to do. */
744 return integer_zero_node
;
745 else if (init
== void_type_node
)
746 return build_value_init (inner_type
, complain
);
748 gcc_assert (init
== NULL_TREE
749 || (same_type_ignoring_top_level_qualifiers_p
750 (type
, TREE_TYPE (init
))));
752 releasing_vec argvec
;
755 tree init_type
= strip_array_types (TREE_TYPE (init
));
756 tree dummy
= build_dummy_object (init_type
);
757 if (!lvalue_p (init
))
758 dummy
= move (dummy
);
759 argvec
->quick_push (dummy
);
761 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
762 &argvec
, inner_type
, LOOKUP_NORMAL
,
765 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
766 we don't want one here because we aren't creating a temporary. */
767 if (TREE_CODE (init
) == TARGET_EXPR
)
768 init
= TARGET_EXPR_INITIAL (init
);
773 /* Return a TARGET_EXPR which expresses the initialization of an array to
774 be named later, either default-initialization or copy-initialization
775 from another array of the same type. */
778 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
781 bool value_init
= false;
782 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
784 if (init
== void_type_node
)
790 slot
= build_local_temp (type
);
791 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
792 TREE_SIDE_EFFECTS (init
) = true;
793 SET_EXPR_LOCATION (init
, input_location
);
795 if (cxx_dialect
>= cxx11
796 && potential_constant_expression (elt_init
))
797 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
798 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
803 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
804 that requires a constant expression. */
807 diagnose_non_constexpr_vec_init (tree expr
)
809 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
811 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
812 init
= void_type_node
;
814 init
= VEC_INIT_EXPR_INIT (expr
);
816 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
817 require_potential_constant_expression (elt_init
);
821 build_array_copy (tree init
)
823 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
826 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
830 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
832 gcc_assert (!VOID_TYPE_P (type
));
834 if (TREE_CODE (init
) == TARGET_EXPR
835 || init
== error_mark_node
)
837 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
838 && !VOID_TYPE_P (TREE_TYPE (init
))
839 && TREE_CODE (init
) != COND_EXPR
840 && TREE_CODE (init
) != CONSTRUCTOR
841 && TREE_CODE (init
) != VA_ARG_EXPR
)
842 /* We need to build up a copy constructor call. A void initializer
843 means we're being called from bot_manip. COND_EXPR is a special
844 case because we already have copies on the arms and we don't want
845 another one here. A CONSTRUCTOR is aggregate initialization, which
846 is handled separately. A VA_ARG_EXPR is magic creation of an
847 aggregate; there's no additional work to be done. */
848 return force_rvalue (init
, complain
);
850 return force_target_expr (type
, init
, complain
);
853 /* Like the above function, but without the checking. This function should
854 only be used by code which is deliberately trying to subvert the type
855 system, such as call_builtin_trap. Or build_over_call, to avoid
856 infinite recursion. */
859 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
863 gcc_assert (!VOID_TYPE_P (type
));
865 slot
= build_local_temp (type
);
866 return build_target_expr (slot
, init
, complain
);
869 /* Like build_target_expr_with_type, but use the type of INIT. */
872 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
874 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
875 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
876 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
877 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
880 init
= convert_bitfield_to_declared_type (init
);
881 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
886 get_target_expr (tree init
)
888 return get_target_expr_sfinae (init
, tf_warning_or_error
);
891 /* If EXPR is a bitfield reference, convert it to the declared type of
892 the bitfield, and return the resulting expression. Otherwise,
893 return EXPR itself. */
896 convert_bitfield_to_declared_type (tree expr
)
900 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
902 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
907 /* EXPR is being used in an rvalue context. Return a version of EXPR
908 that is marked as an rvalue. */
915 if (error_operand_p (expr
))
918 expr
= mark_rvalue_use (expr
);
922 Non-class rvalues always have cv-unqualified types. */
923 type
= TREE_TYPE (expr
);
924 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
925 type
= cv_unqualified (type
);
927 /* We need to do this for rvalue refs as well to get the right answer
928 from decltype; see c++/36628. */
929 if (!processing_template_decl
&& glvalue_p (expr
))
930 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
931 else if (type
!= TREE_TYPE (expr
))
932 expr
= build_nop (type
, expr
);
938 struct cplus_array_info
944 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
946 typedef cplus_array_info
*compare_type
;
948 static hashval_t
hash (tree t
);
949 static bool equal (tree
, cplus_array_info
*);
952 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
955 cplus_array_hasher::hash (tree t
)
959 hash
= TYPE_UID (TREE_TYPE (t
));
961 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
965 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
966 of type `cplus_array_info*'. */
969 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
971 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
974 /* Hash table containing dependent array types, which are unsuitable for
975 the language-independent type hash table. */
976 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
978 /* Build an ARRAY_TYPE without laying it out. */
981 build_min_array_type (tree elt_type
, tree index_type
)
983 tree t
= cxx_make_type (ARRAY_TYPE
);
984 TREE_TYPE (t
) = elt_type
;
985 TYPE_DOMAIN (t
) = index_type
;
989 /* Set TYPE_CANONICAL like build_array_type_1, but using
990 build_cplus_array_type. */
993 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
995 /* Set the canonical type for this new node. */
996 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
997 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
998 SET_TYPE_STRUCTURAL_EQUALITY (t
);
999 else if (TYPE_CANONICAL (elt_type
) != elt_type
1000 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1002 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1004 ? TYPE_CANONICAL (index_type
) : index_type
);
1006 TYPE_CANONICAL (t
) = t
;
1009 /* Like build_array_type, but handle special C++ semantics: an array of a
1010 variant element type is a variant of the array of the main variant of
1011 the element type. */
1014 build_cplus_array_type (tree elt_type
, tree index_type
)
1018 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1019 return error_mark_node
;
1021 bool dependent
= (uses_template_parms (elt_type
)
1022 || (index_type
&& uses_template_parms (index_type
)));
1024 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1025 /* Start with an array of the TYPE_MAIN_VARIANT. */
1026 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1030 /* Since type_hash_canon calls layout_type, we need to use our own
1032 cplus_array_info cai
;
1035 if (cplus_array_htab
== NULL
)
1036 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1038 hash
= TYPE_UID (elt_type
);
1040 hash
^= TYPE_UID (index_type
);
1041 cai
.type
= elt_type
;
1042 cai
.domain
= index_type
;
1044 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1046 /* We have found the type: we're done. */
1050 /* Build a new array type. */
1051 t
= build_min_array_type (elt_type
, index_type
);
1053 /* Store it in the hash table. */
1056 /* Set the canonical type for this new node. */
1057 set_array_type_canon (t
, elt_type
, index_type
);
1062 bool typeless_storage
1063 = (elt_type
== unsigned_char_type_node
1064 || elt_type
== signed_char_type_node
1065 || elt_type
== char_type_node
1066 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1067 && TYPE_CONTEXT (elt_type
) == std_node
1068 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1069 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1072 /* Now check whether we already have this array variant. */
1073 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1076 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1077 if (TREE_TYPE (t
) == elt_type
1078 && TYPE_NAME (t
) == NULL_TREE
1079 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1083 t
= build_min_array_type (elt_type
, index_type
);
1084 set_array_type_canon (t
, elt_type
, index_type
);
1088 /* Make sure sizes are shared with the main variant.
1089 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1090 as it will overwrite alignment etc. of all variants. */
1091 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1092 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1093 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1096 TYPE_MAIN_VARIANT (t
) = m
;
1097 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1098 TYPE_NEXT_VARIANT (m
) = t
;
1102 /* Avoid spurious warnings with VLAs (c++/54583). */
1103 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1104 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1106 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1107 place more easily. */
1108 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1109 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1110 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1111 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1113 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1114 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1116 /* The element type has been completed since the last time we saw
1117 this array type; update the layout and 'tor flags for any variants
1120 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1122 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1123 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1130 /* Return an ARRAY_TYPE with element type ELT and length N. */
1133 build_array_of_n_type (tree elt
, int n
)
1135 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1138 /* True iff T is an array of unknown bound. */
1141 array_of_unknown_bound_p (const_tree t
)
1143 return (TREE_CODE (t
) == ARRAY_TYPE
1144 && !TYPE_DOMAIN (t
));
1147 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1148 for C++14 but then removed. This should only be used for N3639
1149 specifically; code wondering more generally if something is a VLA should use
1153 array_of_runtime_bound_p (tree t
)
1155 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1157 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1159 tree dom
= TYPE_DOMAIN (t
);
1162 tree max
= TYPE_MAX_VALUE (dom
);
1163 return (!potential_rvalue_constant_expression (max
)
1164 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1167 /* True iff T is a variable length array. */
1172 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1174 if (tree dom
= TYPE_DOMAIN (t
))
1176 tree max
= TYPE_MAX_VALUE (dom
);
1177 if (!potential_rvalue_constant_expression (max
)
1178 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1184 /* Return a reference type node referring to TO_TYPE. If RVAL is
1185 true, return an rvalue reference type, otherwise return an lvalue
1186 reference type. If a type node exists, reuse it, otherwise create
1189 cp_build_reference_type (tree to_type
, bool rval
)
1193 if (to_type
== error_mark_node
)
1194 return error_mark_node
;
1196 if (TYPE_REF_P (to_type
))
1198 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1199 to_type
= TREE_TYPE (to_type
);
1202 lvalue_ref
= build_reference_type (to_type
);
1206 /* This code to create rvalue reference types is based on and tied
1207 to the code creating lvalue reference types in the middle-end
1208 functions build_reference_type_for_mode and build_reference_type.
1210 It works by putting the rvalue reference type nodes after the
1211 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1212 they will effectively be ignored by the middle end. */
1214 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1215 if (TYPE_REF_IS_RVALUE (t
))
1218 t
= build_distinct_type_copy (lvalue_ref
);
1220 TYPE_REF_IS_RVALUE (t
) = true;
1221 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1222 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1224 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1225 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1226 else if (TYPE_CANONICAL (to_type
) != to_type
)
1228 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1230 TYPE_CANONICAL (t
) = t
;
1238 /* Returns EXPR cast to rvalue reference type, like std::move. */
1243 tree type
= TREE_TYPE (expr
);
1244 gcc_assert (!TYPE_REF_P (type
));
1245 type
= cp_build_reference_type (type
, /*rval*/true);
1246 return build_static_cast (input_location
, type
, expr
,
1247 tf_warning_or_error
);
1250 /* Used by the C++ front end to build qualified array types. However,
1251 the C version of this function does not properly maintain canonical
1252 types (which are not used in C). */
1254 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1255 size_t /* orig_qual_indirect */)
1257 return cp_build_qualified_type (type
, type_quals
);
1261 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1262 arrays correctly. In particular, if TYPE is an array of T's, and
1263 TYPE_QUALS is non-empty, returns an array of qualified T's.
1265 FLAGS determines how to deal with ill-formed qualifications. If
1266 tf_ignore_bad_quals is set, then bad qualifications are dropped
1267 (this is permitted if TYPE was introduced via a typedef or template
1268 type parameter). If bad qualifications are dropped and tf_warning
1269 is set, then a warning is issued for non-const qualifications. If
1270 tf_ignore_bad_quals is not set and tf_error is not set, we
1271 return error_mark_node. Otherwise, we issue an error, and ignore
1274 Qualification of a reference type is valid when the reference came
1275 via a typedef or template type argument. [dcl.ref] No such
1276 dispensation is provided for qualifying a function type. [dcl.fct]
1277 DR 295 queries this and the proposed resolution brings it into line
1278 with qualifying a reference. We implement the DR. We also behave
1279 in a similar manner for restricting non-pointer types. */
1282 cp_build_qualified_type_real (tree type
,
1284 tsubst_flags_t complain
)
1287 int bad_quals
= TYPE_UNQUALIFIED
;
1289 if (type
== error_mark_node
)
1292 if (type_quals
== cp_type_quals (type
))
1295 if (TREE_CODE (type
) == ARRAY_TYPE
)
1297 /* In C++, the qualification really applies to the array element
1298 type. Obtain the appropriately qualified element type. */
1301 = cp_build_qualified_type_real (TREE_TYPE (type
),
1305 if (element_type
== error_mark_node
)
1306 return error_mark_node
;
1308 /* See if we already have an identically qualified type. Tests
1309 should be equivalent to those in check_qualified_type. */
1310 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1311 if (TREE_TYPE (t
) == element_type
1312 && TYPE_NAME (t
) == TYPE_NAME (type
)
1313 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1314 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1315 TYPE_ATTRIBUTES (type
)))
1320 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1322 /* Keep the typedef name. */
1323 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1325 t
= build_variant_type_copy (t
);
1326 TYPE_NAME (t
) = TYPE_NAME (type
);
1327 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1328 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1332 /* Even if we already had this variant, we update
1333 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1334 they changed since the variant was originally created.
1336 This seems hokey; if there is some way to use a previous
1337 variant *without* coming through here,
1338 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1339 TYPE_NEEDS_CONSTRUCTING (t
)
1340 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1341 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1342 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1345 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1347 tree t
= PACK_EXPANSION_PATTERN (type
);
1349 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1350 return make_pack_expansion (t
, complain
);
1353 /* A reference or method type shall not be cv-qualified.
1354 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1355 (in CD1) we always ignore extra cv-quals on functions. */
1356 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1357 && (TYPE_REF_P (type
)
1358 || FUNC_OR_METHOD_TYPE_P (type
)))
1360 if (TYPE_REF_P (type
))
1361 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1362 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1365 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1366 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1367 type_quals
|= type_memfn_quals (type
);
1369 /* A restrict-qualified type must be a pointer (or reference)
1370 to object or incomplete type. */
1371 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1372 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1373 && TREE_CODE (type
) != TYPENAME_TYPE
1374 && !INDIRECT_TYPE_P (type
))
1376 bad_quals
|= TYPE_QUAL_RESTRICT
;
1377 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1380 if (bad_quals
== TYPE_UNQUALIFIED
1381 || (complain
& tf_ignore_bad_quals
))
1383 else if (!(complain
& tf_error
))
1384 return error_mark_node
;
1387 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1388 error ("%qV qualifiers cannot be applied to %qT",
1392 /* Retrieve (or create) the appropriately qualified variant. */
1393 result
= build_qualified_type (type
, type_quals
);
1398 /* Return TYPE with const and volatile removed. */
1401 cv_unqualified (tree type
)
1405 if (type
== error_mark_node
)
1408 quals
= cp_type_quals (type
);
1409 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1410 return cp_build_qualified_type (type
, quals
);
1413 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1414 from ATTRIBS that affect type identity, and no others. If any are not
1415 applied, set *remove_attributes to true. */
1418 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1420 tree first_ident
= NULL_TREE
;
1421 tree new_attribs
= NULL_TREE
;
1422 tree
*p
= &new_attribs
;
1424 if (OVERLOAD_TYPE_P (result
))
1426 /* On classes and enums all attributes are ingrained. */
1427 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1431 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1433 const attribute_spec
*as
1434 = lookup_attribute_spec (get_attribute_name (a
));
1435 if (as
&& as
->affects_type_identity
)
1439 else if (first_ident
== error_mark_node
)
1441 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1442 p
= &TREE_CHAIN (*p
);
1445 else if (first_ident
)
1447 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1449 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1450 p
= &TREE_CHAIN (*p
);
1452 first_ident
= error_mark_node
;
1455 if (first_ident
!= error_mark_node
)
1456 new_attribs
= first_ident
;
1458 if (first_ident
== attribs
)
1459 /* All attributes affected type identity. */;
1461 *remove_attributes
= true;
1463 return cp_build_type_attribute_variant (result
, new_attribs
);
1466 /* Builds a qualified variant of T that is either not a typedef variant
1467 (the default behavior) or not a typedef variant of a user-facing type
1468 (if FLAGS contains STF_USER_FACING).
1470 E.g. consider the following declarations:
1471 typedef const int ConstInt;
1472 typedef ConstInt* PtrConstInt;
1473 If T is PtrConstInt, this function returns a type representing
1475 In other words, if T is a typedef, the function returns the underlying type.
1476 The cv-qualification and attributes of the type returned match the
1478 They will always be compatible types.
1479 The returned type is built so that all of its subtypes
1480 recursively have their typedefs stripped as well.
1482 This is different from just returning TYPE_CANONICAL (T)
1483 Because of several reasons:
1484 * If T is a type that needs structural equality
1485 its TYPE_CANONICAL (T) will be NULL.
1486 * TYPE_CANONICAL (T) desn't carry type attributes
1487 and loses template parameter names.
1489 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1490 affect type identity, and set the referent to true if any were
1494 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1496 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1498 if (!t
|| t
== error_mark_node
)
1501 if (TREE_CODE (t
) == TREE_LIST
)
1503 bool changed
= false;
1506 for (; t
; t
= TREE_CHAIN (t
))
1508 gcc_assert (!TREE_PURPOSE (t
));
1509 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1510 if (elt
!= TREE_VALUE (t
))
1512 vec_safe_push (vec
, elt
);
1515 r
= build_tree_list_vec (vec
);
1519 gcc_assert (TYPE_P (t
));
1521 if (t
== TYPE_CANONICAL (t
))
1524 if (!(flags
& STF_STRIP_DEPENDENT
)
1525 && dependent_alias_template_spec_p (t
, nt_opaque
))
1526 /* DR 1558: However, if the template-id is dependent, subsequent
1527 template argument substitution still applies to the template-id. */
1530 switch (TREE_CODE (t
))
1533 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1534 result
= build_pointer_type (type
);
1536 case REFERENCE_TYPE
:
1537 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1538 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1541 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1542 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1543 result
= build_offset_type (t0
, type
);
1546 if (TYPE_PTRMEMFUNC_P (t
))
1548 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1549 remove_attributes
, flags
);
1550 result
= build_ptrmemfunc_type (t0
);
1554 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1555 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1556 result
= build_cplus_array_type (type
, t0
);
1561 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1564 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1565 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1566 can't expect that re-hashing a function type will find a previous
1567 equivalent type, so try to reuse the input type if nothing has
1568 changed. If the type is itself a variant, that will change. */
1569 bool is_variant
= typedef_variant_p (t
);
1570 if (remove_attributes
1571 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1574 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1575 tree canon_spec
= (flag_noexcept_type
1576 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1578 changed
= (type
!= TREE_TYPE (t
) || is_variant
1579 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1581 for (arg_node
= TYPE_ARG_TYPES (t
);
1583 arg_node
= TREE_CHAIN (arg_node
))
1585 if (arg_node
== void_list_node
)
1587 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1588 remove_attributes
, flags
);
1589 gcc_assert (arg_type
);
1590 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1596 for (arg_node2
= TYPE_ARG_TYPES (t
);
1597 arg_node2
!= arg_node
;
1598 arg_node2
= TREE_CHAIN (arg_node2
))
1600 = tree_cons (TREE_PURPOSE (arg_node2
),
1601 TREE_VALUE (arg_node2
), arg_types
);
1605 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1612 arg_types
= nreverse (arg_types
);
1614 /* A list of parameters not ending with an ellipsis
1615 must end with void_list_node. */
1617 arg_types
= chainon (arg_types
, void_list_node
);
1619 if (TREE_CODE (t
) == METHOD_TYPE
)
1621 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1622 gcc_assert (class_type
);
1624 build_method_type_directly (class_type
, type
,
1625 TREE_CHAIN (arg_types
));
1629 result
= build_function_type (type
, arg_types
);
1630 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1633 result
= build_cp_fntype_variant (result
,
1634 type_memfn_rqual (t
), canon_spec
,
1635 TYPE_HAS_LATE_RETURN_TYPE (t
));
1640 bool changed
= false;
1641 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1642 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1643 && TREE_OPERAND (fullname
, 1))
1645 tree args
= TREE_OPERAND (fullname
, 1);
1646 tree new_args
= copy_node (args
);
1647 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1649 tree arg
= TREE_VEC_ELT (args
, i
);
1652 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1654 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1656 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1657 if (strip_arg
!= arg
)
1662 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1663 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1665 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1669 ggc_free (new_args
);
1671 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1672 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1674 tree name
= fullname
;
1675 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1676 name
= TREE_OPERAND (fullname
, 0);
1677 /* Use build_typename_type rather than make_typename_type because we
1678 don't want to resolve it here, just strip typedefs. */
1679 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1683 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1684 remove_attributes
, flags
);
1685 if (result
== DECLTYPE_TYPE_EXPR (t
))
1688 result
= (finish_decltype_type
1690 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1693 case UNDERLYING_TYPE
:
1694 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1695 remove_attributes
, flags
);
1696 result
= finish_underlying_type (type
);
1704 if (typedef_variant_p (t
))
1706 if ((flags
& STF_USER_VISIBLE
)
1707 && !user_facing_original_type_p (t
))
1709 /* If T is a non-template alias or typedef, we can assume that
1710 instantiating its definition will hit any substitution failure,
1711 so we don't need to retain it here as well. */
1712 if (!alias_template_specialization_p (t
, nt_opaque
))
1713 flags
|= STF_STRIP_DEPENDENT
;
1714 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1715 remove_attributes
, flags
);
1718 result
= TYPE_MAIN_VARIANT (t
);
1720 /*gcc_assert (!typedef_variant_p (result)
1721 || dependent_alias_template_spec_p (result, nt_opaque)
1722 || ((flags & STF_USER_VISIBLE)
1723 && !user_facing_original_type_p (result)));*/
1725 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1726 /* If RESULT is complete and T isn't, it's likely the case that T
1727 is a variant of RESULT which hasn't been updated yet. Skip the
1728 attribute handling. */;
1731 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1732 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1734 gcc_assert (TYPE_USER_ALIGN (t
));
1735 if (remove_attributes
)
1736 *remove_attributes
= true;
1739 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1740 result
= build_variant_type_copy (result
);
1742 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1743 TYPE_USER_ALIGN (result
) = true;
1747 if (TYPE_ATTRIBUTES (t
))
1749 if (remove_attributes
)
1750 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1753 result
= cp_build_type_attribute_variant (result
,
1754 TYPE_ATTRIBUTES (t
));
1758 return cp_build_qualified_type (result
, cp_type_quals (t
));
1761 /* Like strip_typedefs above, but works on expressions, so that in
1763 template<class T> struct A
1769 sizeof(TT) is replaced by sizeof(T). */
1772 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1776 enum tree_code code
;
1778 if (t
== NULL_TREE
|| t
== error_mark_node
)
1781 STRIP_ANY_LOCATION_WRAPPER (t
);
1783 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1786 /* Some expressions have type operands, so let's handle types here rather
1787 than check TYPE_P in multiple places below. */
1789 return strip_typedefs (t
, remove_attributes
, flags
);
1791 code
= TREE_CODE (t
);
1794 case IDENTIFIER_NODE
:
1795 case TEMPLATE_PARM_INDEX
:
1798 case ARGUMENT_PACK_SELECT
:
1803 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1804 remove_attributes
, flags
);
1805 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1806 remove_attributes
, flags
);
1807 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1808 && type2
== TRAIT_EXPR_TYPE2 (t
))
1811 TRAIT_EXPR_TYPE1 (r
) = type1
;
1812 TRAIT_EXPR_TYPE2 (r
) = type2
;
1819 bool changed
= false;
1821 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1823 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1824 remove_attributes
, flags
);
1825 vec_safe_push (vec
, val
);
1826 if (val
!= TREE_VALUE (it
))
1828 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1833 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1834 r
= tree_cons (NULL_TREE
, it
, r
);
1843 bool changed
= false;
1845 n
= TREE_VEC_LENGTH (t
);
1846 vec_safe_reserve (vec
, n
);
1847 for (i
= 0; i
< n
; ++i
)
1849 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1850 remove_attributes
, flags
);
1851 vec
->quick_push (op
);
1852 if (op
!= TREE_VEC_ELT (t
, i
))
1858 for (i
= 0; i
< n
; ++i
)
1859 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1860 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1861 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1870 bool changed
= false;
1871 vec
<constructor_elt
, va_gc
> *vec
1872 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1873 n
= CONSTRUCTOR_NELTS (t
);
1874 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1875 for (i
= 0; i
< n
; ++i
)
1877 constructor_elt
*e
= &(*vec
)[i
];
1878 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1885 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1889 if (!changed
&& type
== TREE_TYPE (t
))
1897 TREE_TYPE (r
) = type
;
1898 CONSTRUCTOR_ELTS (r
) = vec
;
1906 case STATEMENT_LIST
:
1907 error ("statement-expression in a constant expression");
1908 return error_mark_node
;
1914 gcc_assert (EXPR_P (t
));
1916 n
= cp_tree_operand_length (t
);
1917 ops
= XALLOCAVEC (tree
, n
);
1918 type
= TREE_TYPE (t
);
1923 case IMPLICIT_CONV_EXPR
:
1924 case DYNAMIC_CAST_EXPR
:
1925 case STATIC_CAST_EXPR
:
1926 case CONST_CAST_EXPR
:
1927 case REINTERPRET_CAST_EXPR
:
1930 type
= strip_typedefs (type
, remove_attributes
, flags
);
1934 for (i
= 0; i
< n
; ++i
)
1935 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1936 remove_attributes
, flags
);
1940 /* If nothing changed, return t. */
1941 for (i
= 0; i
< n
; ++i
)
1942 if (ops
[i
] != TREE_OPERAND (t
, i
))
1944 if (i
== n
&& type
== TREE_TYPE (t
))
1948 TREE_TYPE (r
) = type
;
1949 for (i
= 0; i
< n
; ++i
)
1950 TREE_OPERAND (r
, i
) = ops
[i
];
1954 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1955 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1956 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1957 VIRT indicates whether TYPE is inherited virtually or not.
1958 IGO_PREV points at the previous binfo of the inheritance graph
1959 order chain. The newly copied binfo's TREE_CHAIN forms this
1962 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1963 correct order. That is in the order the bases themselves should be
1966 The BINFO_INHERITANCE of a virtual base class points to the binfo
1967 of the most derived type. ??? We could probably change this so that
1968 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1969 remove a field. They currently can only differ for primary virtual
1973 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1979 /* See if we've already made this virtual base. */
1980 new_binfo
= binfo_for_vbase (type
, t
);
1985 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1986 BINFO_TYPE (new_binfo
) = type
;
1988 /* Chain it into the inheritance graph. */
1989 TREE_CHAIN (*igo_prev
) = new_binfo
;
1990 *igo_prev
= new_binfo
;
1992 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1997 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1999 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2000 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2002 /* We do not need to copy the accesses, as they are read only. */
2003 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2005 /* Recursively copy base binfos of BINFO. */
2006 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2008 tree new_base_binfo
;
2009 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2011 BINFO_VIRTUAL_P (base_binfo
));
2013 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2014 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2015 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2019 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2023 /* Push it onto the list after any virtual bases it contains
2024 will have been pushed. */
2025 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2026 BINFO_VIRTUAL_P (new_binfo
) = 1;
2027 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2033 /* Hashing of lists so that we don't make duplicates.
2034 The entry point is `list_hash_canon'. */
2043 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2045 typedef list_proxy
*compare_type
;
2047 static hashval_t
hash (tree
);
2048 static bool equal (tree
, list_proxy
*);
2051 /* Now here is the hash table. When recording a list, it is added
2052 to the slot whose index is the hash code mod the table size.
2053 Note that the hash table is used for several kinds of lists.
2054 While all these live in the same table, they are completely independent,
2055 and the hash code is computed differently for each of these. */
2057 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2059 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2060 for a node we are thinking about adding). */
2063 list_hasher::equal (tree t
, list_proxy
*proxy
)
2065 return (TREE_VALUE (t
) == proxy
->value
2066 && TREE_PURPOSE (t
) == proxy
->purpose
2067 && TREE_CHAIN (t
) == proxy
->chain
);
2070 /* Compute a hash code for a list (chain of TREE_LIST nodes
2071 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2072 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2075 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2077 hashval_t hashcode
= 0;
2080 hashcode
+= TREE_HASH (chain
);
2083 hashcode
+= TREE_HASH (value
);
2087 hashcode
+= TREE_HASH (purpose
);
2093 /* Hash an already existing TREE_LIST. */
2096 list_hasher::hash (tree t
)
2098 return list_hash_pieces (TREE_PURPOSE (t
),
2103 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2104 object for an identical list if one already exists. Otherwise, build a
2105 new one, and record it as the canonical object. */
2108 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2112 struct list_proxy proxy
;
2114 /* Hash the list node. */
2115 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2116 /* Create a proxy for the TREE_LIST we would like to create. We
2117 don't actually create it so as to avoid creating garbage. */
2118 proxy
.purpose
= purpose
;
2119 proxy
.value
= value
;
2120 proxy
.chain
= chain
;
2121 /* See if it is already in the table. */
2122 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2123 /* If not, create a new node. */
2125 *slot
= tree_cons (purpose
, value
, chain
);
2126 return (tree
) *slot
;
2129 /* Constructor for hashed lists. */
2132 hash_tree_chain (tree value
, tree chain
)
2134 return hash_tree_cons (NULL_TREE
, value
, chain
);
2138 debug_binfo (tree elem
)
2143 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2145 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2146 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2147 debug_tree (BINFO_TYPE (elem
));
2148 if (BINFO_VTABLE (elem
))
2149 fprintf (stderr
, "vtable decl \"%s\"\n",
2150 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2152 fprintf (stderr
, "no vtable decl yet\n");
2153 fprintf (stderr
, "virtuals:\n");
2154 virtuals
= BINFO_VIRTUALS (elem
);
2159 tree fndecl
= TREE_VALUE (virtuals
);
2160 fprintf (stderr
, "%s [%ld =? %ld]\n",
2161 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2162 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2164 virtuals
= TREE_CHAIN (virtuals
);
2168 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2169 the type of the result expression, if known, or NULL_TREE if the
2170 resulting expression is type-dependent. If TEMPLATE_P is true,
2171 NAME is known to be a template because the user explicitly used the
2172 "template" keyword after the "::".
2174 All SCOPE_REFs should be built by use of this function. */
2177 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2180 if (type
== error_mark_node
2181 || scope
== error_mark_node
2182 || name
== error_mark_node
)
2183 return error_mark_node
;
2184 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2185 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2186 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2187 PTRMEM_OK_P (t
) = true;
2189 t
= convert_from_reference (t
);
2193 /* Like check_qualified_type, but also check ref-qualifier, exception
2194 specification, and whether the return type was specified after the
2198 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2199 cp_ref_qualifier rqual
, tree raises
, bool late
)
2201 return (TYPE_QUALS (cand
) == type_quals
2202 && check_base_type (cand
, base
)
2203 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2205 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2206 && type_memfn_rqual (cand
) == rqual
);
2209 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2212 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2214 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2215 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2216 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2219 /* Make a raw overload node containing FN. */
2222 ovl_make (tree fn
, tree next
)
2224 tree result
= make_node (OVERLOAD
);
2226 if (TREE_CODE (fn
) == OVERLOAD
)
2227 OVL_NESTED_P (result
) = true;
2229 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2230 ? unknown_type_node
: TREE_TYPE (fn
));
2231 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2232 OVL_DEDUP_P (result
) = true;
2233 OVL_FUNCTION (result
) = fn
;
2234 OVL_CHAIN (result
) = next
;
2238 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2239 true, if FN is via a using declaration. We also pay attention to
2240 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2244 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2246 tree result
= maybe_ovl
;
2247 tree insert_after
= NULL_TREE
;
2250 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2251 && OVL_HIDDEN_P (maybe_ovl
);
2252 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2254 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2255 insert_after
= maybe_ovl
;
2258 bool hidden_p
= DECL_HIDDEN_P (fn
);
2259 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2261 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2263 OVL_HIDDEN_P (maybe_ovl
) = true;
2265 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2272 OVL_CHAIN (insert_after
) = maybe_ovl
;
2273 TREE_TYPE (insert_after
) = unknown_type_node
;
2281 /* Skip any hidden names at the beginning of OVL. */
2284 ovl_skip_hidden (tree ovl
)
2287 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2288 ovl
= OVL_CHAIN (ovl
))
2289 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2291 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2293 /* Any hidden functions should have been wrapped in an
2294 overload, but injected friend classes will not. */
2295 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2302 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2305 ovl_iterator::reveal_node (tree overload
, tree node
)
2307 /* We cannot have returned NODE as part of a lookup overload, so we
2308 don't have to worry about preserving that. */
2310 OVL_HIDDEN_P (node
) = false;
2311 if (tree chain
= OVL_CHAIN (node
))
2312 if (TREE_CODE (chain
) == OVERLOAD
)
2314 if (OVL_HIDDEN_P (chain
))
2316 /* The node needs moving, and the simplest way is to remove it
2318 overload
= remove_node (overload
, node
);
2319 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2321 else if (OVL_DEDUP_P (chain
))
2322 OVL_DEDUP_P (node
) = true;
2327 /* NODE is on the overloads of OVL. Remove it.
2328 The removed node is unaltered and may continue to be iterated
2329 from (i.e. it is safe to remove a node from an overload one is
2330 currently iterating over). */
2333 ovl_iterator::remove_node (tree overload
, tree node
)
2335 tree
*slot
= &overload
;
2336 while (*slot
!= node
)
2339 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2341 slot
= &OVL_CHAIN (probe
);
2344 /* Stitch out NODE. We don't have to worry about now making a
2345 singleton overload (and consequently maybe setting its type),
2346 because all uses of this function will be followed by inserting a
2347 new node that must follow the place we've cut this out from. */
2348 if (TREE_CODE (node
) != OVERLOAD
)
2349 /* Cloned inherited ctors don't mark themselves as via_using. */
2352 *slot
= OVL_CHAIN (node
);
2357 /* Mark or unmark a lookup set. */
2360 lookup_mark (tree ovl
, bool val
)
2362 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2364 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2365 LOOKUP_SEEN_P (*iter
) = val
;
2369 /* Add a set of new FNS into a lookup. */
2372 lookup_add (tree fns
, tree lookup
)
2374 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2375 return error_mark_node
;
2377 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2379 lookup
= ovl_make (fns
, lookup
);
2380 OVL_LOOKUP_P (lookup
) = true;
2388 /* FNS is a new overload set, add them to LOOKUP, if they are not
2389 already present there. */
2392 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2395 for (tree next
, probe
= fns
; probe
; probe
= next
)
2400 if (TREE_CODE (probe
) == OVERLOAD
)
2402 fn
= OVL_FUNCTION (probe
);
2403 next
= OVL_CHAIN (probe
);
2406 if (!LOOKUP_SEEN_P (fn
))
2407 LOOKUP_SEEN_P (fn
) = true;
2410 /* This function was already seen. Insert all the
2411 predecessors onto the lookup. */
2412 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2414 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2415 /* Propagate OVL_USING, but OVL_HIDDEN &
2416 OVL_DEDUP_P don't matter. */
2417 if (OVL_USING_P (fns
))
2418 OVL_USING_P (lookup
) = true;
2421 /* And now skip this function. */
2427 /* We ended in a set of new functions. Add them all in one go. */
2428 lookup
= lookup_add (fns
, lookup
);
2433 /* Returns nonzero if X is an expression for a (possibly overloaded)
2434 function. If "f" is a function or function template, "f", "c->f",
2435 "c.f", "C::f", and "f<int>" will all be considered possibly
2436 overloaded functions. Returns 2 if the function is actually
2437 overloaded, i.e., if it is impossible to know the type of the
2438 function without performing overload resolution. */
2441 is_overloaded_fn (tree x
)
2443 STRIP_ANY_LOCATION_WRAPPER (x
);
2445 /* A baselink is also considered an overloaded function. */
2446 if (TREE_CODE (x
) == OFFSET_REF
2447 || TREE_CODE (x
) == COMPONENT_REF
)
2448 x
= TREE_OPERAND (x
, 1);
2449 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2450 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2451 x
= TREE_OPERAND (x
, 0);
2453 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2454 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2460 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2461 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2465 dependent_name (tree x
)
2467 /* FIXME a dependent name must be unqualified, but this function doesn't
2468 distinguish between qualified and unqualified identifiers. */
2469 if (identifier_p (x
))
2471 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2472 x
= TREE_OPERAND (x
, 0);
2474 return OVL_NAME (x
);
2478 /* Returns true iff X is an expression for an overloaded function
2479 whose type cannot be known without performing overload
2483 really_overloaded_fn (tree x
)
2485 return is_overloaded_fn (x
) == 2;
2488 /* Get the overload set FROM refers to. Returns NULL if it's not an
2492 maybe_get_fns (tree from
)
2494 STRIP_ANY_LOCATION_WRAPPER (from
);
2496 /* A baselink is also considered an overloaded function. */
2497 if (TREE_CODE (from
) == OFFSET_REF
2498 || TREE_CODE (from
) == COMPONENT_REF
)
2499 from
= TREE_OPERAND (from
, 1);
2500 if (BASELINK_P (from
))
2501 from
= BASELINK_FUNCTIONS (from
);
2502 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2503 from
= TREE_OPERAND (from
, 0);
2511 /* FROM refers to an overload set. Return that set (or die). */
2516 tree res
= maybe_get_fns (from
);
2522 /* Return the first function of the overload set FROM refers to. */
2525 get_first_fn (tree from
)
2527 return OVL_FIRST (get_fns (from
));
2530 /* Return the scope where the overloaded functions OVL were found. */
2533 ovl_scope (tree ovl
)
2535 if (TREE_CODE (ovl
) == OFFSET_REF
2536 || TREE_CODE (ovl
) == COMPONENT_REF
)
2537 ovl
= TREE_OPERAND (ovl
, 1);
2538 if (TREE_CODE (ovl
) == BASELINK
)
2539 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2540 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2541 ovl
= TREE_OPERAND (ovl
, 0);
2542 /* Skip using-declarations. */
2543 lkp_iterator
iter (ovl
);
2546 while (iter
.using_p () && ++iter
);
2548 return CP_DECL_CONTEXT (ovl
);
2551 #define PRINT_RING_SIZE 4
2554 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2556 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2557 static char *print_ring
[PRINT_RING_SIZE
];
2558 static bool trans_ring
[PRINT_RING_SIZE
];
2559 static int ring_counter
;
2562 /* Only cache functions. */
2564 || TREE_CODE (decl
) != FUNCTION_DECL
2565 || DECL_LANG_SPECIFIC (decl
) == 0)
2566 return lang_decl_name (decl
, v
, translate
);
2568 /* See if this print name is lying around. */
2569 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2570 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2571 /* yes, so return it. */
2572 return print_ring
[i
];
2574 if (++ring_counter
== PRINT_RING_SIZE
)
2577 if (current_function_decl
!= NULL_TREE
)
2579 /* There may be both translated and untranslated versions of the
2581 for (i
= 0; i
< 2; i
++)
2583 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2585 if (ring_counter
== PRINT_RING_SIZE
)
2588 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2591 free (print_ring
[ring_counter
]);
2593 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2594 uid_ring
[ring_counter
] = DECL_UID (decl
);
2595 trans_ring
[ring_counter
] = translate
;
2596 return print_ring
[ring_counter
];
2600 cxx_printable_name (tree decl
, int v
)
2602 return cxx_printable_name_internal (decl
, v
, false);
2606 cxx_printable_name_translate (tree decl
, int v
)
2608 return cxx_printable_name_internal (decl
, v
, true);
2611 /* Return the canonical version of exception-specification RAISES for a C++17
2612 function type, for use in type comparison and building TYPE_CANONICAL. */
2615 canonical_eh_spec (tree raises
)
2617 if (raises
== NULL_TREE
)
2619 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2620 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2621 || uses_template_parms (raises
)
2622 || uses_template_parms (TREE_PURPOSE (raises
)))
2623 /* Keep a dependent or deferred exception specification. */
2625 else if (nothrow_spec_p (raises
))
2626 /* throw() -> noexcept. */
2627 return noexcept_true_spec
;
2629 /* For C++17 type matching, anything else -> nothing. */
2634 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2635 tree raises
, bool late
)
2637 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2639 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2642 tree v
= TYPE_MAIN_VARIANT (type
);
2643 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2644 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2647 /* Need to build a new variant. */
2648 v
= build_variant_type_copy (type
);
2649 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2650 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2653 case REF_QUAL_RVALUE
:
2654 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2655 FUNCTION_REF_QUALIFIED (v
) = 1;
2657 case REF_QUAL_LVALUE
:
2658 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2659 FUNCTION_REF_QUALIFIED (v
) = 1;
2662 FUNCTION_REF_QUALIFIED (v
) = 0;
2666 /* Canonicalize the exception specification. */
2667 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2669 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2670 /* Propagate structural equality. */
2671 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2672 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2673 /* Build the underlying canonical type, since it is different
2675 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2678 /* T is its own canonical type. */
2679 TYPE_CANONICAL (v
) = v
;
2684 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2685 listed in RAISES. */
2688 build_exception_variant (tree type
, tree raises
)
2690 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2691 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2692 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2695 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2696 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2700 bind_template_template_parm (tree t
, tree newargs
)
2702 tree decl
= TYPE_NAME (t
);
2705 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2706 decl
= build_decl (input_location
,
2707 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2709 /* These nodes have to be created to reflect new TYPE_DECL and template
2711 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2712 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2713 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2714 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2716 TREE_TYPE (decl
) = t2
;
2717 TYPE_NAME (t2
) = decl
;
2718 TYPE_STUB_DECL (t2
) = decl
;
2720 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2725 /* Called from count_trees via walk_tree. */
2728 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2738 /* Debugging function for measuring the rough complexity of a tree
2742 count_trees (tree t
)
2745 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2749 /* Called from verify_stmt_tree via walk_tree. */
2752 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2755 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2756 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2759 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2762 /* If this statement is already present in the hash table, then
2763 there is a circularity in the statement tree. */
2764 gcc_assert (!statements
->find (t
));
2766 slot
= statements
->find_slot (t
, INSERT
);
2772 /* Debugging function to check that the statement T has not been
2773 corrupted. For now, this function simply checks that T contains no
2777 verify_stmt_tree (tree t
)
2779 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2780 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2783 /* Check if the type T depends on a type with no linkage and if so, return
2784 it. If RELAXED_P then do not consider a class type declared within
2785 a vague-linkage function to have no linkage. */
2788 no_linkage_check (tree t
, bool relaxed_p
)
2792 /* Lambda types that don't have mangling scope have no linkage. We
2793 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2794 when we get here from pushtag none of the lambda information is
2795 set up yet, so we want to assume that the lambda has linkage and
2796 fix it up later if not. We need to check this even in templates so
2797 that we properly handle a lambda-expression in the signature. */
2798 if (LAMBDA_TYPE_P (t
)
2799 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2801 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2805 /* If the mangling scope is internal-linkage or not repeatable
2806 elsewhere, the lambda effectively has no linkage. (Sadly
2807 we're not very careful with the linkages of types.) */
2808 if (TREE_CODE (extra
) == VAR_DECL
2809 && !(TREE_PUBLIC (extra
)
2810 && (processing_template_decl
2811 || (DECL_LANG_SPECIFIC (extra
) && DECL_USE_TEMPLATE (extra
))
2812 /* DECL_COMDAT is set too late for us to check. */
2813 || DECL_VAR_DECLARED_INLINE_P (extra
))))
2817 /* Otherwise there's no point in checking linkage on template functions; we
2818 can't know their complete types. */
2819 if (processing_template_decl
)
2822 switch (TREE_CODE (t
))
2825 if (TYPE_PTRMEMFUNC_P (t
))
2829 if (!CLASS_TYPE_P (t
))
2833 /* Only treat unnamed types as having no linkage if they're at
2834 namespace scope. This is core issue 966. */
2835 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2838 for (r
= CP_TYPE_CONTEXT (t
); ; )
2840 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2841 have linkage, or we might just be in an anonymous namespace.
2842 If we're in a TREE_PUBLIC class, we have linkage. */
2843 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2844 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2845 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2847 if (!relaxed_p
|| !vague_linkage_p (r
))
2850 r
= CP_DECL_CONTEXT (r
);
2860 case REFERENCE_TYPE
:
2862 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2866 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2870 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2875 tree parm
= TYPE_ARG_TYPES (t
);
2876 if (TREE_CODE (t
) == METHOD_TYPE
)
2877 /* The 'this' pointer isn't interesting; a method has the same
2878 linkage (or lack thereof) as its enclosing class. */
2879 parm
= TREE_CHAIN (parm
);
2881 parm
&& parm
!= void_list_node
;
2882 parm
= TREE_CHAIN (parm
))
2884 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2888 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2896 extern int depth_reached
;
2899 cxx_print_statistics (void)
2901 print_template_statistics ();
2902 if (GATHER_STATISTICS
)
2903 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2907 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2908 (which is an ARRAY_TYPE). This counts only elements of the top
2912 array_type_nelts_top (tree type
)
2914 return fold_build2_loc (input_location
,
2915 PLUS_EXPR
, sizetype
,
2916 array_type_nelts (type
),
2920 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2921 (which is an ARRAY_TYPE). This one is a recursive count of all
2922 ARRAY_TYPEs that are clumped together. */
2925 array_type_nelts_total (tree type
)
2927 tree sz
= array_type_nelts_top (type
);
2928 type
= TREE_TYPE (type
);
2929 while (TREE_CODE (type
) == ARRAY_TYPE
)
2931 tree n
= array_type_nelts_top (type
);
2932 sz
= fold_build2_loc (input_location
,
2933 MULT_EXPR
, sizetype
, sz
, n
);
2934 type
= TREE_TYPE (type
);
2941 splay_tree target_remap
;
2942 bool clear_location
;
2945 /* Called from break_out_target_exprs via mapcar. */
2948 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2950 bot_data
&data
= *(bot_data
*)data_
;
2951 splay_tree target_remap
= data
.target_remap
;
2954 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2956 /* There can't be any TARGET_EXPRs or their slot variables below this
2957 point. But we must make a copy, in case subsequent processing
2958 alters any part of it. For example, during gimplification a cast
2959 of the form (T) &X::f (where "f" is a member function) will lead
2960 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2962 *tp
= unshare_expr (t
);
2965 if (TREE_CODE (t
) == TARGET_EXPR
)
2969 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2971 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2972 tf_warning_or_error
);
2973 if (u
== error_mark_node
)
2975 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2976 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2979 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2980 tf_warning_or_error
);
2982 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2983 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2984 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2986 /* Map the old variable to the new one. */
2987 splay_tree_insert (target_remap
,
2988 (splay_tree_key
) TREE_OPERAND (t
, 0),
2989 (splay_tree_value
) TREE_OPERAND (u
, 0));
2991 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2992 data
.clear_location
);
2993 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2994 return error_mark_node
;
2996 /* Replace the old expression with the new version. */
2998 /* We don't have to go below this point; the recursive call to
2999 break_out_target_exprs will have handled anything below this
3004 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3007 splay_tree_node n
= splay_tree_lookup (target_remap
,
3008 (splay_tree_key
) t
);
3011 *tp
= (tree
)n
->value
;
3016 copy_tree_r (tp
, walk_subtrees
, NULL
);
3017 splay_tree_insert (target_remap
,
3019 (splay_tree_value
)*tp
);
3020 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3021 splay_tree_insert (target_remap
,
3022 (splay_tree_key
)*tp
,
3023 (splay_tree_value
)*tp
);
3028 /* Make a copy of this node. */
3029 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3030 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3031 if (!processing_template_decl
)
3032 set_flags_from_callee (*tp
);
3033 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3034 SET_EXPR_LOCATION (*tp
, input_location
);
3038 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3039 DATA is really a splay-tree mapping old variables to new
3043 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3045 bot_data
&data
= *(bot_data
*)data_
;
3046 splay_tree target_remap
= data
.target_remap
;
3050 splay_tree_node n
= splay_tree_lookup (target_remap
,
3051 (splay_tree_key
) *t
);
3053 *t
= (tree
) n
->value
;
3055 else if (TREE_CODE (*t
) == PARM_DECL
3056 && DECL_NAME (*t
) == this_identifier
3057 && !DECL_CONTEXT (*t
))
3059 /* In an NSDMI we need to replace the 'this' parameter we used for
3060 parsing with the real one for this function. */
3061 *t
= current_class_ptr
;
3063 else if (TREE_CODE (*t
) == CONVERT_EXPR
3064 && CONVERT_EXPR_VBASE_PATH (*t
))
3066 /* In an NSDMI build_base_path defers building conversions to virtual
3067 bases, and we handle it here. */
3068 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3069 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3071 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3072 if (BINFO_TYPE (binfo
) == basetype
)
3074 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3075 tf_warning_or_error
);
3081 /* When we parse a default argument expression, we may create
3082 temporary variables via TARGET_EXPRs. When we actually use the
3083 default-argument expression, we make a copy of the expression
3084 and replace the temporaries with appropriate local versions.
3086 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3090 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3092 static int target_remap_count
;
3093 static splay_tree target_remap
;
3095 if (!target_remap_count
++)
3096 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3097 /*splay_tree_delete_key_fn=*/NULL
,
3098 /*splay_tree_delete_value_fn=*/NULL
);
3099 bot_data data
= { target_remap
, clear_location
};
3100 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3101 t
= error_mark_node
;
3102 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3104 if (!--target_remap_count
)
3106 splay_tree_delete (target_remap
);
3107 target_remap
= NULL
;
3113 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3114 which we expect to have type TYPE. */
3117 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3119 if (index
== NULL_TREE
)
3120 /* Can't refer to a particular member of a vector. */
3122 else if (TREE_CODE (index
) == INTEGER_CST
)
3123 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3125 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3126 /*reference*/false, tf_none
);
3129 tree objtype
= TREE_TYPE (obj
);
3130 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3132 /* When the destination object refers to a flexible array member
3133 verify that it matches the type of the source object except
3134 for its domain and qualifiers. */
3135 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3136 TYPE_MAIN_VARIANT (objtype
),
3137 COMPARE_REDECLARATION
));
3140 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3146 struct replace_placeholders_t
3148 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3149 tree exp
; /* The outermost exp. */
3150 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3151 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3154 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3155 build up subexpressions as we go deeper. */
3158 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3160 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3163 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3165 *walk_subtrees
= false;
3169 switch (TREE_CODE (*t
))
3171 case PLACEHOLDER_EXPR
:
3174 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3176 x
= TREE_OPERAND (x
, 0))
3177 gcc_assert (handled_component_p (x
));
3178 *t
= unshare_expr (x
);
3179 *walk_subtrees
= false;
3186 constructor_elt
*ce
;
3187 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3188 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3189 other than the d->exp one, those have PLACEHOLDER_EXPRs
3190 related to another object. */
3191 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3193 || d
->pset
->add (*t
))
3195 *walk_subtrees
= false;
3198 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3200 tree
*valp
= &ce
->value
;
3201 tree type
= TREE_TYPE (*valp
);
3204 /* Elements with RANGE_EXPR index shouldn't have any
3205 placeholders in them. */
3206 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3209 if (TREE_CODE (*valp
) == CONSTRUCTOR
3210 && AGGREGATE_TYPE_P (type
))
3212 /* If we're looking at the initializer for OBJ, then build
3213 a sub-object reference. If we're looking at an
3214 initializer for another object, just pass OBJ down. */
3215 if (same_type_ignoring_top_level_qualifiers_p
3216 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3217 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3218 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3219 valp
= &TARGET_EXPR_INITIAL (*valp
);
3222 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3225 *walk_subtrees
= false;
3230 if (d
->pset
->add (*t
))
3231 *walk_subtrees
= false;
3238 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3239 a PLACEHOLDER_EXPR has been encountered. */
3242 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3244 /* This is only relevant for C++14. */
3245 if (cxx_dialect
< cxx14
)
3248 /* If the object isn't a (member of a) class, do nothing. */
3250 while (TREE_CODE (op0
) == COMPONENT_REF
)
3251 op0
= TREE_OPERAND (op0
, 0);
3252 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3256 if (TREE_CODE (exp
) == TARGET_EXPR
)
3257 tp
= &TARGET_EXPR_INITIAL (exp
);
3258 hash_set
<tree
> pset
;
3259 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3260 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3262 *seen_p
= data
.seen
;
3266 /* Callback function for find_placeholders. */
3269 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3271 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3273 *walk_subtrees
= false;
3277 switch (TREE_CODE (*t
))
3279 case PLACEHOLDER_EXPR
:
3283 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3284 *walk_subtrees
= false;
3294 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3295 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3298 find_placeholders (tree exp
)
3300 /* This is only relevant for C++14. */
3301 if (cxx_dialect
< cxx14
)
3304 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3307 /* Similar to `build_nt', but for template definitions of dependent
3311 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3318 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3322 t
= make_node (code
);
3323 SET_EXPR_LOCATION (t
, loc
);
3324 length
= TREE_CODE_LENGTH (code
);
3326 for (i
= 0; i
< length
; i
++)
3327 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3333 /* Similar to `build', but for template definitions. */
3336 build_min (enum tree_code code
, tree tt
, ...)
3343 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3347 t
= make_node (code
);
3348 length
= TREE_CODE_LENGTH (code
);
3351 for (i
= 0; i
< length
; i
++)
3353 tree x
= va_arg (p
, tree
);
3354 TREE_OPERAND (t
, i
) = x
;
3355 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3356 TREE_SIDE_EFFECTS (t
) = 1;
3364 /* Similar to `build', but for template definitions of non-dependent
3365 expressions. NON_DEP is the non-dependent expression that has been
3369 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3376 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3378 va_start (p
, non_dep
);
3380 if (REFERENCE_REF_P (non_dep
))
3381 non_dep
= TREE_OPERAND (non_dep
, 0);
3383 t
= make_node (code
);
3384 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3385 length
= TREE_CODE_LENGTH (code
);
3386 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3387 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3389 for (i
= 0; i
< length
; i
++)
3390 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3392 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3393 /* This should not be considered a COMPOUND_EXPR, because it
3394 resolves to an overload. */
3395 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3398 return convert_from_reference (t
);
3401 /* Similar to build_min_nt, but call expressions */
3404 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3409 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3410 CALL_EXPR_FN (ret
) = fn
;
3411 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3412 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3413 CALL_EXPR_ARG (ret
, ix
) = t
;
3418 /* Similar to `build_min_nt_call_vec', but for template definitions of
3419 non-dependent expressions. NON_DEP is the non-dependent expression
3420 that has been built. */
3423 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3425 tree t
= build_min_nt_call_vec (fn
, argvec
);
3426 if (REFERENCE_REF_P (non_dep
))
3427 non_dep
= TREE_OPERAND (non_dep
, 0);
3428 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3429 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3430 return convert_from_reference (t
);
3433 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3434 a call to an operator overload. OP is the operator that has been
3435 overloaded. NON_DEP is the non-dependent expression that's been built,
3436 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3437 the overload that NON_DEP is calling. */
3440 build_min_non_dep_op_overload (enum tree_code op
,
3445 int nargs
, expected_nargs
;
3448 non_dep
= extract_call_expr (non_dep
);
3450 nargs
= call_expr_nargs (non_dep
);
3452 expected_nargs
= cp_tree_code_length (op
);
3453 if ((op
== POSTINCREMENT_EXPR
3454 || op
== POSTDECREMENT_EXPR
)
3455 /* With -fpermissive non_dep could be operator++(). */
3456 && (!flag_permissive
|| nargs
!= expected_nargs
))
3457 expected_nargs
+= 1;
3458 gcc_assert (nargs
== expected_nargs
);
3461 va_start (p
, overload
);
3463 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3466 for (int i
= 0; i
< nargs
; i
++)
3468 tree arg
= va_arg (p
, tree
);
3469 vec_safe_push (args
, arg
);
3472 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3474 tree object
= va_arg (p
, tree
);
3475 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3476 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3477 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3478 object
, method
, NULL_TREE
);
3479 for (int i
= 1; i
< nargs
; i
++)
3481 tree arg
= va_arg (p
, tree
);
3482 vec_safe_push (args
, arg
);
3489 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3491 tree call_expr
= extract_call_expr (call
);
3492 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3493 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3494 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3495 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3500 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3503 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3505 unsigned len
= vec_safe_length (old_vec
);
3506 gcc_assert (idx
<= len
);
3508 vec
<tree
, va_gc
> *new_vec
= NULL
;
3509 vec_alloc (new_vec
, len
+ 1);
3512 for (i
= 0; i
< len
; ++i
)
3515 new_vec
->quick_push (elt
);
3516 new_vec
->quick_push ((*old_vec
)[i
]);
3519 new_vec
->quick_push (elt
);
3525 get_type_decl (tree t
)
3527 if (TREE_CODE (t
) == TYPE_DECL
)
3530 return TYPE_STUB_DECL (t
);
3531 gcc_assert (t
== error_mark_node
);
3535 /* Returns the namespace that contains DECL, whether directly or
3539 decl_namespace_context (tree decl
)
3543 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3545 else if (TYPE_P (decl
))
3546 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3548 decl
= CP_DECL_CONTEXT (decl
);
3552 /* Returns true if decl is within an anonymous namespace, however deeply
3553 nested, or false otherwise. */
3556 decl_anon_ns_mem_p (const_tree decl
)
3558 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3560 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3562 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3564 decl
= CP_DECL_CONTEXT (decl
);
3566 return !TREE_PUBLIC (decl
);
3569 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3570 CALL_EXPRS. Return whether they are equivalent. */
3573 called_fns_equal (tree t1
, tree t2
)
3575 /* Core 1321: dependent names are equivalent even if the overload sets
3576 are different. But do compare explicit template arguments. */
3577 tree name1
= dependent_name (t1
);
3578 tree name2
= dependent_name (t2
);
3581 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3586 /* FIXME dependent_name currently returns an unqualified name regardless
3587 of whether the function was named with a qualified- or unqualified-id.
3588 Until that's fixed, check that we aren't looking at overload sets from
3589 different scopes. */
3590 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3591 && (DECL_CONTEXT (get_first_fn (t1
))
3592 != DECL_CONTEXT (get_first_fn (t2
))))
3595 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3596 targs1
= TREE_OPERAND (t1
, 1);
3597 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3598 targs2
= TREE_OPERAND (t2
, 1);
3599 return cp_tree_equal (targs1
, targs2
);
3602 return cp_tree_equal (t1
, t2
);
3605 /* Return truthvalue of whether T1 is the same tree structure as T2.
3606 Return 1 if they are the same. Return 0 if they are different. */
3609 cp_tree_equal (tree t1
, tree t2
)
3611 enum tree_code code1
, code2
;
3618 code1
= TREE_CODE (t1
);
3619 code2
= TREE_CODE (t2
);
3624 if (CONSTANT_CLASS_P (t1
)
3625 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3631 /* There's only a single VOID_CST node, so we should never reach
3636 return tree_int_cst_equal (t1
, t2
);
3639 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3642 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3643 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3644 TREE_STRING_LENGTH (t1
));
3647 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3648 TREE_FIXED_CST (t2
));
3651 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3652 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3655 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3658 /* We need to do this when determining whether or not two
3659 non-type pointer to member function template arguments
3661 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3662 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3667 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3669 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3670 if (!cp_tree_equal (field
, elt2
->index
)
3671 || !cp_tree_equal (value
, elt2
->value
))
3678 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3680 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3682 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3685 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3690 call_expr_arg_iterator iter1
, iter2
;
3691 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
)
3692 || !called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3694 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3695 arg2
= first_call_expr_arg (t2
, &iter2
);
3697 arg1
= next_call_expr_arg (&iter1
),
3698 arg2
= next_call_expr_arg (&iter2
))
3699 if (!cp_tree_equal (arg1
, arg2
))
3708 tree o1
= TREE_OPERAND (t1
, 0);
3709 tree o2
= TREE_OPERAND (t2
, 0);
3711 /* Special case: if either target is an unallocated VAR_DECL,
3712 it means that it's going to be unified with whatever the
3713 TARGET_EXPR is really supposed to initialize, so treat it
3714 as being equivalent to anything. */
3715 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3716 && !DECL_RTL_SET_P (o1
))
3718 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3719 && !DECL_RTL_SET_P (o2
))
3721 else if (!cp_tree_equal (o1
, o2
))
3724 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3728 /* For comparing uses of parameters in late-specified return types
3729 with an out-of-class definition of the function, but can also come
3730 up for expressions that involve 'this' in a member function
3733 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3734 /* When comparing hash table entries, only an exact match is
3735 good enough; we don't want to replace 'this' with the
3736 version from another function. But be more flexible
3737 with local parameters in a requires-expression. */
3740 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3742 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3744 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3746 if (DECL_ARTIFICIAL (t1
)
3747 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3748 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3758 case IDENTIFIER_NODE
:
3761 case DEFERRED_PARSE
:
3765 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3766 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3767 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3768 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3769 BASELINK_FUNCTIONS (t2
)));
3771 case TEMPLATE_PARM_INDEX
:
3772 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3773 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3774 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3775 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3776 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3777 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3779 case TEMPLATE_ID_EXPR
:
3780 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3781 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3783 case CONSTRAINT_INFO
:
3784 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3785 CI_ASSOCIATED_CONSTRAINTS (t2
));
3788 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3789 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3790 CHECK_CONSTR_ARGS (t2
)));
3795 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3797 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3798 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3799 TREE_VEC_ELT (t2
, ix
)))
3807 tree o1
= TREE_OPERAND (t1
, 0);
3808 tree o2
= TREE_OPERAND (t2
, 0);
3810 if (code1
== SIZEOF_EXPR
)
3812 if (SIZEOF_EXPR_TYPE_P (t1
))
3813 o1
= TREE_TYPE (o1
);
3814 if (SIZEOF_EXPR_TYPE_P (t2
))
3815 o2
= TREE_TYPE (o2
);
3818 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3821 if (ARGUMENT_PACK_P (o1
))
3822 return template_args_equal (o1
, o2
);
3823 else if (TYPE_P (o1
))
3824 return same_type_p (o1
, o2
);
3826 return cp_tree_equal (o1
, o2
);
3831 tree t1_op1
, t2_op1
;
3833 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3836 t1_op1
= TREE_OPERAND (t1
, 1);
3837 t2_op1
= TREE_OPERAND (t2
, 1);
3838 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3841 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3845 /* Two pointer-to-members are the same if they point to the same
3846 field or function in the same class. */
3847 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3850 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3854 /* Two overloads. Must be exactly the same set of decls. */
3855 lkp_iterator
first (t1
);
3856 lkp_iterator
second (t2
);
3858 for (; first
&& second
; ++first
, ++second
)
3859 if (*first
!= *second
)
3861 return !(first
|| second
);
3865 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3867 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3868 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3871 case STATIC_CAST_EXPR
:
3872 case REINTERPRET_CAST_EXPR
:
3873 case CONST_CAST_EXPR
:
3874 case DYNAMIC_CAST_EXPR
:
3875 case IMPLICIT_CONV_EXPR
:
3878 case NON_LVALUE_EXPR
:
3879 case VIEW_CONVERT_EXPR
:
3880 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3882 /* Now compare operands as usual. */
3885 case DEFERRED_NOEXCEPT
:
3886 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3887 DEFERRED_NOEXCEPT_PATTERN (t2
))
3888 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3889 DEFERRED_NOEXCEPT_ARGS (t2
)));
3892 /* Two lambda-expressions are never considered equivalent. */
3895 case TYPE_ARGUMENT_PACK
:
3896 case NONTYPE_ARGUMENT_PACK
:
3898 tree p1
= ARGUMENT_PACK_ARGS (t1
);
3899 tree p2
= ARGUMENT_PACK_ARGS (t2
);
3900 int len
= TREE_VEC_LENGTH (p1
);
3901 if (TREE_VEC_LENGTH (p2
) != len
)
3904 for (int ix
= 0; ix
!= len
; ix
++)
3905 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
3906 TREE_VEC_ELT (p2
, ix
)))
3915 switch (TREE_CODE_CLASS (code1
))
3919 case tcc_comparison
:
3920 case tcc_expression
:
3927 n
= cp_tree_operand_length (t1
);
3928 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3929 && n
!= TREE_OPERAND_LENGTH (t2
))
3932 for (i
= 0; i
< n
; ++i
)
3933 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3940 return same_type_p (t1
, t2
);
3944 /* We can get here with --disable-checking. */
3948 /* The type of ARG when used as an lvalue. */
3951 lvalue_type (tree arg
)
3953 tree type
= TREE_TYPE (arg
);
3957 /* The type of ARG for printing error messages; denote lvalues with
3961 error_type (tree arg
)
3963 tree type
= TREE_TYPE (arg
);
3965 if (TREE_CODE (type
) == ARRAY_TYPE
)
3967 else if (TREE_CODE (type
) == ERROR_MARK
)
3969 else if (lvalue_p (arg
))
3970 type
= build_reference_type (lvalue_type (arg
));
3971 else if (MAYBE_CLASS_TYPE_P (type
))
3972 type
= lvalue_type (arg
);
3977 /* Does FUNCTION use a variable-length argument list? */
3980 varargs_function_p (const_tree function
)
3982 return stdarg_p (TREE_TYPE (function
));
3985 /* Returns 1 if decl is a member of a class. */
3988 member_p (const_tree decl
)
3990 const_tree
const ctx
= DECL_CONTEXT (decl
);
3991 return (ctx
&& TYPE_P (ctx
));
3994 /* Create a placeholder for member access where we don't actually have an
3995 object that the access is against. */
3998 build_dummy_object (tree type
)
4000 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4001 return cp_build_fold_indirect_ref (decl
);
4004 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4005 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4006 binfo path from current_class_type to TYPE, or 0. */
4009 maybe_dummy_object (tree type
, tree
* binfop
)
4013 tree current
= current_nonlambda_class_type ();
4016 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4017 tf_warning_or_error
)))
4021 /* Reference from a nested class member function. */
4023 binfo
= TYPE_BINFO (type
);
4029 if (current_class_ref
4030 /* current_class_ref might not correspond to current_class_type if
4031 we're in tsubst_default_argument or a lambda-declarator; in either
4032 case, we want to use current_class_ref if it matches CONTEXT. */
4033 && (same_type_ignoring_top_level_qualifiers_p
4034 (TREE_TYPE (current_class_ref
), context
)))
4035 decl
= current_class_ref
;
4037 decl
= build_dummy_object (context
);
4042 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4045 is_dummy_object (const_tree ob
)
4047 if (INDIRECT_REF_P (ob
))
4048 ob
= TREE_OPERAND (ob
, 0);
4049 return (TREE_CODE (ob
) == CONVERT_EXPR
4050 && TREE_OPERAND (ob
, 0) == void_node
);
4053 /* Returns 1 iff type T is something we want to treat as a scalar type for
4054 the purpose of deciding whether it is trivial/POD/standard-layout. */
4057 scalarish_type_p (const_tree t
)
4059 if (t
== error_mark_node
)
4062 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4065 /* Returns true iff T requires non-trivial default initialization. */
4068 type_has_nontrivial_default_init (const_tree t
)
4070 t
= strip_array_types (CONST_CAST_TREE (t
));
4072 if (CLASS_TYPE_P (t
))
4073 return TYPE_HAS_COMPLEX_DFLT (t
);
4078 /* Track classes with only deleted copy/move constructors so that we can warn
4079 if they are used in call/return by value. */
4081 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4083 remember_deleted_copy (const_tree t
)
4085 if (!deleted_copy_types
)
4086 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4087 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4090 maybe_warn_parm_abi (tree t
, location_t loc
)
4092 if (!deleted_copy_types
4093 || !deleted_copy_types
->contains (t
))
4096 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4097 && classtype_has_non_deleted_move_ctor (t
))
4100 auto_diagnostic_group d
;
4101 if (flag_abi_version
> 12)
4102 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4103 "the calling convention for %qT, which was "
4104 "accidentally changed in 8.1", t
);
4106 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4107 "ally changes the calling convention for %qT", t
);
4109 inform (location_of (t
), " declared here");
4113 auto_diagnostic_group d
;
4114 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4115 "%<-fabi-version=13%> (GCC 8.2)", t
))
4116 inform (location_of (t
), " because all of its copy and move "
4117 "constructors are deleted");
4120 /* Returns true iff copying an object of type T (including via move
4121 constructor) is non-trivial. That is, T has no non-trivial copy
4122 constructors and no non-trivial move constructors, and not all copy/move
4123 constructors are deleted. This function implements the ABI notion of
4124 non-trivial copy, which has diverged from the one in the standard. */
4127 type_has_nontrivial_copy_init (const_tree type
)
4129 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4131 if (CLASS_TYPE_P (t
))
4133 gcc_assert (COMPLETE_TYPE_P (t
));
4135 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4136 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4140 if (cxx_dialect
< cxx11
)
4141 /* No deleted functions before C++11. */
4144 /* Before ABI v12 we did a bitwise copy of types with only deleted
4145 copy/move constructors. */
4146 if (!abi_version_at_least (12)
4147 && !(warn_abi
&& abi_version_crosses (12)))
4150 bool saw_copy
= false;
4151 bool saw_non_deleted
= false;
4152 bool saw_non_deleted_move
= false;
4154 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4155 saw_copy
= saw_non_deleted
= true;
4156 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4159 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4160 /* [class.copy]/8 If the class definition declares a move
4161 constructor or move assignment operator, the implicitly declared
4162 copy constructor is defined as deleted.... */;
4164 /* Any other reason the implicitly-declared function would be
4165 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4167 saw_non_deleted
= true;
4170 if (!saw_non_deleted
)
4171 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4177 if (!DECL_DELETED_FN (fn
))
4179 /* Not deleted, therefore trivial. */
4180 saw_non_deleted
= true;
4184 else if (move_fn_p (fn
))
4185 if (!DECL_DELETED_FN (fn
))
4186 saw_non_deleted_move
= true;
4189 gcc_assert (saw_copy
);
4191 /* ABI v12 buggily ignored move constructors. */
4192 bool v11nontriv
= false;
4193 bool v12nontriv
= !saw_non_deleted
;
4194 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4195 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4196 : flag_abi_version
== 12 ? v12nontriv
4198 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4199 : warn_abi_version
== 12 ? v12nontriv
4201 if (nontriv
!= warn_nontriv
)
4202 remember_deleted_copy (t
);
4210 /* Returns 1 iff type T is a trivially copyable type, as defined in
4211 [basic.types] and [class]. */
4214 trivially_copyable_p (const_tree t
)
4216 t
= strip_array_types (CONST_CAST_TREE (t
));
4218 if (CLASS_TYPE_P (t
))
4219 return ((!TYPE_HAS_COPY_CTOR (t
)
4220 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4221 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4222 && (!TYPE_HAS_COPY_ASSIGN (t
)
4223 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4224 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4225 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4227 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4228 return scalarish_type_p (t
);
4231 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4235 trivial_type_p (const_tree t
)
4237 t
= strip_array_types (CONST_CAST_TREE (t
));
4239 if (CLASS_TYPE_P (t
))
4240 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4241 && trivially_copyable_p (t
));
4243 return scalarish_type_p (t
);
4246 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4249 pod_type_p (const_tree t
)
4251 /* This CONST_CAST is okay because strip_array_types returns its
4252 argument unmodified and we assign it to a const_tree. */
4253 t
= strip_array_types (CONST_CAST_TREE(t
));
4255 if (!CLASS_TYPE_P (t
))
4256 return scalarish_type_p (t
);
4257 else if (cxx_dialect
> cxx98
)
4258 /* [class]/10: A POD struct is a class that is both a trivial class and a
4259 standard-layout class, and has no non-static data members of type
4260 non-POD struct, non-POD union (or array of such types).
4262 We don't need to check individual members because if a member is
4263 non-std-layout or non-trivial, the class will be too. */
4264 return (std_layout_type_p (t
) && trivial_type_p (t
));
4266 /* The C++98 definition of POD is different. */
4267 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4270 /* Returns true iff T is POD for the purpose of layout, as defined in the
4274 layout_pod_type_p (const_tree t
)
4276 t
= strip_array_types (CONST_CAST_TREE (t
));
4278 if (CLASS_TYPE_P (t
))
4279 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4281 return scalarish_type_p (t
);
4284 /* Returns true iff T is a standard-layout type, as defined in
4288 std_layout_type_p (const_tree t
)
4290 t
= strip_array_types (CONST_CAST_TREE (t
));
4292 if (CLASS_TYPE_P (t
))
4293 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4295 return scalarish_type_p (t
);
4298 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4300 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4301 as defined in [meta.unary.prop]. */
4304 type_has_unique_obj_representations (const_tree t
)
4308 t
= strip_array_types (CONST_CAST_TREE (t
));
4310 if (!trivially_copyable_p (t
))
4313 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4314 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4316 switch (TREE_CODE (t
))
4320 case REFERENCE_TYPE
:
4321 /* If some backend has any paddings in these types, we should add
4322 a target hook for this and handle it there. */
4326 /* For bool values other than 0 and 1 should only appear with
4327 undefined behavior. */
4331 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4334 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4335 when storing long double values, so for that we have to return false.
4336 Other kinds of floating point values are questionable due to +.0/-.0
4337 and NaNs, let's play safe for now. */
4340 case FIXED_POINT_TYPE
:
4348 return type_has_unique_obj_representations (TREE_TYPE (t
));
4351 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4352 if (CLASS_TYPE_P (t
))
4354 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4355 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4363 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4364 if (TREE_CODE (field
) == FIELD_DECL
)
4367 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4368 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4374 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4376 if (CLASS_TYPE_P (t
))
4378 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4379 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4394 /* Helper function for type_has_unique_obj_representations. */
4397 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4399 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4400 if (TREE_CODE (field
) != FIELD_DECL
)
4402 /* For bases, can't use type_has_unique_obj_representations here, as in
4403 struct S { int i : 24; S (); };
4404 struct T : public S { int j : 8; T (); };
4405 S doesn't have unique obj representations, but T does. */
4406 else if (DECL_FIELD_IS_BASE (field
))
4408 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4412 else if (DECL_C_BIT_FIELD (field
))
4414 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4415 if (!type_has_unique_obj_representations (btype
))
4418 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4422 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4423 if (TREE_CODE (field
) == FIELD_DECL
)
4425 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4426 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4427 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4430 if (DECL_SIZE (field
))
4432 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4436 if (cur
!= wi::to_offset (sz
))
4442 /* Nonzero iff type T is a class template implicit specialization. */
4445 class_tmpl_impl_spec_p (const_tree t
)
4447 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4450 /* Returns 1 iff zero initialization of type T means actually storing
4454 zero_init_p (const_tree t
)
4456 /* This CONST_CAST is okay because strip_array_types returns its
4457 argument unmodified and we assign it to a const_tree. */
4458 t
= strip_array_types (CONST_CAST_TREE(t
));
4460 if (t
== error_mark_node
)
4463 /* NULL pointers to data members are initialized with -1. */
4464 if (TYPE_PTRDATAMEM_P (t
))
4467 /* Classes that contain types that can't be zero-initialized, cannot
4468 be zero-initialized themselves. */
4469 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4475 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4476 non-type template parameter. If EXPLAIN, explain why not. */
4479 structural_type_p (tree t
, bool explain
)
4481 t
= strip_array_types (t
);
4482 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
4484 if (NULLPTR_TYPE_P (t
))
4486 if (TYPE_PTR_P (t
) || TYPE_PTRMEM_P (t
))
4488 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4490 if (!CLASS_TYPE_P (t
))
4492 if (TREE_CODE (t
) == UNION_TYPE
)
4495 inform (location_of (t
), "%qT is a union", t
);
4498 if (!literal_type_p (t
))
4501 explain_non_literal_class (t
);
4504 if (CLASSTYPE_HAS_MUTABLE (t
))
4507 inform (location_of (t
), "%qT has a mutable member", t
);
4510 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4511 m
= next_initializable_field (DECL_CHAIN (m
)))
4513 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4517 if (DECL_FIELD_IS_BASE (m
))
4518 inform (location_of (m
), "base class %qT is not public",
4521 inform (location_of (m
), "%qD is not public", m
);
4525 if (!structural_type_p (TREE_TYPE (m
)))
4529 inform (location_of (m
), "%qD has a non-structural type", m
);
4530 structural_type_p (TREE_TYPE (m
), true);
4538 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4539 warn_unused_result attribute. */
4542 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4543 int /*flags*/, bool *no_add_attrs
)
4545 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4547 error ("%qE attribute argument must be a string constant", name
);
4548 *no_add_attrs
= true;
4550 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4552 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4553 && !DECL_CONSTRUCTOR_P (*node
))
4554 warning_at (DECL_SOURCE_LOCATION (*node
),
4555 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4556 "return type", name
, *node
);
4558 else if (OVERLOAD_TYPE_P (*node
))
4562 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4563 "functions or to class or enumeration types", name
);
4564 *no_add_attrs
= true;
4569 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4570 struct attribute_spec.handler. */
4572 handle_no_unique_addr_attribute (tree
* node
,
4578 if (TREE_CODE (*node
) != FIELD_DECL
)
4580 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4581 "non-static data members", name
);
4582 *no_add_attrs
= true;
4584 else if (DECL_C_BIT_FIELD (*node
))
4586 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4587 "a bit-field", name
);
4588 *no_add_attrs
= true;
4594 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4595 hot/cold attributes. */
4598 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4599 int flags
, bool *no_add_attrs
)
4601 *no_add_attrs
= true;
4602 if (TREE_CODE (*node
) == LABEL_DECL
4603 || TREE_CODE (*node
) == FUNCTION_DECL
)
4606 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4607 tree bname
= (is_attribute_p ("likely", name
)
4608 ? get_identifier ("hot") : get_identifier ("cold"));
4609 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4610 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4611 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4612 tree battr
= build_tree_list (bname
, NULL_TREE
);
4613 decl_attributes (node
, battr
, flags
);
4617 return error_mark_node
;
4620 /* Table of valid C++ attributes. */
4621 const struct attribute_spec cxx_attribute_table
[] =
4623 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4624 affects_type_identity, handler, exclude } */
4625 { "init_priority", 1, 1, true, false, false, false,
4626 handle_init_priority_attribute
, NULL
},
4627 { "abi_tag", 1, -1, false, false, false, true,
4628 handle_abi_tag_attribute
, NULL
},
4629 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4632 /* Table of C++ standard attributes. */
4633 const struct attribute_spec std_attribute_table
[] =
4635 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4636 affects_type_identity, handler, exclude } */
4637 { "maybe_unused", 0, 0, false, false, false, false,
4638 handle_unused_attribute
, NULL
},
4639 { "nodiscard", 0, 1, false, false, false, false,
4640 handle_nodiscard_attribute
, NULL
},
4641 { "no_unique_address", 0, 0, true, false, false, false,
4642 handle_no_unique_addr_attribute
, NULL
},
4643 { "likely", 0, 0, false, false, false, false,
4644 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4645 { "unlikely", 0, 0, false, false, false, false,
4646 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4647 { "noreturn", 0, 0, true, false, false, false,
4648 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4649 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4652 /* Handle an "init_priority" attribute; arguments as in
4653 struct attribute_spec.handler. */
4655 handle_init_priority_attribute (tree
* node
,
4661 tree initp_expr
= TREE_VALUE (args
);
4663 tree type
= TREE_TYPE (decl
);
4666 STRIP_NOPS (initp_expr
);
4667 initp_expr
= default_conversion (initp_expr
);
4669 initp_expr
= maybe_constant_value (initp_expr
);
4671 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4673 error ("requested %<init_priority%> is not an integer constant");
4674 cxx_constant_value (initp_expr
);
4675 *no_add_attrs
= true;
4679 pri
= TREE_INT_CST_LOW (initp_expr
);
4681 type
= strip_array_types (type
);
4683 if (decl
== NULL_TREE
4685 || !TREE_STATIC (decl
)
4686 || DECL_EXTERNAL (decl
)
4687 || (TREE_CODE (type
) != RECORD_TYPE
4688 && TREE_CODE (type
) != UNION_TYPE
)
4689 /* Static objects in functions are initialized the
4690 first time control passes through that
4691 function. This is not precise enough to pin down an
4692 init_priority value, so don't allow it. */
4693 || current_function_decl
)
4695 error ("can only use %qE attribute on file-scope definitions "
4696 "of objects of class type", name
);
4697 *no_add_attrs
= true;
4701 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4703 error ("requested %<init_priority%> %i is out of range [0, %i]",
4704 pri
, MAX_INIT_PRIORITY
);
4705 *no_add_attrs
= true;
4709 /* Check for init_priorities that are reserved for
4710 language and runtime support implementations.*/
4711 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4714 (0, "requested %<init_priority%> %i is reserved for internal use",
4718 if (SUPPORTS_INIT_PRIORITY
)
4720 SET_DECL_INIT_PRIORITY (decl
, pri
);
4721 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4726 error ("%qE attribute is not supported on this platform", name
);
4727 *no_add_attrs
= true;
4732 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4733 and the new one has the tags in NEW_. Give an error if there are tags
4734 in NEW_ that weren't in OLD. */
4737 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4739 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4740 old
= TREE_VALUE (old
);
4741 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4742 new_
= TREE_VALUE (new_
);
4744 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4746 tree str
= TREE_VALUE (t
);
4747 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4749 tree ostr
= TREE_VALUE (in
);
4750 if (cp_tree_equal (str
, ostr
))
4753 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4759 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4765 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4766 ill-formed, give an error and return false; otherwise, return true. */
4769 check_abi_tag_args (tree args
, tree name
)
4773 error ("the %qE attribute requires arguments", name
);
4776 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4778 tree elt
= TREE_VALUE (arg
);
4779 if (TREE_CODE (elt
) != STRING_CST
4780 || (!same_type_ignoring_top_level_qualifiers_p
4781 (strip_array_types (TREE_TYPE (elt
)),
4784 error ("arguments to the %qE attribute must be narrow string "
4788 const char *begin
= TREE_STRING_POINTER (elt
);
4789 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4790 for (const char *p
= begin
; p
!= end
; ++p
)
4795 if (!ISALPHA (c
) && c
!= '_')
4797 error ("arguments to the %qE attribute must contain valid "
4798 "identifiers", name
);
4799 inform (input_location
, "%<%c%> is not a valid first "
4800 "character for an identifier", c
);
4804 else if (p
== end
- 1)
4805 gcc_assert (c
== 0);
4808 if (!ISALNUM (c
) && c
!= '_')
4810 error ("arguments to the %qE attribute must contain valid "
4811 "identifiers", name
);
4812 inform (input_location
, "%<%c%> is not a valid character "
4813 "in an identifier", c
);
4822 /* Handle an "abi_tag" attribute; arguments as in
4823 struct attribute_spec.handler. */
4826 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4827 int flags
, bool* no_add_attrs
)
4829 if (!check_abi_tag_args (args
, name
))
4834 if (!OVERLOAD_TYPE_P (*node
))
4836 error ("%qE attribute applied to non-class, non-enum type %qT",
4840 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4842 error ("%qE attribute applied to %qT after its definition",
4846 else if (CLASS_TYPE_P (*node
)
4847 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4849 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4850 "template instantiation %qT", name
, *node
);
4853 else if (CLASS_TYPE_P (*node
)
4854 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4856 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4857 "template specialization %qT", name
, *node
);
4861 tree attributes
= TYPE_ATTRIBUTES (*node
);
4862 tree decl
= TYPE_NAME (*node
);
4864 /* Make sure all declarations have the same abi tags. */
4865 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4867 if (!check_abi_tag_redeclaration (decl
,
4868 lookup_attribute ("abi_tag",
4876 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4878 error ("%qE attribute applied to non-function, non-variable %qD",
4882 else if (DECL_LANGUAGE (*node
) == lang_c
)
4884 error ("%qE attribute applied to extern \"C\" declaration %qD",
4893 *no_add_attrs
= true;
4897 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4898 thing pointed to by the constant. */
4901 make_ptrmem_cst (tree type
, tree member
)
4903 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4904 TREE_TYPE (ptrmem_cst
) = type
;
4905 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4909 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4910 return an existing type if an appropriate type already exists. */
4913 cp_build_type_attribute_variant (tree type
, tree attributes
)
4917 new_type
= build_type_attribute_variant (type
, attributes
);
4918 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4919 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4921 /* Making a new main variant of a class type is broken. */
4922 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4927 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4928 Called only after doing all language independent checks. */
4931 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4933 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4935 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4937 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4939 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4940 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4943 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4944 C++, these are the exception-specifier and ref-qualifier. */
4947 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4949 tree type
= CONST_CAST_TREE (typea
);
4950 if (FUNC_OR_METHOD_TYPE_P (type
))
4951 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4952 TYPE_RAISES_EXCEPTIONS (typeb
),
4953 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4957 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4958 traversal. Called from walk_tree. */
4961 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4962 void *data
, hash_set
<tree
> *pset
)
4964 enum tree_code code
= TREE_CODE (*tp
);
4967 #define WALK_SUBTREE(NODE) \
4970 result = cp_walk_tree (&(NODE), func, data, pset); \
4971 if (result) goto out; \
4976 /* Walk into template args without looking through typedefs. */
4977 if (tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (*tp
))
4978 WALK_SUBTREE (TI_ARGS (ti
));
4980 /* Not one of the easy cases. We must explicitly go through the
4985 case DEFERRED_PARSE
:
4986 case TEMPLATE_TEMPLATE_PARM
:
4987 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4988 case UNBOUND_CLASS_TEMPLATE
:
4989 case TEMPLATE_PARM_INDEX
:
4990 case TEMPLATE_TYPE_PARM
:
4993 case UNDERLYING_TYPE
:
4994 /* None of these have subtrees other than those already walked
4996 *walk_subtrees_p
= 0;
5000 if (BASELINK_QUALIFIED_P (*tp
))
5001 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
5002 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
5003 *walk_subtrees_p
= 0;
5007 WALK_SUBTREE (TREE_TYPE (*tp
));
5008 *walk_subtrees_p
= 0;
5012 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5016 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5017 WALK_SUBTREE (OVL_CHAIN (*tp
));
5018 *walk_subtrees_p
= 0;
5022 WALK_SUBTREE (DECL_NAME (*tp
));
5023 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5024 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5025 *walk_subtrees_p
= 0;
5029 if (TYPE_PTRMEMFUNC_P (*tp
))
5030 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5033 case TYPE_ARGUMENT_PACK
:
5034 case NONTYPE_ARGUMENT_PACK
:
5036 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5037 int i
, len
= TREE_VEC_LENGTH (args
);
5038 for (i
= 0; i
< len
; i
++)
5039 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5043 case TYPE_PACK_EXPANSION
:
5044 WALK_SUBTREE (TREE_TYPE (*tp
));
5045 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5046 *walk_subtrees_p
= 0;
5049 case EXPR_PACK_EXPANSION
:
5050 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5051 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5052 *walk_subtrees_p
= 0;
5056 case REINTERPRET_CAST_EXPR
:
5057 case STATIC_CAST_EXPR
:
5058 case CONST_CAST_EXPR
:
5059 case DYNAMIC_CAST_EXPR
:
5060 case IMPLICIT_CONV_EXPR
:
5061 if (TREE_TYPE (*tp
))
5062 WALK_SUBTREE (TREE_TYPE (*tp
));
5066 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
5067 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
5069 *walk_subtrees_p
= 0;
5073 if (COMPOUND_LITERAL_P (*tp
))
5074 WALK_SUBTREE (TREE_TYPE (*tp
));
5078 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5079 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5080 *walk_subtrees_p
= 0;
5084 ++cp_unevaluated_operand
;
5085 /* We can't use WALK_SUBTREE here because of the goto. */
5086 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5087 --cp_unevaluated_operand
;
5088 *walk_subtrees_p
= 0;
5094 ++cp_unevaluated_operand
;
5095 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5096 --cp_unevaluated_operand
;
5097 *walk_subtrees_p
= 0;
5101 // Only recurse through the nested expression. Do not
5102 // walk the parameter list. Doing so causes false
5103 // positives in the pack expansion checker since the
5104 // requires parameters are introduced as pack expansions.
5105 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5106 *walk_subtrees_p
= 0;
5110 /* User variables should be mentioned in BIND_EXPR_VARS
5111 and their initializers and sizes walked when walking
5112 the containing BIND_EXPR. Compiler temporaries are
5113 handled here. And also normal variables in templates,
5114 since do_poplevel doesn't build a BIND_EXPR then. */
5115 if (VAR_P (TREE_OPERAND (*tp
, 0))
5116 && (processing_template_decl
5117 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5118 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5120 tree decl
= TREE_OPERAND (*tp
, 0);
5121 WALK_SUBTREE (DECL_INITIAL (decl
));
5122 WALK_SUBTREE (DECL_SIZE (decl
));
5123 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5128 /* Don't walk into the body of the lambda, but the capture initializers
5129 are part of the enclosing context. */
5130 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5131 cap
= TREE_CHAIN (cap
))
5132 WALK_SUBTREE (TREE_VALUE (cap
));
5136 if (TREE_OPERAND (*tp
, 1))
5137 /* Operand 1 is the tree for the relevant co_await which has any
5138 interesting sub-trees. */
5139 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5143 if (TREE_OPERAND (*tp
, 1))
5144 /* Operand 1 is frame variable. */
5145 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5146 if (TREE_OPERAND (*tp
, 2))
5147 /* Operand 2 has the initialiser, and we need to walk any subtrees
5149 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5152 case CO_RETURN_EXPR
:
5153 if (TREE_OPERAND (*tp
, 0))
5155 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5156 /* For void expressions, operand 1 is a trivial call, and any
5157 interesting subtrees will be part of operand 0. */
5158 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5159 else if (TREE_OPERAND (*tp
, 1))
5160 /* Interesting sub-trees will be in the return_value () call
5162 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5170 /* We didn't find what we were looking for. */
5177 /* Like save_expr, but for C++. */
5180 cp_save_expr (tree expr
)
5182 /* There is no reason to create a SAVE_EXPR within a template; if
5183 needed, we can create the SAVE_EXPR when instantiating the
5184 template. Furthermore, the middle-end cannot handle C++-specific
5186 if (processing_template_decl
)
5189 /* TARGET_EXPRs are only expanded once. */
5190 if (TREE_CODE (expr
) == TARGET_EXPR
)
5193 return save_expr (expr
);
5196 /* Initialize tree.c. */
5201 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5202 register_scoped_attributes (std_attribute_table
, NULL
);
5205 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5206 is. Note that sfk_none is zero, so this function can be used as a
5207 predicate to test whether or not DECL is a special function. */
5209 special_function_kind
5210 special_function_p (const_tree decl
)
5212 /* Rather than doing all this stuff with magic names, we should
5213 probably have a field of type `special_function_kind' in
5214 DECL_LANG_SPECIFIC. */
5215 if (DECL_INHERITED_CTOR (decl
))
5216 return sfk_inheriting_constructor
;
5217 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5218 return sfk_copy_constructor
;
5219 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5220 return sfk_move_constructor
;
5221 if (DECL_CONSTRUCTOR_P (decl
))
5222 return sfk_constructor
;
5223 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5224 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5226 if (copy_fn_p (decl
))
5227 return sfk_copy_assignment
;
5228 if (move_fn_p (decl
))
5229 return sfk_move_assignment
;
5231 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5232 return sfk_destructor
;
5233 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5234 return sfk_complete_destructor
;
5235 if (DECL_BASE_DESTRUCTOR_P (decl
))
5236 return sfk_base_destructor
;
5237 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5238 return sfk_deleting_destructor
;
5239 if (DECL_CONV_FN_P (decl
))
5240 return sfk_conversion
;
5241 if (deduction_guide_p (decl
))
5242 return sfk_deduction_guide
;
5243 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5244 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5245 return sfk_comparison
;
5250 /* As above, but only if DECL is a special member function as per 11.3.3
5251 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5253 special_function_kind
5254 special_memfn_p (const_tree decl
)
5256 switch (special_function_kind sfk
= special_function_p (decl
))
5258 case sfk_constructor
:
5259 if (!default_ctor_p (decl
))
5262 case sfk_copy_constructor
:
5263 case sfk_copy_assignment
:
5264 case sfk_move_assignment
:
5265 case sfk_move_constructor
:
5266 case sfk_destructor
:
5275 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5278 char_type_p (tree type
)
5280 return (same_type_p (type
, char_type_node
)
5281 || same_type_p (type
, unsigned_char_type_node
)
5282 || same_type_p (type
, signed_char_type_node
)
5283 || same_type_p (type
, char8_type_node
)
5284 || same_type_p (type
, char16_type_node
)
5285 || same_type_p (type
, char32_type_node
)
5286 || same_type_p (type
, wchar_type_node
));
5289 /* Returns the kind of linkage associated with the indicated DECL. Th
5290 value returned is as specified by the language standard; it is
5291 independent of implementation details regarding template
5292 instantiation, etc. For example, it is possible that a declaration
5293 to which this function assigns external linkage would not show up
5294 as a global symbol when you run `nm' on the resulting object file. */
5297 decl_linkage (tree decl
)
5299 /* This function doesn't attempt to calculate the linkage from first
5300 principles as given in [basic.link]. Instead, it makes use of
5301 the fact that we have already set TREE_PUBLIC appropriately, and
5302 then handles a few special cases. Ideally, we would calculate
5303 linkage first, and then transform that into a concrete
5306 /* Things that don't have names have no linkage. */
5307 if (!DECL_NAME (decl
))
5310 /* Fields have no linkage. */
5311 if (TREE_CODE (decl
) == FIELD_DECL
)
5314 /* Things in local scope do not have linkage. */
5315 if (decl_function_context (decl
))
5318 /* Things that are TREE_PUBLIC have external linkage. */
5319 if (TREE_PUBLIC (decl
))
5322 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5323 check one of the "clones" for the real linkage. */
5324 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5325 && DECL_CHAIN (decl
)
5326 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5327 return decl_linkage (DECL_CHAIN (decl
));
5329 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5332 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5334 if (TREE_CODE (decl
) == CONST_DECL
)
5335 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5337 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5338 are considered to have external linkage for language purposes, as do
5339 template instantiations on targets without weak symbols. DECLs really
5340 meant to have internal linkage have DECL_THIS_STATIC set. */
5341 if (TREE_CODE (decl
) == TYPE_DECL
)
5343 if (VAR_OR_FUNCTION_DECL_P (decl
))
5345 if (!DECL_THIS_STATIC (decl
))
5348 /* Static data members and static member functions from classes
5349 in anonymous namespace also don't have TREE_PUBLIC set. */
5350 if (DECL_CLASS_CONTEXT (decl
))
5354 /* Everything else has internal linkage. */
5358 /* Returns the storage duration of the object or reference associated with
5359 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5362 decl_storage_duration (tree decl
)
5364 if (TREE_CODE (decl
) == PARM_DECL
)
5366 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5368 gcc_assert (VAR_P (decl
));
5369 if (!TREE_STATIC (decl
)
5370 && !DECL_EXTERNAL (decl
))
5372 if (CP_DECL_THREAD_LOCAL_P (decl
))
5377 /* EXP is an expression that we want to pre-evaluate. Returns (in
5378 *INITP) an expression that will perform the pre-evaluation. The
5379 value returned by this function is a side-effect free expression
5380 equivalent to the pre-evaluated expression. Callers must ensure
5381 that *INITP is evaluated before EXP. */
5384 stabilize_expr (tree exp
, tree
* initp
)
5388 if (!TREE_SIDE_EFFECTS (exp
))
5389 init_expr
= NULL_TREE
;
5390 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5395 /* There are no expressions with REFERENCE_TYPE, but there can be call
5396 arguments with such a type; just treat it as a pointer. */
5397 else if (TYPE_REF_P (TREE_TYPE (exp
))
5398 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5399 || !glvalue_p (exp
))
5401 init_expr
= get_target_expr (exp
);
5402 exp
= TARGET_EXPR_SLOT (init_expr
);
5403 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5410 bool xval
= !lvalue_p (exp
);
5411 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5412 init_expr
= get_target_expr (exp
);
5413 exp
= TARGET_EXPR_SLOT (init_expr
);
5414 exp
= cp_build_fold_indirect_ref (exp
);
5420 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5424 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5425 similar expression ORIG. */
5428 add_stmt_to_compound (tree orig
, tree new_expr
)
5430 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5432 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5434 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5437 /* Like stabilize_expr, but for a call whose arguments we want to
5438 pre-evaluate. CALL is modified in place to use the pre-evaluated
5439 arguments, while, upon return, *INITP contains an expression to
5440 compute the arguments. */
5443 stabilize_call (tree call
, tree
*initp
)
5445 tree inits
= NULL_TREE
;
5447 int nargs
= call_expr_nargs (call
);
5449 if (call
== error_mark_node
|| processing_template_decl
)
5455 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5457 for (i
= 0; i
< nargs
; i
++)
5460 CALL_EXPR_ARG (call
, i
) =
5461 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5462 inits
= add_stmt_to_compound (inits
, init
);
5468 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5469 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5470 arguments, while, upon return, *INITP contains an expression to
5471 compute the arguments. */
5474 stabilize_aggr_init (tree call
, tree
*initp
)
5476 tree inits
= NULL_TREE
;
5478 int nargs
= aggr_init_expr_nargs (call
);
5480 if (call
== error_mark_node
)
5483 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5485 for (i
= 0; i
< nargs
; i
++)
5488 AGGR_INIT_EXPR_ARG (call
, i
) =
5489 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5490 inits
= add_stmt_to_compound (inits
, init
);
5496 /* Like stabilize_expr, but for an initialization.
5498 If the initialization is for an object of class type, this function
5499 takes care not to introduce additional temporaries.
5501 Returns TRUE iff the expression was successfully pre-evaluated,
5502 i.e., if INIT is now side-effect free, except for, possibly, a
5503 single call to a constructor. */
5506 stabilize_init (tree init
, tree
*initp
)
5512 if (t
== error_mark_node
|| processing_template_decl
)
5515 if (TREE_CODE (t
) == INIT_EXPR
)
5516 t
= TREE_OPERAND (t
, 1);
5517 if (TREE_CODE (t
) == TARGET_EXPR
)
5518 t
= TARGET_EXPR_INITIAL (t
);
5520 /* If the RHS can be stabilized without breaking copy elision, stabilize
5521 it. We specifically don't stabilize class prvalues here because that
5522 would mean an extra copy, but they might be stabilized below. */
5523 if (TREE_CODE (init
) == INIT_EXPR
5524 && TREE_CODE (t
) != CONSTRUCTOR
5525 && TREE_CODE (t
) != AGGR_INIT_EXPR
5526 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5529 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5533 if (TREE_CODE (t
) == COMPOUND_EXPR
5534 && TREE_CODE (init
) == INIT_EXPR
)
5536 tree last
= expr_last (t
);
5537 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5538 if (!TREE_SIDE_EFFECTS (last
))
5541 TREE_OPERAND (init
, 1) = last
;
5546 if (TREE_CODE (t
) == CONSTRUCTOR
)
5548 /* Aggregate initialization: stabilize each of the field
5551 constructor_elt
*ce
;
5553 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5554 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5556 tree type
= TREE_TYPE (ce
->value
);
5558 if (TYPE_REF_P (type
)
5559 || SCALAR_TYPE_P (type
))
5560 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5561 else if (!stabilize_init (ce
->value
, &subinit
))
5563 *initp
= add_stmt_to_compound (*initp
, subinit
);
5568 if (TREE_CODE (t
) == CALL_EXPR
)
5570 stabilize_call (t
, initp
);
5574 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5576 stabilize_aggr_init (t
, initp
);
5580 /* The initialization is being performed via a bitwise copy -- and
5581 the item copied may have side effects. */
5582 return !TREE_SIDE_EFFECTS (init
);
5585 /* Returns true if a cast to TYPE may appear in an integral constant
5589 cast_valid_in_integral_constant_expression_p (tree type
)
5591 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5592 || cxx_dialect
>= cxx11
5593 || dependent_type_p (type
)
5594 || type
== error_mark_node
);
5597 /* Return true if we need to fix linkage information of DECL. */
5600 cp_fix_function_decl_p (tree decl
)
5602 /* Skip if DECL is not externally visible. */
5603 if (!TREE_PUBLIC (decl
))
5606 /* We need to fix DECL if it a appears to be exported but with no
5607 function body. Thunks do not have CFGs and we may need to
5608 handle them specially later. */
5609 if (!gimple_has_body_p (decl
)
5610 && !DECL_THUNK_P (decl
)
5611 && !DECL_EXTERNAL (decl
))
5613 struct cgraph_node
*node
= cgraph_node::get (decl
);
5615 /* Don't fix same_body aliases. Although they don't have their own
5616 CFG, they share it with what they alias to. */
5617 if (!node
|| !node
->alias
5618 || !vec_safe_length (node
->ref_list
.references
))
5625 /* Clean the C++ specific parts of the tree T. */
5628 cp_free_lang_data (tree t
)
5630 if (FUNC_OR_METHOD_TYPE_P (t
))
5632 /* Default args are not interesting anymore. */
5633 tree argtypes
= TYPE_ARG_TYPES (t
);
5636 TREE_PURPOSE (argtypes
) = 0;
5637 argtypes
= TREE_CHAIN (argtypes
);
5640 else if (TREE_CODE (t
) == FUNCTION_DECL
5641 && cp_fix_function_decl_p (t
))
5643 /* If T is used in this translation unit at all, the definition
5644 must exist somewhere else since we have decided to not emit it
5645 in this TU. So make it an external reference. */
5646 DECL_EXTERNAL (t
) = 1;
5647 TREE_STATIC (t
) = 0;
5649 if (TREE_CODE (t
) == FUNCTION_DECL
)
5650 discard_operator_bindings (t
);
5651 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5652 /* We do not need the leftover chaining of namespaces from the
5654 DECL_CHAIN (t
) = NULL_TREE
;
5657 /* Stub for c-common. Please keep in sync with c-decl.c.
5658 FIXME: If address space support is target specific, then this
5659 should be a C target hook. But currently this is not possible,
5660 because this function is called via REGISTER_TARGET_PRAGMAS. */
5662 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5666 /* Return the number of operands in T that we care about for things like
5670 cp_tree_operand_length (const_tree t
)
5672 enum tree_code code
= TREE_CODE (t
);
5674 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5675 return VL_EXP_OPERAND_LENGTH (t
);
5677 return cp_tree_code_length (code
);
5680 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5683 cp_tree_code_length (enum tree_code code
)
5685 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5689 case PREINCREMENT_EXPR
:
5690 case PREDECREMENT_EXPR
:
5691 case POSTINCREMENT_EXPR
:
5692 case POSTDECREMENT_EXPR
:
5698 case EXPR_PACK_EXPANSION
:
5702 return TREE_CODE_LENGTH (code
);
5706 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5710 cp_expr_location (const_tree t_
)
5712 tree t
= CONST_CAST_TREE (t_
);
5714 return UNKNOWN_LOCATION
;
5715 switch (TREE_CODE (t
))
5718 return LAMBDA_EXPR_LOCATION (t
);
5720 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5722 return TRAIT_EXPR_LOCATION (t
);
5724 return EXPR_LOCATION (t
);
5728 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5729 conditions for the warning hold, false otherwise. */
5731 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5733 if (c_inhibit_evaluation_warnings
== 0
5734 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5736 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5737 "zero as null pointer constant");
5743 /* Given an initializer INIT for a TYPE, return true if INIT is zero
5744 so that it can be replaced by value initialization. This function
5745 distinguishes betwen empty strings as initializers for arrays and
5746 for pointers (which make it return false). */
5749 type_initializer_zero_p (tree type
, tree init
)
5751 if (type
== error_mark_node
|| init
== error_mark_node
)
5756 if (POINTER_TYPE_P (type
))
5757 return TREE_CODE (init
) != STRING_CST
&& initializer_zerop (init
);
5759 if (TREE_CODE (init
) != CONSTRUCTOR
)
5761 /* A class can only be initialized by a non-class type if it has
5762 a ctor that converts from that type. Such classes are excluded
5763 since their semantics are unknown. */
5764 if (RECORD_OR_UNION_TYPE_P (type
)
5765 && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (init
)))
5767 return initializer_zerop (init
);
5770 if (TREE_CODE (type
) == ARRAY_TYPE
)
5772 tree elt_type
= TREE_TYPE (type
);
5773 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
5774 if (elt_type
== char_type_node
)
5775 return initializer_zerop (init
);
5778 unsigned HOST_WIDE_INT i
;
5779 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, elt_init
)
5780 if (!type_initializer_zero_p (elt_type
, elt_init
))
5785 if (TREE_CODE (type
) != RECORD_TYPE
)
5786 return initializer_zerop (init
);
5788 if (TYPE_NON_AGGREGATE_CLASS (type
))
5791 tree fld
= TYPE_FIELDS (type
);
5794 unsigned HOST_WIDE_INT i
;
5795 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, fld_init
)
5797 fld
= next_initializable_field (fld
);
5801 tree fldtype
= TREE_TYPE (fld
);
5802 if (!type_initializer_zero_p (fldtype
, fld_init
))
5805 fld
= DECL_CHAIN (fld
);
5813 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5814 /* Complain that some language-specific thing hanging off a tree
5815 node has been accessed improperly. */
5818 lang_check_failed (const char* file
, int line
, const char* function
)
5820 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5821 function
, trim_filename (file
), line
);
5823 #endif /* ENABLE_TREE_CHECKING */
5827 namespace selftest
{
5829 /* Verify that lvalue_kind () works, for various expressions,
5830 and that location wrappers don't affect the results. */
5835 location_t loc
= BUILTINS_LOCATION
;
5837 /* Verify constants and parameters, without and with
5838 location wrappers. */
5839 tree int_cst
= build_int_cst (integer_type_node
, 42);
5840 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5842 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5843 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5844 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5846 tree string_lit
= build_string (4, "foo");
5847 TREE_TYPE (string_lit
) = char_array_type_node
;
5848 string_lit
= fix_string_type (string_lit
);
5849 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5851 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5852 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5853 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5855 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5856 get_identifier ("some_parm"),
5858 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5860 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5861 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5862 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5864 /* Verify that lvalue_kind of std::move on a parm isn't
5865 affected by location wrappers. */
5866 tree rvalue_ref_of_parm
= move (parm
);
5867 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5868 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5869 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5871 /* Verify lvalue_p. */
5872 ASSERT_FALSE (lvalue_p (int_cst
));
5873 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5874 ASSERT_TRUE (lvalue_p (parm
));
5875 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5876 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5877 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5880 /* Run all of the selftests within this file. */
5885 test_lvalue_kind ();
5888 } // namespace selftest
5890 #endif /* #if CHECKING_P */
5893 #include "gt-cp-tree.h"