1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 /* Expressions with cv void type are prvalues. */
86 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
89 switch (TREE_CODE (ref
))
94 /* preincrements and predecrements are valid lvals, provided
95 what they refer to are valid lvals. */
96 case PREINCREMENT_EXPR
:
97 case PREDECREMENT_EXPR
:
101 case VIEW_CONVERT_EXPR
:
102 return lvalue_kind (TREE_OPERAND (ref
, 0));
106 tree op1
= TREE_OPERAND (ref
, 0);
107 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
109 op1_lvalue_kind
= lvalue_kind (op1
);
110 if (op1_lvalue_kind
== clk_class
)
111 /* in the case of an array operand, the result is an lvalue if
112 that operand is an lvalue and an xvalue otherwise */
113 op1_lvalue_kind
= clk_rvalueref
;
114 return op1_lvalue_kind
;
122 if (TREE_CODE (ref
) == MEMBER_REF
)
123 op1_lvalue_kind
= clk_ordinary
;
125 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
126 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
127 op1_lvalue_kind
= clk_none
;
128 else if (op1_lvalue_kind
== clk_class
)
129 /* The result of a .* expression whose second operand is a pointer to a
130 data member is an lvalue if the first operand is an lvalue and an
132 op1_lvalue_kind
= clk_rvalueref
;
133 return op1_lvalue_kind
;
136 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
138 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
140 /* For static member function recurse on the BASELINK, we can get
141 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
142 OVERLOAD, the overload is resolved first if possible through
143 resolve_address_of_overloaded_function. */
144 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
145 return lvalue_kind (TREE_OPERAND (ref
, 1));
147 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
148 if (op1_lvalue_kind
== clk_class
)
149 /* If E1 is an lvalue, then E1.E2 is an lvalue;
150 otherwise E1.E2 is an xvalue. */
151 op1_lvalue_kind
= clk_rvalueref
;
153 /* Look at the member designator. */
154 if (!op1_lvalue_kind
)
156 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
157 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
158 situations. If we're seeing a COMPONENT_REF, it's a non-static
159 member, so it isn't an lvalue. */
160 op1_lvalue_kind
= clk_none
;
161 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
162 /* This can be IDENTIFIER_NODE in a template. */;
163 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
165 /* Clear the ordinary bit. If this object was a class
166 rvalue we want to preserve that information. */
167 op1_lvalue_kind
&= ~clk_ordinary
;
168 /* The lvalue is for a bitfield. */
169 op1_lvalue_kind
|= clk_bitfield
;
171 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
172 op1_lvalue_kind
|= clk_packed
;
174 return op1_lvalue_kind
;
177 case COMPOUND_LITERAL_EXPR
:
181 /* CONST_DECL without TREE_STATIC are enumeration values and
182 thus not lvalues. With TREE_STATIC they are used by ObjC++
183 in objc_build_string_object and need to be considered as
185 if (! TREE_STATIC (ref
))
189 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
190 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
192 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
193 && DECL_LANG_SPECIFIC (ref
)
194 && DECL_IN_AGGR_P (ref
))
201 case PLACEHOLDER_EXPR
:
204 /* A scope ref in a template, left as SCOPE_REF to support later
207 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
209 tree op
= TREE_OPERAND (ref
, 1);
210 if (TREE_CODE (op
) == FIELD_DECL
)
211 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
213 return lvalue_kind (op
);
218 /* Disallow <? and >? as lvalues if either argument side-effects. */
219 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
220 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
222 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
223 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
227 if (processing_template_decl
)
229 /* Within templates, a REFERENCE_TYPE will indicate whether
230 the COND_EXPR result is an ordinary lvalue or rvalueref.
231 Since REFERENCE_TYPEs are handled above, if we reach this
232 point, we know we got a plain rvalue. Unless we have a
233 type-dependent expr, that is, but we shouldn't be testing
234 lvalueness if we can't even tell the types yet! */
235 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
239 tree op1
= TREE_OPERAND (ref
, 1);
240 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
241 tree op2
= TREE_OPERAND (ref
, 2);
242 op1_lvalue_kind
= lvalue_kind (op1
);
243 op2_lvalue_kind
= lvalue_kind (op2
);
244 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
246 /* The second or the third operand (but not both) is a
247 throw-expression; the result is of the type
248 and value category of the other. */
249 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
250 op2_lvalue_kind
= op1_lvalue_kind
;
251 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
252 op1_lvalue_kind
= op2_lvalue_kind
;
258 /* We expect to see unlowered MODOP_EXPRs only during
259 template processing. */
260 gcc_assert (processing_template_decl
);
268 return lvalue_kind (TREE_OPERAND (ref
, 1));
274 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
277 /* We can see calls outside of TARGET_EXPR in templates. */
278 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
283 /* All functions (except non-static-member functions) are
285 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
286 ? clk_none
: clk_ordinary
);
289 /* We now represent a reference to a single static member function
291 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
292 its argument unmodified and we assign it to a const_tree. */
293 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
295 case NON_DEPENDENT_EXPR
:
297 return lvalue_kind (TREE_OPERAND (ref
, 0));
299 case TEMPLATE_PARM_INDEX
:
300 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
301 /* A template parameter object is an lvalue. */
307 if (!TREE_TYPE (ref
))
309 if (CLASS_TYPE_P (TREE_TYPE (ref
))
310 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
315 /* If one operand is not an lvalue at all, then this expression is
317 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
320 /* Otherwise, it's an lvalue, and it has all the odd properties
321 contributed by either operand. */
322 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
323 /* It's not an ordinary lvalue if it involves any other kind. */
324 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
325 op1_lvalue_kind
&= ~clk_ordinary
;
326 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
327 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
328 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
329 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
330 op1_lvalue_kind
= clk_none
;
331 return op1_lvalue_kind
;
334 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
337 real_lvalue_p (const_tree ref
)
339 cp_lvalue_kind kind
= lvalue_kind (ref
);
340 if (kind
& (clk_rvalueref
|clk_class
))
346 /* c-common wants us to return bool. */
349 lvalue_p (const_tree t
)
351 return real_lvalue_p (t
);
354 /* This differs from lvalue_p in that xvalues are included. */
357 glvalue_p (const_tree ref
)
359 cp_lvalue_kind kind
= lvalue_kind (ref
);
360 if (kind
& clk_class
)
363 return (kind
!= clk_none
);
366 /* This differs from glvalue_p in that class prvalues are included. */
369 obvalue_p (const_tree ref
)
371 return (lvalue_kind (ref
) != clk_none
);
374 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
375 reference), false otherwise. */
378 xvalue_p (const_tree ref
)
380 return (lvalue_kind (ref
) == clk_rvalueref
);
383 /* True if REF is a bit-field. */
386 bitfield_p (const_tree ref
)
388 return (lvalue_kind (ref
) & clk_bitfield
);
391 /* C++-specific version of stabilize_reference. */
394 cp_stabilize_reference (tree ref
)
396 STRIP_ANY_LOCATION_WRAPPER (ref
);
397 switch (TREE_CODE (ref
))
399 case NON_DEPENDENT_EXPR
:
400 /* We aren't actually evaluating this. */
403 /* We need to treat specially anything stabilize_reference doesn't
404 handle specifically. */
415 case ARRAY_RANGE_REF
:
419 cp_lvalue_kind kind
= lvalue_kind (ref
);
420 if ((kind
& ~clk_class
) != clk_none
)
422 tree type
= unlowered_expr_type (ref
);
423 bool rval
= !!(kind
& clk_rvalueref
);
424 type
= cp_build_reference_type (type
, rval
);
425 /* This inhibits warnings in, eg, cxx_mark_addressable
427 warning_sentinel
s (extra_warnings
);
428 ref
= build_static_cast (input_location
, type
, ref
,
433 return stabilize_reference (ref
);
436 /* Test whether DECL is a builtin that may appear in a
437 constant-expression. */
440 builtin_valid_in_constant_expr_p (const_tree decl
)
442 STRIP_ANY_LOCATION_WRAPPER (decl
);
443 if (TREE_CODE (decl
) != FUNCTION_DECL
)
444 /* Not a function. */
446 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
448 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
450 || fndecl_built_in_p (decl
, CP_BUILT_IN_SOURCE_LOCATION
,
453 /* Not a built-in. */
456 switch (DECL_FUNCTION_CODE (decl
))
458 /* These always have constant results like the corresponding
461 case BUILT_IN_FUNCTION
:
464 /* The following built-ins are valid in constant expressions
465 when their arguments are. */
466 case BUILT_IN_ADD_OVERFLOW_P
:
467 case BUILT_IN_SUB_OVERFLOW_P
:
468 case BUILT_IN_MUL_OVERFLOW_P
:
470 /* These have constant results even if their operands are
472 case BUILT_IN_CONSTANT_P
:
473 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
480 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
483 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
486 tree type
= TREE_TYPE (decl
);
488 value
= mark_rvalue_use (value
);
490 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
491 || TREE_TYPE (decl
) == TREE_TYPE (value
)
492 /* On ARM ctors return 'this'. */
493 || (TYPE_PTR_P (TREE_TYPE (value
))
494 && TREE_CODE (value
) == CALL_EXPR
)
495 || useless_type_conversion_p (TREE_TYPE (decl
),
498 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
499 moving a constant aggregate into .rodata. */
500 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
501 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
502 && !VOID_TYPE_P (TREE_TYPE (value
))
503 && reduced_constant_expression_p (value
))
504 TREE_READONLY (decl
) = true;
506 if (complain
& tf_no_cleanup
)
507 /* The caller is building a new-expr and does not need a cleanup. */
511 t
= cxx_maybe_build_cleanup (decl
, complain
);
512 if (t
== error_mark_node
)
513 return error_mark_node
;
515 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
516 if (location_t eloc
= cp_expr_location (value
))
517 SET_EXPR_LOCATION (t
, eloc
);
518 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
519 ignore the TARGET_EXPR. If there really turn out to be no
520 side-effects, then the optimizer should be able to get rid of
521 whatever code is generated anyhow. */
522 TREE_SIDE_EFFECTS (t
) = 1;
527 /* Return an undeclared local temporary of type TYPE for use in building a
531 build_local_temp (tree type
)
533 tree slot
= build_decl (input_location
,
534 VAR_DECL
, NULL_TREE
, type
);
535 DECL_ARTIFICIAL (slot
) = 1;
536 DECL_IGNORED_P (slot
) = 1;
537 DECL_CONTEXT (slot
) = current_function_decl
;
538 layout_decl (slot
, 0);
542 /* Return whether DECL is such a local temporary (or one from
543 create_tmp_var_raw). */
546 is_local_temp (tree decl
)
548 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
549 && !TREE_STATIC (decl
)
550 && DECL_FUNCTION_SCOPE_P (decl
));
553 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
556 process_aggr_init_operands (tree t
)
560 side_effects
= TREE_SIDE_EFFECTS (t
);
564 n
= TREE_OPERAND_LENGTH (t
);
565 for (i
= 1; i
< n
; i
++)
567 tree op
= TREE_OPERAND (t
, i
);
568 if (op
&& TREE_SIDE_EFFECTS (op
))
575 TREE_SIDE_EFFECTS (t
) = side_effects
;
578 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
579 FN, and SLOT. NARGS is the number of call arguments which are specified
580 as a tree array ARGS. */
583 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
589 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
590 TREE_TYPE (t
) = return_type
;
591 AGGR_INIT_EXPR_FN (t
) = fn
;
592 AGGR_INIT_EXPR_SLOT (t
) = slot
;
593 for (i
= 0; i
< nargs
; i
++)
594 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
595 process_aggr_init_operands (t
);
599 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
600 target. TYPE is the type to be initialized.
602 Build an AGGR_INIT_EXPR to represent the initialization. This function
603 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
604 to initialize another object, whereas a TARGET_EXPR can either
605 initialize another object or create its own temporary object, and as a
606 result building up a TARGET_EXPR requires that the type's destructor be
610 build_aggr_init_expr (tree type
, tree init
)
617 gcc_assert (!VOID_TYPE_P (type
));
619 /* Don't build AGGR_INIT_EXPR in a template. */
620 if (processing_template_decl
)
623 fn
= cp_get_callee (init
);
625 return convert (type
, init
);
627 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
628 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
629 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
631 /* We split the CALL_EXPR into its function and its arguments here.
632 Then, in expand_expr, we put them back together. The reason for
633 this is that this expression might be a default argument
634 expression. In that case, we need a new temporary every time the
635 expression is used. That's what break_out_target_exprs does; it
636 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
637 temporary slot. Then, expand_expr builds up a call-expression
638 using the new slot. */
640 /* If we don't need to use a constructor to create an object of this
641 type, don't mess with AGGR_INIT_EXPR. */
642 if (is_ctor
|| TREE_ADDRESSABLE (type
))
644 slot
= build_local_temp (type
);
646 if (TREE_CODE (init
) == CALL_EXPR
)
648 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
649 call_expr_nargs (init
),
650 CALL_EXPR_ARGP (init
));
651 AGGR_INIT_FROM_THUNK_P (rval
)
652 = CALL_FROM_THUNK_P (init
);
656 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
657 aggr_init_expr_nargs (init
),
658 AGGR_INIT_EXPR_ARGP (init
));
659 AGGR_INIT_FROM_THUNK_P (rval
)
660 = AGGR_INIT_FROM_THUNK_P (init
);
662 TREE_SIDE_EFFECTS (rval
) = 1;
663 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
664 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
665 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
666 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
667 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
672 if (location_t loc
= EXPR_LOCATION (init
))
673 SET_EXPR_LOCATION (rval
, loc
);
678 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
679 target. TYPE is the type that this initialization should appear to
682 Build an encapsulation of the initialization to perform
683 and return it so that it can be processed by language-independent
684 and language-specific expression expanders. */
687 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
689 /* This function should cope with what build_special_member_call
690 can produce. When performing parenthesized aggregate initialization,
691 it can produce a { }. */
692 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
694 gcc_assert (cxx_dialect
>= cxx2a
);
695 return finish_compound_literal (type
, init
, complain
);
698 tree rval
= build_aggr_init_expr (type
, init
);
701 if (init
== error_mark_node
)
702 return error_mark_node
;
704 if (!complete_type_or_maybe_complain (type
, init
, complain
))
705 return error_mark_node
;
707 /* Make sure that we're not trying to create an instance of an
709 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
710 return error_mark_node
;
712 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
713 slot
= AGGR_INIT_EXPR_SLOT (rval
);
714 else if (TREE_CODE (rval
) == CALL_EXPR
715 || TREE_CODE (rval
) == CONSTRUCTOR
)
716 slot
= build_local_temp (type
);
720 rval
= build_target_expr (slot
, rval
, complain
);
722 if (rval
!= error_mark_node
)
723 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
728 /* Subroutine of build_vec_init_expr: Build up a single element
729 intialization as a proxy for the full array initialization to get things
730 marked as used and any appropriate diagnostics.
732 Since we're deferring building the actual constructor calls until
733 gimplification time, we need to build one now and throw it away so
734 that the relevant constructor gets mark_used before cgraph decides
735 what functions are needed. Here we assume that init is either
736 NULL_TREE, void_type_node (indicating value-initialization), or
737 another array to copy. */
740 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
742 tree inner_type
= strip_array_types (type
);
744 if (integer_zerop (array_type_nelts_total (type
))
745 || !CLASS_TYPE_P (inner_type
))
746 /* No interesting initialization to do. */
747 return integer_zero_node
;
748 else if (init
== void_type_node
)
749 return build_value_init (inner_type
, complain
);
751 gcc_assert (init
== NULL_TREE
752 || (same_type_ignoring_top_level_qualifiers_p
753 (type
, TREE_TYPE (init
))));
755 releasing_vec argvec
;
758 tree init_type
= strip_array_types (TREE_TYPE (init
));
759 tree dummy
= build_dummy_object (init_type
);
760 if (!lvalue_p (init
))
761 dummy
= move (dummy
);
762 argvec
->quick_push (dummy
);
764 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
765 &argvec
, inner_type
, LOOKUP_NORMAL
,
768 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
769 we don't want one here because we aren't creating a temporary. */
770 if (TREE_CODE (init
) == TARGET_EXPR
)
771 init
= TARGET_EXPR_INITIAL (init
);
776 /* Return a TARGET_EXPR which expresses the initialization of an array to
777 be named later, either default-initialization or copy-initialization
778 from another array of the same type. */
781 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
784 bool value_init
= false;
785 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
787 if (init
== void_type_node
)
793 slot
= build_local_temp (type
);
794 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
795 TREE_SIDE_EFFECTS (init
) = true;
796 SET_EXPR_LOCATION (init
, input_location
);
798 if (cxx_dialect
>= cxx11
799 && potential_constant_expression (elt_init
))
800 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
801 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
806 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
807 that requires a constant expression. */
810 diagnose_non_constexpr_vec_init (tree expr
)
812 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
814 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
815 init
= void_type_node
;
817 init
= VEC_INIT_EXPR_INIT (expr
);
819 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
820 require_potential_constant_expression (elt_init
);
824 build_array_copy (tree init
)
826 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
829 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
833 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
835 gcc_assert (!VOID_TYPE_P (type
));
837 if (TREE_CODE (init
) == TARGET_EXPR
838 || init
== error_mark_node
)
840 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
841 && !VOID_TYPE_P (TREE_TYPE (init
))
842 && TREE_CODE (init
) != COND_EXPR
843 && TREE_CODE (init
) != CONSTRUCTOR
844 && TREE_CODE (init
) != VA_ARG_EXPR
)
845 /* We need to build up a copy constructor call. A void initializer
846 means we're being called from bot_manip. COND_EXPR is a special
847 case because we already have copies on the arms and we don't want
848 another one here. A CONSTRUCTOR is aggregate initialization, which
849 is handled separately. A VA_ARG_EXPR is magic creation of an
850 aggregate; there's no additional work to be done. */
851 return force_rvalue (init
, complain
);
853 return force_target_expr (type
, init
, complain
);
856 /* Like the above function, but without the checking. This function should
857 only be used by code which is deliberately trying to subvert the type
858 system, such as call_builtin_trap. Or build_over_call, to avoid
859 infinite recursion. */
862 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
866 gcc_assert (!VOID_TYPE_P (type
));
868 slot
= build_local_temp (type
);
869 return build_target_expr (slot
, init
, complain
);
872 /* Like build_target_expr_with_type, but use the type of INIT. */
875 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
877 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
878 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
879 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
880 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
883 init
= convert_bitfield_to_declared_type (init
);
884 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
889 get_target_expr (tree init
)
891 return get_target_expr_sfinae (init
, tf_warning_or_error
);
894 /* If EXPR is a bitfield reference, convert it to the declared type of
895 the bitfield, and return the resulting expression. Otherwise,
896 return EXPR itself. */
899 convert_bitfield_to_declared_type (tree expr
)
903 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
905 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
910 /* EXPR is being used in an rvalue context. Return a version of EXPR
911 that is marked as an rvalue. */
918 if (error_operand_p (expr
))
921 expr
= mark_rvalue_use (expr
);
925 Non-class rvalues always have cv-unqualified types. */
926 type
= TREE_TYPE (expr
);
927 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
928 type
= cv_unqualified (type
);
930 /* We need to do this for rvalue refs as well to get the right answer
931 from decltype; see c++/36628. */
932 if (!processing_template_decl
&& glvalue_p (expr
))
933 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
934 else if (type
!= TREE_TYPE (expr
))
935 expr
= build_nop (type
, expr
);
941 struct cplus_array_info
947 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
949 typedef cplus_array_info
*compare_type
;
951 static hashval_t
hash (tree t
);
952 static bool equal (tree
, cplus_array_info
*);
955 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
958 cplus_array_hasher::hash (tree t
)
962 hash
= TYPE_UID (TREE_TYPE (t
));
964 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
968 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
969 of type `cplus_array_info*'. */
972 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
974 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
977 /* Hash table containing dependent array types, which are unsuitable for
978 the language-independent type hash table. */
979 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
981 /* Build an ARRAY_TYPE without laying it out. */
984 build_min_array_type (tree elt_type
, tree index_type
)
986 tree t
= cxx_make_type (ARRAY_TYPE
);
987 TREE_TYPE (t
) = elt_type
;
988 TYPE_DOMAIN (t
) = index_type
;
992 /* Set TYPE_CANONICAL like build_array_type_1, but using
993 build_cplus_array_type. */
996 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
998 /* Set the canonical type for this new node. */
999 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1000 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1001 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1002 else if (TYPE_CANONICAL (elt_type
) != elt_type
1003 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1005 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1007 ? TYPE_CANONICAL (index_type
) : index_type
);
1009 TYPE_CANONICAL (t
) = t
;
1012 /* Like build_array_type, but handle special C++ semantics: an array of a
1013 variant element type is a variant of the array of the main variant of
1014 the element type. */
1017 build_cplus_array_type (tree elt_type
, tree index_type
)
1021 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1022 return error_mark_node
;
1024 bool dependent
= (uses_template_parms (elt_type
)
1025 || (index_type
&& uses_template_parms (index_type
)));
1027 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1028 /* Start with an array of the TYPE_MAIN_VARIANT. */
1029 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1033 /* Since type_hash_canon calls layout_type, we need to use our own
1035 cplus_array_info cai
;
1038 if (cplus_array_htab
== NULL
)
1039 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1041 hash
= TYPE_UID (elt_type
);
1043 hash
^= TYPE_UID (index_type
);
1044 cai
.type
= elt_type
;
1045 cai
.domain
= index_type
;
1047 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1049 /* We have found the type: we're done. */
1053 /* Build a new array type. */
1054 t
= build_min_array_type (elt_type
, index_type
);
1056 /* Store it in the hash table. */
1059 /* Set the canonical type for this new node. */
1060 set_array_type_canon (t
, elt_type
, index_type
);
1065 bool typeless_storage
1066 = (elt_type
== unsigned_char_type_node
1067 || elt_type
== signed_char_type_node
1068 || elt_type
== char_type_node
1069 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1070 && TYPE_CONTEXT (elt_type
) == std_node
1071 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1072 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1075 /* Now check whether we already have this array variant. */
1076 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1079 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1080 if (TREE_TYPE (t
) == elt_type
1081 && TYPE_NAME (t
) == NULL_TREE
1082 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1086 t
= build_min_array_type (elt_type
, index_type
);
1087 set_array_type_canon (t
, elt_type
, index_type
);
1091 /* Make sure sizes are shared with the main variant.
1092 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1093 as it will overwrite alignment etc. of all variants. */
1094 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1095 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1096 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1099 TYPE_MAIN_VARIANT (t
) = m
;
1100 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1101 TYPE_NEXT_VARIANT (m
) = t
;
1105 /* Avoid spurious warnings with VLAs (c++/54583). */
1106 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1107 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1109 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1110 place more easily. */
1111 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1112 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1113 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1114 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1116 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1117 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1119 /* The element type has been completed since the last time we saw
1120 this array type; update the layout and 'tor flags for any variants
1123 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1125 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1126 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1133 /* Return an ARRAY_TYPE with element type ELT and length N. */
1136 build_array_of_n_type (tree elt
, int n
)
1138 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1141 /* True iff T is an array of unknown bound. */
1144 array_of_unknown_bound_p (const_tree t
)
1146 return (TREE_CODE (t
) == ARRAY_TYPE
1147 && !TYPE_DOMAIN (t
));
1150 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1151 for C++14 but then removed. This should only be used for N3639
1152 specifically; code wondering more generally if something is a VLA should use
1156 array_of_runtime_bound_p (tree t
)
1158 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1160 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1162 tree dom
= TYPE_DOMAIN (t
);
1165 tree max
= TYPE_MAX_VALUE (dom
);
1166 return (!potential_rvalue_constant_expression (max
)
1167 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1170 /* True iff T is a variable length array. */
1175 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1177 if (tree dom
= TYPE_DOMAIN (t
))
1179 tree max
= TYPE_MAX_VALUE (dom
);
1180 if (!potential_rvalue_constant_expression (max
)
1181 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1187 /* Return a reference type node referring to TO_TYPE. If RVAL is
1188 true, return an rvalue reference type, otherwise return an lvalue
1189 reference type. If a type node exists, reuse it, otherwise create
1192 cp_build_reference_type (tree to_type
, bool rval
)
1196 if (to_type
== error_mark_node
)
1197 return error_mark_node
;
1199 if (TYPE_REF_P (to_type
))
1201 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1202 to_type
= TREE_TYPE (to_type
);
1205 lvalue_ref
= build_reference_type (to_type
);
1209 /* This code to create rvalue reference types is based on and tied
1210 to the code creating lvalue reference types in the middle-end
1211 functions build_reference_type_for_mode and build_reference_type.
1213 It works by putting the rvalue reference type nodes after the
1214 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1215 they will effectively be ignored by the middle end. */
1217 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1218 if (TYPE_REF_IS_RVALUE (t
))
1221 t
= build_distinct_type_copy (lvalue_ref
);
1223 TYPE_REF_IS_RVALUE (t
) = true;
1224 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1225 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1227 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1228 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1229 else if (TYPE_CANONICAL (to_type
) != to_type
)
1231 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1233 TYPE_CANONICAL (t
) = t
;
1241 /* Returns EXPR cast to rvalue reference type, like std::move. */
1246 tree type
= TREE_TYPE (expr
);
1247 gcc_assert (!TYPE_REF_P (type
));
1248 type
= cp_build_reference_type (type
, /*rval*/true);
1249 return build_static_cast (input_location
, type
, expr
,
1250 tf_warning_or_error
);
1253 /* Used by the C++ front end to build qualified array types. However,
1254 the C version of this function does not properly maintain canonical
1255 types (which are not used in C). */
1257 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1258 size_t /* orig_qual_indirect */)
1260 return cp_build_qualified_type (type
, type_quals
);
1264 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1265 arrays correctly. In particular, if TYPE is an array of T's, and
1266 TYPE_QUALS is non-empty, returns an array of qualified T's.
1268 FLAGS determines how to deal with ill-formed qualifications. If
1269 tf_ignore_bad_quals is set, then bad qualifications are dropped
1270 (this is permitted if TYPE was introduced via a typedef or template
1271 type parameter). If bad qualifications are dropped and tf_warning
1272 is set, then a warning is issued for non-const qualifications. If
1273 tf_ignore_bad_quals is not set and tf_error is not set, we
1274 return error_mark_node. Otherwise, we issue an error, and ignore
1277 Qualification of a reference type is valid when the reference came
1278 via a typedef or template type argument. [dcl.ref] No such
1279 dispensation is provided for qualifying a function type. [dcl.fct]
1280 DR 295 queries this and the proposed resolution brings it into line
1281 with qualifying a reference. We implement the DR. We also behave
1282 in a similar manner for restricting non-pointer types. */
1285 cp_build_qualified_type_real (tree type
,
1287 tsubst_flags_t complain
)
1290 int bad_quals
= TYPE_UNQUALIFIED
;
1292 if (type
== error_mark_node
)
1295 if (type_quals
== cp_type_quals (type
))
1298 if (TREE_CODE (type
) == ARRAY_TYPE
)
1300 /* In C++, the qualification really applies to the array element
1301 type. Obtain the appropriately qualified element type. */
1304 = cp_build_qualified_type_real (TREE_TYPE (type
),
1308 if (element_type
== error_mark_node
)
1309 return error_mark_node
;
1311 /* See if we already have an identically qualified type. Tests
1312 should be equivalent to those in check_qualified_type. */
1313 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1314 if (TREE_TYPE (t
) == element_type
1315 && TYPE_NAME (t
) == TYPE_NAME (type
)
1316 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1317 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1318 TYPE_ATTRIBUTES (type
)))
1323 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1325 /* Keep the typedef name. */
1326 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1328 t
= build_variant_type_copy (t
);
1329 TYPE_NAME (t
) = TYPE_NAME (type
);
1330 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1331 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1335 /* Even if we already had this variant, we update
1336 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1337 they changed since the variant was originally created.
1339 This seems hokey; if there is some way to use a previous
1340 variant *without* coming through here,
1341 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1342 TYPE_NEEDS_CONSTRUCTING (t
)
1343 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1344 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1345 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1348 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1350 tree t
= PACK_EXPANSION_PATTERN (type
);
1352 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1353 return make_pack_expansion (t
, complain
);
1356 /* A reference or method type shall not be cv-qualified.
1357 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1358 (in CD1) we always ignore extra cv-quals on functions. */
1359 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1360 && (TYPE_REF_P (type
)
1361 || FUNC_OR_METHOD_TYPE_P (type
)))
1363 if (TYPE_REF_P (type
))
1364 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1365 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1368 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1369 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1370 type_quals
|= type_memfn_quals (type
);
1372 /* A restrict-qualified type must be a pointer (or reference)
1373 to object or incomplete type. */
1374 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1375 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1376 && TREE_CODE (type
) != TYPENAME_TYPE
1377 && !INDIRECT_TYPE_P (type
))
1379 bad_quals
|= TYPE_QUAL_RESTRICT
;
1380 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1383 if (bad_quals
== TYPE_UNQUALIFIED
1384 || (complain
& tf_ignore_bad_quals
))
1386 else if (!(complain
& tf_error
))
1387 return error_mark_node
;
1390 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1391 error ("%qV qualifiers cannot be applied to %qT",
1395 /* Retrieve (or create) the appropriately qualified variant. */
1396 result
= build_qualified_type (type
, type_quals
);
1401 /* Return TYPE with const and volatile removed. */
1404 cv_unqualified (tree type
)
1408 if (type
== error_mark_node
)
1411 quals
= cp_type_quals (type
);
1412 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1413 return cp_build_qualified_type (type
, quals
);
1416 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1417 from ATTRIBS that affect type identity, and no others. If any are not
1418 applied, set *remove_attributes to true. */
1421 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1423 tree first_ident
= NULL_TREE
;
1424 tree new_attribs
= NULL_TREE
;
1425 tree
*p
= &new_attribs
;
1427 if (OVERLOAD_TYPE_P (result
))
1429 /* On classes and enums all attributes are ingrained. */
1430 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1434 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1436 const attribute_spec
*as
1437 = lookup_attribute_spec (get_attribute_name (a
));
1438 if (as
&& as
->affects_type_identity
)
1442 else if (first_ident
== error_mark_node
)
1444 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1445 p
= &TREE_CHAIN (*p
);
1448 else if (first_ident
)
1450 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1452 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1453 p
= &TREE_CHAIN (*p
);
1455 first_ident
= error_mark_node
;
1458 if (first_ident
!= error_mark_node
)
1459 new_attribs
= first_ident
;
1461 if (first_ident
== attribs
)
1462 /* All attributes affected type identity. */;
1464 *remove_attributes
= true;
1466 return cp_build_type_attribute_variant (result
, new_attribs
);
1469 /* Builds a qualified variant of T that is either not a typedef variant
1470 (the default behavior) or not a typedef variant of a user-facing type
1471 (if FLAGS contains STF_USER_FACING).
1473 E.g. consider the following declarations:
1474 typedef const int ConstInt;
1475 typedef ConstInt* PtrConstInt;
1476 If T is PtrConstInt, this function returns a type representing
1478 In other words, if T is a typedef, the function returns the underlying type.
1479 The cv-qualification and attributes of the type returned match the
1481 They will always be compatible types.
1482 The returned type is built so that all of its subtypes
1483 recursively have their typedefs stripped as well.
1485 This is different from just returning TYPE_CANONICAL (T)
1486 Because of several reasons:
1487 * If T is a type that needs structural equality
1488 its TYPE_CANONICAL (T) will be NULL.
1489 * TYPE_CANONICAL (T) desn't carry type attributes
1490 and loses template parameter names.
1492 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1493 affect type identity, and set the referent to true if any were
1497 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1499 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1501 if (!t
|| t
== error_mark_node
)
1504 if (TREE_CODE (t
) == TREE_LIST
)
1506 bool changed
= false;
1509 for (; t
; t
= TREE_CHAIN (t
))
1511 gcc_assert (!TREE_PURPOSE (t
));
1512 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1513 if (elt
!= TREE_VALUE (t
))
1515 vec_safe_push (vec
, elt
);
1518 r
= build_tree_list_vec (vec
);
1522 gcc_assert (TYPE_P (t
));
1524 if (t
== TYPE_CANONICAL (t
))
1527 if (!(flags
& STF_STRIP_DEPENDENT
)
1528 && dependent_alias_template_spec_p (t
, nt_opaque
))
1529 /* DR 1558: However, if the template-id is dependent, subsequent
1530 template argument substitution still applies to the template-id. */
1533 switch (TREE_CODE (t
))
1536 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1537 result
= build_pointer_type (type
);
1539 case REFERENCE_TYPE
:
1540 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1541 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1544 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1545 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1546 result
= build_offset_type (t0
, type
);
1549 if (TYPE_PTRMEMFUNC_P (t
))
1551 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1552 remove_attributes
, flags
);
1553 result
= build_ptrmemfunc_type (t0
);
1557 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1558 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1559 result
= build_cplus_array_type (type
, t0
);
1564 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1567 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1568 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1569 can't expect that re-hashing a function type will find a previous
1570 equivalent type, so try to reuse the input type if nothing has
1571 changed. If the type is itself a variant, that will change. */
1572 bool is_variant
= typedef_variant_p (t
);
1573 if (remove_attributes
1574 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1577 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1578 tree canon_spec
= (flag_noexcept_type
1579 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1581 changed
= (type
!= TREE_TYPE (t
) || is_variant
1582 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1584 for (arg_node
= TYPE_ARG_TYPES (t
);
1586 arg_node
= TREE_CHAIN (arg_node
))
1588 if (arg_node
== void_list_node
)
1590 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1591 remove_attributes
, flags
);
1592 gcc_assert (arg_type
);
1593 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1599 for (arg_node2
= TYPE_ARG_TYPES (t
);
1600 arg_node2
!= arg_node
;
1601 arg_node2
= TREE_CHAIN (arg_node2
))
1603 = tree_cons (TREE_PURPOSE (arg_node2
),
1604 TREE_VALUE (arg_node2
), arg_types
);
1608 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1615 arg_types
= nreverse (arg_types
);
1617 /* A list of parameters not ending with an ellipsis
1618 must end with void_list_node. */
1620 arg_types
= chainon (arg_types
, void_list_node
);
1622 if (TREE_CODE (t
) == METHOD_TYPE
)
1624 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1625 gcc_assert (class_type
);
1627 build_method_type_directly (class_type
, type
,
1628 TREE_CHAIN (arg_types
));
1632 result
= build_function_type (type
, arg_types
);
1633 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1636 result
= build_cp_fntype_variant (result
,
1637 type_memfn_rqual (t
), canon_spec
,
1638 TYPE_HAS_LATE_RETURN_TYPE (t
));
1643 bool changed
= false;
1644 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1645 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1646 && TREE_OPERAND (fullname
, 1))
1648 tree args
= TREE_OPERAND (fullname
, 1);
1649 tree new_args
= copy_node (args
);
1650 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1652 tree arg
= TREE_VEC_ELT (args
, i
);
1655 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1657 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1659 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1660 if (strip_arg
!= arg
)
1665 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1666 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1668 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1672 ggc_free (new_args
);
1674 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1675 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1677 tree name
= fullname
;
1678 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1679 name
= TREE_OPERAND (fullname
, 0);
1680 /* Use build_typename_type rather than make_typename_type because we
1681 don't want to resolve it here, just strip typedefs. */
1682 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1686 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1687 remove_attributes
, flags
);
1688 if (result
== DECLTYPE_TYPE_EXPR (t
))
1691 result
= (finish_decltype_type
1693 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1696 case UNDERLYING_TYPE
:
1697 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1698 remove_attributes
, flags
);
1699 result
= finish_underlying_type (type
);
1707 if (typedef_variant_p (t
))
1709 if ((flags
& STF_USER_VISIBLE
)
1710 && !user_facing_original_type_p (t
))
1712 /* If T is a non-template alias or typedef, we can assume that
1713 instantiating its definition will hit any substitution failure,
1714 so we don't need to retain it here as well. */
1715 if (!alias_template_specialization_p (t
, nt_opaque
))
1716 flags
|= STF_STRIP_DEPENDENT
;
1717 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1718 remove_attributes
, flags
);
1721 result
= TYPE_MAIN_VARIANT (t
);
1723 /*gcc_assert (!typedef_variant_p (result)
1724 || dependent_alias_template_spec_p (result, nt_opaque)
1725 || ((flags & STF_USER_VISIBLE)
1726 && !user_facing_original_type_p (result)));*/
1728 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1729 /* If RESULT is complete and T isn't, it's likely the case that T
1730 is a variant of RESULT which hasn't been updated yet. Skip the
1731 attribute handling. */;
1734 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1735 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1737 gcc_assert (TYPE_USER_ALIGN (t
));
1738 if (remove_attributes
)
1739 *remove_attributes
= true;
1742 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1743 result
= build_variant_type_copy (result
);
1745 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1746 TYPE_USER_ALIGN (result
) = true;
1750 if (TYPE_ATTRIBUTES (t
))
1752 if (remove_attributes
)
1753 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1756 result
= cp_build_type_attribute_variant (result
,
1757 TYPE_ATTRIBUTES (t
));
1761 return cp_build_qualified_type (result
, cp_type_quals (t
));
1764 /* Like strip_typedefs above, but works on expressions, so that in
1766 template<class T> struct A
1772 sizeof(TT) is replaced by sizeof(T). */
1775 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1779 enum tree_code code
;
1781 if (t
== NULL_TREE
|| t
== error_mark_node
)
1784 STRIP_ANY_LOCATION_WRAPPER (t
);
1786 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1789 /* Some expressions have type operands, so let's handle types here rather
1790 than check TYPE_P in multiple places below. */
1792 return strip_typedefs (t
, remove_attributes
, flags
);
1794 code
= TREE_CODE (t
);
1797 case IDENTIFIER_NODE
:
1798 case TEMPLATE_PARM_INDEX
:
1801 case ARGUMENT_PACK_SELECT
:
1806 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1807 remove_attributes
, flags
);
1808 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1809 remove_attributes
, flags
);
1810 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1811 && type2
== TRAIT_EXPR_TYPE2 (t
))
1814 TRAIT_EXPR_TYPE1 (r
) = type1
;
1815 TRAIT_EXPR_TYPE2 (r
) = type2
;
1822 bool changed
= false;
1824 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1826 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1827 remove_attributes
, flags
);
1828 vec_safe_push (vec
, val
);
1829 if (val
!= TREE_VALUE (it
))
1831 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1836 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1837 r
= tree_cons (NULL_TREE
, it
, r
);
1846 bool changed
= false;
1848 n
= TREE_VEC_LENGTH (t
);
1849 vec_safe_reserve (vec
, n
);
1850 for (i
= 0; i
< n
; ++i
)
1852 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1853 remove_attributes
, flags
);
1854 vec
->quick_push (op
);
1855 if (op
!= TREE_VEC_ELT (t
, i
))
1861 for (i
= 0; i
< n
; ++i
)
1862 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1863 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1864 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1873 bool changed
= false;
1874 vec
<constructor_elt
, va_gc
> *vec
1875 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1876 n
= CONSTRUCTOR_NELTS (t
);
1877 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1878 for (i
= 0; i
< n
; ++i
)
1880 constructor_elt
*e
= &(*vec
)[i
];
1881 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1888 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1892 if (!changed
&& type
== TREE_TYPE (t
))
1900 TREE_TYPE (r
) = type
;
1901 CONSTRUCTOR_ELTS (r
) = vec
;
1909 case STATEMENT_LIST
:
1910 error ("statement-expression in a constant expression");
1911 return error_mark_node
;
1917 gcc_assert (EXPR_P (t
));
1919 n
= cp_tree_operand_length (t
);
1920 ops
= XALLOCAVEC (tree
, n
);
1921 type
= TREE_TYPE (t
);
1926 case IMPLICIT_CONV_EXPR
:
1927 case DYNAMIC_CAST_EXPR
:
1928 case STATIC_CAST_EXPR
:
1929 case CONST_CAST_EXPR
:
1930 case REINTERPRET_CAST_EXPR
:
1933 type
= strip_typedefs (type
, remove_attributes
, flags
);
1937 for (i
= 0; i
< n
; ++i
)
1938 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1939 remove_attributes
, flags
);
1943 /* If nothing changed, return t. */
1944 for (i
= 0; i
< n
; ++i
)
1945 if (ops
[i
] != TREE_OPERAND (t
, i
))
1947 if (i
== n
&& type
== TREE_TYPE (t
))
1951 TREE_TYPE (r
) = type
;
1952 for (i
= 0; i
< n
; ++i
)
1953 TREE_OPERAND (r
, i
) = ops
[i
];
1957 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1958 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1959 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1960 VIRT indicates whether TYPE is inherited virtually or not.
1961 IGO_PREV points at the previous binfo of the inheritance graph
1962 order chain. The newly copied binfo's TREE_CHAIN forms this
1965 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1966 correct order. That is in the order the bases themselves should be
1969 The BINFO_INHERITANCE of a virtual base class points to the binfo
1970 of the most derived type. ??? We could probably change this so that
1971 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1972 remove a field. They currently can only differ for primary virtual
1976 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1982 /* See if we've already made this virtual base. */
1983 new_binfo
= binfo_for_vbase (type
, t
);
1988 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1989 BINFO_TYPE (new_binfo
) = type
;
1991 /* Chain it into the inheritance graph. */
1992 TREE_CHAIN (*igo_prev
) = new_binfo
;
1993 *igo_prev
= new_binfo
;
1995 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
2000 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2002 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2003 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2005 /* We do not need to copy the accesses, as they are read only. */
2006 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2008 /* Recursively copy base binfos of BINFO. */
2009 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2011 tree new_base_binfo
;
2012 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2014 BINFO_VIRTUAL_P (base_binfo
));
2016 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2017 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2018 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2022 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2026 /* Push it onto the list after any virtual bases it contains
2027 will have been pushed. */
2028 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2029 BINFO_VIRTUAL_P (new_binfo
) = 1;
2030 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2036 /* Hashing of lists so that we don't make duplicates.
2037 The entry point is `list_hash_canon'. */
2046 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2048 typedef list_proxy
*compare_type
;
2050 static hashval_t
hash (tree
);
2051 static bool equal (tree
, list_proxy
*);
2054 /* Now here is the hash table. When recording a list, it is added
2055 to the slot whose index is the hash code mod the table size.
2056 Note that the hash table is used for several kinds of lists.
2057 While all these live in the same table, they are completely independent,
2058 and the hash code is computed differently for each of these. */
2060 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2062 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2063 for a node we are thinking about adding). */
2066 list_hasher::equal (tree t
, list_proxy
*proxy
)
2068 return (TREE_VALUE (t
) == proxy
->value
2069 && TREE_PURPOSE (t
) == proxy
->purpose
2070 && TREE_CHAIN (t
) == proxy
->chain
);
2073 /* Compute a hash code for a list (chain of TREE_LIST nodes
2074 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2075 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2078 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2080 hashval_t hashcode
= 0;
2083 hashcode
+= TREE_HASH (chain
);
2086 hashcode
+= TREE_HASH (value
);
2090 hashcode
+= TREE_HASH (purpose
);
2096 /* Hash an already existing TREE_LIST. */
2099 list_hasher::hash (tree t
)
2101 return list_hash_pieces (TREE_PURPOSE (t
),
2106 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2107 object for an identical list if one already exists. Otherwise, build a
2108 new one, and record it as the canonical object. */
2111 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2115 struct list_proxy proxy
;
2117 /* Hash the list node. */
2118 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2119 /* Create a proxy for the TREE_LIST we would like to create. We
2120 don't actually create it so as to avoid creating garbage. */
2121 proxy
.purpose
= purpose
;
2122 proxy
.value
= value
;
2123 proxy
.chain
= chain
;
2124 /* See if it is already in the table. */
2125 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2126 /* If not, create a new node. */
2128 *slot
= tree_cons (purpose
, value
, chain
);
2129 return (tree
) *slot
;
2132 /* Constructor for hashed lists. */
2135 hash_tree_chain (tree value
, tree chain
)
2137 return hash_tree_cons (NULL_TREE
, value
, chain
);
2141 debug_binfo (tree elem
)
2146 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2148 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2149 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2150 debug_tree (BINFO_TYPE (elem
));
2151 if (BINFO_VTABLE (elem
))
2152 fprintf (stderr
, "vtable decl \"%s\"\n",
2153 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2155 fprintf (stderr
, "no vtable decl yet\n");
2156 fprintf (stderr
, "virtuals:\n");
2157 virtuals
= BINFO_VIRTUALS (elem
);
2162 tree fndecl
= TREE_VALUE (virtuals
);
2163 fprintf (stderr
, "%s [%ld =? %ld]\n",
2164 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2165 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2167 virtuals
= TREE_CHAIN (virtuals
);
2171 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2172 the type of the result expression, if known, or NULL_TREE if the
2173 resulting expression is type-dependent. If TEMPLATE_P is true,
2174 NAME is known to be a template because the user explicitly used the
2175 "template" keyword after the "::".
2177 All SCOPE_REFs should be built by use of this function. */
2180 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2183 if (type
== error_mark_node
2184 || scope
== error_mark_node
2185 || name
== error_mark_node
)
2186 return error_mark_node
;
2187 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2188 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2189 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2190 PTRMEM_OK_P (t
) = true;
2192 t
= convert_from_reference (t
);
2196 /* Like check_qualified_type, but also check ref-qualifier, exception
2197 specification, and whether the return type was specified after the
2201 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2202 cp_ref_qualifier rqual
, tree raises
, bool late
)
2204 return (TYPE_QUALS (cand
) == type_quals
2205 && check_base_type (cand
, base
)
2206 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2208 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2209 && type_memfn_rqual (cand
) == rqual
);
2212 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2215 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2217 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2218 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2219 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2222 /* Make a raw overload node containing FN. */
2225 ovl_make (tree fn
, tree next
)
2227 tree result
= make_node (OVERLOAD
);
2229 if (TREE_CODE (fn
) == OVERLOAD
)
2230 OVL_NESTED_P (result
) = true;
2232 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2233 ? unknown_type_node
: TREE_TYPE (fn
));
2234 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2235 OVL_DEDUP_P (result
) = true;
2236 OVL_FUNCTION (result
) = fn
;
2237 OVL_CHAIN (result
) = next
;
2241 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2242 true, if FN is via a using declaration. We also pay attention to
2243 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2247 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2249 tree result
= maybe_ovl
;
2250 tree insert_after
= NULL_TREE
;
2253 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2254 && OVL_HIDDEN_P (maybe_ovl
);
2255 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2257 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2258 insert_after
= maybe_ovl
;
2261 bool hidden_p
= DECL_HIDDEN_P (fn
);
2262 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2264 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2266 OVL_HIDDEN_P (maybe_ovl
) = true;
2268 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2275 OVL_CHAIN (insert_after
) = maybe_ovl
;
2276 TREE_TYPE (insert_after
) = unknown_type_node
;
2284 /* Skip any hidden names at the beginning of OVL. */
2287 ovl_skip_hidden (tree ovl
)
2290 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2291 ovl
= OVL_CHAIN (ovl
))
2292 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2294 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2296 /* Any hidden functions should have been wrapped in an
2297 overload, but injected friend classes will not. */
2298 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2305 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2308 ovl_iterator::reveal_node (tree overload
, tree node
)
2310 /* We cannot have returned NODE as part of a lookup overload, so we
2311 don't have to worry about preserving that. */
2313 OVL_HIDDEN_P (node
) = false;
2314 if (tree chain
= OVL_CHAIN (node
))
2315 if (TREE_CODE (chain
) == OVERLOAD
)
2317 if (OVL_HIDDEN_P (chain
))
2319 /* The node needs moving, and the simplest way is to remove it
2321 overload
= remove_node (overload
, node
);
2322 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2324 else if (OVL_DEDUP_P (chain
))
2325 OVL_DEDUP_P (node
) = true;
2330 /* NODE is on the overloads of OVL. Remove it.
2331 The removed node is unaltered and may continue to be iterated
2332 from (i.e. it is safe to remove a node from an overload one is
2333 currently iterating over). */
2336 ovl_iterator::remove_node (tree overload
, tree node
)
2338 tree
*slot
= &overload
;
2339 while (*slot
!= node
)
2342 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2344 slot
= &OVL_CHAIN (probe
);
2347 /* Stitch out NODE. We don't have to worry about now making a
2348 singleton overload (and consequently maybe setting its type),
2349 because all uses of this function will be followed by inserting a
2350 new node that must follow the place we've cut this out from. */
2351 if (TREE_CODE (node
) != OVERLOAD
)
2352 /* Cloned inherited ctors don't mark themselves as via_using. */
2355 *slot
= OVL_CHAIN (node
);
2360 /* Mark or unmark a lookup set. */
2363 lookup_mark (tree ovl
, bool val
)
2365 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2367 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2368 LOOKUP_SEEN_P (*iter
) = val
;
2372 /* Add a set of new FNS into a lookup. */
2375 lookup_add (tree fns
, tree lookup
)
2377 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2378 return error_mark_node
;
2380 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2382 lookup
= ovl_make (fns
, lookup
);
2383 OVL_LOOKUP_P (lookup
) = true;
2391 /* FNS is a new overload set, add them to LOOKUP, if they are not
2392 already present there. */
2395 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2398 for (tree next
, probe
= fns
; probe
; probe
= next
)
2403 if (TREE_CODE (probe
) == OVERLOAD
)
2405 fn
= OVL_FUNCTION (probe
);
2406 next
= OVL_CHAIN (probe
);
2409 if (!LOOKUP_SEEN_P (fn
))
2410 LOOKUP_SEEN_P (fn
) = true;
2413 /* This function was already seen. Insert all the
2414 predecessors onto the lookup. */
2415 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2417 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2418 /* Propagate OVL_USING, but OVL_HIDDEN &
2419 OVL_DEDUP_P don't matter. */
2420 if (OVL_USING_P (fns
))
2421 OVL_USING_P (lookup
) = true;
2424 /* And now skip this function. */
2430 /* We ended in a set of new functions. Add them all in one go. */
2431 lookup
= lookup_add (fns
, lookup
);
2436 /* Returns nonzero if X is an expression for a (possibly overloaded)
2437 function. If "f" is a function or function template, "f", "c->f",
2438 "c.f", "C::f", and "f<int>" will all be considered possibly
2439 overloaded functions. Returns 2 if the function is actually
2440 overloaded, i.e., if it is impossible to know the type of the
2441 function without performing overload resolution. */
2444 is_overloaded_fn (tree x
)
2446 STRIP_ANY_LOCATION_WRAPPER (x
);
2448 /* A baselink is also considered an overloaded function. */
2449 if (TREE_CODE (x
) == OFFSET_REF
2450 || TREE_CODE (x
) == COMPONENT_REF
)
2451 x
= TREE_OPERAND (x
, 1);
2452 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2453 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2454 x
= TREE_OPERAND (x
, 0);
2456 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2457 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2463 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2464 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2468 dependent_name (tree x
)
2470 /* FIXME a dependent name must be unqualified, but this function doesn't
2471 distinguish between qualified and unqualified identifiers. */
2472 if (identifier_p (x
))
2474 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2475 x
= TREE_OPERAND (x
, 0);
2477 return OVL_NAME (x
);
2481 /* Returns true iff X is an expression for an overloaded function
2482 whose type cannot be known without performing overload
2486 really_overloaded_fn (tree x
)
2488 return is_overloaded_fn (x
) == 2;
2491 /* Get the overload set FROM refers to. Returns NULL if it's not an
2495 maybe_get_fns (tree from
)
2497 STRIP_ANY_LOCATION_WRAPPER (from
);
2499 /* A baselink is also considered an overloaded function. */
2500 if (TREE_CODE (from
) == OFFSET_REF
2501 || TREE_CODE (from
) == COMPONENT_REF
)
2502 from
= TREE_OPERAND (from
, 1);
2503 if (BASELINK_P (from
))
2504 from
= BASELINK_FUNCTIONS (from
);
2505 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2506 from
= TREE_OPERAND (from
, 0);
2514 /* FROM refers to an overload set. Return that set (or die). */
2519 tree res
= maybe_get_fns (from
);
2525 /* Return the first function of the overload set FROM refers to. */
2528 get_first_fn (tree from
)
2530 return OVL_FIRST (get_fns (from
));
2533 /* Return the scope where the overloaded functions OVL were found. */
2536 ovl_scope (tree ovl
)
2538 if (TREE_CODE (ovl
) == OFFSET_REF
2539 || TREE_CODE (ovl
) == COMPONENT_REF
)
2540 ovl
= TREE_OPERAND (ovl
, 1);
2541 if (TREE_CODE (ovl
) == BASELINK
)
2542 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2543 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2544 ovl
= TREE_OPERAND (ovl
, 0);
2545 /* Skip using-declarations. */
2546 lkp_iterator
iter (ovl
);
2549 while (iter
.using_p () && ++iter
);
2551 return CP_DECL_CONTEXT (ovl
);
2554 #define PRINT_RING_SIZE 4
2557 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2559 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2560 static char *print_ring
[PRINT_RING_SIZE
];
2561 static bool trans_ring
[PRINT_RING_SIZE
];
2562 static int ring_counter
;
2565 /* Only cache functions. */
2567 || TREE_CODE (decl
) != FUNCTION_DECL
2568 || DECL_LANG_SPECIFIC (decl
) == 0)
2569 return lang_decl_name (decl
, v
, translate
);
2571 /* See if this print name is lying around. */
2572 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2573 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2574 /* yes, so return it. */
2575 return print_ring
[i
];
2577 if (++ring_counter
== PRINT_RING_SIZE
)
2580 if (current_function_decl
!= NULL_TREE
)
2582 /* There may be both translated and untranslated versions of the
2584 for (i
= 0; i
< 2; i
++)
2586 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2588 if (ring_counter
== PRINT_RING_SIZE
)
2591 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2594 free (print_ring
[ring_counter
]);
2596 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2597 uid_ring
[ring_counter
] = DECL_UID (decl
);
2598 trans_ring
[ring_counter
] = translate
;
2599 return print_ring
[ring_counter
];
2603 cxx_printable_name (tree decl
, int v
)
2605 return cxx_printable_name_internal (decl
, v
, false);
2609 cxx_printable_name_translate (tree decl
, int v
)
2611 return cxx_printable_name_internal (decl
, v
, true);
2614 /* Return the canonical version of exception-specification RAISES for a C++17
2615 function type, for use in type comparison and building TYPE_CANONICAL. */
2618 canonical_eh_spec (tree raises
)
2620 if (raises
== NULL_TREE
)
2622 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2623 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2624 || uses_template_parms (raises
)
2625 || uses_template_parms (TREE_PURPOSE (raises
)))
2626 /* Keep a dependent or deferred exception specification. */
2628 else if (nothrow_spec_p (raises
))
2629 /* throw() -> noexcept. */
2630 return noexcept_true_spec
;
2632 /* For C++17 type matching, anything else -> nothing. */
2637 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2638 tree raises
, bool late
)
2640 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2642 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2645 tree v
= TYPE_MAIN_VARIANT (type
);
2646 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2647 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2650 /* Need to build a new variant. */
2651 v
= build_variant_type_copy (type
);
2652 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2653 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2656 case REF_QUAL_RVALUE
:
2657 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2658 FUNCTION_REF_QUALIFIED (v
) = 1;
2660 case REF_QUAL_LVALUE
:
2661 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2662 FUNCTION_REF_QUALIFIED (v
) = 1;
2665 FUNCTION_REF_QUALIFIED (v
) = 0;
2669 /* Canonicalize the exception specification. */
2670 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2672 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2673 /* Propagate structural equality. */
2674 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2675 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2676 /* Build the underlying canonical type, since it is different
2678 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2681 /* T is its own canonical type. */
2682 TYPE_CANONICAL (v
) = v
;
2687 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2688 listed in RAISES. */
2691 build_exception_variant (tree type
, tree raises
)
2693 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2694 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2695 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2698 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2699 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2703 bind_template_template_parm (tree t
, tree newargs
)
2705 tree decl
= TYPE_NAME (t
);
2708 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2709 decl
= build_decl (input_location
,
2710 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2712 /* These nodes have to be created to reflect new TYPE_DECL and template
2714 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2715 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2716 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2717 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2719 TREE_TYPE (decl
) = t2
;
2720 TYPE_NAME (t2
) = decl
;
2721 TYPE_STUB_DECL (t2
) = decl
;
2723 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2728 /* Called from count_trees via walk_tree. */
2731 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2741 /* Debugging function for measuring the rough complexity of a tree
2745 count_trees (tree t
)
2748 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2752 /* Called from verify_stmt_tree via walk_tree. */
2755 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2758 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2759 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2762 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2765 /* If this statement is already present in the hash table, then
2766 there is a circularity in the statement tree. */
2767 gcc_assert (!statements
->find (t
));
2769 slot
= statements
->find_slot (t
, INSERT
);
2775 /* Debugging function to check that the statement T has not been
2776 corrupted. For now, this function simply checks that T contains no
2780 verify_stmt_tree (tree t
)
2782 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2783 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2786 /* Check if the type T depends on a type with no linkage and if so,
2787 return it. If RELAXED_P then do not consider a class type declared
2788 within a vague-linkage function to have no linkage. Remember:
2789 no-linkage is not the same as internal-linkage*/
2792 no_linkage_check (tree t
, bool relaxed_p
)
2796 /* Lambda types that don't have mangling scope have no linkage. We
2797 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2798 when we get here from pushtag none of the lambda information is
2799 set up yet, so we want to assume that the lambda has linkage and
2800 fix it up later if not. We need to check this even in templates so
2801 that we properly handle a lambda-expression in the signature. */
2802 if (LAMBDA_TYPE_P (t
)
2803 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2805 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2810 /* Otherwise there's no point in checking linkage on template functions; we
2811 can't know their complete types. */
2812 if (processing_template_decl
)
2815 switch (TREE_CODE (t
))
2818 if (TYPE_PTRMEMFUNC_P (t
))
2822 if (!CLASS_TYPE_P (t
))
2826 /* Only treat unnamed types as having no linkage if they're at
2827 namespace scope. This is core issue 966. */
2828 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2831 for (r
= CP_TYPE_CONTEXT (t
); ; )
2833 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2834 have linkage, or we might just be in an anonymous namespace.
2835 If we're in a TREE_PUBLIC class, we have linkage. */
2836 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2837 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2838 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2840 if (!relaxed_p
|| !vague_linkage_p (r
))
2843 r
= CP_DECL_CONTEXT (r
);
2853 case REFERENCE_TYPE
:
2855 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2859 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2863 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2868 tree parm
= TYPE_ARG_TYPES (t
);
2869 if (TREE_CODE (t
) == METHOD_TYPE
)
2870 /* The 'this' pointer isn't interesting; a method has the same
2871 linkage (or lack thereof) as its enclosing class. */
2872 parm
= TREE_CHAIN (parm
);
2874 parm
&& parm
!= void_list_node
;
2875 parm
= TREE_CHAIN (parm
))
2877 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2881 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2889 extern int depth_reached
;
2892 cxx_print_statistics (void)
2894 print_template_statistics ();
2895 if (GATHER_STATISTICS
)
2896 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2900 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2901 (which is an ARRAY_TYPE). This counts only elements of the top
2905 array_type_nelts_top (tree type
)
2907 return fold_build2_loc (input_location
,
2908 PLUS_EXPR
, sizetype
,
2909 array_type_nelts (type
),
2913 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2914 (which is an ARRAY_TYPE). This one is a recursive count of all
2915 ARRAY_TYPEs that are clumped together. */
2918 array_type_nelts_total (tree type
)
2920 tree sz
= array_type_nelts_top (type
);
2921 type
= TREE_TYPE (type
);
2922 while (TREE_CODE (type
) == ARRAY_TYPE
)
2924 tree n
= array_type_nelts_top (type
);
2925 sz
= fold_build2_loc (input_location
,
2926 MULT_EXPR
, sizetype
, sz
, n
);
2927 type
= TREE_TYPE (type
);
2934 splay_tree target_remap
;
2935 bool clear_location
;
2938 /* Called from break_out_target_exprs via mapcar. */
2941 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2943 bot_data
&data
= *(bot_data
*)data_
;
2944 splay_tree target_remap
= data
.target_remap
;
2947 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2949 /* There can't be any TARGET_EXPRs or their slot variables below this
2950 point. But we must make a copy, in case subsequent processing
2951 alters any part of it. For example, during gimplification a cast
2952 of the form (T) &X::f (where "f" is a member function) will lead
2953 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2955 *tp
= unshare_expr (t
);
2958 if (TREE_CODE (t
) == TARGET_EXPR
)
2962 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2964 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2965 tf_warning_or_error
);
2966 if (u
== error_mark_node
)
2968 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2969 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2972 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2973 tf_warning_or_error
);
2975 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2976 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2977 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2979 /* Map the old variable to the new one. */
2980 splay_tree_insert (target_remap
,
2981 (splay_tree_key
) TREE_OPERAND (t
, 0),
2982 (splay_tree_value
) TREE_OPERAND (u
, 0));
2984 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2985 data
.clear_location
);
2986 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2987 return error_mark_node
;
2989 /* Replace the old expression with the new version. */
2991 /* We don't have to go below this point; the recursive call to
2992 break_out_target_exprs will have handled anything below this
2997 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3000 splay_tree_node n
= splay_tree_lookup (target_remap
,
3001 (splay_tree_key
) t
);
3004 *tp
= (tree
)n
->value
;
3009 copy_tree_r (tp
, walk_subtrees
, NULL
);
3010 splay_tree_insert (target_remap
,
3012 (splay_tree_value
)*tp
);
3013 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3014 splay_tree_insert (target_remap
,
3015 (splay_tree_key
)*tp
,
3016 (splay_tree_value
)*tp
);
3021 /* Make a copy of this node. */
3022 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3023 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3024 if (!processing_template_decl
)
3025 set_flags_from_callee (*tp
);
3026 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3027 SET_EXPR_LOCATION (*tp
, input_location
);
3031 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3032 DATA is really a splay-tree mapping old variables to new
3036 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3038 bot_data
&data
= *(bot_data
*)data_
;
3039 splay_tree target_remap
= data
.target_remap
;
3043 splay_tree_node n
= splay_tree_lookup (target_remap
,
3044 (splay_tree_key
) *t
);
3046 *t
= (tree
) n
->value
;
3048 else if (TREE_CODE (*t
) == PARM_DECL
3049 && DECL_NAME (*t
) == this_identifier
3050 && !DECL_CONTEXT (*t
))
3052 /* In an NSDMI we need to replace the 'this' parameter we used for
3053 parsing with the real one for this function. */
3054 *t
= current_class_ptr
;
3056 else if (TREE_CODE (*t
) == CONVERT_EXPR
3057 && CONVERT_EXPR_VBASE_PATH (*t
))
3059 /* In an NSDMI build_base_path defers building conversions to virtual
3060 bases, and we handle it here. */
3061 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3062 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3064 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3065 if (BINFO_TYPE (binfo
) == basetype
)
3067 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3068 tf_warning_or_error
);
3074 /* When we parse a default argument expression, we may create
3075 temporary variables via TARGET_EXPRs. When we actually use the
3076 default-argument expression, we make a copy of the expression
3077 and replace the temporaries with appropriate local versions.
3079 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3083 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3085 static int target_remap_count
;
3086 static splay_tree target_remap
;
3088 if (!target_remap_count
++)
3089 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3090 /*splay_tree_delete_key_fn=*/NULL
,
3091 /*splay_tree_delete_value_fn=*/NULL
);
3092 bot_data data
= { target_remap
, clear_location
};
3093 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3094 t
= error_mark_node
;
3095 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3097 if (!--target_remap_count
)
3099 splay_tree_delete (target_remap
);
3100 target_remap
= NULL
;
3106 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3107 which we expect to have type TYPE. */
3110 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3112 if (index
== NULL_TREE
)
3113 /* Can't refer to a particular member of a vector. */
3115 else if (TREE_CODE (index
) == INTEGER_CST
)
3116 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3118 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3119 /*reference*/false, tf_none
);
3122 tree objtype
= TREE_TYPE (obj
);
3123 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3125 /* When the destination object refers to a flexible array member
3126 verify that it matches the type of the source object except
3127 for its domain and qualifiers. */
3128 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3129 TYPE_MAIN_VARIANT (objtype
),
3130 COMPARE_REDECLARATION
));
3133 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3139 struct replace_placeholders_t
3141 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3142 tree exp
; /* The outermost exp. */
3143 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3144 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3147 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3148 build up subexpressions as we go deeper. */
3151 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3153 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3156 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3158 *walk_subtrees
= false;
3162 switch (TREE_CODE (*t
))
3164 case PLACEHOLDER_EXPR
:
3167 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3169 x
= TREE_OPERAND (x
, 0))
3170 gcc_assert (handled_component_p (x
));
3171 *t
= unshare_expr (x
);
3172 *walk_subtrees
= false;
3179 constructor_elt
*ce
;
3180 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3181 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3182 other than the d->exp one, those have PLACEHOLDER_EXPRs
3183 related to another object. */
3184 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3186 || d
->pset
->add (*t
))
3188 *walk_subtrees
= false;
3191 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3193 tree
*valp
= &ce
->value
;
3194 tree type
= TREE_TYPE (*valp
);
3197 /* Elements with RANGE_EXPR index shouldn't have any
3198 placeholders in them. */
3199 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3202 if (TREE_CODE (*valp
) == CONSTRUCTOR
3203 && AGGREGATE_TYPE_P (type
))
3205 /* If we're looking at the initializer for OBJ, then build
3206 a sub-object reference. If we're looking at an
3207 initializer for another object, just pass OBJ down. */
3208 if (same_type_ignoring_top_level_qualifiers_p
3209 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3210 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3211 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3212 valp
= &TARGET_EXPR_INITIAL (*valp
);
3215 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3218 *walk_subtrees
= false;
3223 if (d
->pset
->add (*t
))
3224 *walk_subtrees
= false;
3231 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3232 a PLACEHOLDER_EXPR has been encountered. */
3235 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3237 /* This is only relevant for C++14. */
3238 if (cxx_dialect
< cxx14
)
3241 /* If the object isn't a (member of a) class, do nothing. */
3243 while (handled_component_p (op0
))
3244 op0
= TREE_OPERAND (op0
, 0);
3245 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3249 if (TREE_CODE (exp
) == TARGET_EXPR
)
3250 tp
= &TARGET_EXPR_INITIAL (exp
);
3251 hash_set
<tree
> pset
;
3252 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3253 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3255 *seen_p
= data
.seen
;
3259 /* Callback function for find_placeholders. */
3262 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3264 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3266 *walk_subtrees
= false;
3270 switch (TREE_CODE (*t
))
3272 case PLACEHOLDER_EXPR
:
3276 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3277 *walk_subtrees
= false;
3287 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3288 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3291 find_placeholders (tree exp
)
3293 /* This is only relevant for C++14. */
3294 if (cxx_dialect
< cxx14
)
3297 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3300 /* Similar to `build_nt', but for template definitions of dependent
3304 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3311 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3315 t
= make_node (code
);
3316 SET_EXPR_LOCATION (t
, loc
);
3317 length
= TREE_CODE_LENGTH (code
);
3319 for (i
= 0; i
< length
; i
++)
3320 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3326 /* Similar to `build', but for template definitions. */
3329 build_min (enum tree_code code
, tree tt
, ...)
3336 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3340 t
= make_node (code
);
3341 length
= TREE_CODE_LENGTH (code
);
3344 for (i
= 0; i
< length
; i
++)
3346 tree x
= va_arg (p
, tree
);
3347 TREE_OPERAND (t
, i
) = x
;
3348 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3349 TREE_SIDE_EFFECTS (t
) = 1;
3357 /* Similar to `build', but for template definitions of non-dependent
3358 expressions. NON_DEP is the non-dependent expression that has been
3362 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3369 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3371 va_start (p
, non_dep
);
3373 if (REFERENCE_REF_P (non_dep
))
3374 non_dep
= TREE_OPERAND (non_dep
, 0);
3376 t
= make_node (code
);
3377 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3378 length
= TREE_CODE_LENGTH (code
);
3379 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3380 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3382 for (i
= 0; i
< length
; i
++)
3383 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3385 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3386 /* This should not be considered a COMPOUND_EXPR, because it
3387 resolves to an overload. */
3388 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3391 return convert_from_reference (t
);
3394 /* Similar to build_min_nt, but call expressions */
3397 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3402 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3403 CALL_EXPR_FN (ret
) = fn
;
3404 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3405 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3406 CALL_EXPR_ARG (ret
, ix
) = t
;
3411 /* Similar to `build_min_nt_call_vec', but for template definitions of
3412 non-dependent expressions. NON_DEP is the non-dependent expression
3413 that has been built. */
3416 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3418 tree t
= build_min_nt_call_vec (fn
, argvec
);
3419 if (REFERENCE_REF_P (non_dep
))
3420 non_dep
= TREE_OPERAND (non_dep
, 0);
3421 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3422 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3423 return convert_from_reference (t
);
3426 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3427 a call to an operator overload. OP is the operator that has been
3428 overloaded. NON_DEP is the non-dependent expression that's been built,
3429 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3430 the overload that NON_DEP is calling. */
3433 build_min_non_dep_op_overload (enum tree_code op
,
3438 int nargs
, expected_nargs
;
3441 non_dep
= extract_call_expr (non_dep
);
3443 nargs
= call_expr_nargs (non_dep
);
3445 expected_nargs
= cp_tree_code_length (op
);
3446 if ((op
== POSTINCREMENT_EXPR
3447 || op
== POSTDECREMENT_EXPR
)
3448 /* With -fpermissive non_dep could be operator++(). */
3449 && (!flag_permissive
|| nargs
!= expected_nargs
))
3450 expected_nargs
+= 1;
3451 gcc_assert (nargs
== expected_nargs
);
3454 va_start (p
, overload
);
3456 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3459 for (int i
= 0; i
< nargs
; i
++)
3461 tree arg
= va_arg (p
, tree
);
3462 vec_safe_push (args
, arg
);
3465 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3467 tree object
= va_arg (p
, tree
);
3468 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3469 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3470 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3471 object
, method
, NULL_TREE
);
3472 for (int i
= 1; i
< nargs
; i
++)
3474 tree arg
= va_arg (p
, tree
);
3475 vec_safe_push (args
, arg
);
3482 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3484 tree call_expr
= extract_call_expr (call
);
3485 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3486 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3487 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3488 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3493 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3496 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3498 unsigned len
= vec_safe_length (old_vec
);
3499 gcc_assert (idx
<= len
);
3501 vec
<tree
, va_gc
> *new_vec
= NULL
;
3502 vec_alloc (new_vec
, len
+ 1);
3505 for (i
= 0; i
< len
; ++i
)
3508 new_vec
->quick_push (elt
);
3509 new_vec
->quick_push ((*old_vec
)[i
]);
3512 new_vec
->quick_push (elt
);
3518 get_type_decl (tree t
)
3520 if (TREE_CODE (t
) == TYPE_DECL
)
3523 return TYPE_STUB_DECL (t
);
3524 gcc_assert (t
== error_mark_node
);
3528 /* Returns the namespace that contains DECL, whether directly or
3532 decl_namespace_context (tree decl
)
3536 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3538 else if (TYPE_P (decl
))
3539 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3541 decl
= CP_DECL_CONTEXT (decl
);
3545 /* Returns true if decl is within an anonymous namespace, however deeply
3546 nested, or false otherwise. */
3549 decl_anon_ns_mem_p (const_tree decl
)
3551 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3553 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3555 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3557 decl
= CP_DECL_CONTEXT (decl
);
3559 return !TREE_PUBLIC (decl
);
3562 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3563 CALL_EXPRS. Return whether they are equivalent. */
3566 called_fns_equal (tree t1
, tree t2
)
3568 /* Core 1321: dependent names are equivalent even if the overload sets
3569 are different. But do compare explicit template arguments. */
3570 tree name1
= dependent_name (t1
);
3571 tree name2
= dependent_name (t2
);
3574 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3579 /* FIXME dependent_name currently returns an unqualified name regardless
3580 of whether the function was named with a qualified- or unqualified-id.
3581 Until that's fixed, check that we aren't looking at overload sets from
3582 different scopes. */
3583 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3584 && (DECL_CONTEXT (get_first_fn (t1
))
3585 != DECL_CONTEXT (get_first_fn (t2
))))
3588 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3589 targs1
= TREE_OPERAND (t1
, 1);
3590 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3591 targs2
= TREE_OPERAND (t2
, 1);
3592 return cp_tree_equal (targs1
, targs2
);
3595 return cp_tree_equal (t1
, t2
);
3598 /* Return truthvalue of whether T1 is the same tree structure as T2.
3599 Return 1 if they are the same. Return 0 if they are different. */
3602 cp_tree_equal (tree t1
, tree t2
)
3604 enum tree_code code1
, code2
;
3611 code1
= TREE_CODE (t1
);
3612 code2
= TREE_CODE (t2
);
3617 if (CONSTANT_CLASS_P (t1
)
3618 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3624 /* There's only a single VOID_CST node, so we should never reach
3629 return tree_int_cst_equal (t1
, t2
);
3632 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3635 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3636 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3637 TREE_STRING_LENGTH (t1
));
3640 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3641 TREE_FIXED_CST (t2
));
3644 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3645 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3648 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3651 /* We need to do this when determining whether or not two
3652 non-type pointer to member function template arguments
3654 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3655 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3660 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3662 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3663 if (!cp_tree_equal (field
, elt2
->index
)
3664 || !cp_tree_equal (value
, elt2
->value
))
3671 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3673 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3675 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3678 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3683 call_expr_arg_iterator iter1
, iter2
;
3684 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
)
3685 || !called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3687 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3688 arg2
= first_call_expr_arg (t2
, &iter2
);
3690 arg1
= next_call_expr_arg (&iter1
),
3691 arg2
= next_call_expr_arg (&iter2
))
3692 if (!cp_tree_equal (arg1
, arg2
))
3701 tree o1
= TREE_OPERAND (t1
, 0);
3702 tree o2
= TREE_OPERAND (t2
, 0);
3704 /* Special case: if either target is an unallocated VAR_DECL,
3705 it means that it's going to be unified with whatever the
3706 TARGET_EXPR is really supposed to initialize, so treat it
3707 as being equivalent to anything. */
3708 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3709 && !DECL_RTL_SET_P (o1
))
3711 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3712 && !DECL_RTL_SET_P (o2
))
3714 else if (!cp_tree_equal (o1
, o2
))
3717 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3721 /* For comparing uses of parameters in late-specified return types
3722 with an out-of-class definition of the function, but can also come
3723 up for expressions that involve 'this' in a member function
3726 if (comparing_specializations
3727 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
3728 /* When comparing hash table entries, only an exact match is
3729 good enough; we don't want to replace 'this' with the
3730 version from another function. But be more flexible
3731 with parameters with identical contexts. */
3734 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3736 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3738 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3740 if (DECL_ARTIFICIAL (t1
)
3741 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3742 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3752 case IDENTIFIER_NODE
:
3755 case DEFERRED_PARSE
:
3759 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3760 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3761 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3762 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3763 BASELINK_FUNCTIONS (t2
)));
3765 case TEMPLATE_PARM_INDEX
:
3766 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3767 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3768 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3769 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3770 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3771 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3773 case TEMPLATE_ID_EXPR
:
3774 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3775 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3777 case CONSTRAINT_INFO
:
3778 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3779 CI_ASSOCIATED_CONSTRAINTS (t2
));
3782 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3783 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3784 CHECK_CONSTR_ARGS (t2
)));
3789 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3791 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3792 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3793 TREE_VEC_ELT (t2
, ix
)))
3801 tree o1
= TREE_OPERAND (t1
, 0);
3802 tree o2
= TREE_OPERAND (t2
, 0);
3804 if (code1
== SIZEOF_EXPR
)
3806 if (SIZEOF_EXPR_TYPE_P (t1
))
3807 o1
= TREE_TYPE (o1
);
3808 if (SIZEOF_EXPR_TYPE_P (t2
))
3809 o2
= TREE_TYPE (o2
);
3812 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3815 if (ARGUMENT_PACK_P (o1
))
3816 return template_args_equal (o1
, o2
);
3817 else if (TYPE_P (o1
))
3818 return same_type_p (o1
, o2
);
3820 return cp_tree_equal (o1
, o2
);
3825 tree t1_op1
, t2_op1
;
3827 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3830 t1_op1
= TREE_OPERAND (t1
, 1);
3831 t2_op1
= TREE_OPERAND (t2
, 1);
3832 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3835 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3839 /* Two pointer-to-members are the same if they point to the same
3840 field or function in the same class. */
3841 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3844 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3848 /* Two overloads. Must be exactly the same set of decls. */
3849 lkp_iterator
first (t1
);
3850 lkp_iterator
second (t2
);
3852 for (; first
&& second
; ++first
, ++second
)
3853 if (*first
!= *second
)
3855 return !(first
|| second
);
3859 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3861 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3862 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3865 case STATIC_CAST_EXPR
:
3866 case REINTERPRET_CAST_EXPR
:
3867 case CONST_CAST_EXPR
:
3868 case DYNAMIC_CAST_EXPR
:
3869 case IMPLICIT_CONV_EXPR
:
3872 case NON_LVALUE_EXPR
:
3873 case VIEW_CONVERT_EXPR
:
3874 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3876 /* Now compare operands as usual. */
3879 case DEFERRED_NOEXCEPT
:
3880 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3881 DEFERRED_NOEXCEPT_PATTERN (t2
))
3882 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3883 DEFERRED_NOEXCEPT_ARGS (t2
)));
3886 /* Two lambda-expressions are never considered equivalent. */
3889 case TYPE_ARGUMENT_PACK
:
3890 case NONTYPE_ARGUMENT_PACK
:
3892 tree p1
= ARGUMENT_PACK_ARGS (t1
);
3893 tree p2
= ARGUMENT_PACK_ARGS (t2
);
3894 int len
= TREE_VEC_LENGTH (p1
);
3895 if (TREE_VEC_LENGTH (p2
) != len
)
3898 for (int ix
= 0; ix
!= len
; ix
++)
3899 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
3900 TREE_VEC_ELT (p2
, ix
)))
3909 switch (TREE_CODE_CLASS (code1
))
3913 case tcc_comparison
:
3914 case tcc_expression
:
3921 n
= cp_tree_operand_length (t1
);
3922 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3923 && n
!= TREE_OPERAND_LENGTH (t2
))
3926 for (i
= 0; i
< n
; ++i
)
3927 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3934 return same_type_p (t1
, t2
);
3938 /* We can get here with --disable-checking. */
3942 /* The type of ARG when used as an lvalue. */
3945 lvalue_type (tree arg
)
3947 tree type
= TREE_TYPE (arg
);
3951 /* The type of ARG for printing error messages; denote lvalues with
3955 error_type (tree arg
)
3957 tree type
= TREE_TYPE (arg
);
3959 if (TREE_CODE (type
) == ARRAY_TYPE
)
3961 else if (TREE_CODE (type
) == ERROR_MARK
)
3963 else if (lvalue_p (arg
))
3964 type
= build_reference_type (lvalue_type (arg
));
3965 else if (MAYBE_CLASS_TYPE_P (type
))
3966 type
= lvalue_type (arg
);
3971 /* Does FUNCTION use a variable-length argument list? */
3974 varargs_function_p (const_tree function
)
3976 return stdarg_p (TREE_TYPE (function
));
3979 /* Returns 1 if decl is a member of a class. */
3982 member_p (const_tree decl
)
3984 const_tree
const ctx
= DECL_CONTEXT (decl
);
3985 return (ctx
&& TYPE_P (ctx
));
3988 /* Create a placeholder for member access where we don't actually have an
3989 object that the access is against. */
3992 build_dummy_object (tree type
)
3994 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3995 return cp_build_fold_indirect_ref (decl
);
3998 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3999 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4000 binfo path from current_class_type to TYPE, or 0. */
4003 maybe_dummy_object (tree type
, tree
* binfop
)
4007 tree current
= current_nonlambda_class_type ();
4010 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4011 tf_warning_or_error
)))
4015 /* Reference from a nested class member function. */
4017 binfo
= TYPE_BINFO (type
);
4023 if (current_class_ref
4024 /* current_class_ref might not correspond to current_class_type if
4025 we're in tsubst_default_argument or a lambda-declarator; in either
4026 case, we want to use current_class_ref if it matches CONTEXT. */
4027 && (same_type_ignoring_top_level_qualifiers_p
4028 (TREE_TYPE (current_class_ref
), context
)))
4029 decl
= current_class_ref
;
4031 decl
= build_dummy_object (context
);
4036 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4039 is_dummy_object (const_tree ob
)
4041 if (INDIRECT_REF_P (ob
))
4042 ob
= TREE_OPERAND (ob
, 0);
4043 return (TREE_CODE (ob
) == CONVERT_EXPR
4044 && TREE_OPERAND (ob
, 0) == void_node
);
4047 /* Returns 1 iff type T is something we want to treat as a scalar type for
4048 the purpose of deciding whether it is trivial/POD/standard-layout. */
4051 scalarish_type_p (const_tree t
)
4053 if (t
== error_mark_node
)
4056 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4059 /* Returns true iff T requires non-trivial default initialization. */
4062 type_has_nontrivial_default_init (const_tree t
)
4064 t
= strip_array_types (CONST_CAST_TREE (t
));
4066 if (CLASS_TYPE_P (t
))
4067 return TYPE_HAS_COMPLEX_DFLT (t
);
4072 /* Track classes with only deleted copy/move constructors so that we can warn
4073 if they are used in call/return by value. */
4075 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4077 remember_deleted_copy (const_tree t
)
4079 if (!deleted_copy_types
)
4080 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4081 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4084 maybe_warn_parm_abi (tree t
, location_t loc
)
4086 if (!deleted_copy_types
4087 || !deleted_copy_types
->contains (t
))
4090 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4091 && classtype_has_non_deleted_move_ctor (t
))
4094 auto_diagnostic_group d
;
4095 if (flag_abi_version
> 12)
4096 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4097 "the calling convention for %qT, which was "
4098 "accidentally changed in 8.1", t
);
4100 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4101 "ally changes the calling convention for %qT", t
);
4103 inform (location_of (t
), " declared here");
4107 auto_diagnostic_group d
;
4108 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4109 "%<-fabi-version=13%> (GCC 8.2)", t
))
4110 inform (location_of (t
), " because all of its copy and move "
4111 "constructors are deleted");
4114 /* Returns true iff copying an object of type T (including via move
4115 constructor) is non-trivial. That is, T has no non-trivial copy
4116 constructors and no non-trivial move constructors, and not all copy/move
4117 constructors are deleted. This function implements the ABI notion of
4118 non-trivial copy, which has diverged from the one in the standard. */
4121 type_has_nontrivial_copy_init (const_tree type
)
4123 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4125 if (CLASS_TYPE_P (t
))
4127 gcc_assert (COMPLETE_TYPE_P (t
));
4129 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4130 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4134 if (cxx_dialect
< cxx11
)
4135 /* No deleted functions before C++11. */
4138 /* Before ABI v12 we did a bitwise copy of types with only deleted
4139 copy/move constructors. */
4140 if (!abi_version_at_least (12)
4141 && !(warn_abi
&& abi_version_crosses (12)))
4144 bool saw_copy
= false;
4145 bool saw_non_deleted
= false;
4146 bool saw_non_deleted_move
= false;
4148 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4149 saw_copy
= saw_non_deleted
= true;
4150 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4153 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4154 /* [class.copy]/8 If the class definition declares a move
4155 constructor or move assignment operator, the implicitly declared
4156 copy constructor is defined as deleted.... */;
4158 /* Any other reason the implicitly-declared function would be
4159 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4161 saw_non_deleted
= true;
4164 if (!saw_non_deleted
)
4165 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4171 if (!DECL_DELETED_FN (fn
))
4173 /* Not deleted, therefore trivial. */
4174 saw_non_deleted
= true;
4178 else if (move_fn_p (fn
))
4179 if (!DECL_DELETED_FN (fn
))
4180 saw_non_deleted_move
= true;
4183 gcc_assert (saw_copy
);
4185 /* ABI v12 buggily ignored move constructors. */
4186 bool v11nontriv
= false;
4187 bool v12nontriv
= !saw_non_deleted
;
4188 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4189 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4190 : flag_abi_version
== 12 ? v12nontriv
4192 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4193 : warn_abi_version
== 12 ? v12nontriv
4195 if (nontriv
!= warn_nontriv
)
4196 remember_deleted_copy (t
);
4204 /* Returns 1 iff type T is a trivially copyable type, as defined in
4205 [basic.types] and [class]. */
4208 trivially_copyable_p (const_tree t
)
4210 t
= strip_array_types (CONST_CAST_TREE (t
));
4212 if (CLASS_TYPE_P (t
))
4213 return ((!TYPE_HAS_COPY_CTOR (t
)
4214 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4215 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4216 && (!TYPE_HAS_COPY_ASSIGN (t
)
4217 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4218 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4219 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4221 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4222 return scalarish_type_p (t
);
4225 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4229 trivial_type_p (const_tree t
)
4231 t
= strip_array_types (CONST_CAST_TREE (t
));
4233 if (CLASS_TYPE_P (t
))
4234 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4235 && trivially_copyable_p (t
));
4237 return scalarish_type_p (t
);
4240 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4243 pod_type_p (const_tree t
)
4245 /* This CONST_CAST is okay because strip_array_types returns its
4246 argument unmodified and we assign it to a const_tree. */
4247 t
= strip_array_types (CONST_CAST_TREE(t
));
4249 if (!CLASS_TYPE_P (t
))
4250 return scalarish_type_p (t
);
4251 else if (cxx_dialect
> cxx98
)
4252 /* [class]/10: A POD struct is a class that is both a trivial class and a
4253 standard-layout class, and has no non-static data members of type
4254 non-POD struct, non-POD union (or array of such types).
4256 We don't need to check individual members because if a member is
4257 non-std-layout or non-trivial, the class will be too. */
4258 return (std_layout_type_p (t
) && trivial_type_p (t
));
4260 /* The C++98 definition of POD is different. */
4261 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4264 /* Returns true iff T is POD for the purpose of layout, as defined in the
4268 layout_pod_type_p (const_tree t
)
4270 t
= strip_array_types (CONST_CAST_TREE (t
));
4272 if (CLASS_TYPE_P (t
))
4273 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4275 return scalarish_type_p (t
);
4278 /* Returns true iff T is a standard-layout type, as defined in
4282 std_layout_type_p (const_tree t
)
4284 t
= strip_array_types (CONST_CAST_TREE (t
));
4286 if (CLASS_TYPE_P (t
))
4287 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4289 return scalarish_type_p (t
);
4292 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4294 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4295 as defined in [meta.unary.prop]. */
4298 type_has_unique_obj_representations (const_tree t
)
4302 t
= strip_array_types (CONST_CAST_TREE (t
));
4304 if (!trivially_copyable_p (t
))
4307 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4308 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4310 switch (TREE_CODE (t
))
4314 case REFERENCE_TYPE
:
4315 /* If some backend has any paddings in these types, we should add
4316 a target hook for this and handle it there. */
4320 /* For bool values other than 0 and 1 should only appear with
4321 undefined behavior. */
4325 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4328 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4329 when storing long double values, so for that we have to return false.
4330 Other kinds of floating point values are questionable due to +.0/-.0
4331 and NaNs, let's play safe for now. */
4334 case FIXED_POINT_TYPE
:
4342 return type_has_unique_obj_representations (TREE_TYPE (t
));
4345 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4346 if (CLASS_TYPE_P (t
))
4348 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4349 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4357 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4358 if (TREE_CODE (field
) == FIELD_DECL
)
4361 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4362 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4368 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4370 if (CLASS_TYPE_P (t
))
4372 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4373 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4388 /* Helper function for type_has_unique_obj_representations. */
4391 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4393 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4394 if (TREE_CODE (field
) != FIELD_DECL
)
4396 /* For bases, can't use type_has_unique_obj_representations here, as in
4397 struct S { int i : 24; S (); };
4398 struct T : public S { int j : 8; T (); };
4399 S doesn't have unique obj representations, but T does. */
4400 else if (DECL_FIELD_IS_BASE (field
))
4402 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4406 else if (DECL_C_BIT_FIELD (field
))
4408 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4409 if (!type_has_unique_obj_representations (btype
))
4412 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4416 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4417 if (TREE_CODE (field
) == FIELD_DECL
)
4419 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4420 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4421 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4424 if (DECL_SIZE (field
))
4426 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4430 if (cur
!= wi::to_offset (sz
))
4436 /* Nonzero iff type T is a class template implicit specialization. */
4439 class_tmpl_impl_spec_p (const_tree t
)
4441 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4444 /* Returns 1 iff zero initialization of type T means actually storing
4448 zero_init_p (const_tree t
)
4450 /* This CONST_CAST is okay because strip_array_types returns its
4451 argument unmodified and we assign it to a const_tree. */
4452 t
= strip_array_types (CONST_CAST_TREE(t
));
4454 if (t
== error_mark_node
)
4457 /* NULL pointers to data members are initialized with -1. */
4458 if (TYPE_PTRDATAMEM_P (t
))
4461 /* Classes that contain types that can't be zero-initialized, cannot
4462 be zero-initialized themselves. */
4463 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4469 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4470 non-type template parameter. If EXPLAIN, explain why not. */
4473 structural_type_p (tree t
, bool explain
)
4475 t
= strip_array_types (t
);
4476 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
4478 if (NULLPTR_TYPE_P (t
))
4480 if (TYPE_PTR_P (t
) || TYPE_PTRMEM_P (t
))
4482 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4484 if (!CLASS_TYPE_P (t
))
4486 if (TREE_CODE (t
) == UNION_TYPE
)
4489 inform (location_of (t
), "%qT is a union", t
);
4492 if (!literal_type_p (t
))
4495 explain_non_literal_class (t
);
4498 if (CLASSTYPE_HAS_MUTABLE (t
))
4501 inform (location_of (t
), "%qT has a mutable member", t
);
4504 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4505 m
= next_initializable_field (DECL_CHAIN (m
)))
4507 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4511 if (DECL_FIELD_IS_BASE (m
))
4512 inform (location_of (m
), "base class %qT is not public",
4515 inform (location_of (m
), "%qD is not public", m
);
4519 if (!structural_type_p (TREE_TYPE (m
)))
4523 inform (location_of (m
), "%qD has a non-structural type", m
);
4524 structural_type_p (TREE_TYPE (m
), true);
4532 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4533 warn_unused_result attribute. */
4536 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4537 int /*flags*/, bool *no_add_attrs
)
4539 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4541 error ("%qE attribute argument must be a string constant", name
);
4542 *no_add_attrs
= true;
4544 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4546 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4547 && !DECL_CONSTRUCTOR_P (*node
))
4548 warning_at (DECL_SOURCE_LOCATION (*node
),
4549 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4550 "return type", name
, *node
);
4552 else if (OVERLOAD_TYPE_P (*node
))
4556 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4557 "functions or to class or enumeration types", name
);
4558 *no_add_attrs
= true;
4563 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4564 struct attribute_spec.handler. */
4566 handle_no_unique_addr_attribute (tree
* node
,
4572 if (TREE_CODE (*node
) != FIELD_DECL
)
4574 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4575 "non-static data members", name
);
4576 *no_add_attrs
= true;
4578 else if (DECL_C_BIT_FIELD (*node
))
4580 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4581 "a bit-field", name
);
4582 *no_add_attrs
= true;
4588 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4589 hot/cold attributes. */
4592 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4593 int flags
, bool *no_add_attrs
)
4595 *no_add_attrs
= true;
4596 if (TREE_CODE (*node
) == LABEL_DECL
4597 || TREE_CODE (*node
) == FUNCTION_DECL
)
4600 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4601 tree bname
= (is_attribute_p ("likely", name
)
4602 ? get_identifier ("hot") : get_identifier ("cold"));
4603 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4604 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4605 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4606 tree battr
= build_tree_list (bname
, NULL_TREE
);
4607 decl_attributes (node
, battr
, flags
);
4611 return error_mark_node
;
4614 /* Table of valid C++ attributes. */
4615 const struct attribute_spec cxx_attribute_table
[] =
4617 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4618 affects_type_identity, handler, exclude } */
4619 { "init_priority", 1, 1, true, false, false, false,
4620 handle_init_priority_attribute
, NULL
},
4621 { "abi_tag", 1, -1, false, false, false, true,
4622 handle_abi_tag_attribute
, NULL
},
4623 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4626 /* Table of C++ standard attributes. */
4627 const struct attribute_spec std_attribute_table
[] =
4629 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4630 affects_type_identity, handler, exclude } */
4631 { "maybe_unused", 0, 0, false, false, false, false,
4632 handle_unused_attribute
, NULL
},
4633 { "nodiscard", 0, 1, false, false, false, false,
4634 handle_nodiscard_attribute
, NULL
},
4635 { "no_unique_address", 0, 0, true, false, false, false,
4636 handle_no_unique_addr_attribute
, NULL
},
4637 { "likely", 0, 0, false, false, false, false,
4638 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4639 { "unlikely", 0, 0, false, false, false, false,
4640 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4641 { "noreturn", 0, 0, true, false, false, false,
4642 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4643 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4646 /* Handle an "init_priority" attribute; arguments as in
4647 struct attribute_spec.handler. */
4649 handle_init_priority_attribute (tree
* node
,
4655 tree initp_expr
= TREE_VALUE (args
);
4657 tree type
= TREE_TYPE (decl
);
4660 STRIP_NOPS (initp_expr
);
4661 initp_expr
= default_conversion (initp_expr
);
4663 initp_expr
= maybe_constant_value (initp_expr
);
4665 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4667 error ("requested %<init_priority%> is not an integer constant");
4668 cxx_constant_value (initp_expr
);
4669 *no_add_attrs
= true;
4673 pri
= TREE_INT_CST_LOW (initp_expr
);
4675 type
= strip_array_types (type
);
4677 if (decl
== NULL_TREE
4679 || !TREE_STATIC (decl
)
4680 || DECL_EXTERNAL (decl
)
4681 || (TREE_CODE (type
) != RECORD_TYPE
4682 && TREE_CODE (type
) != UNION_TYPE
)
4683 /* Static objects in functions are initialized the
4684 first time control passes through that
4685 function. This is not precise enough to pin down an
4686 init_priority value, so don't allow it. */
4687 || current_function_decl
)
4689 error ("can only use %qE attribute on file-scope definitions "
4690 "of objects of class type", name
);
4691 *no_add_attrs
= true;
4695 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4697 error ("requested %<init_priority%> %i is out of range [0, %i]",
4698 pri
, MAX_INIT_PRIORITY
);
4699 *no_add_attrs
= true;
4703 /* Check for init_priorities that are reserved for
4704 language and runtime support implementations.*/
4705 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4708 (0, "requested %<init_priority%> %i is reserved for internal use",
4712 if (SUPPORTS_INIT_PRIORITY
)
4714 SET_DECL_INIT_PRIORITY (decl
, pri
);
4715 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4720 error ("%qE attribute is not supported on this platform", name
);
4721 *no_add_attrs
= true;
4726 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4727 and the new one has the tags in NEW_. Give an error if there are tags
4728 in NEW_ that weren't in OLD. */
4731 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4733 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4734 old
= TREE_VALUE (old
);
4735 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4736 new_
= TREE_VALUE (new_
);
4738 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4740 tree str
= TREE_VALUE (t
);
4741 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4743 tree ostr
= TREE_VALUE (in
);
4744 if (cp_tree_equal (str
, ostr
))
4747 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4753 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4759 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4760 ill-formed, give an error and return false; otherwise, return true. */
4763 check_abi_tag_args (tree args
, tree name
)
4767 error ("the %qE attribute requires arguments", name
);
4770 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4772 tree elt
= TREE_VALUE (arg
);
4773 if (TREE_CODE (elt
) != STRING_CST
4774 || (!same_type_ignoring_top_level_qualifiers_p
4775 (strip_array_types (TREE_TYPE (elt
)),
4778 error ("arguments to the %qE attribute must be narrow string "
4782 const char *begin
= TREE_STRING_POINTER (elt
);
4783 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4784 for (const char *p
= begin
; p
!= end
; ++p
)
4789 if (!ISALPHA (c
) && c
!= '_')
4791 error ("arguments to the %qE attribute must contain valid "
4792 "identifiers", name
);
4793 inform (input_location
, "%<%c%> is not a valid first "
4794 "character for an identifier", c
);
4798 else if (p
== end
- 1)
4799 gcc_assert (c
== 0);
4802 if (!ISALNUM (c
) && c
!= '_')
4804 error ("arguments to the %qE attribute must contain valid "
4805 "identifiers", name
);
4806 inform (input_location
, "%<%c%> is not a valid character "
4807 "in an identifier", c
);
4816 /* Handle an "abi_tag" attribute; arguments as in
4817 struct attribute_spec.handler. */
4820 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4821 int flags
, bool* no_add_attrs
)
4823 if (!check_abi_tag_args (args
, name
))
4828 if (!OVERLOAD_TYPE_P (*node
))
4830 error ("%qE attribute applied to non-class, non-enum type %qT",
4834 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4836 error ("%qE attribute applied to %qT after its definition",
4840 else if (CLASS_TYPE_P (*node
)
4841 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4843 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4844 "template instantiation %qT", name
, *node
);
4847 else if (CLASS_TYPE_P (*node
)
4848 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4850 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4851 "template specialization %qT", name
, *node
);
4855 tree attributes
= TYPE_ATTRIBUTES (*node
);
4856 tree decl
= TYPE_NAME (*node
);
4858 /* Make sure all declarations have the same abi tags. */
4859 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4861 if (!check_abi_tag_redeclaration (decl
,
4862 lookup_attribute ("abi_tag",
4870 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4872 error ("%qE attribute applied to non-function, non-variable %qD",
4876 else if (DECL_LANGUAGE (*node
) == lang_c
)
4878 error ("%qE attribute applied to extern \"C\" declaration %qD",
4887 *no_add_attrs
= true;
4891 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4892 thing pointed to by the constant. */
4895 make_ptrmem_cst (tree type
, tree member
)
4897 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4898 TREE_TYPE (ptrmem_cst
) = type
;
4899 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4903 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4904 return an existing type if an appropriate type already exists. */
4907 cp_build_type_attribute_variant (tree type
, tree attributes
)
4911 new_type
= build_type_attribute_variant (type
, attributes
);
4912 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4913 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4915 /* Making a new main variant of a class type is broken. */
4916 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4921 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4922 Called only after doing all language independent checks. */
4925 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4927 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4929 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4931 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4933 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4934 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4937 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4938 C++, these are the exception-specifier and ref-qualifier. */
4941 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4943 tree type
= CONST_CAST_TREE (typea
);
4944 if (FUNC_OR_METHOD_TYPE_P (type
))
4945 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4946 TYPE_RAISES_EXCEPTIONS (typeb
),
4947 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4951 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4952 traversal. Called from walk_tree. */
4955 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4956 void *data
, hash_set
<tree
> *pset
)
4958 enum tree_code code
= TREE_CODE (*tp
);
4961 #define WALK_SUBTREE(NODE) \
4964 result = cp_walk_tree (&(NODE), func, data, pset); \
4965 if (result) goto out; \
4970 /* Walk into template args without looking through typedefs. */
4971 if (tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (*tp
))
4972 WALK_SUBTREE (TI_ARGS (ti
));
4974 /* Not one of the easy cases. We must explicitly go through the
4979 case DEFERRED_PARSE
:
4980 case TEMPLATE_TEMPLATE_PARM
:
4981 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4982 case UNBOUND_CLASS_TEMPLATE
:
4983 case TEMPLATE_PARM_INDEX
:
4984 case TEMPLATE_TYPE_PARM
:
4987 case UNDERLYING_TYPE
:
4988 /* None of these have subtrees other than those already walked
4990 *walk_subtrees_p
= 0;
4994 if (BASELINK_QUALIFIED_P (*tp
))
4995 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4996 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4997 *walk_subtrees_p
= 0;
5001 WALK_SUBTREE (TREE_TYPE (*tp
));
5002 *walk_subtrees_p
= 0;
5006 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5010 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5011 WALK_SUBTREE (OVL_CHAIN (*tp
));
5012 *walk_subtrees_p
= 0;
5016 WALK_SUBTREE (DECL_NAME (*tp
));
5017 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5018 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5019 *walk_subtrees_p
= 0;
5023 if (TYPE_PTRMEMFUNC_P (*tp
))
5024 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5027 case TYPE_ARGUMENT_PACK
:
5028 case NONTYPE_ARGUMENT_PACK
:
5030 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5031 int i
, len
= TREE_VEC_LENGTH (args
);
5032 for (i
= 0; i
< len
; i
++)
5033 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5037 case TYPE_PACK_EXPANSION
:
5038 WALK_SUBTREE (TREE_TYPE (*tp
));
5039 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5040 *walk_subtrees_p
= 0;
5043 case EXPR_PACK_EXPANSION
:
5044 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5045 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5046 *walk_subtrees_p
= 0;
5050 case REINTERPRET_CAST_EXPR
:
5051 case STATIC_CAST_EXPR
:
5052 case CONST_CAST_EXPR
:
5053 case DYNAMIC_CAST_EXPR
:
5054 case IMPLICIT_CONV_EXPR
:
5055 if (TREE_TYPE (*tp
))
5056 WALK_SUBTREE (TREE_TYPE (*tp
));
5060 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
5061 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
5063 *walk_subtrees_p
= 0;
5067 if (COMPOUND_LITERAL_P (*tp
))
5068 WALK_SUBTREE (TREE_TYPE (*tp
));
5072 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5073 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5074 *walk_subtrees_p
= 0;
5078 ++cp_unevaluated_operand
;
5079 /* We can't use WALK_SUBTREE here because of the goto. */
5080 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5081 --cp_unevaluated_operand
;
5082 *walk_subtrees_p
= 0;
5088 ++cp_unevaluated_operand
;
5089 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5090 --cp_unevaluated_operand
;
5091 *walk_subtrees_p
= 0;
5095 // Only recurse through the nested expression. Do not
5096 // walk the parameter list. Doing so causes false
5097 // positives in the pack expansion checker since the
5098 // requires parameters are introduced as pack expansions.
5099 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5100 *walk_subtrees_p
= 0;
5104 /* User variables should be mentioned in BIND_EXPR_VARS
5105 and their initializers and sizes walked when walking
5106 the containing BIND_EXPR. Compiler temporaries are
5107 handled here. And also normal variables in templates,
5108 since do_poplevel doesn't build a BIND_EXPR then. */
5109 if (VAR_P (TREE_OPERAND (*tp
, 0))
5110 && (processing_template_decl
5111 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5112 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5114 tree decl
= TREE_OPERAND (*tp
, 0);
5115 WALK_SUBTREE (DECL_INITIAL (decl
));
5116 WALK_SUBTREE (DECL_SIZE (decl
));
5117 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5122 /* Don't walk into the body of the lambda, but the capture initializers
5123 are part of the enclosing context. */
5124 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5125 cap
= TREE_CHAIN (cap
))
5126 WALK_SUBTREE (TREE_VALUE (cap
));
5130 if (TREE_OPERAND (*tp
, 1))
5131 /* Operand 1 is the tree for the relevant co_await which has any
5132 interesting sub-trees. */
5133 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5137 if (TREE_OPERAND (*tp
, 1))
5138 /* Operand 1 is frame variable. */
5139 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5140 if (TREE_OPERAND (*tp
, 2))
5141 /* Operand 2 has the initialiser, and we need to walk any subtrees
5143 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5146 case CO_RETURN_EXPR
:
5147 if (TREE_OPERAND (*tp
, 0))
5149 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5150 /* For void expressions, operand 1 is a trivial call, and any
5151 interesting subtrees will be part of operand 0. */
5152 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5153 else if (TREE_OPERAND (*tp
, 1))
5154 /* Interesting sub-trees will be in the return_value () call
5156 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5164 /* We didn't find what we were looking for. */
5171 /* Like save_expr, but for C++. */
5174 cp_save_expr (tree expr
)
5176 /* There is no reason to create a SAVE_EXPR within a template; if
5177 needed, we can create the SAVE_EXPR when instantiating the
5178 template. Furthermore, the middle-end cannot handle C++-specific
5180 if (processing_template_decl
)
5183 /* TARGET_EXPRs are only expanded once. */
5184 if (TREE_CODE (expr
) == TARGET_EXPR
)
5187 return save_expr (expr
);
5190 /* Initialize tree.c. */
5195 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5196 register_scoped_attributes (std_attribute_table
, NULL
);
5199 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5200 is. Note that sfk_none is zero, so this function can be used as a
5201 predicate to test whether or not DECL is a special function. */
5203 special_function_kind
5204 special_function_p (const_tree decl
)
5206 /* Rather than doing all this stuff with magic names, we should
5207 probably have a field of type `special_function_kind' in
5208 DECL_LANG_SPECIFIC. */
5209 if (DECL_INHERITED_CTOR (decl
))
5210 return sfk_inheriting_constructor
;
5211 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5212 return sfk_copy_constructor
;
5213 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5214 return sfk_move_constructor
;
5215 if (DECL_CONSTRUCTOR_P (decl
))
5216 return sfk_constructor
;
5217 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5218 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5220 if (copy_fn_p (decl
))
5221 return sfk_copy_assignment
;
5222 if (move_fn_p (decl
))
5223 return sfk_move_assignment
;
5225 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5226 return sfk_destructor
;
5227 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5228 return sfk_complete_destructor
;
5229 if (DECL_BASE_DESTRUCTOR_P (decl
))
5230 return sfk_base_destructor
;
5231 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5232 return sfk_deleting_destructor
;
5233 if (DECL_CONV_FN_P (decl
))
5234 return sfk_conversion
;
5235 if (deduction_guide_p (decl
))
5236 return sfk_deduction_guide
;
5237 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5238 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5239 return sfk_comparison
;
5244 /* As above, but only if DECL is a special member function as per 11.3.3
5245 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5247 special_function_kind
5248 special_memfn_p (const_tree decl
)
5250 switch (special_function_kind sfk
= special_function_p (decl
))
5252 case sfk_constructor
:
5253 if (!default_ctor_p (decl
))
5256 case sfk_copy_constructor
:
5257 case sfk_copy_assignment
:
5258 case sfk_move_assignment
:
5259 case sfk_move_constructor
:
5260 case sfk_destructor
:
5269 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5272 char_type_p (tree type
)
5274 return (same_type_p (type
, char_type_node
)
5275 || same_type_p (type
, unsigned_char_type_node
)
5276 || same_type_p (type
, signed_char_type_node
)
5277 || same_type_p (type
, char8_type_node
)
5278 || same_type_p (type
, char16_type_node
)
5279 || same_type_p (type
, char32_type_node
)
5280 || same_type_p (type
, wchar_type_node
));
5283 /* Returns the kind of linkage associated with the indicated DECL. Th
5284 value returned is as specified by the language standard; it is
5285 independent of implementation details regarding template
5286 instantiation, etc. For example, it is possible that a declaration
5287 to which this function assigns external linkage would not show up
5288 as a global symbol when you run `nm' on the resulting object file. */
5291 decl_linkage (tree decl
)
5293 /* This function doesn't attempt to calculate the linkage from first
5294 principles as given in [basic.link]. Instead, it makes use of
5295 the fact that we have already set TREE_PUBLIC appropriately, and
5296 then handles a few special cases. Ideally, we would calculate
5297 linkage first, and then transform that into a concrete
5300 /* Things that don't have names have no linkage. */
5301 if (!DECL_NAME (decl
))
5304 /* Fields have no linkage. */
5305 if (TREE_CODE (decl
) == FIELD_DECL
)
5308 /* Things in local scope do not have linkage. */
5309 if (decl_function_context (decl
))
5312 /* Things that are TREE_PUBLIC have external linkage. */
5313 if (TREE_PUBLIC (decl
))
5316 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5317 check one of the "clones" for the real linkage. */
5318 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5319 && DECL_CHAIN (decl
)
5320 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5321 return decl_linkage (DECL_CHAIN (decl
));
5323 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5326 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5328 if (TREE_CODE (decl
) == CONST_DECL
)
5329 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5331 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5332 are considered to have external linkage for language purposes, as do
5333 template instantiations on targets without weak symbols. DECLs really
5334 meant to have internal linkage have DECL_THIS_STATIC set. */
5335 if (TREE_CODE (decl
) == TYPE_DECL
)
5337 if (VAR_OR_FUNCTION_DECL_P (decl
))
5339 if (!DECL_THIS_STATIC (decl
))
5342 /* Static data members and static member functions from classes
5343 in anonymous namespace also don't have TREE_PUBLIC set. */
5344 if (DECL_CLASS_CONTEXT (decl
))
5348 /* Everything else has internal linkage. */
5352 /* Returns the storage duration of the object or reference associated with
5353 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5356 decl_storage_duration (tree decl
)
5358 if (TREE_CODE (decl
) == PARM_DECL
)
5360 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5362 gcc_assert (VAR_P (decl
));
5363 if (!TREE_STATIC (decl
)
5364 && !DECL_EXTERNAL (decl
))
5366 if (CP_DECL_THREAD_LOCAL_P (decl
))
5371 /* EXP is an expression that we want to pre-evaluate. Returns (in
5372 *INITP) an expression that will perform the pre-evaluation. The
5373 value returned by this function is a side-effect free expression
5374 equivalent to the pre-evaluated expression. Callers must ensure
5375 that *INITP is evaluated before EXP. */
5378 stabilize_expr (tree exp
, tree
* initp
)
5382 if (!TREE_SIDE_EFFECTS (exp
))
5383 init_expr
= NULL_TREE
;
5384 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5389 /* There are no expressions with REFERENCE_TYPE, but there can be call
5390 arguments with such a type; just treat it as a pointer. */
5391 else if (TYPE_REF_P (TREE_TYPE (exp
))
5392 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5393 || !glvalue_p (exp
))
5395 init_expr
= get_target_expr (exp
);
5396 exp
= TARGET_EXPR_SLOT (init_expr
);
5397 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5404 bool xval
= !lvalue_p (exp
);
5405 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5406 init_expr
= get_target_expr (exp
);
5407 exp
= TARGET_EXPR_SLOT (init_expr
);
5408 exp
= cp_build_fold_indirect_ref (exp
);
5414 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5418 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5419 similar expression ORIG. */
5422 add_stmt_to_compound (tree orig
, tree new_expr
)
5424 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5426 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5428 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5431 /* Like stabilize_expr, but for a call whose arguments we want to
5432 pre-evaluate. CALL is modified in place to use the pre-evaluated
5433 arguments, while, upon return, *INITP contains an expression to
5434 compute the arguments. */
5437 stabilize_call (tree call
, tree
*initp
)
5439 tree inits
= NULL_TREE
;
5441 int nargs
= call_expr_nargs (call
);
5443 if (call
== error_mark_node
|| processing_template_decl
)
5449 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5451 for (i
= 0; i
< nargs
; i
++)
5454 CALL_EXPR_ARG (call
, i
) =
5455 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5456 inits
= add_stmt_to_compound (inits
, init
);
5462 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5463 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5464 arguments, while, upon return, *INITP contains an expression to
5465 compute the arguments. */
5468 stabilize_aggr_init (tree call
, tree
*initp
)
5470 tree inits
= NULL_TREE
;
5472 int nargs
= aggr_init_expr_nargs (call
);
5474 if (call
== error_mark_node
)
5477 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5479 for (i
= 0; i
< nargs
; i
++)
5482 AGGR_INIT_EXPR_ARG (call
, i
) =
5483 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5484 inits
= add_stmt_to_compound (inits
, init
);
5490 /* Like stabilize_expr, but for an initialization.
5492 If the initialization is for an object of class type, this function
5493 takes care not to introduce additional temporaries.
5495 Returns TRUE iff the expression was successfully pre-evaluated,
5496 i.e., if INIT is now side-effect free, except for, possibly, a
5497 single call to a constructor. */
5500 stabilize_init (tree init
, tree
*initp
)
5506 if (t
== error_mark_node
|| processing_template_decl
)
5509 if (TREE_CODE (t
) == INIT_EXPR
)
5510 t
= TREE_OPERAND (t
, 1);
5511 if (TREE_CODE (t
) == TARGET_EXPR
)
5512 t
= TARGET_EXPR_INITIAL (t
);
5514 /* If the RHS can be stabilized without breaking copy elision, stabilize
5515 it. We specifically don't stabilize class prvalues here because that
5516 would mean an extra copy, but they might be stabilized below. */
5517 if (TREE_CODE (init
) == INIT_EXPR
5518 && TREE_CODE (t
) != CONSTRUCTOR
5519 && TREE_CODE (t
) != AGGR_INIT_EXPR
5520 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5523 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5527 if (TREE_CODE (t
) == COMPOUND_EXPR
5528 && TREE_CODE (init
) == INIT_EXPR
)
5530 tree last
= expr_last (t
);
5531 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5532 if (!TREE_SIDE_EFFECTS (last
))
5535 TREE_OPERAND (init
, 1) = last
;
5540 if (TREE_CODE (t
) == CONSTRUCTOR
)
5542 /* Aggregate initialization: stabilize each of the field
5545 constructor_elt
*ce
;
5547 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5548 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5550 tree type
= TREE_TYPE (ce
->value
);
5552 if (TYPE_REF_P (type
)
5553 || SCALAR_TYPE_P (type
))
5554 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5555 else if (!stabilize_init (ce
->value
, &subinit
))
5557 *initp
= add_stmt_to_compound (*initp
, subinit
);
5562 if (TREE_CODE (t
) == CALL_EXPR
)
5564 stabilize_call (t
, initp
);
5568 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5570 stabilize_aggr_init (t
, initp
);
5574 /* The initialization is being performed via a bitwise copy -- and
5575 the item copied may have side effects. */
5576 return !TREE_SIDE_EFFECTS (init
);
5579 /* Returns true if a cast to TYPE may appear in an integral constant
5583 cast_valid_in_integral_constant_expression_p (tree type
)
5585 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5586 || cxx_dialect
>= cxx11
5587 || dependent_type_p (type
)
5588 || type
== error_mark_node
);
5591 /* Return true if we need to fix linkage information of DECL. */
5594 cp_fix_function_decl_p (tree decl
)
5596 /* Skip if DECL is not externally visible. */
5597 if (!TREE_PUBLIC (decl
))
5600 /* We need to fix DECL if it a appears to be exported but with no
5601 function body. Thunks do not have CFGs and we may need to
5602 handle them specially later. */
5603 if (!gimple_has_body_p (decl
)
5604 && !DECL_THUNK_P (decl
)
5605 && !DECL_EXTERNAL (decl
))
5607 struct cgraph_node
*node
= cgraph_node::get (decl
);
5609 /* Don't fix same_body aliases. Although they don't have their own
5610 CFG, they share it with what they alias to. */
5611 if (!node
|| !node
->alias
5612 || !vec_safe_length (node
->ref_list
.references
))
5619 /* Clean the C++ specific parts of the tree T. */
5622 cp_free_lang_data (tree t
)
5624 if (FUNC_OR_METHOD_TYPE_P (t
))
5626 /* Default args are not interesting anymore. */
5627 tree argtypes
= TYPE_ARG_TYPES (t
);
5630 TREE_PURPOSE (argtypes
) = 0;
5631 argtypes
= TREE_CHAIN (argtypes
);
5634 else if (TREE_CODE (t
) == FUNCTION_DECL
5635 && cp_fix_function_decl_p (t
))
5637 /* If T is used in this translation unit at all, the definition
5638 must exist somewhere else since we have decided to not emit it
5639 in this TU. So make it an external reference. */
5640 DECL_EXTERNAL (t
) = 1;
5641 TREE_STATIC (t
) = 0;
5643 if (TREE_CODE (t
) == FUNCTION_DECL
)
5644 discard_operator_bindings (t
);
5645 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5646 /* We do not need the leftover chaining of namespaces from the
5648 DECL_CHAIN (t
) = NULL_TREE
;
5651 /* Stub for c-common. Please keep in sync with c-decl.c.
5652 FIXME: If address space support is target specific, then this
5653 should be a C target hook. But currently this is not possible,
5654 because this function is called via REGISTER_TARGET_PRAGMAS. */
5656 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5660 /* Return the number of operands in T that we care about for things like
5664 cp_tree_operand_length (const_tree t
)
5666 enum tree_code code
= TREE_CODE (t
);
5668 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5669 return VL_EXP_OPERAND_LENGTH (t
);
5671 return cp_tree_code_length (code
);
5674 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5677 cp_tree_code_length (enum tree_code code
)
5679 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5683 case PREINCREMENT_EXPR
:
5684 case PREDECREMENT_EXPR
:
5685 case POSTINCREMENT_EXPR
:
5686 case POSTDECREMENT_EXPR
:
5692 case EXPR_PACK_EXPANSION
:
5696 return TREE_CODE_LENGTH (code
);
5700 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5704 cp_expr_location (const_tree t_
)
5706 tree t
= CONST_CAST_TREE (t_
);
5708 return UNKNOWN_LOCATION
;
5709 switch (TREE_CODE (t
))
5712 return LAMBDA_EXPR_LOCATION (t
);
5714 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5716 return TRAIT_EXPR_LOCATION (t
);
5718 return EXPR_LOCATION (t
);
5722 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5723 conditions for the warning hold, false otherwise. */
5725 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5727 if (c_inhibit_evaluation_warnings
== 0
5728 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5730 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5731 "zero as null pointer constant");
5737 /* Given an initializer INIT for a TYPE, return true if INIT is zero
5738 so that it can be replaced by value initialization. This function
5739 distinguishes betwen empty strings as initializers for arrays and
5740 for pointers (which make it return false). */
5743 type_initializer_zero_p (tree type
, tree init
)
5745 if (type
== error_mark_node
|| init
== error_mark_node
)
5750 if (POINTER_TYPE_P (type
))
5751 return TREE_CODE (init
) != STRING_CST
&& initializer_zerop (init
);
5753 if (TREE_CODE (init
) != CONSTRUCTOR
)
5755 /* A class can only be initialized by a non-class type if it has
5756 a ctor that converts from that type. Such classes are excluded
5757 since their semantics are unknown. */
5758 if (RECORD_OR_UNION_TYPE_P (type
)
5759 && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (init
)))
5761 return initializer_zerop (init
);
5764 if (TREE_CODE (type
) == ARRAY_TYPE
)
5766 tree elt_type
= TREE_TYPE (type
);
5767 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
5768 if (elt_type
== char_type_node
)
5769 return initializer_zerop (init
);
5772 unsigned HOST_WIDE_INT i
;
5773 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, elt_init
)
5774 if (!type_initializer_zero_p (elt_type
, elt_init
))
5779 if (TREE_CODE (type
) != RECORD_TYPE
)
5780 return initializer_zerop (init
);
5782 if (TYPE_NON_AGGREGATE_CLASS (type
))
5785 tree fld
= TYPE_FIELDS (type
);
5788 unsigned HOST_WIDE_INT i
;
5789 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, fld_init
)
5791 fld
= next_initializable_field (fld
);
5795 tree fldtype
= TREE_TYPE (fld
);
5796 if (!type_initializer_zero_p (fldtype
, fld_init
))
5799 fld
= DECL_CHAIN (fld
);
5807 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5808 /* Complain that some language-specific thing hanging off a tree
5809 node has been accessed improperly. */
5812 lang_check_failed (const char* file
, int line
, const char* function
)
5814 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5815 function
, trim_filename (file
), line
);
5817 #endif /* ENABLE_TREE_CHECKING */
5821 namespace selftest
{
5823 /* Verify that lvalue_kind () works, for various expressions,
5824 and that location wrappers don't affect the results. */
5829 location_t loc
= BUILTINS_LOCATION
;
5831 /* Verify constants and parameters, without and with
5832 location wrappers. */
5833 tree int_cst
= build_int_cst (integer_type_node
, 42);
5834 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5836 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5837 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5838 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5840 tree string_lit
= build_string (4, "foo");
5841 TREE_TYPE (string_lit
) = char_array_type_node
;
5842 string_lit
= fix_string_type (string_lit
);
5843 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5845 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5846 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5847 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5849 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5850 get_identifier ("some_parm"),
5852 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5854 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5855 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5856 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5858 /* Verify that lvalue_kind of std::move on a parm isn't
5859 affected by location wrappers. */
5860 tree rvalue_ref_of_parm
= move (parm
);
5861 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5862 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5863 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5865 /* Verify lvalue_p. */
5866 ASSERT_FALSE (lvalue_p (int_cst
));
5867 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5868 ASSERT_TRUE (lvalue_p (parm
));
5869 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5870 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5871 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5874 /* Run all of the selftests within this file. */
5879 test_lvalue_kind ();
5882 } // namespace selftest
5884 #endif /* #if CHECKING_P */
5887 #include "gt-cp-tree.h"