1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2019 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 (type
, ref
, tf_error
);
432 return stabilize_reference (ref
);
435 /* Test whether DECL is a builtin that may appear in a
436 constant-expression. */
439 builtin_valid_in_constant_expr_p (const_tree decl
)
441 STRIP_ANY_LOCATION_WRAPPER (decl
);
442 if (TREE_CODE (decl
) != FUNCTION_DECL
)
443 /* Not a function. */
445 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
447 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
450 /* Not a built-in. */
453 switch (DECL_FUNCTION_CODE (decl
))
455 /* These always have constant results like the corresponding
458 case BUILT_IN_FUNCTION
:
461 /* The following built-ins are valid in constant expressions
462 when their arguments are. */
463 case BUILT_IN_ADD_OVERFLOW_P
:
464 case BUILT_IN_SUB_OVERFLOW_P
:
465 case BUILT_IN_MUL_OVERFLOW_P
:
467 /* These have constant results even if their operands are
469 case BUILT_IN_CONSTANT_P
:
470 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
477 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
480 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
483 tree type
= TREE_TYPE (decl
);
485 value
= mark_rvalue_use (value
);
487 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
488 || TREE_TYPE (decl
) == TREE_TYPE (value
)
489 /* On ARM ctors return 'this'. */
490 || (TYPE_PTR_P (TREE_TYPE (value
))
491 && TREE_CODE (value
) == CALL_EXPR
)
492 || useless_type_conversion_p (TREE_TYPE (decl
),
495 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
496 moving a constant aggregate into .rodata. */
497 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
498 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
499 && !VOID_TYPE_P (TREE_TYPE (value
))
500 && reduced_constant_expression_p (value
))
501 TREE_READONLY (decl
) = true;
503 if (complain
& tf_no_cleanup
)
504 /* The caller is building a new-expr and does not need a cleanup. */
508 t
= cxx_maybe_build_cleanup (decl
, complain
);
509 if (t
== error_mark_node
)
510 return error_mark_node
;
512 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
513 if (location_t eloc
= cp_expr_location (value
))
514 SET_EXPR_LOCATION (t
, eloc
);
515 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
516 ignore the TARGET_EXPR. If there really turn out to be no
517 side-effects, then the optimizer should be able to get rid of
518 whatever code is generated anyhow. */
519 TREE_SIDE_EFFECTS (t
) = 1;
524 /* Return an undeclared local temporary of type TYPE for use in building a
528 build_local_temp (tree type
)
530 tree slot
= build_decl (input_location
,
531 VAR_DECL
, NULL_TREE
, type
);
532 DECL_ARTIFICIAL (slot
) = 1;
533 DECL_IGNORED_P (slot
) = 1;
534 DECL_CONTEXT (slot
) = current_function_decl
;
535 layout_decl (slot
, 0);
539 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
542 process_aggr_init_operands (tree t
)
546 side_effects
= TREE_SIDE_EFFECTS (t
);
550 n
= TREE_OPERAND_LENGTH (t
);
551 for (i
= 1; i
< n
; i
++)
553 tree op
= TREE_OPERAND (t
, i
);
554 if (op
&& TREE_SIDE_EFFECTS (op
))
561 TREE_SIDE_EFFECTS (t
) = side_effects
;
564 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
565 FN, and SLOT. NARGS is the number of call arguments which are specified
566 as a tree array ARGS. */
569 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
575 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
576 TREE_TYPE (t
) = return_type
;
577 AGGR_INIT_EXPR_FN (t
) = fn
;
578 AGGR_INIT_EXPR_SLOT (t
) = slot
;
579 for (i
= 0; i
< nargs
; i
++)
580 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
581 process_aggr_init_operands (t
);
585 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
586 target. TYPE is the type to be initialized.
588 Build an AGGR_INIT_EXPR to represent the initialization. This function
589 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
590 to initialize another object, whereas a TARGET_EXPR can either
591 initialize another object or create its own temporary object, and as a
592 result building up a TARGET_EXPR requires that the type's destructor be
596 build_aggr_init_expr (tree type
, tree init
)
603 gcc_assert (!VOID_TYPE_P (type
));
605 /* Don't build AGGR_INIT_EXPR in a template. */
606 if (processing_template_decl
)
609 fn
= cp_get_callee (init
);
611 return convert (type
, init
);
613 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
614 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
615 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
617 /* We split the CALL_EXPR into its function and its arguments here.
618 Then, in expand_expr, we put them back together. The reason for
619 this is that this expression might be a default argument
620 expression. In that case, we need a new temporary every time the
621 expression is used. That's what break_out_target_exprs does; it
622 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
623 temporary slot. Then, expand_expr builds up a call-expression
624 using the new slot. */
626 /* If we don't need to use a constructor to create an object of this
627 type, don't mess with AGGR_INIT_EXPR. */
628 if (is_ctor
|| TREE_ADDRESSABLE (type
))
630 slot
= build_local_temp (type
);
632 if (TREE_CODE (init
) == CALL_EXPR
)
634 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
635 call_expr_nargs (init
),
636 CALL_EXPR_ARGP (init
));
637 AGGR_INIT_FROM_THUNK_P (rval
)
638 = CALL_FROM_THUNK_P (init
);
642 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
643 aggr_init_expr_nargs (init
),
644 AGGR_INIT_EXPR_ARGP (init
));
645 AGGR_INIT_FROM_THUNK_P (rval
)
646 = AGGR_INIT_FROM_THUNK_P (init
);
648 TREE_SIDE_EFFECTS (rval
) = 1;
649 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
650 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
651 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
652 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
653 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
661 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
662 target. TYPE is the type that this initialization should appear to
665 Build an encapsulation of the initialization to perform
666 and return it so that it can be processed by language-independent
667 and language-specific expression expanders. */
670 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
672 tree rval
= build_aggr_init_expr (type
, init
);
675 if (init
== error_mark_node
)
676 return error_mark_node
;
678 if (!complete_type_or_maybe_complain (type
, init
, complain
))
679 return error_mark_node
;
681 /* Make sure that we're not trying to create an instance of an
683 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
684 return error_mark_node
;
686 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
687 slot
= AGGR_INIT_EXPR_SLOT (rval
);
688 else if (TREE_CODE (rval
) == CALL_EXPR
689 || TREE_CODE (rval
) == CONSTRUCTOR
)
690 slot
= build_local_temp (type
);
694 rval
= build_target_expr (slot
, rval
, complain
);
696 if (rval
!= error_mark_node
)
697 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
702 /* Subroutine of build_vec_init_expr: Build up a single element
703 intialization as a proxy for the full array initialization to get things
704 marked as used and any appropriate diagnostics.
706 Since we're deferring building the actual constructor calls until
707 gimplification time, we need to build one now and throw it away so
708 that the relevant constructor gets mark_used before cgraph decides
709 what functions are needed. Here we assume that init is either
710 NULL_TREE, void_type_node (indicating value-initialization), or
711 another array to copy. */
714 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
716 tree inner_type
= strip_array_types (type
);
718 if (integer_zerop (array_type_nelts_total (type
))
719 || !CLASS_TYPE_P (inner_type
))
720 /* No interesting initialization to do. */
721 return integer_zero_node
;
722 else if (init
== void_type_node
)
723 return build_value_init (inner_type
, complain
);
725 gcc_assert (init
== NULL_TREE
726 || (same_type_ignoring_top_level_qualifiers_p
727 (type
, TREE_TYPE (init
))));
729 releasing_vec argvec
;
732 tree init_type
= strip_array_types (TREE_TYPE (init
));
733 tree dummy
= build_dummy_object (init_type
);
734 if (!lvalue_p (init
))
735 dummy
= move (dummy
);
736 argvec
->quick_push (dummy
);
738 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
739 &argvec
, inner_type
, LOOKUP_NORMAL
,
742 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
743 we don't want one here because we aren't creating a temporary. */
744 if (TREE_CODE (init
) == TARGET_EXPR
)
745 init
= TARGET_EXPR_INITIAL (init
);
750 /* Return a TARGET_EXPR which expresses the initialization of an array to
751 be named later, either default-initialization or copy-initialization
752 from another array of the same type. */
755 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
758 bool value_init
= false;
759 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
761 if (init
== void_type_node
)
767 slot
= build_local_temp (type
);
768 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
769 TREE_SIDE_EFFECTS (init
) = true;
770 SET_EXPR_LOCATION (init
, input_location
);
772 if (cxx_dialect
>= cxx11
773 && potential_constant_expression (elt_init
))
774 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
775 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
780 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
781 that requires a constant expression. */
784 diagnose_non_constexpr_vec_init (tree expr
)
786 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
788 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
789 init
= void_type_node
;
791 init
= VEC_INIT_EXPR_INIT (expr
);
793 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
794 require_potential_constant_expression (elt_init
);
798 build_array_copy (tree init
)
800 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
803 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
807 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
809 gcc_assert (!VOID_TYPE_P (type
));
811 if (TREE_CODE (init
) == TARGET_EXPR
812 || init
== error_mark_node
)
814 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
815 && !VOID_TYPE_P (TREE_TYPE (init
))
816 && TREE_CODE (init
) != COND_EXPR
817 && TREE_CODE (init
) != CONSTRUCTOR
818 && TREE_CODE (init
) != VA_ARG_EXPR
)
819 /* We need to build up a copy constructor call. A void initializer
820 means we're being called from bot_manip. COND_EXPR is a special
821 case because we already have copies on the arms and we don't want
822 another one here. A CONSTRUCTOR is aggregate initialization, which
823 is handled separately. A VA_ARG_EXPR is magic creation of an
824 aggregate; there's no additional work to be done. */
825 return force_rvalue (init
, complain
);
827 return force_target_expr (type
, init
, complain
);
830 /* Like the above function, but without the checking. This function should
831 only be used by code which is deliberately trying to subvert the type
832 system, such as call_builtin_trap. Or build_over_call, to avoid
833 infinite recursion. */
836 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
840 gcc_assert (!VOID_TYPE_P (type
));
842 slot
= build_local_temp (type
);
843 return build_target_expr (slot
, init
, complain
);
846 /* Like build_target_expr_with_type, but use the type of INIT. */
849 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
851 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
852 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
853 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
854 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
857 init
= convert_bitfield_to_declared_type (init
);
858 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
863 get_target_expr (tree init
)
865 return get_target_expr_sfinae (init
, tf_warning_or_error
);
868 /* If EXPR is a bitfield reference, convert it to the declared type of
869 the bitfield, and return the resulting expression. Otherwise,
870 return EXPR itself. */
873 convert_bitfield_to_declared_type (tree expr
)
877 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
879 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
884 /* EXPR is being used in an rvalue context. Return a version of EXPR
885 that is marked as an rvalue. */
892 if (error_operand_p (expr
))
895 expr
= mark_rvalue_use (expr
);
899 Non-class rvalues always have cv-unqualified types. */
900 type
= TREE_TYPE (expr
);
901 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
902 type
= cv_unqualified (type
);
904 /* We need to do this for rvalue refs as well to get the right answer
905 from decltype; see c++/36628. */
906 if (!processing_template_decl
&& glvalue_p (expr
))
907 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
908 else if (type
!= TREE_TYPE (expr
))
909 expr
= build_nop (type
, expr
);
915 struct cplus_array_info
921 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
923 typedef cplus_array_info
*compare_type
;
925 static hashval_t
hash (tree t
);
926 static bool equal (tree
, cplus_array_info
*);
929 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
932 cplus_array_hasher::hash (tree t
)
936 hash
= TYPE_UID (TREE_TYPE (t
));
938 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
942 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
943 of type `cplus_array_info*'. */
946 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
948 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
951 /* Hash table containing dependent array types, which are unsuitable for
952 the language-independent type hash table. */
953 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
955 /* Build an ARRAY_TYPE without laying it out. */
958 build_min_array_type (tree elt_type
, tree index_type
)
960 tree t
= cxx_make_type (ARRAY_TYPE
);
961 TREE_TYPE (t
) = elt_type
;
962 TYPE_DOMAIN (t
) = index_type
;
966 /* Set TYPE_CANONICAL like build_array_type_1, but using
967 build_cplus_array_type. */
970 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
972 /* Set the canonical type for this new node. */
973 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
974 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
975 SET_TYPE_STRUCTURAL_EQUALITY (t
);
976 else if (TYPE_CANONICAL (elt_type
) != elt_type
977 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
979 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
981 ? TYPE_CANONICAL (index_type
) : index_type
);
983 TYPE_CANONICAL (t
) = t
;
986 /* Like build_array_type, but handle special C++ semantics: an array of a
987 variant element type is a variant of the array of the main variant of
991 build_cplus_array_type (tree elt_type
, tree index_type
)
995 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
996 return error_mark_node
;
998 bool dependent
= (uses_template_parms (elt_type
)
999 || (index_type
&& uses_template_parms (index_type
)));
1001 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1002 /* Start with an array of the TYPE_MAIN_VARIANT. */
1003 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1007 /* Since type_hash_canon calls layout_type, we need to use our own
1009 cplus_array_info cai
;
1012 if (cplus_array_htab
== NULL
)
1013 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1015 hash
= TYPE_UID (elt_type
);
1017 hash
^= TYPE_UID (index_type
);
1018 cai
.type
= elt_type
;
1019 cai
.domain
= index_type
;
1021 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1023 /* We have found the type: we're done. */
1027 /* Build a new array type. */
1028 t
= build_min_array_type (elt_type
, index_type
);
1030 /* Store it in the hash table. */
1033 /* Set the canonical type for this new node. */
1034 set_array_type_canon (t
, elt_type
, index_type
);
1039 bool typeless_storage
1040 = (elt_type
== unsigned_char_type_node
1041 || elt_type
== signed_char_type_node
1042 || elt_type
== char_type_node
1043 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1044 && TYPE_CONTEXT (elt_type
) == std_node
1045 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1046 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1049 /* Now check whether we already have this array variant. */
1050 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1053 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1054 if (TREE_TYPE (t
) == elt_type
1055 && TYPE_NAME (t
) == NULL_TREE
1056 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1060 t
= build_min_array_type (elt_type
, index_type
);
1061 set_array_type_canon (t
, elt_type
, index_type
);
1065 /* Make sure sizes are shared with the main variant.
1066 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1067 as it will overwrite alignment etc. of all variants. */
1068 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1069 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1070 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1073 TYPE_MAIN_VARIANT (t
) = m
;
1074 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1075 TYPE_NEXT_VARIANT (m
) = t
;
1079 /* Avoid spurious warnings with VLAs (c++/54583). */
1080 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1081 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1083 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1084 place more easily. */
1085 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1086 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1087 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1088 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1090 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1091 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1093 /* The element type has been completed since the last time we saw
1094 this array type; update the layout and 'tor flags for any variants
1097 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1099 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1100 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1107 /* Return an ARRAY_TYPE with element type ELT and length N. */
1110 build_array_of_n_type (tree elt
, int n
)
1112 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1115 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1116 for C++14 but then removed. This should only be used for N3639
1117 specifically; code wondering more generally if something is a VLA should use
1121 array_of_runtime_bound_p (tree t
)
1123 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1125 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1127 tree dom
= TYPE_DOMAIN (t
);
1130 tree max
= TYPE_MAX_VALUE (dom
);
1131 return (!potential_rvalue_constant_expression (max
)
1132 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1135 /* True iff T is a variable length array. */
1140 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1142 if (tree dom
= TYPE_DOMAIN (t
))
1144 tree max
= TYPE_MAX_VALUE (dom
);
1145 if (!potential_rvalue_constant_expression (max
)
1146 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1152 /* Return a reference type node referring to TO_TYPE. If RVAL is
1153 true, return an rvalue reference type, otherwise return an lvalue
1154 reference type. If a type node exists, reuse it, otherwise create
1157 cp_build_reference_type (tree to_type
, bool rval
)
1161 if (to_type
== error_mark_node
)
1162 return error_mark_node
;
1164 if (TYPE_REF_P (to_type
))
1166 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1167 to_type
= TREE_TYPE (to_type
);
1170 lvalue_ref
= build_reference_type (to_type
);
1174 /* This code to create rvalue reference types is based on and tied
1175 to the code creating lvalue reference types in the middle-end
1176 functions build_reference_type_for_mode and build_reference_type.
1178 It works by putting the rvalue reference type nodes after the
1179 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1180 they will effectively be ignored by the middle end. */
1182 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1183 if (TYPE_REF_IS_RVALUE (t
))
1186 t
= build_distinct_type_copy (lvalue_ref
);
1188 TYPE_REF_IS_RVALUE (t
) = true;
1189 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1190 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1192 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1193 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1194 else if (TYPE_CANONICAL (to_type
) != to_type
)
1196 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1198 TYPE_CANONICAL (t
) = t
;
1206 /* Returns EXPR cast to rvalue reference type, like std::move. */
1211 tree type
= TREE_TYPE (expr
);
1212 gcc_assert (!TYPE_REF_P (type
));
1213 type
= cp_build_reference_type (type
, /*rval*/true);
1214 return build_static_cast (type
, expr
, tf_warning_or_error
);
1217 /* Used by the C++ front end to build qualified array types. However,
1218 the C version of this function does not properly maintain canonical
1219 types (which are not used in C). */
1221 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1222 size_t /* orig_qual_indirect */)
1224 return cp_build_qualified_type (type
, type_quals
);
1228 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1229 arrays correctly. In particular, if TYPE is an array of T's, and
1230 TYPE_QUALS is non-empty, returns an array of qualified T's.
1232 FLAGS determines how to deal with ill-formed qualifications. If
1233 tf_ignore_bad_quals is set, then bad qualifications are dropped
1234 (this is permitted if TYPE was introduced via a typedef or template
1235 type parameter). If bad qualifications are dropped and tf_warning
1236 is set, then a warning is issued for non-const qualifications. If
1237 tf_ignore_bad_quals is not set and tf_error is not set, we
1238 return error_mark_node. Otherwise, we issue an error, and ignore
1241 Qualification of a reference type is valid when the reference came
1242 via a typedef or template type argument. [dcl.ref] No such
1243 dispensation is provided for qualifying a function type. [dcl.fct]
1244 DR 295 queries this and the proposed resolution brings it into line
1245 with qualifying a reference. We implement the DR. We also behave
1246 in a similar manner for restricting non-pointer types. */
1249 cp_build_qualified_type_real (tree type
,
1251 tsubst_flags_t complain
)
1254 int bad_quals
= TYPE_UNQUALIFIED
;
1256 if (type
== error_mark_node
)
1259 if (type_quals
== cp_type_quals (type
))
1262 if (TREE_CODE (type
) == ARRAY_TYPE
)
1264 /* In C++, the qualification really applies to the array element
1265 type. Obtain the appropriately qualified element type. */
1268 = cp_build_qualified_type_real (TREE_TYPE (type
),
1272 if (element_type
== error_mark_node
)
1273 return error_mark_node
;
1275 /* See if we already have an identically qualified type. Tests
1276 should be equivalent to those in check_qualified_type. */
1277 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1278 if (TREE_TYPE (t
) == element_type
1279 && TYPE_NAME (t
) == TYPE_NAME (type
)
1280 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1281 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1282 TYPE_ATTRIBUTES (type
)))
1287 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1289 /* Keep the typedef name. */
1290 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1292 t
= build_variant_type_copy (t
);
1293 TYPE_NAME (t
) = TYPE_NAME (type
);
1294 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1295 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1299 /* Even if we already had this variant, we update
1300 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1301 they changed since the variant was originally created.
1303 This seems hokey; if there is some way to use a previous
1304 variant *without* coming through here,
1305 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1306 TYPE_NEEDS_CONSTRUCTING (t
)
1307 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1308 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1309 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1312 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1314 tree t
= PACK_EXPANSION_PATTERN (type
);
1316 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1317 return make_pack_expansion (t
, complain
);
1320 /* A reference or method type shall not be cv-qualified.
1321 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1322 (in CD1) we always ignore extra cv-quals on functions. */
1323 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1324 && (TYPE_REF_P (type
)
1325 || FUNC_OR_METHOD_TYPE_P (type
)))
1327 if (TYPE_REF_P (type
))
1328 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1329 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1332 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1333 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1334 type_quals
|= type_memfn_quals (type
);
1336 /* A restrict-qualified type must be a pointer (or reference)
1337 to object or incomplete type. */
1338 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1339 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1340 && TREE_CODE (type
) != TYPENAME_TYPE
1341 && !INDIRECT_TYPE_P (type
))
1343 bad_quals
|= TYPE_QUAL_RESTRICT
;
1344 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1347 if (bad_quals
== TYPE_UNQUALIFIED
1348 || (complain
& tf_ignore_bad_quals
))
1350 else if (!(complain
& tf_error
))
1351 return error_mark_node
;
1354 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1355 error ("%qV qualifiers cannot be applied to %qT",
1359 /* Retrieve (or create) the appropriately qualified variant. */
1360 result
= build_qualified_type (type
, type_quals
);
1365 /* Return TYPE with const and volatile removed. */
1368 cv_unqualified (tree type
)
1372 if (type
== error_mark_node
)
1375 quals
= cp_type_quals (type
);
1376 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1377 return cp_build_qualified_type (type
, quals
);
1380 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1381 from ATTRIBS that affect type identity, and no others. If any are not
1382 applied, set *remove_attributes to true. */
1385 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1387 tree first_ident
= NULL_TREE
;
1388 tree new_attribs
= NULL_TREE
;
1389 tree
*p
= &new_attribs
;
1391 if (OVERLOAD_TYPE_P (result
))
1393 /* On classes and enums all attributes are ingrained. */
1394 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1398 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1400 const attribute_spec
*as
1401 = lookup_attribute_spec (get_attribute_name (a
));
1402 if (as
&& as
->affects_type_identity
)
1406 else if (first_ident
== error_mark_node
)
1408 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1409 p
= &TREE_CHAIN (*p
);
1412 else if (first_ident
)
1414 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1416 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1417 p
= &TREE_CHAIN (*p
);
1419 first_ident
= error_mark_node
;
1422 if (first_ident
!= error_mark_node
)
1423 new_attribs
= first_ident
;
1425 if (first_ident
== attribs
)
1426 /* All attributes affected type identity. */;
1428 *remove_attributes
= true;
1430 return cp_build_type_attribute_variant (result
, new_attribs
);
1433 /* Builds a qualified variant of T that is either not a typedef variant
1434 (the default behavior) or not a typedef variant of a user-facing type
1435 (if FLAGS contains STF_USER_FACING).
1437 E.g. consider the following declarations:
1438 typedef const int ConstInt;
1439 typedef ConstInt* PtrConstInt;
1440 If T is PtrConstInt, this function returns a type representing
1442 In other words, if T is a typedef, the function returns the underlying type.
1443 The cv-qualification and attributes of the type returned match the
1445 They will always be compatible types.
1446 The returned type is built so that all of its subtypes
1447 recursively have their typedefs stripped as well.
1449 This is different from just returning TYPE_CANONICAL (T)
1450 Because of several reasons:
1451 * If T is a type that needs structural equality
1452 its TYPE_CANONICAL (T) will be NULL.
1453 * TYPE_CANONICAL (T) desn't carry type attributes
1454 and loses template parameter names.
1456 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1457 affect type identity, and set the referent to true if any were
1461 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1463 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1465 if (!t
|| t
== error_mark_node
)
1468 if (TREE_CODE (t
) == TREE_LIST
)
1470 bool changed
= false;
1473 for (; t
; t
= TREE_CHAIN (t
))
1475 gcc_assert (!TREE_PURPOSE (t
));
1476 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1477 if (elt
!= TREE_VALUE (t
))
1479 vec_safe_push (vec
, elt
);
1482 r
= build_tree_list_vec (vec
);
1486 gcc_assert (TYPE_P (t
));
1488 if (t
== TYPE_CANONICAL (t
))
1491 if (dependent_alias_template_spec_p (t
))
1492 /* DR 1558: However, if the template-id is dependent, subsequent
1493 template argument substitution still applies to the template-id. */
1496 switch (TREE_CODE (t
))
1499 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1500 result
= build_pointer_type (type
);
1502 case REFERENCE_TYPE
:
1503 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1504 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1507 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1508 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1509 result
= build_offset_type (t0
, type
);
1512 if (TYPE_PTRMEMFUNC_P (t
))
1514 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1515 remove_attributes
, flags
);
1516 result
= build_ptrmemfunc_type (t0
);
1520 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1521 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1522 result
= build_cplus_array_type (type
, t0
);
1527 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1530 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1531 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1532 can't expect that re-hashing a function type will find a previous
1533 equivalent type, so try to reuse the input type if nothing has
1534 changed. If the type is itself a variant, that will change. */
1535 bool is_variant
= typedef_variant_p (t
);
1536 if (remove_attributes
1537 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1540 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1541 tree canon_spec
= (flag_noexcept_type
1542 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1544 changed
= (type
!= TREE_TYPE (t
) || is_variant
1545 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1547 for (arg_node
= TYPE_ARG_TYPES (t
);
1549 arg_node
= TREE_CHAIN (arg_node
))
1551 if (arg_node
== void_list_node
)
1553 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1554 remove_attributes
, flags
);
1555 gcc_assert (arg_type
);
1556 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1562 for (arg_node2
= TYPE_ARG_TYPES (t
);
1563 arg_node2
!= arg_node
;
1564 arg_node2
= TREE_CHAIN (arg_node2
))
1566 = tree_cons (TREE_PURPOSE (arg_node2
),
1567 TREE_VALUE (arg_node2
), arg_types
);
1571 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1578 arg_types
= nreverse (arg_types
);
1580 /* A list of parameters not ending with an ellipsis
1581 must end with void_list_node. */
1583 arg_types
= chainon (arg_types
, void_list_node
);
1585 if (TREE_CODE (t
) == METHOD_TYPE
)
1587 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1588 gcc_assert (class_type
);
1590 build_method_type_directly (class_type
, type
,
1591 TREE_CHAIN (arg_types
));
1595 result
= build_function_type (type
, arg_types
);
1596 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1599 result
= build_cp_fntype_variant (result
,
1600 type_memfn_rqual (t
), canon_spec
,
1601 TYPE_HAS_LATE_RETURN_TYPE (t
));
1606 bool changed
= false;
1607 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1608 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1609 && TREE_OPERAND (fullname
, 1))
1611 tree args
= TREE_OPERAND (fullname
, 1);
1612 tree new_args
= copy_node (args
);
1613 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1615 tree arg
= TREE_VEC_ELT (args
, i
);
1618 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1620 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1622 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1623 if (strip_arg
!= arg
)
1628 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1629 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1631 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1635 ggc_free (new_args
);
1637 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1638 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1640 tree name
= fullname
;
1641 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1642 name
= TREE_OPERAND (fullname
, 0);
1643 /* Use build_typename_type rather than make_typename_type because we
1644 don't want to resolve it here, just strip typedefs. */
1645 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1649 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1650 remove_attributes
, flags
);
1651 if (result
== DECLTYPE_TYPE_EXPR (t
))
1654 result
= (finish_decltype_type
1656 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1659 case UNDERLYING_TYPE
:
1660 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1661 remove_attributes
, flags
);
1662 result
= finish_underlying_type (type
);
1670 if (typedef_variant_p (t
))
1672 if ((flags
& STF_USER_VISIBLE
)
1673 && !user_facing_original_type_p (t
))
1675 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1676 remove_attributes
, flags
);
1679 result
= TYPE_MAIN_VARIANT (t
);
1681 gcc_assert (!typedef_variant_p (result
)
1682 || ((flags
& STF_USER_VISIBLE
)
1683 && !user_facing_original_type_p (result
)));
1685 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1686 /* If RESULT is complete and T isn't, it's likely the case that T
1687 is a variant of RESULT which hasn't been updated yet. Skip the
1688 attribute handling. */;
1691 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1692 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1694 gcc_assert (TYPE_USER_ALIGN (t
));
1695 if (remove_attributes
)
1696 *remove_attributes
= true;
1699 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1700 result
= build_variant_type_copy (result
);
1702 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1703 TYPE_USER_ALIGN (result
) = true;
1707 if (TYPE_ATTRIBUTES (t
))
1709 if (remove_attributes
)
1710 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1713 result
= cp_build_type_attribute_variant (result
,
1714 TYPE_ATTRIBUTES (t
));
1718 return cp_build_qualified_type (result
, cp_type_quals (t
));
1721 /* Like strip_typedefs above, but works on expressions, so that in
1723 template<class T> struct A
1729 sizeof(TT) is replaced by sizeof(T). */
1732 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1736 enum tree_code code
;
1738 if (t
== NULL_TREE
|| t
== error_mark_node
)
1741 STRIP_ANY_LOCATION_WRAPPER (t
);
1743 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1746 /* Some expressions have type operands, so let's handle types here rather
1747 than check TYPE_P in multiple places below. */
1749 return strip_typedefs (t
, remove_attributes
, flags
);
1751 code
= TREE_CODE (t
);
1754 case IDENTIFIER_NODE
:
1755 case TEMPLATE_PARM_INDEX
:
1758 case ARGUMENT_PACK_SELECT
:
1763 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1764 remove_attributes
, flags
);
1765 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1766 remove_attributes
, flags
);
1767 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1768 && type2
== TRAIT_EXPR_TYPE2 (t
))
1771 TRAIT_EXPR_TYPE1 (r
) = type1
;
1772 TRAIT_EXPR_TYPE2 (r
) = type2
;
1779 bool changed
= false;
1781 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1783 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1784 remove_attributes
, flags
);
1785 vec_safe_push (vec
, val
);
1786 if (val
!= TREE_VALUE (it
))
1788 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1793 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1794 r
= tree_cons (NULL_TREE
, it
, r
);
1803 bool changed
= false;
1805 n
= TREE_VEC_LENGTH (t
);
1806 vec_safe_reserve (vec
, n
);
1807 for (i
= 0; i
< n
; ++i
)
1809 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1810 remove_attributes
, flags
);
1811 vec
->quick_push (op
);
1812 if (op
!= TREE_VEC_ELT (t
, i
))
1818 for (i
= 0; i
< n
; ++i
)
1819 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1820 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1821 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1830 bool changed
= false;
1831 vec
<constructor_elt
, va_gc
> *vec
1832 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1833 n
= CONSTRUCTOR_NELTS (t
);
1834 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1835 for (i
= 0; i
< n
; ++i
)
1837 constructor_elt
*e
= &(*vec
)[i
];
1838 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1845 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1849 if (!changed
&& type
== TREE_TYPE (t
))
1857 TREE_TYPE (r
) = type
;
1858 CONSTRUCTOR_ELTS (r
) = vec
;
1866 case STATEMENT_LIST
:
1867 error ("statement-expression in a constant expression");
1868 return error_mark_node
;
1874 gcc_assert (EXPR_P (t
));
1876 n
= cp_tree_operand_length (t
);
1877 ops
= XALLOCAVEC (tree
, n
);
1878 type
= TREE_TYPE (t
);
1883 case IMPLICIT_CONV_EXPR
:
1884 case DYNAMIC_CAST_EXPR
:
1885 case STATIC_CAST_EXPR
:
1886 case CONST_CAST_EXPR
:
1887 case REINTERPRET_CAST_EXPR
:
1890 type
= strip_typedefs (type
, remove_attributes
, flags
);
1894 for (i
= 0; i
< n
; ++i
)
1895 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1896 remove_attributes
, flags
);
1900 /* If nothing changed, return t. */
1901 for (i
= 0; i
< n
; ++i
)
1902 if (ops
[i
] != TREE_OPERAND (t
, i
))
1904 if (i
== n
&& type
== TREE_TYPE (t
))
1908 TREE_TYPE (r
) = type
;
1909 for (i
= 0; i
< n
; ++i
)
1910 TREE_OPERAND (r
, i
) = ops
[i
];
1914 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1915 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1916 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1917 VIRT indicates whether TYPE is inherited virtually or not.
1918 IGO_PREV points at the previous binfo of the inheritance graph
1919 order chain. The newly copied binfo's TREE_CHAIN forms this
1922 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1923 correct order. That is in the order the bases themselves should be
1926 The BINFO_INHERITANCE of a virtual base class points to the binfo
1927 of the most derived type. ??? We could probably change this so that
1928 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1929 remove a field. They currently can only differ for primary virtual
1933 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1939 /* See if we've already made this virtual base. */
1940 new_binfo
= binfo_for_vbase (type
, t
);
1945 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1946 BINFO_TYPE (new_binfo
) = type
;
1948 /* Chain it into the inheritance graph. */
1949 TREE_CHAIN (*igo_prev
) = new_binfo
;
1950 *igo_prev
= new_binfo
;
1952 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1957 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1959 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1960 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1962 /* We do not need to copy the accesses, as they are read only. */
1963 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1965 /* Recursively copy base binfos of BINFO. */
1966 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1968 tree new_base_binfo
;
1969 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1971 BINFO_VIRTUAL_P (base_binfo
));
1973 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1974 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1975 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1979 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1983 /* Push it onto the list after any virtual bases it contains
1984 will have been pushed. */
1985 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1986 BINFO_VIRTUAL_P (new_binfo
) = 1;
1987 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1993 /* Hashing of lists so that we don't make duplicates.
1994 The entry point is `list_hash_canon'. */
2003 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2005 typedef list_proxy
*compare_type
;
2007 static hashval_t
hash (tree
);
2008 static bool equal (tree
, list_proxy
*);
2011 /* Now here is the hash table. When recording a list, it is added
2012 to the slot whose index is the hash code mod the table size.
2013 Note that the hash table is used for several kinds of lists.
2014 While all these live in the same table, they are completely independent,
2015 and the hash code is computed differently for each of these. */
2017 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2019 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2020 for a node we are thinking about adding). */
2023 list_hasher::equal (tree t
, list_proxy
*proxy
)
2025 return (TREE_VALUE (t
) == proxy
->value
2026 && TREE_PURPOSE (t
) == proxy
->purpose
2027 && TREE_CHAIN (t
) == proxy
->chain
);
2030 /* Compute a hash code for a list (chain of TREE_LIST nodes
2031 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2032 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2035 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2037 hashval_t hashcode
= 0;
2040 hashcode
+= TREE_HASH (chain
);
2043 hashcode
+= TREE_HASH (value
);
2047 hashcode
+= TREE_HASH (purpose
);
2053 /* Hash an already existing TREE_LIST. */
2056 list_hasher::hash (tree t
)
2058 return list_hash_pieces (TREE_PURPOSE (t
),
2063 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2064 object for an identical list if one already exists. Otherwise, build a
2065 new one, and record it as the canonical object. */
2068 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2072 struct list_proxy proxy
;
2074 /* Hash the list node. */
2075 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2076 /* Create a proxy for the TREE_LIST we would like to create. We
2077 don't actually create it so as to avoid creating garbage. */
2078 proxy
.purpose
= purpose
;
2079 proxy
.value
= value
;
2080 proxy
.chain
= chain
;
2081 /* See if it is already in the table. */
2082 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2083 /* If not, create a new node. */
2085 *slot
= tree_cons (purpose
, value
, chain
);
2086 return (tree
) *slot
;
2089 /* Constructor for hashed lists. */
2092 hash_tree_chain (tree value
, tree chain
)
2094 return hash_tree_cons (NULL_TREE
, value
, chain
);
2098 debug_binfo (tree elem
)
2103 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2105 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2106 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2107 debug_tree (BINFO_TYPE (elem
));
2108 if (BINFO_VTABLE (elem
))
2109 fprintf (stderr
, "vtable decl \"%s\"\n",
2110 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2112 fprintf (stderr
, "no vtable decl yet\n");
2113 fprintf (stderr
, "virtuals:\n");
2114 virtuals
= BINFO_VIRTUALS (elem
);
2119 tree fndecl
= TREE_VALUE (virtuals
);
2120 fprintf (stderr
, "%s [%ld =? %ld]\n",
2121 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2122 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2124 virtuals
= TREE_CHAIN (virtuals
);
2128 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2129 the type of the result expression, if known, or NULL_TREE if the
2130 resulting expression is type-dependent. If TEMPLATE_P is true,
2131 NAME is known to be a template because the user explicitly used the
2132 "template" keyword after the "::".
2134 All SCOPE_REFs should be built by use of this function. */
2137 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2140 if (type
== error_mark_node
2141 || scope
== error_mark_node
2142 || name
== error_mark_node
)
2143 return error_mark_node
;
2144 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2145 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2146 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2147 PTRMEM_OK_P (t
) = true;
2149 t
= convert_from_reference (t
);
2153 /* Like check_qualified_type, but also check ref-qualifier, exception
2154 specification, and whether the return type was specified after the
2158 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2159 cp_ref_qualifier rqual
, tree raises
, bool late
)
2161 return (TYPE_QUALS (cand
) == type_quals
2162 && check_base_type (cand
, base
)
2163 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2165 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2166 && type_memfn_rqual (cand
) == rqual
);
2169 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2172 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2174 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2175 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2176 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2179 /* Make a raw overload node containing FN. */
2182 ovl_make (tree fn
, tree next
)
2184 tree result
= make_node (OVERLOAD
);
2186 if (TREE_CODE (fn
) == OVERLOAD
)
2187 OVL_NESTED_P (result
) = true;
2189 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2190 ? unknown_type_node
: TREE_TYPE (fn
));
2191 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2192 OVL_DEDUP_P (result
) = true;
2193 OVL_FUNCTION (result
) = fn
;
2194 OVL_CHAIN (result
) = next
;
2198 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2199 true, if FN is via a using declaration. We also pay attention to
2200 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2204 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2206 tree result
= maybe_ovl
;
2207 tree insert_after
= NULL_TREE
;
2210 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2211 && OVL_HIDDEN_P (maybe_ovl
);
2212 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2214 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2215 insert_after
= maybe_ovl
;
2218 bool hidden_p
= DECL_HIDDEN_P (fn
);
2219 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2221 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2223 OVL_HIDDEN_P (maybe_ovl
) = true;
2225 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2232 OVL_CHAIN (insert_after
) = maybe_ovl
;
2233 TREE_TYPE (insert_after
) = unknown_type_node
;
2241 /* Skip any hidden names at the beginning of OVL. */
2244 ovl_skip_hidden (tree ovl
)
2247 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2248 ovl
= OVL_CHAIN (ovl
))
2249 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2251 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2253 /* Any hidden functions should have been wrapped in an
2254 overload, but injected friend classes will not. */
2255 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2262 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2265 ovl_iterator::reveal_node (tree overload
, tree node
)
2267 /* We cannot have returned NODE as part of a lookup overload, so we
2268 don't have to worry about preserving that. */
2270 OVL_HIDDEN_P (node
) = false;
2271 if (tree chain
= OVL_CHAIN (node
))
2272 if (TREE_CODE (chain
) == OVERLOAD
)
2274 if (OVL_HIDDEN_P (chain
))
2276 /* The node needs moving, and the simplest way is to remove it
2278 overload
= remove_node (overload
, node
);
2279 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2281 else if (OVL_DEDUP_P (chain
))
2282 OVL_DEDUP_P (node
) = true;
2287 /* NODE is on the overloads of OVL. Remove it.
2288 The removed node is unaltered and may continue to be iterated
2289 from (i.e. it is safe to remove a node from an overload one is
2290 currently iterating over). */
2293 ovl_iterator::remove_node (tree overload
, tree node
)
2295 tree
*slot
= &overload
;
2296 while (*slot
!= node
)
2299 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2301 slot
= &OVL_CHAIN (probe
);
2304 /* Stitch out NODE. We don't have to worry about now making a
2305 singleton overload (and consequently maybe setting its type),
2306 because all uses of this function will be followed by inserting a
2307 new node that must follow the place we've cut this out from. */
2308 if (TREE_CODE (node
) != OVERLOAD
)
2309 /* Cloned inherited ctors don't mark themselves as via_using. */
2312 *slot
= OVL_CHAIN (node
);
2317 /* Mark or unmark a lookup set. */
2320 lookup_mark (tree ovl
, bool val
)
2322 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2324 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2325 LOOKUP_SEEN_P (*iter
) = val
;
2329 /* Add a set of new FNS into a lookup. */
2332 lookup_add (tree fns
, tree lookup
)
2334 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2336 lookup
= ovl_make (fns
, lookup
);
2337 OVL_LOOKUP_P (lookup
) = true;
2345 /* FNS is a new overload set, add them to LOOKUP, if they are not
2346 already present there. */
2349 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2352 for (tree next
, probe
= fns
; probe
; probe
= next
)
2357 if (TREE_CODE (probe
) == OVERLOAD
)
2359 fn
= OVL_FUNCTION (probe
);
2360 next
= OVL_CHAIN (probe
);
2363 if (!LOOKUP_SEEN_P (fn
))
2364 LOOKUP_SEEN_P (fn
) = true;
2367 /* This function was already seen. Insert all the
2368 predecessors onto the lookup. */
2369 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2371 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2372 /* Propagate OVL_USING, but OVL_HIDDEN &
2373 OVL_DEDUP_P don't matter. */
2374 if (OVL_USING_P (fns
))
2375 OVL_USING_P (lookup
) = true;
2378 /* And now skip this function. */
2384 /* We ended in a set of new functions. Add them all in one go. */
2385 lookup
= lookup_add (fns
, lookup
);
2390 /* Returns nonzero if X is an expression for a (possibly overloaded)
2391 function. If "f" is a function or function template, "f", "c->f",
2392 "c.f", "C::f", and "f<int>" will all be considered possibly
2393 overloaded functions. Returns 2 if the function is actually
2394 overloaded, i.e., if it is impossible to know the type of the
2395 function without performing overload resolution. */
2398 is_overloaded_fn (tree x
)
2400 STRIP_ANY_LOCATION_WRAPPER (x
);
2402 /* A baselink is also considered an overloaded function. */
2403 if (TREE_CODE (x
) == OFFSET_REF
2404 || TREE_CODE (x
) == COMPONENT_REF
)
2405 x
= TREE_OPERAND (x
, 1);
2406 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2407 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2408 x
= TREE_OPERAND (x
, 0);
2410 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2411 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2417 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2418 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2422 dependent_name (tree x
)
2424 if (identifier_p (x
))
2426 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2427 x
= TREE_OPERAND (x
, 0);
2429 return OVL_NAME (x
);
2433 /* Returns true iff X is an expression for an overloaded function
2434 whose type cannot be known without performing overload
2438 really_overloaded_fn (tree x
)
2440 return is_overloaded_fn (x
) == 2;
2443 /* Get the overload set FROM refers to. Returns NULL if it's not an
2447 maybe_get_fns (tree from
)
2449 STRIP_ANY_LOCATION_WRAPPER (from
);
2451 /* A baselink is also considered an overloaded function. */
2452 if (TREE_CODE (from
) == OFFSET_REF
2453 || TREE_CODE (from
) == COMPONENT_REF
)
2454 from
= TREE_OPERAND (from
, 1);
2455 if (BASELINK_P (from
))
2456 from
= BASELINK_FUNCTIONS (from
);
2457 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2458 from
= TREE_OPERAND (from
, 0);
2466 /* FROM refers to an overload set. Return that set (or die). */
2471 tree res
= maybe_get_fns (from
);
2477 /* Return the first function of the overload set FROM refers to. */
2480 get_first_fn (tree from
)
2482 return OVL_FIRST (get_fns (from
));
2485 /* Return the scope where the overloaded functions OVL were found. */
2488 ovl_scope (tree ovl
)
2490 if (TREE_CODE (ovl
) == OFFSET_REF
2491 || TREE_CODE (ovl
) == COMPONENT_REF
)
2492 ovl
= TREE_OPERAND (ovl
, 1);
2493 if (TREE_CODE (ovl
) == BASELINK
)
2494 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2495 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2496 ovl
= TREE_OPERAND (ovl
, 0);
2497 /* Skip using-declarations. */
2498 lkp_iterator
iter (ovl
);
2501 while (iter
.using_p () && ++iter
);
2503 return CP_DECL_CONTEXT (ovl
);
2506 #define PRINT_RING_SIZE 4
2509 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2511 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2512 static char *print_ring
[PRINT_RING_SIZE
];
2513 static bool trans_ring
[PRINT_RING_SIZE
];
2514 static int ring_counter
;
2517 /* Only cache functions. */
2519 || TREE_CODE (decl
) != FUNCTION_DECL
2520 || DECL_LANG_SPECIFIC (decl
) == 0)
2521 return lang_decl_name (decl
, v
, translate
);
2523 /* See if this print name is lying around. */
2524 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2525 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2526 /* yes, so return it. */
2527 return print_ring
[i
];
2529 if (++ring_counter
== PRINT_RING_SIZE
)
2532 if (current_function_decl
!= NULL_TREE
)
2534 /* There may be both translated and untranslated versions of the
2536 for (i
= 0; i
< 2; i
++)
2538 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2540 if (ring_counter
== PRINT_RING_SIZE
)
2543 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2546 free (print_ring
[ring_counter
]);
2548 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2549 uid_ring
[ring_counter
] = DECL_UID (decl
);
2550 trans_ring
[ring_counter
] = translate
;
2551 return print_ring
[ring_counter
];
2555 cxx_printable_name (tree decl
, int v
)
2557 return cxx_printable_name_internal (decl
, v
, false);
2561 cxx_printable_name_translate (tree decl
, int v
)
2563 return cxx_printable_name_internal (decl
, v
, true);
2566 /* Return the canonical version of exception-specification RAISES for a C++17
2567 function type, for use in type comparison and building TYPE_CANONICAL. */
2570 canonical_eh_spec (tree raises
)
2572 if (raises
== NULL_TREE
)
2574 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2575 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2576 || uses_template_parms (raises
)
2577 || uses_template_parms (TREE_PURPOSE (raises
)))
2578 /* Keep a dependent or deferred exception specification. */
2580 else if (nothrow_spec_p (raises
))
2581 /* throw() -> noexcept. */
2582 return noexcept_true_spec
;
2584 /* For C++17 type matching, anything else -> nothing. */
2589 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2590 tree raises
, bool late
)
2592 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2594 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2597 tree v
= TYPE_MAIN_VARIANT (type
);
2598 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2599 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2602 /* Need to build a new variant. */
2603 v
= build_variant_type_copy (type
);
2604 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2605 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2608 case REF_QUAL_RVALUE
:
2609 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2610 FUNCTION_REF_QUALIFIED (v
) = 1;
2612 case REF_QUAL_LVALUE
:
2613 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2614 FUNCTION_REF_QUALIFIED (v
) = 1;
2617 FUNCTION_REF_QUALIFIED (v
) = 0;
2621 /* Canonicalize the exception specification. */
2622 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2624 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2625 /* Propagate structural equality. */
2626 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2627 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2628 /* Build the underlying canonical type, since it is different
2630 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2633 /* T is its own canonical type. */
2634 TYPE_CANONICAL (v
) = v
;
2639 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2640 listed in RAISES. */
2643 build_exception_variant (tree type
, tree raises
)
2645 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2646 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2647 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2650 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2651 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2655 bind_template_template_parm (tree t
, tree newargs
)
2657 tree decl
= TYPE_NAME (t
);
2660 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2661 decl
= build_decl (input_location
,
2662 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2664 /* These nodes have to be created to reflect new TYPE_DECL and template
2666 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2667 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2668 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2669 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2671 TREE_TYPE (decl
) = t2
;
2672 TYPE_NAME (t2
) = decl
;
2673 TYPE_STUB_DECL (t2
) = decl
;
2675 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2680 /* Called from count_trees via walk_tree. */
2683 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2693 /* Debugging function for measuring the rough complexity of a tree
2697 count_trees (tree t
)
2700 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2704 /* Called from verify_stmt_tree via walk_tree. */
2707 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2710 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2711 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2714 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2717 /* If this statement is already present in the hash table, then
2718 there is a circularity in the statement tree. */
2719 gcc_assert (!statements
->find (t
));
2721 slot
= statements
->find_slot (t
, INSERT
);
2727 /* Debugging function to check that the statement T has not been
2728 corrupted. For now, this function simply checks that T contains no
2732 verify_stmt_tree (tree t
)
2734 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2735 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2738 /* Check if the type T depends on a type with no linkage and if so, return
2739 it. If RELAXED_P then do not consider a class type declared within
2740 a vague-linkage function to have no linkage. */
2743 no_linkage_check (tree t
, bool relaxed_p
)
2747 /* Lambda types that don't have mangling scope have no linkage. We
2748 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2749 when we get here from pushtag none of the lambda information is
2750 set up yet, so we want to assume that the lambda has linkage and
2751 fix it up later if not. We need to check this even in templates so
2752 that we properly handle a lambda-expression in the signature. */
2753 if (LAMBDA_TYPE_P (t
)
2754 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2755 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2758 /* Otherwise there's no point in checking linkage on template functions; we
2759 can't know their complete types. */
2760 if (processing_template_decl
)
2763 switch (TREE_CODE (t
))
2766 if (TYPE_PTRMEMFUNC_P (t
))
2770 if (!CLASS_TYPE_P (t
))
2774 /* Only treat unnamed types as having no linkage if they're at
2775 namespace scope. This is core issue 966. */
2776 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2779 for (r
= CP_TYPE_CONTEXT (t
); ; )
2781 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2782 have linkage, or we might just be in an anonymous namespace.
2783 If we're in a TREE_PUBLIC class, we have linkage. */
2784 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2785 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2786 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2788 if (!relaxed_p
|| !vague_linkage_p (r
))
2791 r
= CP_DECL_CONTEXT (r
);
2801 case REFERENCE_TYPE
:
2803 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2807 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2811 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2816 tree parm
= TYPE_ARG_TYPES (t
);
2817 if (TREE_CODE (t
) == METHOD_TYPE
)
2818 /* The 'this' pointer isn't interesting; a method has the same
2819 linkage (or lack thereof) as its enclosing class. */
2820 parm
= TREE_CHAIN (parm
);
2822 parm
&& parm
!= void_list_node
;
2823 parm
= TREE_CHAIN (parm
))
2825 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2829 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2837 extern int depth_reached
;
2840 cxx_print_statistics (void)
2842 print_template_statistics ();
2843 if (GATHER_STATISTICS
)
2844 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2848 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2849 (which is an ARRAY_TYPE). This counts only elements of the top
2853 array_type_nelts_top (tree type
)
2855 return fold_build2_loc (input_location
,
2856 PLUS_EXPR
, sizetype
,
2857 array_type_nelts (type
),
2861 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2862 (which is an ARRAY_TYPE). This one is a recursive count of all
2863 ARRAY_TYPEs that are clumped together. */
2866 array_type_nelts_total (tree type
)
2868 tree sz
= array_type_nelts_top (type
);
2869 type
= TREE_TYPE (type
);
2870 while (TREE_CODE (type
) == ARRAY_TYPE
)
2872 tree n
= array_type_nelts_top (type
);
2873 sz
= fold_build2_loc (input_location
,
2874 MULT_EXPR
, sizetype
, sz
, n
);
2875 type
= TREE_TYPE (type
);
2882 splay_tree target_remap
;
2883 bool clear_location
;
2886 /* Called from break_out_target_exprs via mapcar. */
2889 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2891 bot_data
&data
= *(bot_data
*)data_
;
2892 splay_tree target_remap
= data
.target_remap
;
2895 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2897 /* There can't be any TARGET_EXPRs or their slot variables below this
2898 point. But we must make a copy, in case subsequent processing
2899 alters any part of it. For example, during gimplification a cast
2900 of the form (T) &X::f (where "f" is a member function) will lead
2901 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2903 *tp
= unshare_expr (t
);
2906 if (TREE_CODE (t
) == TARGET_EXPR
)
2910 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2912 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2913 tf_warning_or_error
);
2914 if (u
== error_mark_node
)
2916 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2917 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2920 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2921 tf_warning_or_error
);
2923 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2924 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2925 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2927 /* Map the old variable to the new one. */
2928 splay_tree_insert (target_remap
,
2929 (splay_tree_key
) TREE_OPERAND (t
, 0),
2930 (splay_tree_value
) TREE_OPERAND (u
, 0));
2932 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2933 data
.clear_location
);
2934 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2935 return error_mark_node
;
2937 /* Replace the old expression with the new version. */
2939 /* We don't have to go below this point; the recursive call to
2940 break_out_target_exprs will have handled anything below this
2945 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2948 splay_tree_node n
= splay_tree_lookup (target_remap
,
2949 (splay_tree_key
) t
);
2952 *tp
= (tree
)n
->value
;
2957 copy_tree_r (tp
, walk_subtrees
, NULL
);
2958 splay_tree_insert (target_remap
,
2960 (splay_tree_value
)*tp
);
2961 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2962 splay_tree_insert (target_remap
,
2963 (splay_tree_key
)*tp
,
2964 (splay_tree_value
)*tp
);
2969 /* Make a copy of this node. */
2970 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2971 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2972 if (!processing_template_decl
)
2973 set_flags_from_callee (*tp
);
2974 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2975 SET_EXPR_LOCATION (*tp
, input_location
);
2979 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2980 DATA is really a splay-tree mapping old variables to new
2984 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
2986 bot_data
&data
= *(bot_data
*)data_
;
2987 splay_tree target_remap
= data
.target_remap
;
2991 splay_tree_node n
= splay_tree_lookup (target_remap
,
2992 (splay_tree_key
) *t
);
2994 *t
= (tree
) n
->value
;
2996 else if (TREE_CODE (*t
) == PARM_DECL
2997 && DECL_NAME (*t
) == this_identifier
2998 && !DECL_CONTEXT (*t
))
3000 /* In an NSDMI we need to replace the 'this' parameter we used for
3001 parsing with the real one for this function. */
3002 *t
= current_class_ptr
;
3004 else if (TREE_CODE (*t
) == CONVERT_EXPR
3005 && CONVERT_EXPR_VBASE_PATH (*t
))
3007 /* In an NSDMI build_base_path defers building conversions to virtual
3008 bases, and we handle it here. */
3009 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3010 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3012 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3013 if (BINFO_TYPE (binfo
) == basetype
)
3015 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3016 tf_warning_or_error
);
3022 /* When we parse a default argument expression, we may create
3023 temporary variables via TARGET_EXPRs. When we actually use the
3024 default-argument expression, we make a copy of the expression
3025 and replace the temporaries with appropriate local versions.
3027 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3031 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3033 static int target_remap_count
;
3034 static splay_tree target_remap
;
3036 if (!target_remap_count
++)
3037 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3038 /*splay_tree_delete_key_fn=*/NULL
,
3039 /*splay_tree_delete_value_fn=*/NULL
);
3040 bot_data data
= { target_remap
, clear_location
};
3041 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3042 t
= error_mark_node
;
3043 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3045 if (!--target_remap_count
)
3047 splay_tree_delete (target_remap
);
3048 target_remap
= NULL
;
3054 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3055 which we expect to have type TYPE. */
3058 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3060 if (index
== NULL_TREE
)
3061 /* Can't refer to a particular member of a vector. */
3063 else if (TREE_CODE (index
) == INTEGER_CST
)
3064 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3066 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3067 /*reference*/false, tf_none
);
3070 tree objtype
= TREE_TYPE (obj
);
3071 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3073 /* When the destination object refers to a flexible array member
3074 verify that it matches the type of the source object except
3075 for its domain and qualifiers. */
3076 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3077 TYPE_MAIN_VARIANT (objtype
),
3078 COMPARE_REDECLARATION
));
3081 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3087 struct replace_placeholders_t
3089 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3090 tree exp
; /* The outermost exp. */
3091 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3092 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3095 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3096 build up subexpressions as we go deeper. */
3099 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3101 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3104 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3106 *walk_subtrees
= false;
3110 switch (TREE_CODE (*t
))
3112 case PLACEHOLDER_EXPR
:
3115 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3117 x
= TREE_OPERAND (x
, 0))
3118 gcc_assert (handled_component_p (x
));
3119 *t
= unshare_expr (x
);
3120 *walk_subtrees
= false;
3127 constructor_elt
*ce
;
3128 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3129 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3130 other than the d->exp one, those have PLACEHOLDER_EXPRs
3131 related to another object. */
3132 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3134 || d
->pset
->add (*t
))
3136 *walk_subtrees
= false;
3139 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3141 tree
*valp
= &ce
->value
;
3142 tree type
= TREE_TYPE (*valp
);
3145 if (TREE_CODE (*valp
) == CONSTRUCTOR
3146 && AGGREGATE_TYPE_P (type
))
3148 /* If we're looking at the initializer for OBJ, then build
3149 a sub-object reference. If we're looking at an
3150 initializer for another object, just pass OBJ down. */
3151 if (same_type_ignoring_top_level_qualifiers_p
3152 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3153 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3154 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3155 valp
= &TARGET_EXPR_INITIAL (*valp
);
3158 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3161 *walk_subtrees
= false;
3166 if (d
->pset
->add (*t
))
3167 *walk_subtrees
= false;
3174 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3175 a PLACEHOLDER_EXPR has been encountered. */
3178 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3180 /* This is only relevant for C++14. */
3181 if (cxx_dialect
< cxx14
)
3184 /* If the object isn't a (member of a) class, do nothing. */
3186 while (TREE_CODE (op0
) == COMPONENT_REF
)
3187 op0
= TREE_OPERAND (op0
, 0);
3188 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3192 if (TREE_CODE (exp
) == TARGET_EXPR
)
3193 tp
= &TARGET_EXPR_INITIAL (exp
);
3194 hash_set
<tree
> pset
;
3195 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3196 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3198 *seen_p
= data
.seen
;
3202 /* Callback function for find_placeholders. */
3205 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3207 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3209 *walk_subtrees
= false;
3213 switch (TREE_CODE (*t
))
3215 case PLACEHOLDER_EXPR
:
3219 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3220 *walk_subtrees
= false;
3230 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3231 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3234 find_placeholders (tree exp
)
3236 /* This is only relevant for C++14. */
3237 if (cxx_dialect
< cxx14
)
3240 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3243 /* Similar to `build_nt', but for template definitions of dependent
3247 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3254 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3258 t
= make_node (code
);
3259 SET_EXPR_LOCATION (t
, loc
);
3260 length
= TREE_CODE_LENGTH (code
);
3262 for (i
= 0; i
< length
; i
++)
3263 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3269 /* Similar to `build', but for template definitions. */
3272 build_min (enum tree_code code
, tree tt
, ...)
3279 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3283 t
= make_node (code
);
3284 length
= TREE_CODE_LENGTH (code
);
3287 for (i
= 0; i
< length
; i
++)
3289 tree x
= va_arg (p
, tree
);
3290 TREE_OPERAND (t
, i
) = x
;
3291 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3292 TREE_SIDE_EFFECTS (t
) = 1;
3300 /* Similar to `build', but for template definitions of non-dependent
3301 expressions. NON_DEP is the non-dependent expression that has been
3305 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3312 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3314 va_start (p
, non_dep
);
3316 if (REFERENCE_REF_P (non_dep
))
3317 non_dep
= TREE_OPERAND (non_dep
, 0);
3319 t
= make_node (code
);
3320 length
= TREE_CODE_LENGTH (code
);
3321 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3322 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3324 for (i
= 0; i
< length
; i
++)
3325 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3327 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3328 /* This should not be considered a COMPOUND_EXPR, because it
3329 resolves to an overload. */
3330 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3333 return convert_from_reference (t
);
3336 /* Similar to build_min_nt, but call expressions */
3339 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3344 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3345 CALL_EXPR_FN (ret
) = fn
;
3346 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3347 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3348 CALL_EXPR_ARG (ret
, ix
) = t
;
3353 /* Similar to `build_min_nt_call_vec', but for template definitions of
3354 non-dependent expressions. NON_DEP is the non-dependent expression
3355 that has been built. */
3358 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3360 tree t
= build_min_nt_call_vec (fn
, argvec
);
3361 if (REFERENCE_REF_P (non_dep
))
3362 non_dep
= TREE_OPERAND (non_dep
, 0);
3363 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3364 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3365 return convert_from_reference (t
);
3368 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3369 a call to an operator overload. OP is the operator that has been
3370 overloaded. NON_DEP is the non-dependent expression that's been built,
3371 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3372 the overload that NON_DEP is calling. */
3375 build_min_non_dep_op_overload (enum tree_code op
,
3380 int nargs
, expected_nargs
;
3383 non_dep
= extract_call_expr (non_dep
);
3385 nargs
= call_expr_nargs (non_dep
);
3387 expected_nargs
= cp_tree_code_length (op
);
3388 if ((op
== POSTINCREMENT_EXPR
3389 || op
== POSTDECREMENT_EXPR
)
3390 /* With -fpermissive non_dep could be operator++(). */
3391 && (!flag_permissive
|| nargs
!= expected_nargs
))
3392 expected_nargs
+= 1;
3393 gcc_assert (nargs
== expected_nargs
);
3396 va_start (p
, overload
);
3398 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3401 for (int i
= 0; i
< nargs
; i
++)
3403 tree arg
= va_arg (p
, tree
);
3404 vec_safe_push (args
, arg
);
3407 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3409 tree object
= va_arg (p
, tree
);
3410 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3411 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3412 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3413 object
, method
, NULL_TREE
);
3414 for (int i
= 1; i
< nargs
; i
++)
3416 tree arg
= va_arg (p
, tree
);
3417 vec_safe_push (args
, arg
);
3424 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3426 tree call_expr
= extract_call_expr (call
);
3427 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3428 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3429 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3430 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3435 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3438 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3440 unsigned len
= vec_safe_length (old_vec
);
3441 gcc_assert (idx
<= len
);
3443 vec
<tree
, va_gc
> *new_vec
= NULL
;
3444 vec_alloc (new_vec
, len
+ 1);
3447 for (i
= 0; i
< len
; ++i
)
3450 new_vec
->quick_push (elt
);
3451 new_vec
->quick_push ((*old_vec
)[i
]);
3454 new_vec
->quick_push (elt
);
3460 get_type_decl (tree t
)
3462 if (TREE_CODE (t
) == TYPE_DECL
)
3465 return TYPE_STUB_DECL (t
);
3466 gcc_assert (t
== error_mark_node
);
3470 /* Returns the namespace that contains DECL, whether directly or
3474 decl_namespace_context (tree decl
)
3478 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3480 else if (TYPE_P (decl
))
3481 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3483 decl
= CP_DECL_CONTEXT (decl
);
3487 /* Returns true if decl is within an anonymous namespace, however deeply
3488 nested, or false otherwise. */
3491 decl_anon_ns_mem_p (const_tree decl
)
3493 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3495 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3497 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3499 decl
= CP_DECL_CONTEXT (decl
);
3501 return !TREE_PUBLIC (decl
);
3504 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3505 CALL_EXPRS. Return whether they are equivalent. */
3508 called_fns_equal (tree t1
, tree t2
)
3510 /* Core 1321: dependent names are equivalent even if the overload sets
3511 are different. But do compare explicit template arguments. */
3512 tree name1
= dependent_name (t1
);
3513 tree name2
= dependent_name (t2
);
3516 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3521 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3522 targs1
= TREE_OPERAND (t1
, 1);
3523 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3524 targs2
= TREE_OPERAND (t2
, 1);
3525 return cp_tree_equal (targs1
, targs2
);
3528 return cp_tree_equal (t1
, t2
);
3531 /* Return truthvalue of whether T1 is the same tree structure as T2.
3532 Return 1 if they are the same. Return 0 if they are different. */
3535 cp_tree_equal (tree t1
, tree t2
)
3537 enum tree_code code1
, code2
;
3544 code1
= TREE_CODE (t1
);
3545 code2
= TREE_CODE (t2
);
3550 if (CONSTANT_CLASS_P (t1
)
3551 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3557 /* There's only a single VOID_CST node, so we should never reach
3562 return tree_int_cst_equal (t1
, t2
);
3565 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3568 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3569 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3570 TREE_STRING_LENGTH (t1
));
3573 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3574 TREE_FIXED_CST (t2
));
3577 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3578 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3581 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3584 /* We need to do this when determining whether or not two
3585 non-type pointer to member function template arguments
3587 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3588 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3593 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3595 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3596 if (!cp_tree_equal (field
, elt2
->index
)
3597 || !cp_tree_equal (value
, elt2
->value
))
3604 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3606 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3608 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3611 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3616 call_expr_arg_iterator iter1
, iter2
;
3617 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3619 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3620 arg2
= first_call_expr_arg (t2
, &iter2
);
3622 arg1
= next_call_expr_arg (&iter1
),
3623 arg2
= next_call_expr_arg (&iter2
))
3624 if (!cp_tree_equal (arg1
, arg2
))
3633 tree o1
= TREE_OPERAND (t1
, 0);
3634 tree o2
= TREE_OPERAND (t2
, 0);
3636 /* Special case: if either target is an unallocated VAR_DECL,
3637 it means that it's going to be unified with whatever the
3638 TARGET_EXPR is really supposed to initialize, so treat it
3639 as being equivalent to anything. */
3640 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3641 && !DECL_RTL_SET_P (o1
))
3643 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3644 && !DECL_RTL_SET_P (o2
))
3646 else if (!cp_tree_equal (o1
, o2
))
3649 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3653 /* For comparing uses of parameters in late-specified return types
3654 with an out-of-class definition of the function, but can also come
3655 up for expressions that involve 'this' in a member function
3658 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3659 /* When comparing hash table entries, only an exact match is
3660 good enough; we don't want to replace 'this' with the
3661 version from another function. But be more flexible
3662 with local parameters in a requires-expression. */
3665 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3667 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3669 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3671 if (DECL_ARTIFICIAL (t1
)
3672 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3673 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3683 case IDENTIFIER_NODE
:
3686 case DEFERRED_PARSE
:
3690 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3691 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3692 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3693 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3694 BASELINK_FUNCTIONS (t2
)));
3696 case TEMPLATE_PARM_INDEX
:
3697 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3698 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3699 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3700 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3701 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3702 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3704 case TEMPLATE_ID_EXPR
:
3705 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3706 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3708 case CONSTRAINT_INFO
:
3709 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3710 CI_ASSOCIATED_CONSTRAINTS (t2
));
3713 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3714 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3715 CHECK_CONSTR_ARGS (t2
)));
3720 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3722 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3723 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3724 TREE_VEC_ELT (t2
, ix
)))
3732 tree o1
= TREE_OPERAND (t1
, 0);
3733 tree o2
= TREE_OPERAND (t2
, 0);
3735 if (code1
== SIZEOF_EXPR
)
3737 if (SIZEOF_EXPR_TYPE_P (t1
))
3738 o1
= TREE_TYPE (o1
);
3739 if (SIZEOF_EXPR_TYPE_P (t2
))
3740 o2
= TREE_TYPE (o2
);
3742 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3745 return same_type_p (o1
, o2
);
3747 return cp_tree_equal (o1
, o2
);
3752 tree t1_op1
, t2_op1
;
3754 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3757 t1_op1
= TREE_OPERAND (t1
, 1);
3758 t2_op1
= TREE_OPERAND (t2
, 1);
3759 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3762 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3766 /* Two pointer-to-members are the same if they point to the same
3767 field or function in the same class. */
3768 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3771 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3775 /* Two overloads. Must be exactly the same set of decls. */
3776 lkp_iterator
first (t1
);
3777 lkp_iterator
second (t2
);
3779 for (; first
&& second
; ++first
, ++second
)
3780 if (*first
!= *second
)
3782 return !(first
|| second
);
3786 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3788 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3789 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3792 case STATIC_CAST_EXPR
:
3793 case REINTERPRET_CAST_EXPR
:
3794 case CONST_CAST_EXPR
:
3795 case DYNAMIC_CAST_EXPR
:
3796 case IMPLICIT_CONV_EXPR
:
3799 case NON_LVALUE_EXPR
:
3800 case VIEW_CONVERT_EXPR
:
3801 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3803 /* Now compare operands as usual. */
3806 case DEFERRED_NOEXCEPT
:
3807 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3808 DEFERRED_NOEXCEPT_PATTERN (t2
))
3809 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3810 DEFERRED_NOEXCEPT_ARGS (t2
)));
3814 /* Two lambda-expressions are never considered equivalent. */
3821 switch (TREE_CODE_CLASS (code1
))
3825 case tcc_comparison
:
3826 case tcc_expression
:
3833 n
= cp_tree_operand_length (t1
);
3834 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3835 && n
!= TREE_OPERAND_LENGTH (t2
))
3838 for (i
= 0; i
< n
; ++i
)
3839 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3846 return same_type_p (t1
, t2
);
3850 /* We can get here with --disable-checking. */
3854 /* The type of ARG when used as an lvalue. */
3857 lvalue_type (tree arg
)
3859 tree type
= TREE_TYPE (arg
);
3863 /* The type of ARG for printing error messages; denote lvalues with
3867 error_type (tree arg
)
3869 tree type
= TREE_TYPE (arg
);
3871 if (TREE_CODE (type
) == ARRAY_TYPE
)
3873 else if (TREE_CODE (type
) == ERROR_MARK
)
3875 else if (lvalue_p (arg
))
3876 type
= build_reference_type (lvalue_type (arg
));
3877 else if (MAYBE_CLASS_TYPE_P (type
))
3878 type
= lvalue_type (arg
);
3883 /* Does FUNCTION use a variable-length argument list? */
3886 varargs_function_p (const_tree function
)
3888 return stdarg_p (TREE_TYPE (function
));
3891 /* Returns 1 if decl is a member of a class. */
3894 member_p (const_tree decl
)
3896 const_tree
const ctx
= DECL_CONTEXT (decl
);
3897 return (ctx
&& TYPE_P (ctx
));
3900 /* Create a placeholder for member access where we don't actually have an
3901 object that the access is against. */
3904 build_dummy_object (tree type
)
3906 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3907 return cp_build_fold_indirect_ref (decl
);
3910 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3911 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3912 binfo path from current_class_type to TYPE, or 0. */
3915 maybe_dummy_object (tree type
, tree
* binfop
)
3919 tree current
= current_nonlambda_class_type ();
3922 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3923 tf_warning_or_error
)))
3927 /* Reference from a nested class member function. */
3929 binfo
= TYPE_BINFO (type
);
3935 if (current_class_ref
3936 /* current_class_ref might not correspond to current_class_type if
3937 we're in tsubst_default_argument or a lambda-declarator; in either
3938 case, we want to use current_class_ref if it matches CONTEXT. */
3939 && (same_type_ignoring_top_level_qualifiers_p
3940 (TREE_TYPE (current_class_ref
), context
)))
3941 decl
= current_class_ref
;
3943 decl
= build_dummy_object (context
);
3948 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3951 is_dummy_object (const_tree ob
)
3953 if (INDIRECT_REF_P (ob
))
3954 ob
= TREE_OPERAND (ob
, 0);
3955 return (TREE_CODE (ob
) == CONVERT_EXPR
3956 && TREE_OPERAND (ob
, 0) == void_node
);
3959 /* Returns 1 iff type T is something we want to treat as a scalar type for
3960 the purpose of deciding whether it is trivial/POD/standard-layout. */
3963 scalarish_type_p (const_tree t
)
3965 if (t
== error_mark_node
)
3968 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3971 /* Returns true iff T requires non-trivial default initialization. */
3974 type_has_nontrivial_default_init (const_tree t
)
3976 t
= strip_array_types (CONST_CAST_TREE (t
));
3978 if (CLASS_TYPE_P (t
))
3979 return TYPE_HAS_COMPLEX_DFLT (t
);
3984 /* Track classes with only deleted copy/move constructors so that we can warn
3985 if they are used in call/return by value. */
3987 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
3989 remember_deleted_copy (const_tree t
)
3991 if (!deleted_copy_types
)
3992 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
3993 deleted_copy_types
->add (CONST_CAST_TREE (t
));
3996 maybe_warn_parm_abi (tree t
, location_t loc
)
3998 if (!deleted_copy_types
3999 || !deleted_copy_types
->contains (t
))
4002 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4003 && classtype_has_non_deleted_move_ctor (t
))
4006 auto_diagnostic_group d
;
4007 if (flag_abi_version
> 12)
4008 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4009 "the calling convention for %qT, which was "
4010 "accidentally changed in 8.1", t
);
4012 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4013 "ally changes the calling convention for %qT", t
);
4015 inform (location_of (t
), " declared here");
4019 auto_diagnostic_group d
;
4020 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4021 "%<-fabi-version=13%> (GCC 8.2)", t
))
4022 inform (location_of (t
), " because all of its copy and move "
4023 "constructors are deleted");
4026 /* Returns true iff copying an object of type T (including via move
4027 constructor) is non-trivial. That is, T has no non-trivial copy
4028 constructors and no non-trivial move constructors, and not all copy/move
4029 constructors are deleted. This function implements the ABI notion of
4030 non-trivial copy, which has diverged from the one in the standard. */
4033 type_has_nontrivial_copy_init (const_tree type
)
4035 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4037 if (CLASS_TYPE_P (t
))
4039 gcc_assert (COMPLETE_TYPE_P (t
));
4041 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4042 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4046 if (cxx_dialect
< cxx11
)
4047 /* No deleted functions before C++11. */
4050 /* Before ABI v12 we did a bitwise copy of types with only deleted
4051 copy/move constructors. */
4052 if (!abi_version_at_least (12)
4053 && !(warn_abi
&& abi_version_crosses (12)))
4056 bool saw_copy
= false;
4057 bool saw_non_deleted
= false;
4058 bool saw_non_deleted_move
= false;
4060 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4061 saw_copy
= saw_non_deleted
= true;
4062 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4065 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4066 /* [class.copy]/8 If the class definition declares a move
4067 constructor or move assignment operator, the implicitly declared
4068 copy constructor is defined as deleted.... */;
4070 /* Any other reason the implicitly-declared function would be
4071 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4073 saw_non_deleted
= true;
4076 if (!saw_non_deleted
)
4077 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4083 if (!DECL_DELETED_FN (fn
))
4085 /* Not deleted, therefore trivial. */
4086 saw_non_deleted
= true;
4090 else if (move_fn_p (fn
))
4091 if (!DECL_DELETED_FN (fn
))
4092 saw_non_deleted_move
= true;
4095 gcc_assert (saw_copy
);
4097 /* ABI v12 buggily ignored move constructors. */
4098 bool v11nontriv
= false;
4099 bool v12nontriv
= !saw_non_deleted
;
4100 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4101 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4102 : flag_abi_version
== 12 ? v12nontriv
4104 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4105 : warn_abi_version
== 12 ? v12nontriv
4107 if (nontriv
!= warn_nontriv
)
4108 remember_deleted_copy (t
);
4116 /* Returns 1 iff type T is a trivially copyable type, as defined in
4117 [basic.types] and [class]. */
4120 trivially_copyable_p (const_tree t
)
4122 t
= strip_array_types (CONST_CAST_TREE (t
));
4124 if (CLASS_TYPE_P (t
))
4125 return ((!TYPE_HAS_COPY_CTOR (t
)
4126 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4127 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4128 && (!TYPE_HAS_COPY_ASSIGN (t
)
4129 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4130 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4131 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4133 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4134 return scalarish_type_p (t
);
4137 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4141 trivial_type_p (const_tree t
)
4143 t
= strip_array_types (CONST_CAST_TREE (t
));
4145 if (CLASS_TYPE_P (t
))
4146 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4147 && trivially_copyable_p (t
));
4149 return scalarish_type_p (t
);
4152 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4155 pod_type_p (const_tree t
)
4157 /* This CONST_CAST is okay because strip_array_types returns its
4158 argument unmodified and we assign it to a const_tree. */
4159 t
= strip_array_types (CONST_CAST_TREE(t
));
4161 if (!CLASS_TYPE_P (t
))
4162 return scalarish_type_p (t
);
4163 else if (cxx_dialect
> cxx98
)
4164 /* [class]/10: A POD struct is a class that is both a trivial class and a
4165 standard-layout class, and has no non-static data members of type
4166 non-POD struct, non-POD union (or array of such types).
4168 We don't need to check individual members because if a member is
4169 non-std-layout or non-trivial, the class will be too. */
4170 return (std_layout_type_p (t
) && trivial_type_p (t
));
4172 /* The C++98 definition of POD is different. */
4173 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4176 /* Returns true iff T is POD for the purpose of layout, as defined in the
4180 layout_pod_type_p (const_tree t
)
4182 t
= strip_array_types (CONST_CAST_TREE (t
));
4184 if (CLASS_TYPE_P (t
))
4185 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4187 return scalarish_type_p (t
);
4190 /* Returns true iff T is a standard-layout type, as defined in
4194 std_layout_type_p (const_tree t
)
4196 t
= strip_array_types (CONST_CAST_TREE (t
));
4198 if (CLASS_TYPE_P (t
))
4199 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4201 return scalarish_type_p (t
);
4204 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4206 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4207 as defined in [meta.unary.prop]. */
4210 type_has_unique_obj_representations (const_tree t
)
4214 t
= strip_array_types (CONST_CAST_TREE (t
));
4216 if (!trivially_copyable_p (t
))
4219 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4220 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4222 switch (TREE_CODE (t
))
4226 case REFERENCE_TYPE
:
4227 /* If some backend has any paddings in these types, we should add
4228 a target hook for this and handle it there. */
4232 /* For bool values other than 0 and 1 should only appear with
4233 undefined behavior. */
4237 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4240 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4241 when storing long double values, so for that we have to return false.
4242 Other kinds of floating point values are questionable due to +.0/-.0
4243 and NaNs, let's play safe for now. */
4246 case FIXED_POINT_TYPE
:
4254 return type_has_unique_obj_representations (TREE_TYPE (t
));
4257 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4258 if (CLASS_TYPE_P (t
))
4260 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4261 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4269 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4270 if (TREE_CODE (field
) == FIELD_DECL
)
4273 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4274 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4280 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4282 if (CLASS_TYPE_P (t
))
4284 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4285 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4300 /* Helper function for type_has_unique_obj_representations. */
4303 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4305 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4306 if (TREE_CODE (field
) != FIELD_DECL
)
4308 /* For bases, can't use type_has_unique_obj_representations here, as in
4309 struct S { int i : 24; S (); };
4310 struct T : public S { int j : 8; T (); };
4311 S doesn't have unique obj representations, but T does. */
4312 else if (DECL_FIELD_IS_BASE (field
))
4314 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4318 else if (DECL_C_BIT_FIELD (field
))
4320 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4321 if (!type_has_unique_obj_representations (btype
))
4324 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4328 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4329 if (TREE_CODE (field
) == FIELD_DECL
)
4331 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4332 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4333 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4336 if (DECL_SIZE (field
))
4338 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4342 if (cur
!= wi::to_offset (sz
))
4348 /* Nonzero iff type T is a class template implicit specialization. */
4351 class_tmpl_impl_spec_p (const_tree t
)
4353 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4356 /* Returns 1 iff zero initialization of type T means actually storing
4360 zero_init_p (const_tree t
)
4362 /* This CONST_CAST is okay because strip_array_types returns its
4363 argument unmodified and we assign it to a const_tree. */
4364 t
= strip_array_types (CONST_CAST_TREE(t
));
4366 if (t
== error_mark_node
)
4369 /* NULL pointers to data members are initialized with -1. */
4370 if (TYPE_PTRDATAMEM_P (t
))
4373 /* Classes that contain types that can't be zero-initialized, cannot
4374 be zero-initialized themselves. */
4375 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4381 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4382 warn_unused_result attribute. */
4385 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4386 int /*flags*/, bool *no_add_attrs
)
4388 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4390 error ("%qE attribute argument must be a string constant", name
);
4391 *no_add_attrs
= true;
4393 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4395 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4396 && !DECL_CONSTRUCTOR_P (*node
))
4397 warning_at (DECL_SOURCE_LOCATION (*node
),
4398 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4399 "return type", name
, *node
);
4401 else if (OVERLOAD_TYPE_P (*node
))
4405 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4406 "functions or to class or enumeration types", name
);
4407 *no_add_attrs
= true;
4412 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4413 struct attribute_spec.handler. */
4415 handle_no_unique_addr_attribute (tree
* node
,
4421 if (TREE_CODE (*node
) != FIELD_DECL
)
4423 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4424 "non-static data members", name
);
4425 *no_add_attrs
= true;
4427 else if (DECL_C_BIT_FIELD (*node
))
4429 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4430 "a bit-field", name
);
4431 *no_add_attrs
= true;
4437 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4438 hot/cold attributes. */
4441 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4442 int flags
, bool *no_add_attrs
)
4444 *no_add_attrs
= true;
4445 if (TREE_CODE (*node
) == LABEL_DECL
4446 || TREE_CODE (*node
) == FUNCTION_DECL
)
4449 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4450 tree bname
= (is_attribute_p ("likely", name
)
4451 ? get_identifier ("hot") : get_identifier ("cold"));
4452 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4453 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4454 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4455 tree battr
= build_tree_list (bname
, NULL_TREE
);
4456 decl_attributes (node
, battr
, flags
);
4460 return error_mark_node
;
4463 /* Table of valid C++ attributes. */
4464 const struct attribute_spec cxx_attribute_table
[] =
4466 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4467 affects_type_identity, handler, exclude } */
4468 { "init_priority", 1, 1, true, false, false, false,
4469 handle_init_priority_attribute
, NULL
},
4470 { "abi_tag", 1, -1, false, false, false, true,
4471 handle_abi_tag_attribute
, NULL
},
4472 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4475 /* Table of C++ standard attributes. */
4476 const struct attribute_spec std_attribute_table
[] =
4478 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4479 affects_type_identity, handler, exclude } */
4480 { "maybe_unused", 0, 0, false, false, false, false,
4481 handle_unused_attribute
, NULL
},
4482 { "nodiscard", 0, 1, false, false, false, false,
4483 handle_nodiscard_attribute
, NULL
},
4484 { "no_unique_address", 0, 0, true, false, false, false,
4485 handle_no_unique_addr_attribute
, NULL
},
4486 { "likely", 0, 0, false, false, false, false,
4487 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4488 { "unlikely", 0, 0, false, false, false, false,
4489 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4490 { "noreturn", 0, 0, true, false, false, false,
4491 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4492 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4495 /* Handle an "init_priority" attribute; arguments as in
4496 struct attribute_spec.handler. */
4498 handle_init_priority_attribute (tree
* node
,
4504 tree initp_expr
= TREE_VALUE (args
);
4506 tree type
= TREE_TYPE (decl
);
4509 STRIP_NOPS (initp_expr
);
4510 initp_expr
= default_conversion (initp_expr
);
4512 initp_expr
= maybe_constant_value (initp_expr
);
4514 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4516 error ("requested %<init_priority%> is not an integer constant");
4517 cxx_constant_value (initp_expr
);
4518 *no_add_attrs
= true;
4522 pri
= TREE_INT_CST_LOW (initp_expr
);
4524 type
= strip_array_types (type
);
4526 if (decl
== NULL_TREE
4528 || !TREE_STATIC (decl
)
4529 || DECL_EXTERNAL (decl
)
4530 || (TREE_CODE (type
) != RECORD_TYPE
4531 && TREE_CODE (type
) != UNION_TYPE
)
4532 /* Static objects in functions are initialized the
4533 first time control passes through that
4534 function. This is not precise enough to pin down an
4535 init_priority value, so don't allow it. */
4536 || current_function_decl
)
4538 error ("can only use %qE attribute on file-scope definitions "
4539 "of objects of class type", name
);
4540 *no_add_attrs
= true;
4544 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4546 error ("requested %<init_priority%> %i is out of range [0, %i]",
4547 pri
, MAX_INIT_PRIORITY
);
4548 *no_add_attrs
= true;
4552 /* Check for init_priorities that are reserved for
4553 language and runtime support implementations.*/
4554 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4557 (0, "requested %<init_priority%> %i is reserved for internal use",
4561 if (SUPPORTS_INIT_PRIORITY
)
4563 SET_DECL_INIT_PRIORITY (decl
, pri
);
4564 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4569 error ("%qE attribute is not supported on this platform", name
);
4570 *no_add_attrs
= true;
4575 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4576 and the new one has the tags in NEW_. Give an error if there are tags
4577 in NEW_ that weren't in OLD. */
4580 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4582 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4583 old
= TREE_VALUE (old
);
4584 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4585 new_
= TREE_VALUE (new_
);
4587 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4589 tree str
= TREE_VALUE (t
);
4590 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4592 tree ostr
= TREE_VALUE (in
);
4593 if (cp_tree_equal (str
, ostr
))
4596 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4602 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4608 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4609 ill-formed, give an error and return false; otherwise, return true. */
4612 check_abi_tag_args (tree args
, tree name
)
4616 error ("the %qE attribute requires arguments", name
);
4619 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4621 tree elt
= TREE_VALUE (arg
);
4622 if (TREE_CODE (elt
) != STRING_CST
4623 || (!same_type_ignoring_top_level_qualifiers_p
4624 (strip_array_types (TREE_TYPE (elt
)),
4627 error ("arguments to the %qE attribute must be narrow string "
4631 const char *begin
= TREE_STRING_POINTER (elt
);
4632 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4633 for (const char *p
= begin
; p
!= end
; ++p
)
4638 if (!ISALPHA (c
) && c
!= '_')
4640 error ("arguments to the %qE attribute must contain valid "
4641 "identifiers", name
);
4642 inform (input_location
, "%<%c%> is not a valid first "
4643 "character for an identifier", c
);
4647 else if (p
== end
- 1)
4648 gcc_assert (c
== 0);
4651 if (!ISALNUM (c
) && c
!= '_')
4653 error ("arguments to the %qE attribute must contain valid "
4654 "identifiers", name
);
4655 inform (input_location
, "%<%c%> is not a valid character "
4656 "in an identifier", c
);
4665 /* Handle an "abi_tag" attribute; arguments as in
4666 struct attribute_spec.handler. */
4669 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4670 int flags
, bool* no_add_attrs
)
4672 if (!check_abi_tag_args (args
, name
))
4677 if (!OVERLOAD_TYPE_P (*node
))
4679 error ("%qE attribute applied to non-class, non-enum type %qT",
4683 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4685 error ("%qE attribute applied to %qT after its definition",
4689 else if (CLASS_TYPE_P (*node
)
4690 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4692 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4693 "template instantiation %qT", name
, *node
);
4696 else if (CLASS_TYPE_P (*node
)
4697 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4699 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4700 "template specialization %qT", name
, *node
);
4704 tree attributes
= TYPE_ATTRIBUTES (*node
);
4705 tree decl
= TYPE_NAME (*node
);
4707 /* Make sure all declarations have the same abi tags. */
4708 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4710 if (!check_abi_tag_redeclaration (decl
,
4711 lookup_attribute ("abi_tag",
4719 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4721 error ("%qE attribute applied to non-function, non-variable %qD",
4725 else if (DECL_LANGUAGE (*node
) == lang_c
)
4727 error ("%qE attribute applied to extern \"C\" declaration %qD",
4736 *no_add_attrs
= true;
4740 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4741 thing pointed to by the constant. */
4744 make_ptrmem_cst (tree type
, tree member
)
4746 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4747 TREE_TYPE (ptrmem_cst
) = type
;
4748 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4752 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4753 return an existing type if an appropriate type already exists. */
4756 cp_build_type_attribute_variant (tree type
, tree attributes
)
4760 new_type
= build_type_attribute_variant (type
, attributes
);
4761 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4762 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4764 /* Making a new main variant of a class type is broken. */
4765 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4770 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4771 Called only after doing all language independent checks. */
4774 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4776 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4778 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4780 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4782 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4783 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4786 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4787 C++, these are the exception-specifier and ref-qualifier. */
4790 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4792 tree type
= CONST_CAST_TREE (typea
);
4793 if (FUNC_OR_METHOD_TYPE_P (type
))
4794 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4795 TYPE_RAISES_EXCEPTIONS (typeb
),
4796 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4800 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4801 traversal. Called from walk_tree. */
4804 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4805 void *data
, hash_set
<tree
> *pset
)
4807 enum tree_code code
= TREE_CODE (*tp
);
4810 #define WALK_SUBTREE(NODE) \
4813 result = cp_walk_tree (&(NODE), func, data, pset); \
4814 if (result) goto out; \
4818 /* Not one of the easy cases. We must explicitly go through the
4823 case DEFERRED_PARSE
:
4824 case TEMPLATE_TEMPLATE_PARM
:
4825 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4826 case UNBOUND_CLASS_TEMPLATE
:
4827 case TEMPLATE_PARM_INDEX
:
4828 case TEMPLATE_TYPE_PARM
:
4831 case UNDERLYING_TYPE
:
4832 /* None of these have subtrees other than those already walked
4834 *walk_subtrees_p
= 0;
4838 if (BASELINK_QUALIFIED_P (*tp
))
4839 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4840 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4841 *walk_subtrees_p
= 0;
4845 WALK_SUBTREE (TREE_TYPE (*tp
));
4846 *walk_subtrees_p
= 0;
4850 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4854 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4855 WALK_SUBTREE (OVL_CHAIN (*tp
));
4856 *walk_subtrees_p
= 0;
4860 WALK_SUBTREE (DECL_NAME (*tp
));
4861 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4862 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4863 *walk_subtrees_p
= 0;
4867 if (TYPE_PTRMEMFUNC_P (*tp
))
4868 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4871 case TYPE_ARGUMENT_PACK
:
4872 case NONTYPE_ARGUMENT_PACK
:
4874 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4875 int i
, len
= TREE_VEC_LENGTH (args
);
4876 for (i
= 0; i
< len
; i
++)
4877 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4881 case TYPE_PACK_EXPANSION
:
4882 WALK_SUBTREE (TREE_TYPE (*tp
));
4883 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4884 *walk_subtrees_p
= 0;
4887 case EXPR_PACK_EXPANSION
:
4888 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4889 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4890 *walk_subtrees_p
= 0;
4894 case REINTERPRET_CAST_EXPR
:
4895 case STATIC_CAST_EXPR
:
4896 case CONST_CAST_EXPR
:
4897 case DYNAMIC_CAST_EXPR
:
4898 case IMPLICIT_CONV_EXPR
:
4899 if (TREE_TYPE (*tp
))
4900 WALK_SUBTREE (TREE_TYPE (*tp
));
4904 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4905 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4907 *walk_subtrees_p
= 0;
4911 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4912 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4913 *walk_subtrees_p
= 0;
4917 ++cp_unevaluated_operand
;
4918 /* We can't use WALK_SUBTREE here because of the goto. */
4919 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4920 --cp_unevaluated_operand
;
4921 *walk_subtrees_p
= 0;
4927 ++cp_unevaluated_operand
;
4928 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4929 --cp_unevaluated_operand
;
4930 *walk_subtrees_p
= 0;
4934 // Only recurse through the nested expression. Do not
4935 // walk the parameter list. Doing so causes false
4936 // positives in the pack expansion checker since the
4937 // requires parameters are introduced as pack expansions.
4938 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4939 *walk_subtrees_p
= 0;
4943 /* User variables should be mentioned in BIND_EXPR_VARS
4944 and their initializers and sizes walked when walking
4945 the containing BIND_EXPR. Compiler temporaries are
4946 handled here. And also normal variables in templates,
4947 since do_poplevel doesn't build a BIND_EXPR then. */
4948 if (VAR_P (TREE_OPERAND (*tp
, 0))
4949 && (processing_template_decl
4950 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4951 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4953 tree decl
= TREE_OPERAND (*tp
, 0);
4954 WALK_SUBTREE (DECL_INITIAL (decl
));
4955 WALK_SUBTREE (DECL_SIZE (decl
));
4956 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4961 /* Don't walk into the body of the lambda, but the capture initializers
4962 are part of the enclosing context. */
4963 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
4964 cap
= TREE_CHAIN (cap
))
4965 WALK_SUBTREE (TREE_VALUE (cap
));
4972 /* We didn't find what we were looking for. */
4979 /* Like save_expr, but for C++. */
4982 cp_save_expr (tree expr
)
4984 /* There is no reason to create a SAVE_EXPR within a template; if
4985 needed, we can create the SAVE_EXPR when instantiating the
4986 template. Furthermore, the middle-end cannot handle C++-specific
4988 if (processing_template_decl
)
4991 /* TARGET_EXPRs are only expanded once. */
4992 if (TREE_CODE (expr
) == TARGET_EXPR
)
4995 return save_expr (expr
);
4998 /* Initialize tree.c. */
5003 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5004 register_scoped_attributes (std_attribute_table
, NULL
);
5007 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5008 is. Note that sfk_none is zero, so this function can be used as a
5009 predicate to test whether or not DECL is a special function. */
5011 special_function_kind
5012 special_function_p (const_tree decl
)
5014 /* Rather than doing all this stuff with magic names, we should
5015 probably have a field of type `special_function_kind' in
5016 DECL_LANG_SPECIFIC. */
5017 if (DECL_INHERITED_CTOR (decl
))
5018 return sfk_inheriting_constructor
;
5019 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5020 return sfk_copy_constructor
;
5021 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5022 return sfk_move_constructor
;
5023 if (DECL_CONSTRUCTOR_P (decl
))
5024 return sfk_constructor
;
5025 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5026 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5028 if (copy_fn_p (decl
))
5029 return sfk_copy_assignment
;
5030 if (move_fn_p (decl
))
5031 return sfk_move_assignment
;
5033 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5034 return sfk_destructor
;
5035 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5036 return sfk_complete_destructor
;
5037 if (DECL_BASE_DESTRUCTOR_P (decl
))
5038 return sfk_base_destructor
;
5039 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5040 return sfk_deleting_destructor
;
5041 if (DECL_CONV_FN_P (decl
))
5042 return sfk_conversion
;
5043 if (deduction_guide_p (decl
))
5044 return sfk_deduction_guide
;
5045 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5046 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5047 return sfk_comparison
;
5052 /* As above, but only if DECL is a special member function as per 11.3.3
5053 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5055 special_function_kind
5056 special_memfn_p (const_tree decl
)
5058 switch (special_function_kind sfk
= special_function_p (decl
))
5060 case sfk_constructor
:
5061 if (!default_ctor_p (decl
))
5064 case sfk_copy_constructor
:
5065 case sfk_copy_assignment
:
5066 case sfk_move_assignment
:
5067 case sfk_move_constructor
:
5068 case sfk_destructor
:
5077 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5080 char_type_p (tree type
)
5082 return (same_type_p (type
, char_type_node
)
5083 || same_type_p (type
, unsigned_char_type_node
)
5084 || same_type_p (type
, signed_char_type_node
)
5085 || same_type_p (type
, char8_type_node
)
5086 || same_type_p (type
, char16_type_node
)
5087 || same_type_p (type
, char32_type_node
)
5088 || same_type_p (type
, wchar_type_node
));
5091 /* Returns the kind of linkage associated with the indicated DECL. Th
5092 value returned is as specified by the language standard; it is
5093 independent of implementation details regarding template
5094 instantiation, etc. For example, it is possible that a declaration
5095 to which this function assigns external linkage would not show up
5096 as a global symbol when you run `nm' on the resulting object file. */
5099 decl_linkage (tree decl
)
5101 /* This function doesn't attempt to calculate the linkage from first
5102 principles as given in [basic.link]. Instead, it makes use of
5103 the fact that we have already set TREE_PUBLIC appropriately, and
5104 then handles a few special cases. Ideally, we would calculate
5105 linkage first, and then transform that into a concrete
5108 /* Things that don't have names have no linkage. */
5109 if (!DECL_NAME (decl
))
5112 /* Fields have no linkage. */
5113 if (TREE_CODE (decl
) == FIELD_DECL
)
5116 /* Things that are TREE_PUBLIC have external linkage. */
5117 if (TREE_PUBLIC (decl
))
5120 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5121 check one of the "clones" for the real linkage. */
5122 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5123 && DECL_CHAIN (decl
)
5124 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5125 return decl_linkage (DECL_CHAIN (decl
));
5127 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5130 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5132 if (TREE_CODE (decl
) == CONST_DECL
)
5133 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5135 /* Things in local scope do not have linkage, if they don't have
5137 if (decl_function_context (decl
))
5140 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5141 are considered to have external linkage for language purposes, as do
5142 template instantiations on targets without weak symbols. DECLs really
5143 meant to have internal linkage have DECL_THIS_STATIC set. */
5144 if (TREE_CODE (decl
) == TYPE_DECL
)
5146 if (VAR_OR_FUNCTION_DECL_P (decl
))
5148 if (!DECL_THIS_STATIC (decl
))
5151 /* Static data members and static member functions from classes
5152 in anonymous namespace also don't have TREE_PUBLIC set. */
5153 if (DECL_CLASS_CONTEXT (decl
))
5157 /* Everything else has internal linkage. */
5161 /* Returns the storage duration of the object or reference associated with
5162 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5165 decl_storage_duration (tree decl
)
5167 if (TREE_CODE (decl
) == PARM_DECL
)
5169 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5171 gcc_assert (VAR_P (decl
));
5172 if (!TREE_STATIC (decl
)
5173 && !DECL_EXTERNAL (decl
))
5175 if (CP_DECL_THREAD_LOCAL_P (decl
))
5180 /* EXP is an expression that we want to pre-evaluate. Returns (in
5181 *INITP) an expression that will perform the pre-evaluation. The
5182 value returned by this function is a side-effect free expression
5183 equivalent to the pre-evaluated expression. Callers must ensure
5184 that *INITP is evaluated before EXP. */
5187 stabilize_expr (tree exp
, tree
* initp
)
5191 if (!TREE_SIDE_EFFECTS (exp
))
5192 init_expr
= NULL_TREE
;
5193 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5198 /* There are no expressions with REFERENCE_TYPE, but there can be call
5199 arguments with such a type; just treat it as a pointer. */
5200 else if (TYPE_REF_P (TREE_TYPE (exp
))
5201 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5202 || !glvalue_p (exp
))
5204 init_expr
= get_target_expr (exp
);
5205 exp
= TARGET_EXPR_SLOT (init_expr
);
5206 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5213 bool xval
= !lvalue_p (exp
);
5214 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5215 init_expr
= get_target_expr (exp
);
5216 exp
= TARGET_EXPR_SLOT (init_expr
);
5217 exp
= cp_build_fold_indirect_ref (exp
);
5223 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5227 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5228 similar expression ORIG. */
5231 add_stmt_to_compound (tree orig
, tree new_expr
)
5233 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5235 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5237 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5240 /* Like stabilize_expr, but for a call whose arguments we want to
5241 pre-evaluate. CALL is modified in place to use the pre-evaluated
5242 arguments, while, upon return, *INITP contains an expression to
5243 compute the arguments. */
5246 stabilize_call (tree call
, tree
*initp
)
5248 tree inits
= NULL_TREE
;
5250 int nargs
= call_expr_nargs (call
);
5252 if (call
== error_mark_node
|| processing_template_decl
)
5258 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5260 for (i
= 0; i
< nargs
; i
++)
5263 CALL_EXPR_ARG (call
, i
) =
5264 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5265 inits
= add_stmt_to_compound (inits
, init
);
5271 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5272 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5273 arguments, while, upon return, *INITP contains an expression to
5274 compute the arguments. */
5277 stabilize_aggr_init (tree call
, tree
*initp
)
5279 tree inits
= NULL_TREE
;
5281 int nargs
= aggr_init_expr_nargs (call
);
5283 if (call
== error_mark_node
)
5286 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5288 for (i
= 0; i
< nargs
; i
++)
5291 AGGR_INIT_EXPR_ARG (call
, i
) =
5292 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5293 inits
= add_stmt_to_compound (inits
, init
);
5299 /* Like stabilize_expr, but for an initialization.
5301 If the initialization is for an object of class type, this function
5302 takes care not to introduce additional temporaries.
5304 Returns TRUE iff the expression was successfully pre-evaluated,
5305 i.e., if INIT is now side-effect free, except for, possibly, a
5306 single call to a constructor. */
5309 stabilize_init (tree init
, tree
*initp
)
5315 if (t
== error_mark_node
|| processing_template_decl
)
5318 if (TREE_CODE (t
) == INIT_EXPR
)
5319 t
= TREE_OPERAND (t
, 1);
5320 if (TREE_CODE (t
) == TARGET_EXPR
)
5321 t
= TARGET_EXPR_INITIAL (t
);
5323 /* If the RHS can be stabilized without breaking copy elision, stabilize
5324 it. We specifically don't stabilize class prvalues here because that
5325 would mean an extra copy, but they might be stabilized below. */
5326 if (TREE_CODE (init
) == INIT_EXPR
5327 && TREE_CODE (t
) != CONSTRUCTOR
5328 && TREE_CODE (t
) != AGGR_INIT_EXPR
5329 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5332 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5336 if (TREE_CODE (t
) == COMPOUND_EXPR
5337 && TREE_CODE (init
) == INIT_EXPR
)
5339 tree last
= expr_last (t
);
5340 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5341 if (!TREE_SIDE_EFFECTS (last
))
5344 TREE_OPERAND (init
, 1) = last
;
5349 if (TREE_CODE (t
) == CONSTRUCTOR
)
5351 /* Aggregate initialization: stabilize each of the field
5354 constructor_elt
*ce
;
5356 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5357 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5359 tree type
= TREE_TYPE (ce
->value
);
5361 if (TYPE_REF_P (type
)
5362 || SCALAR_TYPE_P (type
))
5363 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5364 else if (!stabilize_init (ce
->value
, &subinit
))
5366 *initp
= add_stmt_to_compound (*initp
, subinit
);
5371 if (TREE_CODE (t
) == CALL_EXPR
)
5373 stabilize_call (t
, initp
);
5377 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5379 stabilize_aggr_init (t
, initp
);
5383 /* The initialization is being performed via a bitwise copy -- and
5384 the item copied may have side effects. */
5385 return !TREE_SIDE_EFFECTS (init
);
5388 /* Returns true if a cast to TYPE may appear in an integral constant
5392 cast_valid_in_integral_constant_expression_p (tree type
)
5394 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5395 || cxx_dialect
>= cxx11
5396 || dependent_type_p (type
)
5397 || type
== error_mark_node
);
5400 /* Return true if we need to fix linkage information of DECL. */
5403 cp_fix_function_decl_p (tree decl
)
5405 /* Skip if DECL is not externally visible. */
5406 if (!TREE_PUBLIC (decl
))
5409 /* We need to fix DECL if it a appears to be exported but with no
5410 function body. Thunks do not have CFGs and we may need to
5411 handle them specially later. */
5412 if (!gimple_has_body_p (decl
)
5413 && !DECL_THUNK_P (decl
)
5414 && !DECL_EXTERNAL (decl
))
5416 struct cgraph_node
*node
= cgraph_node::get (decl
);
5418 /* Don't fix same_body aliases. Although they don't have their own
5419 CFG, they share it with what they alias to. */
5420 if (!node
|| !node
->alias
5421 || !vec_safe_length (node
->ref_list
.references
))
5428 /* Clean the C++ specific parts of the tree T. */
5431 cp_free_lang_data (tree t
)
5433 if (FUNC_OR_METHOD_TYPE_P (t
))
5435 /* Default args are not interesting anymore. */
5436 tree argtypes
= TYPE_ARG_TYPES (t
);
5439 TREE_PURPOSE (argtypes
) = 0;
5440 argtypes
= TREE_CHAIN (argtypes
);
5443 else if (TREE_CODE (t
) == FUNCTION_DECL
5444 && cp_fix_function_decl_p (t
))
5446 /* If T is used in this translation unit at all, the definition
5447 must exist somewhere else since we have decided to not emit it
5448 in this TU. So make it an external reference. */
5449 DECL_EXTERNAL (t
) = 1;
5450 TREE_STATIC (t
) = 0;
5452 if (TREE_CODE (t
) == FUNCTION_DECL
)
5453 discard_operator_bindings (t
);
5454 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5455 /* We do not need the leftover chaining of namespaces from the
5457 DECL_CHAIN (t
) = NULL_TREE
;
5460 /* Stub for c-common. Please keep in sync with c-decl.c.
5461 FIXME: If address space support is target specific, then this
5462 should be a C target hook. But currently this is not possible,
5463 because this function is called via REGISTER_TARGET_PRAGMAS. */
5465 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5469 /* Return the number of operands in T that we care about for things like
5473 cp_tree_operand_length (const_tree t
)
5475 enum tree_code code
= TREE_CODE (t
);
5477 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5478 return VL_EXP_OPERAND_LENGTH (t
);
5480 return cp_tree_code_length (code
);
5483 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5486 cp_tree_code_length (enum tree_code code
)
5488 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5492 case PREINCREMENT_EXPR
:
5493 case PREDECREMENT_EXPR
:
5494 case POSTINCREMENT_EXPR
:
5495 case POSTDECREMENT_EXPR
:
5501 case EXPR_PACK_EXPANSION
:
5505 return TREE_CODE_LENGTH (code
);
5509 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5513 cp_expr_location (const_tree t_
)
5515 tree t
= CONST_CAST_TREE (t_
);
5517 return UNKNOWN_LOCATION
;
5518 switch (TREE_CODE (t
))
5521 return LAMBDA_EXPR_LOCATION (t
);
5523 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5525 return TRAIT_EXPR_LOCATION (t
);
5527 return EXPR_LOCATION (t
);
5531 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5532 conditions for the warning hold, false otherwise. */
5534 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5536 if (c_inhibit_evaluation_warnings
== 0
5537 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5539 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5540 "zero as null pointer constant");
5546 /* Given an initializer INIT for a TYPE, return true if INIT is zero
5547 so that it can be replaced by value initialization. This function
5548 distinguishes betwen empty strings as initializers for arrays and
5549 for pointers (which make it return false). */
5552 type_initializer_zero_p (tree type
, tree init
)
5554 if (type
== error_mark_node
|| init
== error_mark_node
)
5559 if (POINTER_TYPE_P (type
))
5560 return TREE_CODE (init
) != STRING_CST
&& initializer_zerop (init
);
5562 if (TREE_CODE (init
) != CONSTRUCTOR
)
5563 return initializer_zerop (init
);
5565 if (TREE_CODE (type
) == ARRAY_TYPE
)
5567 tree elt_type
= TREE_TYPE (type
);
5568 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
5569 if (elt_type
== char_type_node
)
5570 return initializer_zerop (init
);
5573 unsigned HOST_WIDE_INT i
;
5574 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, elt_init
)
5575 if (!type_initializer_zero_p (elt_type
, elt_init
))
5580 if (TREE_CODE (type
) != RECORD_TYPE
)
5581 return initializer_zerop (init
);
5583 if (TYPE_NON_AGGREGATE_CLASS (type
))
5586 tree fld
= TYPE_FIELDS (type
);
5589 unsigned HOST_WIDE_INT i
;
5590 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, fld_init
)
5592 fld
= next_initializable_field (fld
);
5596 tree fldtype
= TREE_TYPE (fld
);
5597 if (!type_initializer_zero_p (fldtype
, fld_init
))
5600 fld
= DECL_CHAIN (fld
);
5608 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5609 /* Complain that some language-specific thing hanging off a tree
5610 node has been accessed improperly. */
5613 lang_check_failed (const char* file
, int line
, const char* function
)
5615 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5616 function
, trim_filename (file
), line
);
5618 #endif /* ENABLE_TREE_CHECKING */
5622 namespace selftest
{
5624 /* Verify that lvalue_kind () works, for various expressions,
5625 and that location wrappers don't affect the results. */
5630 location_t loc
= BUILTINS_LOCATION
;
5632 /* Verify constants and parameters, without and with
5633 location wrappers. */
5634 tree int_cst
= build_int_cst (integer_type_node
, 42);
5635 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5637 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5638 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5639 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5641 tree string_lit
= build_string (4, "foo");
5642 TREE_TYPE (string_lit
) = char_array_type_node
;
5643 string_lit
= fix_string_type (string_lit
);
5644 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5646 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5647 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5648 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5650 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5651 get_identifier ("some_parm"),
5653 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5655 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5656 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5657 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5659 /* Verify that lvalue_kind of std::move on a parm isn't
5660 affected by location wrappers. */
5661 tree rvalue_ref_of_parm
= move (parm
);
5662 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5663 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5664 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5666 /* Verify lvalue_p. */
5667 ASSERT_FALSE (lvalue_p (int_cst
));
5668 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5669 ASSERT_TRUE (lvalue_p (parm
));
5670 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5671 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5672 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5675 /* Run all of the selftests within this file. */
5680 test_lvalue_kind ();
5683 } // namespace selftest
5685 #endif /* #if CHECKING_P */
5688 #include "gt-cp-tree.h"