1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 /* Expressions with cv void type are prvalues. */
86 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
89 switch (TREE_CODE (ref
))
94 /* preincrements and predecrements are valid lvals, provided
95 what they refer to are valid lvals. */
96 case PREINCREMENT_EXPR
:
97 case PREDECREMENT_EXPR
:
101 case VIEW_CONVERT_EXPR
:
102 return lvalue_kind (TREE_OPERAND (ref
, 0));
106 tree op1
= TREE_OPERAND (ref
, 0);
107 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
109 op1_lvalue_kind
= lvalue_kind (op1
);
110 if (op1_lvalue_kind
== clk_class
)
111 /* in the case of an array operand, the result is an lvalue if
112 that operand is an lvalue and an xvalue otherwise */
113 op1_lvalue_kind
= clk_rvalueref
;
114 return op1_lvalue_kind
;
122 if (TREE_CODE (ref
) == MEMBER_REF
)
123 op1_lvalue_kind
= clk_ordinary
;
125 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
126 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
127 op1_lvalue_kind
= clk_none
;
128 else if (op1_lvalue_kind
== clk_class
)
129 /* The result of a .* expression whose second operand is a pointer to a
130 data member is an lvalue if the first operand is an lvalue and an
132 op1_lvalue_kind
= clk_rvalueref
;
133 return op1_lvalue_kind
;
136 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
138 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
140 /* For static member function recurse on the BASELINK, we can get
141 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
142 OVERLOAD, the overload is resolved first if possible through
143 resolve_address_of_overloaded_function. */
144 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
145 return lvalue_kind (TREE_OPERAND (ref
, 1));
147 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
148 if (op1_lvalue_kind
== clk_class
)
149 /* If E1 is an lvalue, then E1.E2 is an lvalue;
150 otherwise E1.E2 is an xvalue. */
151 op1_lvalue_kind
= clk_rvalueref
;
153 /* Look at the member designator. */
154 if (!op1_lvalue_kind
)
156 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
157 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
158 situations. If we're seeing a COMPONENT_REF, it's a non-static
159 member, so it isn't an lvalue. */
160 op1_lvalue_kind
= clk_none
;
161 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
162 /* This can be IDENTIFIER_NODE in a template. */;
163 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
165 /* Clear the ordinary bit. If this object was a class
166 rvalue we want to preserve that information. */
167 op1_lvalue_kind
&= ~clk_ordinary
;
168 /* The lvalue is for a bitfield. */
169 op1_lvalue_kind
|= clk_bitfield
;
171 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
172 op1_lvalue_kind
|= clk_packed
;
174 return op1_lvalue_kind
;
177 case COMPOUND_LITERAL_EXPR
:
181 /* CONST_DECL without TREE_STATIC are enumeration values and
182 thus not lvalues. With TREE_STATIC they are used by ObjC++
183 in objc_build_string_object and need to be considered as
185 if (! TREE_STATIC (ref
))
189 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
190 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
192 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
193 && DECL_LANG_SPECIFIC (ref
)
194 && DECL_IN_AGGR_P (ref
))
201 case PLACEHOLDER_EXPR
:
204 /* A scope ref in a template, left as SCOPE_REF to support later
207 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
209 tree op
= TREE_OPERAND (ref
, 1);
210 if (TREE_CODE (op
) == FIELD_DECL
)
211 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
213 return lvalue_kind (op
);
218 /* Disallow <? and >? as lvalues if either argument side-effects. */
219 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
220 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
222 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
223 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
227 if (processing_template_decl
)
229 /* Within templates, a REFERENCE_TYPE will indicate whether
230 the COND_EXPR result is an ordinary lvalue or rvalueref.
231 Since REFERENCE_TYPEs are handled above, if we reach this
232 point, we know we got a plain rvalue. Unless we have a
233 type-dependent expr, that is, but we shouldn't be testing
234 lvalueness if we can't even tell the types yet! */
235 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
239 tree op1
= TREE_OPERAND (ref
, 1);
240 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
241 tree op2
= TREE_OPERAND (ref
, 2);
242 op1_lvalue_kind
= lvalue_kind (op1
);
243 op2_lvalue_kind
= lvalue_kind (op2
);
244 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
246 /* The second or the third operand (but not both) is a
247 throw-expression; the result is of the type
248 and value category of the other. */
249 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
250 op2_lvalue_kind
= op1_lvalue_kind
;
251 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
252 op1_lvalue_kind
= op2_lvalue_kind
;
258 /* We expect to see unlowered MODOP_EXPRs only during
259 template processing. */
260 gcc_assert (processing_template_decl
);
268 return lvalue_kind (TREE_OPERAND (ref
, 1));
274 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
277 /* We can see calls outside of TARGET_EXPR in templates. */
278 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
283 /* All functions (except non-static-member functions) are
285 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
286 ? clk_none
: clk_ordinary
);
289 /* We now represent a reference to a single static member function
291 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
292 its argument unmodified and we assign it to a const_tree. */
293 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
295 case NON_DEPENDENT_EXPR
:
297 return lvalue_kind (TREE_OPERAND (ref
, 0));
299 case TEMPLATE_PARM_INDEX
:
300 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
301 /* A template parameter object is an lvalue. */
307 if (!TREE_TYPE (ref
))
309 if (CLASS_TYPE_P (TREE_TYPE (ref
))
310 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
315 /* If one operand is not an lvalue at all, then this expression is
317 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
320 /* Otherwise, it's an lvalue, and it has all the odd properties
321 contributed by either operand. */
322 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
323 /* It's not an ordinary lvalue if it involves any other kind. */
324 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
325 op1_lvalue_kind
&= ~clk_ordinary
;
326 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
327 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
328 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
329 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
330 op1_lvalue_kind
= clk_none
;
331 return op1_lvalue_kind
;
334 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
337 real_lvalue_p (const_tree ref
)
339 cp_lvalue_kind kind
= lvalue_kind (ref
);
340 if (kind
& (clk_rvalueref
|clk_class
))
346 /* c-common wants us to return bool. */
349 lvalue_p (const_tree t
)
351 return real_lvalue_p (t
);
354 /* This differs from lvalue_p in that xvalues are included. */
357 glvalue_p (const_tree ref
)
359 cp_lvalue_kind kind
= lvalue_kind (ref
);
360 if (kind
& clk_class
)
363 return (kind
!= clk_none
);
366 /* This differs from glvalue_p in that class prvalues are included. */
369 obvalue_p (const_tree ref
)
371 return (lvalue_kind (ref
) != clk_none
);
374 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
375 reference), false otherwise. */
378 xvalue_p (const_tree ref
)
380 return (lvalue_kind (ref
) == clk_rvalueref
);
383 /* True if REF is a bit-field. */
386 bitfield_p (const_tree ref
)
388 return (lvalue_kind (ref
) & clk_bitfield
);
391 /* C++-specific version of stabilize_reference. */
394 cp_stabilize_reference (tree ref
)
396 STRIP_ANY_LOCATION_WRAPPER (ref
);
397 switch (TREE_CODE (ref
))
399 case NON_DEPENDENT_EXPR
:
400 /* We aren't actually evaluating this. */
403 /* We need to treat specially anything stabilize_reference doesn't
404 handle specifically. */
415 case ARRAY_RANGE_REF
:
419 cp_lvalue_kind kind
= lvalue_kind (ref
);
420 if ((kind
& ~clk_class
) != clk_none
)
422 tree type
= unlowered_expr_type (ref
);
423 bool rval
= !!(kind
& clk_rvalueref
);
424 type
= cp_build_reference_type (type
, rval
);
425 /* This inhibits warnings in, eg, cxx_mark_addressable
427 warning_sentinel
s (extra_warnings
);
428 ref
= build_static_cast (input_location
, type
, ref
,
433 return stabilize_reference (ref
);
436 /* Test whether DECL is a builtin that may appear in a
437 constant-expression. */
440 builtin_valid_in_constant_expr_p (const_tree decl
)
442 STRIP_ANY_LOCATION_WRAPPER (decl
);
443 if (TREE_CODE (decl
) != FUNCTION_DECL
)
444 /* Not a function. */
446 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
448 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
450 || fndecl_built_in_p (decl
, CP_BUILT_IN_SOURCE_LOCATION
,
453 /* Not a built-in. */
456 switch (DECL_FUNCTION_CODE (decl
))
458 /* These always have constant results like the corresponding
461 case BUILT_IN_FUNCTION
:
464 /* The following built-ins are valid in constant expressions
465 when their arguments are. */
466 case BUILT_IN_ADD_OVERFLOW_P
:
467 case BUILT_IN_SUB_OVERFLOW_P
:
468 case BUILT_IN_MUL_OVERFLOW_P
:
470 /* These have constant results even if their operands are
472 case BUILT_IN_CONSTANT_P
:
473 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
480 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
483 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
486 tree type
= TREE_TYPE (decl
);
488 value
= mark_rvalue_use (value
);
490 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
491 || TREE_TYPE (decl
) == TREE_TYPE (value
)
492 /* On ARM ctors return 'this'. */
493 || (TYPE_PTR_P (TREE_TYPE (value
))
494 && TREE_CODE (value
) == CALL_EXPR
)
495 || useless_type_conversion_p (TREE_TYPE (decl
),
498 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
499 moving a constant aggregate into .rodata. */
500 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
501 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
502 && !VOID_TYPE_P (TREE_TYPE (value
))
503 && reduced_constant_expression_p (value
))
504 TREE_READONLY (decl
) = true;
506 if (complain
& tf_no_cleanup
)
507 /* The caller is building a new-expr and does not need a cleanup. */
511 t
= cxx_maybe_build_cleanup (decl
, complain
);
512 if (t
== error_mark_node
)
513 return error_mark_node
;
515 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
516 if (location_t eloc
= cp_expr_location (value
))
517 SET_EXPR_LOCATION (t
, eloc
);
518 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
519 ignore the TARGET_EXPR. If there really turn out to be no
520 side-effects, then the optimizer should be able to get rid of
521 whatever code is generated anyhow. */
522 TREE_SIDE_EFFECTS (t
) = 1;
527 /* Return an undeclared local temporary of type TYPE for use in building a
531 build_local_temp (tree type
)
533 tree slot
= build_decl (input_location
,
534 VAR_DECL
, NULL_TREE
, type
);
535 DECL_ARTIFICIAL (slot
) = 1;
536 DECL_IGNORED_P (slot
) = 1;
537 DECL_CONTEXT (slot
) = current_function_decl
;
538 layout_decl (slot
, 0);
542 /* Return whether DECL is such a local temporary (or one from
543 create_tmp_var_raw). */
546 is_local_temp (tree decl
)
548 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
549 && !TREE_STATIC (decl
)
550 && DECL_FUNCTION_SCOPE_P (decl
));
553 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
556 process_aggr_init_operands (tree t
)
560 side_effects
= TREE_SIDE_EFFECTS (t
);
564 n
= TREE_OPERAND_LENGTH (t
);
565 for (i
= 1; i
< n
; i
++)
567 tree op
= TREE_OPERAND (t
, i
);
568 if (op
&& TREE_SIDE_EFFECTS (op
))
575 TREE_SIDE_EFFECTS (t
) = side_effects
;
578 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
579 FN, and SLOT. NARGS is the number of call arguments which are specified
580 as a tree array ARGS. */
583 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
589 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
590 TREE_TYPE (t
) = return_type
;
591 AGGR_INIT_EXPR_FN (t
) = fn
;
592 AGGR_INIT_EXPR_SLOT (t
) = slot
;
593 for (i
= 0; i
< nargs
; i
++)
594 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
595 process_aggr_init_operands (t
);
599 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
600 target. TYPE is the type to be initialized.
602 Build an AGGR_INIT_EXPR to represent the initialization. This function
603 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
604 to initialize another object, whereas a TARGET_EXPR can either
605 initialize another object or create its own temporary object, and as a
606 result building up a TARGET_EXPR requires that the type's destructor be
610 build_aggr_init_expr (tree type
, tree init
)
617 gcc_assert (!VOID_TYPE_P (type
));
619 /* Don't build AGGR_INIT_EXPR in a template. */
620 if (processing_template_decl
)
623 fn
= cp_get_callee (init
);
625 return convert (type
, init
);
627 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
628 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
629 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
631 /* We split the CALL_EXPR into its function and its arguments here.
632 Then, in expand_expr, we put them back together. The reason for
633 this is that this expression might be a default argument
634 expression. In that case, we need a new temporary every time the
635 expression is used. That's what break_out_target_exprs does; it
636 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
637 temporary slot. Then, expand_expr builds up a call-expression
638 using the new slot. */
640 /* If we don't need to use a constructor to create an object of this
641 type, don't mess with AGGR_INIT_EXPR. */
642 if (is_ctor
|| TREE_ADDRESSABLE (type
))
644 slot
= build_local_temp (type
);
646 if (TREE_CODE (init
) == CALL_EXPR
)
648 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
649 call_expr_nargs (init
),
650 CALL_EXPR_ARGP (init
));
651 AGGR_INIT_FROM_THUNK_P (rval
)
652 = CALL_FROM_THUNK_P (init
);
656 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
657 aggr_init_expr_nargs (init
),
658 AGGR_INIT_EXPR_ARGP (init
));
659 AGGR_INIT_FROM_THUNK_P (rval
)
660 = AGGR_INIT_FROM_THUNK_P (init
);
662 TREE_SIDE_EFFECTS (rval
) = 1;
663 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
664 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
665 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
666 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
667 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
675 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
676 target. TYPE is the type that this initialization should appear to
679 Build an encapsulation of the initialization to perform
680 and return it so that it can be processed by language-independent
681 and language-specific expression expanders. */
684 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
686 /* This function should cope with what build_special_member_call
687 can produce. When performing parenthesized aggregate initialization,
688 it can produce a { }. */
689 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
691 gcc_assert (cxx_dialect
>= cxx2a
);
692 return finish_compound_literal (type
, init
, complain
);
695 tree rval
= build_aggr_init_expr (type
, init
);
698 if (init
== error_mark_node
)
699 return error_mark_node
;
701 if (!complete_type_or_maybe_complain (type
, init
, complain
))
702 return error_mark_node
;
704 /* Make sure that we're not trying to create an instance of an
706 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
707 return error_mark_node
;
709 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
710 slot
= AGGR_INIT_EXPR_SLOT (rval
);
711 else if (TREE_CODE (rval
) == CALL_EXPR
712 || TREE_CODE (rval
) == CONSTRUCTOR
)
713 slot
= build_local_temp (type
);
717 rval
= build_target_expr (slot
, rval
, complain
);
719 if (rval
!= error_mark_node
)
720 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
725 /* Subroutine of build_vec_init_expr: Build up a single element
726 intialization as a proxy for the full array initialization to get things
727 marked as used and any appropriate diagnostics.
729 Since we're deferring building the actual constructor calls until
730 gimplification time, we need to build one now and throw it away so
731 that the relevant constructor gets mark_used before cgraph decides
732 what functions are needed. Here we assume that init is either
733 NULL_TREE, void_type_node (indicating value-initialization), or
734 another array to copy. */
737 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
739 tree inner_type
= strip_array_types (type
);
741 if (integer_zerop (array_type_nelts_total (type
))
742 || !CLASS_TYPE_P (inner_type
))
743 /* No interesting initialization to do. */
744 return integer_zero_node
;
745 else if (init
== void_type_node
)
746 return build_value_init (inner_type
, complain
);
748 gcc_assert (init
== NULL_TREE
749 || (same_type_ignoring_top_level_qualifiers_p
750 (type
, TREE_TYPE (init
))));
752 releasing_vec argvec
;
755 tree init_type
= strip_array_types (TREE_TYPE (init
));
756 tree dummy
= build_dummy_object (init_type
);
757 if (!lvalue_p (init
))
758 dummy
= move (dummy
);
759 argvec
->quick_push (dummy
);
761 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
762 &argvec
, inner_type
, LOOKUP_NORMAL
,
765 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
766 we don't want one here because we aren't creating a temporary. */
767 if (TREE_CODE (init
) == TARGET_EXPR
)
768 init
= TARGET_EXPR_INITIAL (init
);
773 /* Return a TARGET_EXPR which expresses the initialization of an array to
774 be named later, either default-initialization or copy-initialization
775 from another array of the same type. */
778 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
781 bool value_init
= false;
782 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
784 if (init
== void_type_node
)
790 slot
= build_local_temp (type
);
791 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
792 TREE_SIDE_EFFECTS (init
) = true;
793 SET_EXPR_LOCATION (init
, input_location
);
795 if (cxx_dialect
>= cxx11
796 && potential_constant_expression (elt_init
))
797 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
798 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
803 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
804 that requires a constant expression. */
807 diagnose_non_constexpr_vec_init (tree expr
)
809 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
811 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
812 init
= void_type_node
;
814 init
= VEC_INIT_EXPR_INIT (expr
);
816 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
817 require_potential_constant_expression (elt_init
);
821 build_array_copy (tree init
)
823 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
826 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
830 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
832 gcc_assert (!VOID_TYPE_P (type
));
834 if (TREE_CODE (init
) == TARGET_EXPR
835 || init
== error_mark_node
)
837 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
838 && !VOID_TYPE_P (TREE_TYPE (init
))
839 && TREE_CODE (init
) != COND_EXPR
840 && TREE_CODE (init
) != CONSTRUCTOR
841 && TREE_CODE (init
) != VA_ARG_EXPR
)
842 /* We need to build up a copy constructor call. A void initializer
843 means we're being called from bot_manip. COND_EXPR is a special
844 case because we already have copies on the arms and we don't want
845 another one here. A CONSTRUCTOR is aggregate initialization, which
846 is handled separately. A VA_ARG_EXPR is magic creation of an
847 aggregate; there's no additional work to be done. */
848 return force_rvalue (init
, complain
);
850 return force_target_expr (type
, init
, complain
);
853 /* Like the above function, but without the checking. This function should
854 only be used by code which is deliberately trying to subvert the type
855 system, such as call_builtin_trap. Or build_over_call, to avoid
856 infinite recursion. */
859 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
863 gcc_assert (!VOID_TYPE_P (type
));
865 slot
= build_local_temp (type
);
866 return build_target_expr (slot
, init
, complain
);
869 /* Like build_target_expr_with_type, but use the type of INIT. */
872 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
874 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
875 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
876 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
877 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
880 init
= convert_bitfield_to_declared_type (init
);
881 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
886 get_target_expr (tree init
)
888 return get_target_expr_sfinae (init
, tf_warning_or_error
);
891 /* If EXPR is a bitfield reference, convert it to the declared type of
892 the bitfield, and return the resulting expression. Otherwise,
893 return EXPR itself. */
896 convert_bitfield_to_declared_type (tree expr
)
900 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
902 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
907 /* EXPR is being used in an rvalue context. Return a version of EXPR
908 that is marked as an rvalue. */
915 if (error_operand_p (expr
))
918 expr
= mark_rvalue_use (expr
);
922 Non-class rvalues always have cv-unqualified types. */
923 type
= TREE_TYPE (expr
);
924 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
925 type
= cv_unqualified (type
);
927 /* We need to do this for rvalue refs as well to get the right answer
928 from decltype; see c++/36628. */
929 if (!processing_template_decl
&& glvalue_p (expr
))
930 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
931 else if (type
!= TREE_TYPE (expr
))
932 expr
= build_nop (type
, expr
);
938 struct cplus_array_info
944 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
946 typedef cplus_array_info
*compare_type
;
948 static hashval_t
hash (tree t
);
949 static bool equal (tree
, cplus_array_info
*);
952 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
955 cplus_array_hasher::hash (tree t
)
959 hash
= TYPE_UID (TREE_TYPE (t
));
961 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
965 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
966 of type `cplus_array_info*'. */
969 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
971 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
974 /* Hash table containing dependent array types, which are unsuitable for
975 the language-independent type hash table. */
976 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
978 /* Build an ARRAY_TYPE without laying it out. */
981 build_min_array_type (tree elt_type
, tree index_type
)
983 tree t
= cxx_make_type (ARRAY_TYPE
);
984 TREE_TYPE (t
) = elt_type
;
985 TYPE_DOMAIN (t
) = index_type
;
989 /* Set TYPE_CANONICAL like build_array_type_1, but using
990 build_cplus_array_type. */
993 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
995 /* Set the canonical type for this new node. */
996 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
997 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
998 SET_TYPE_STRUCTURAL_EQUALITY (t
);
999 else if (TYPE_CANONICAL (elt_type
) != elt_type
1000 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1002 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1004 ? TYPE_CANONICAL (index_type
) : index_type
);
1006 TYPE_CANONICAL (t
) = t
;
1009 /* Like build_array_type, but handle special C++ semantics: an array of a
1010 variant element type is a variant of the array of the main variant of
1011 the element type. */
1014 build_cplus_array_type (tree elt_type
, tree index_type
)
1018 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1019 return error_mark_node
;
1021 bool dependent
= (uses_template_parms (elt_type
)
1022 || (index_type
&& uses_template_parms (index_type
)));
1024 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1025 /* Start with an array of the TYPE_MAIN_VARIANT. */
1026 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1030 /* Since type_hash_canon calls layout_type, we need to use our own
1032 cplus_array_info cai
;
1035 if (cplus_array_htab
== NULL
)
1036 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1038 hash
= TYPE_UID (elt_type
);
1040 hash
^= TYPE_UID (index_type
);
1041 cai
.type
= elt_type
;
1042 cai
.domain
= index_type
;
1044 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1046 /* We have found the type: we're done. */
1050 /* Build a new array type. */
1051 t
= build_min_array_type (elt_type
, index_type
);
1053 /* Store it in the hash table. */
1056 /* Set the canonical type for this new node. */
1057 set_array_type_canon (t
, elt_type
, index_type
);
1062 bool typeless_storage
1063 = (elt_type
== unsigned_char_type_node
1064 || elt_type
== signed_char_type_node
1065 || elt_type
== char_type_node
1066 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1067 && TYPE_CONTEXT (elt_type
) == std_node
1068 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1069 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1072 /* Now check whether we already have this array variant. */
1073 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1076 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1077 if (TREE_TYPE (t
) == elt_type
1078 && TYPE_NAME (t
) == NULL_TREE
1079 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1083 t
= build_min_array_type (elt_type
, index_type
);
1084 set_array_type_canon (t
, elt_type
, index_type
);
1088 /* Make sure sizes are shared with the main variant.
1089 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1090 as it will overwrite alignment etc. of all variants. */
1091 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1092 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1093 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1096 TYPE_MAIN_VARIANT (t
) = m
;
1097 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1098 TYPE_NEXT_VARIANT (m
) = t
;
1102 /* Avoid spurious warnings with VLAs (c++/54583). */
1103 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1104 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1106 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1107 place more easily. */
1108 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1109 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1110 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1111 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1113 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1114 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1116 /* The element type has been completed since the last time we saw
1117 this array type; update the layout and 'tor flags for any variants
1120 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1122 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1123 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1130 /* Return an ARRAY_TYPE with element type ELT and length N. */
1133 build_array_of_n_type (tree elt
, int n
)
1135 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1138 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1139 for C++14 but then removed. This should only be used for N3639
1140 specifically; code wondering more generally if something is a VLA should use
1144 array_of_runtime_bound_p (tree t
)
1146 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1148 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1150 tree dom
= TYPE_DOMAIN (t
);
1153 tree max
= TYPE_MAX_VALUE (dom
);
1154 return (!potential_rvalue_constant_expression (max
)
1155 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1158 /* True iff T is a variable length array. */
1163 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1165 if (tree dom
= TYPE_DOMAIN (t
))
1167 tree max
= TYPE_MAX_VALUE (dom
);
1168 if (!potential_rvalue_constant_expression (max
)
1169 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1175 /* Return a reference type node referring to TO_TYPE. If RVAL is
1176 true, return an rvalue reference type, otherwise return an lvalue
1177 reference type. If a type node exists, reuse it, otherwise create
1180 cp_build_reference_type (tree to_type
, bool rval
)
1184 if (to_type
== error_mark_node
)
1185 return error_mark_node
;
1187 if (TYPE_REF_P (to_type
))
1189 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1190 to_type
= TREE_TYPE (to_type
);
1193 lvalue_ref
= build_reference_type (to_type
);
1197 /* This code to create rvalue reference types is based on and tied
1198 to the code creating lvalue reference types in the middle-end
1199 functions build_reference_type_for_mode and build_reference_type.
1201 It works by putting the rvalue reference type nodes after the
1202 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1203 they will effectively be ignored by the middle end. */
1205 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1206 if (TYPE_REF_IS_RVALUE (t
))
1209 t
= build_distinct_type_copy (lvalue_ref
);
1211 TYPE_REF_IS_RVALUE (t
) = true;
1212 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1213 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1215 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1216 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1217 else if (TYPE_CANONICAL (to_type
) != to_type
)
1219 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1221 TYPE_CANONICAL (t
) = t
;
1229 /* Returns EXPR cast to rvalue reference type, like std::move. */
1234 tree type
= TREE_TYPE (expr
);
1235 gcc_assert (!TYPE_REF_P (type
));
1236 type
= cp_build_reference_type (type
, /*rval*/true);
1237 return build_static_cast (input_location
, type
, expr
,
1238 tf_warning_or_error
);
1241 /* Used by the C++ front end to build qualified array types. However,
1242 the C version of this function does not properly maintain canonical
1243 types (which are not used in C). */
1245 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1246 size_t /* orig_qual_indirect */)
1248 return cp_build_qualified_type (type
, type_quals
);
1252 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1253 arrays correctly. In particular, if TYPE is an array of T's, and
1254 TYPE_QUALS is non-empty, returns an array of qualified T's.
1256 FLAGS determines how to deal with ill-formed qualifications. If
1257 tf_ignore_bad_quals is set, then bad qualifications are dropped
1258 (this is permitted if TYPE was introduced via a typedef or template
1259 type parameter). If bad qualifications are dropped and tf_warning
1260 is set, then a warning is issued for non-const qualifications. If
1261 tf_ignore_bad_quals is not set and tf_error is not set, we
1262 return error_mark_node. Otherwise, we issue an error, and ignore
1265 Qualification of a reference type is valid when the reference came
1266 via a typedef or template type argument. [dcl.ref] No such
1267 dispensation is provided for qualifying a function type. [dcl.fct]
1268 DR 295 queries this and the proposed resolution brings it into line
1269 with qualifying a reference. We implement the DR. We also behave
1270 in a similar manner for restricting non-pointer types. */
1273 cp_build_qualified_type_real (tree type
,
1275 tsubst_flags_t complain
)
1278 int bad_quals
= TYPE_UNQUALIFIED
;
1280 if (type
== error_mark_node
)
1283 if (type_quals
== cp_type_quals (type
))
1286 if (TREE_CODE (type
) == ARRAY_TYPE
)
1288 /* In C++, the qualification really applies to the array element
1289 type. Obtain the appropriately qualified element type. */
1292 = cp_build_qualified_type_real (TREE_TYPE (type
),
1296 if (element_type
== error_mark_node
)
1297 return error_mark_node
;
1299 /* See if we already have an identically qualified type. Tests
1300 should be equivalent to those in check_qualified_type. */
1301 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1302 if (TREE_TYPE (t
) == element_type
1303 && TYPE_NAME (t
) == TYPE_NAME (type
)
1304 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1305 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1306 TYPE_ATTRIBUTES (type
)))
1311 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1313 /* Keep the typedef name. */
1314 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1316 t
= build_variant_type_copy (t
);
1317 TYPE_NAME (t
) = TYPE_NAME (type
);
1318 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1319 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1323 /* Even if we already had this variant, we update
1324 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1325 they changed since the variant was originally created.
1327 This seems hokey; if there is some way to use a previous
1328 variant *without* coming through here,
1329 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1330 TYPE_NEEDS_CONSTRUCTING (t
)
1331 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1332 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1333 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1336 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1338 tree t
= PACK_EXPANSION_PATTERN (type
);
1340 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1341 return make_pack_expansion (t
, complain
);
1344 /* A reference or method type shall not be cv-qualified.
1345 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1346 (in CD1) we always ignore extra cv-quals on functions. */
1347 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1348 && (TYPE_REF_P (type
)
1349 || FUNC_OR_METHOD_TYPE_P (type
)))
1351 if (TYPE_REF_P (type
))
1352 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1353 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1356 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1357 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1358 type_quals
|= type_memfn_quals (type
);
1360 /* A restrict-qualified type must be a pointer (or reference)
1361 to object or incomplete type. */
1362 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1363 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1364 && TREE_CODE (type
) != TYPENAME_TYPE
1365 && !INDIRECT_TYPE_P (type
))
1367 bad_quals
|= TYPE_QUAL_RESTRICT
;
1368 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1371 if (bad_quals
== TYPE_UNQUALIFIED
1372 || (complain
& tf_ignore_bad_quals
))
1374 else if (!(complain
& tf_error
))
1375 return error_mark_node
;
1378 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1379 error ("%qV qualifiers cannot be applied to %qT",
1383 /* Retrieve (or create) the appropriately qualified variant. */
1384 result
= build_qualified_type (type
, type_quals
);
1389 /* Return TYPE with const and volatile removed. */
1392 cv_unqualified (tree type
)
1396 if (type
== error_mark_node
)
1399 quals
= cp_type_quals (type
);
1400 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1401 return cp_build_qualified_type (type
, quals
);
1404 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1405 from ATTRIBS that affect type identity, and no others. If any are not
1406 applied, set *remove_attributes to true. */
1409 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1411 tree first_ident
= NULL_TREE
;
1412 tree new_attribs
= NULL_TREE
;
1413 tree
*p
= &new_attribs
;
1415 if (OVERLOAD_TYPE_P (result
))
1417 /* On classes and enums all attributes are ingrained. */
1418 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1422 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1424 const attribute_spec
*as
1425 = lookup_attribute_spec (get_attribute_name (a
));
1426 if (as
&& as
->affects_type_identity
)
1430 else if (first_ident
== error_mark_node
)
1432 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1433 p
= &TREE_CHAIN (*p
);
1436 else if (first_ident
)
1438 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1440 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1441 p
= &TREE_CHAIN (*p
);
1443 first_ident
= error_mark_node
;
1446 if (first_ident
!= error_mark_node
)
1447 new_attribs
= first_ident
;
1449 if (first_ident
== attribs
)
1450 /* All attributes affected type identity. */;
1452 *remove_attributes
= true;
1454 return cp_build_type_attribute_variant (result
, new_attribs
);
1457 /* Builds a qualified variant of T that is either not a typedef variant
1458 (the default behavior) or not a typedef variant of a user-facing type
1459 (if FLAGS contains STF_USER_FACING).
1461 E.g. consider the following declarations:
1462 typedef const int ConstInt;
1463 typedef ConstInt* PtrConstInt;
1464 If T is PtrConstInt, this function returns a type representing
1466 In other words, if T is a typedef, the function returns the underlying type.
1467 The cv-qualification and attributes of the type returned match the
1469 They will always be compatible types.
1470 The returned type is built so that all of its subtypes
1471 recursively have their typedefs stripped as well.
1473 This is different from just returning TYPE_CANONICAL (T)
1474 Because of several reasons:
1475 * If T is a type that needs structural equality
1476 its TYPE_CANONICAL (T) will be NULL.
1477 * TYPE_CANONICAL (T) desn't carry type attributes
1478 and loses template parameter names.
1480 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1481 affect type identity, and set the referent to true if any were
1485 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1487 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1489 if (!t
|| t
== error_mark_node
)
1492 if (TREE_CODE (t
) == TREE_LIST
)
1494 bool changed
= false;
1497 for (; t
; t
= TREE_CHAIN (t
))
1499 gcc_assert (!TREE_PURPOSE (t
));
1500 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1501 if (elt
!= TREE_VALUE (t
))
1503 vec_safe_push (vec
, elt
);
1506 r
= build_tree_list_vec (vec
);
1510 gcc_assert (TYPE_P (t
));
1512 if (t
== TYPE_CANONICAL (t
))
1515 if (!(flags
& STF_STRIP_DEPENDENT
)
1516 && dependent_alias_template_spec_p (t
, nt_opaque
))
1517 /* DR 1558: However, if the template-id is dependent, subsequent
1518 template argument substitution still applies to the template-id. */
1521 switch (TREE_CODE (t
))
1524 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1525 result
= build_pointer_type (type
);
1527 case REFERENCE_TYPE
:
1528 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1529 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1532 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1533 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1534 result
= build_offset_type (t0
, type
);
1537 if (TYPE_PTRMEMFUNC_P (t
))
1539 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1540 remove_attributes
, flags
);
1541 result
= build_ptrmemfunc_type (t0
);
1545 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1546 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1547 result
= build_cplus_array_type (type
, t0
);
1552 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1555 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1556 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1557 can't expect that re-hashing a function type will find a previous
1558 equivalent type, so try to reuse the input type if nothing has
1559 changed. If the type is itself a variant, that will change. */
1560 bool is_variant
= typedef_variant_p (t
);
1561 if (remove_attributes
1562 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1565 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1566 tree canon_spec
= (flag_noexcept_type
1567 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1569 changed
= (type
!= TREE_TYPE (t
) || is_variant
1570 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1572 for (arg_node
= TYPE_ARG_TYPES (t
);
1574 arg_node
= TREE_CHAIN (arg_node
))
1576 if (arg_node
== void_list_node
)
1578 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1579 remove_attributes
, flags
);
1580 gcc_assert (arg_type
);
1581 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1587 for (arg_node2
= TYPE_ARG_TYPES (t
);
1588 arg_node2
!= arg_node
;
1589 arg_node2
= TREE_CHAIN (arg_node2
))
1591 = tree_cons (TREE_PURPOSE (arg_node2
),
1592 TREE_VALUE (arg_node2
), arg_types
);
1596 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1603 arg_types
= nreverse (arg_types
);
1605 /* A list of parameters not ending with an ellipsis
1606 must end with void_list_node. */
1608 arg_types
= chainon (arg_types
, void_list_node
);
1610 if (TREE_CODE (t
) == METHOD_TYPE
)
1612 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1613 gcc_assert (class_type
);
1615 build_method_type_directly (class_type
, type
,
1616 TREE_CHAIN (arg_types
));
1620 result
= build_function_type (type
, arg_types
);
1621 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1624 result
= build_cp_fntype_variant (result
,
1625 type_memfn_rqual (t
), canon_spec
,
1626 TYPE_HAS_LATE_RETURN_TYPE (t
));
1631 bool changed
= false;
1632 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1633 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1634 && TREE_OPERAND (fullname
, 1))
1636 tree args
= TREE_OPERAND (fullname
, 1);
1637 tree new_args
= copy_node (args
);
1638 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1640 tree arg
= TREE_VEC_ELT (args
, i
);
1643 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1645 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1647 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1648 if (strip_arg
!= arg
)
1653 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1654 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1656 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1660 ggc_free (new_args
);
1662 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1663 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1665 tree name
= fullname
;
1666 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1667 name
= TREE_OPERAND (fullname
, 0);
1668 /* Use build_typename_type rather than make_typename_type because we
1669 don't want to resolve it here, just strip typedefs. */
1670 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1674 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1675 remove_attributes
, flags
);
1676 if (result
== DECLTYPE_TYPE_EXPR (t
))
1679 result
= (finish_decltype_type
1681 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1684 case UNDERLYING_TYPE
:
1685 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1686 remove_attributes
, flags
);
1687 result
= finish_underlying_type (type
);
1695 if (typedef_variant_p (t
))
1697 if ((flags
& STF_USER_VISIBLE
)
1698 && !user_facing_original_type_p (t
))
1700 /* If T is a non-template alias or typedef, we can assume that
1701 instantiating its definition will hit any substitution failure,
1702 so we don't need to retain it here as well. */
1703 if (!alias_template_specialization_p (t
, nt_opaque
))
1704 flags
|= STF_STRIP_DEPENDENT
;
1705 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1706 remove_attributes
, flags
);
1709 result
= TYPE_MAIN_VARIANT (t
);
1711 /*gcc_assert (!typedef_variant_p (result)
1712 || dependent_alias_template_spec_p (result, nt_opaque)
1713 || ((flags & STF_USER_VISIBLE)
1714 && !user_facing_original_type_p (result)));*/
1716 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1717 /* If RESULT is complete and T isn't, it's likely the case that T
1718 is a variant of RESULT which hasn't been updated yet. Skip the
1719 attribute handling. */;
1722 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1723 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1725 gcc_assert (TYPE_USER_ALIGN (t
));
1726 if (remove_attributes
)
1727 *remove_attributes
= true;
1730 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1731 result
= build_variant_type_copy (result
);
1733 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1734 TYPE_USER_ALIGN (result
) = true;
1738 if (TYPE_ATTRIBUTES (t
))
1740 if (remove_attributes
)
1741 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1744 result
= cp_build_type_attribute_variant (result
,
1745 TYPE_ATTRIBUTES (t
));
1749 return cp_build_qualified_type (result
, cp_type_quals (t
));
1752 /* Like strip_typedefs above, but works on expressions, so that in
1754 template<class T> struct A
1760 sizeof(TT) is replaced by sizeof(T). */
1763 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1767 enum tree_code code
;
1769 if (t
== NULL_TREE
|| t
== error_mark_node
)
1772 STRIP_ANY_LOCATION_WRAPPER (t
);
1774 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1777 /* Some expressions have type operands, so let's handle types here rather
1778 than check TYPE_P in multiple places below. */
1780 return strip_typedefs (t
, remove_attributes
, flags
);
1782 code
= TREE_CODE (t
);
1785 case IDENTIFIER_NODE
:
1786 case TEMPLATE_PARM_INDEX
:
1789 case ARGUMENT_PACK_SELECT
:
1794 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1795 remove_attributes
, flags
);
1796 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1797 remove_attributes
, flags
);
1798 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1799 && type2
== TRAIT_EXPR_TYPE2 (t
))
1802 TRAIT_EXPR_TYPE1 (r
) = type1
;
1803 TRAIT_EXPR_TYPE2 (r
) = type2
;
1810 bool changed
= false;
1812 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1814 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1815 remove_attributes
, flags
);
1816 vec_safe_push (vec
, val
);
1817 if (val
!= TREE_VALUE (it
))
1819 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1824 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1825 r
= tree_cons (NULL_TREE
, it
, r
);
1834 bool changed
= false;
1836 n
= TREE_VEC_LENGTH (t
);
1837 vec_safe_reserve (vec
, n
);
1838 for (i
= 0; i
< n
; ++i
)
1840 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1841 remove_attributes
, flags
);
1842 vec
->quick_push (op
);
1843 if (op
!= TREE_VEC_ELT (t
, i
))
1849 for (i
= 0; i
< n
; ++i
)
1850 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1851 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1852 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1861 bool changed
= false;
1862 vec
<constructor_elt
, va_gc
> *vec
1863 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1864 n
= CONSTRUCTOR_NELTS (t
);
1865 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1866 for (i
= 0; i
< n
; ++i
)
1868 constructor_elt
*e
= &(*vec
)[i
];
1869 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1876 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1880 if (!changed
&& type
== TREE_TYPE (t
))
1888 TREE_TYPE (r
) = type
;
1889 CONSTRUCTOR_ELTS (r
) = vec
;
1897 case STATEMENT_LIST
:
1898 error ("statement-expression in a constant expression");
1899 return error_mark_node
;
1905 gcc_assert (EXPR_P (t
));
1907 n
= cp_tree_operand_length (t
);
1908 ops
= XALLOCAVEC (tree
, n
);
1909 type
= TREE_TYPE (t
);
1914 case IMPLICIT_CONV_EXPR
:
1915 case DYNAMIC_CAST_EXPR
:
1916 case STATIC_CAST_EXPR
:
1917 case CONST_CAST_EXPR
:
1918 case REINTERPRET_CAST_EXPR
:
1921 type
= strip_typedefs (type
, remove_attributes
, flags
);
1925 for (i
= 0; i
< n
; ++i
)
1926 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1927 remove_attributes
, flags
);
1931 /* If nothing changed, return t. */
1932 for (i
= 0; i
< n
; ++i
)
1933 if (ops
[i
] != TREE_OPERAND (t
, i
))
1935 if (i
== n
&& type
== TREE_TYPE (t
))
1939 TREE_TYPE (r
) = type
;
1940 for (i
= 0; i
< n
; ++i
)
1941 TREE_OPERAND (r
, i
) = ops
[i
];
1945 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1946 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1947 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1948 VIRT indicates whether TYPE is inherited virtually or not.
1949 IGO_PREV points at the previous binfo of the inheritance graph
1950 order chain. The newly copied binfo's TREE_CHAIN forms this
1953 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1954 correct order. That is in the order the bases themselves should be
1957 The BINFO_INHERITANCE of a virtual base class points to the binfo
1958 of the most derived type. ??? We could probably change this so that
1959 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1960 remove a field. They currently can only differ for primary virtual
1964 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1970 /* See if we've already made this virtual base. */
1971 new_binfo
= binfo_for_vbase (type
, t
);
1976 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1977 BINFO_TYPE (new_binfo
) = type
;
1979 /* Chain it into the inheritance graph. */
1980 TREE_CHAIN (*igo_prev
) = new_binfo
;
1981 *igo_prev
= new_binfo
;
1983 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1988 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1990 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1991 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1993 /* We do not need to copy the accesses, as they are read only. */
1994 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1996 /* Recursively copy base binfos of BINFO. */
1997 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1999 tree new_base_binfo
;
2000 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2002 BINFO_VIRTUAL_P (base_binfo
));
2004 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2005 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2006 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2010 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2014 /* Push it onto the list after any virtual bases it contains
2015 will have been pushed. */
2016 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2017 BINFO_VIRTUAL_P (new_binfo
) = 1;
2018 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2024 /* Hashing of lists so that we don't make duplicates.
2025 The entry point is `list_hash_canon'. */
2034 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2036 typedef list_proxy
*compare_type
;
2038 static hashval_t
hash (tree
);
2039 static bool equal (tree
, list_proxy
*);
2042 /* Now here is the hash table. When recording a list, it is added
2043 to the slot whose index is the hash code mod the table size.
2044 Note that the hash table is used for several kinds of lists.
2045 While all these live in the same table, they are completely independent,
2046 and the hash code is computed differently for each of these. */
2048 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2050 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2051 for a node we are thinking about adding). */
2054 list_hasher::equal (tree t
, list_proxy
*proxy
)
2056 return (TREE_VALUE (t
) == proxy
->value
2057 && TREE_PURPOSE (t
) == proxy
->purpose
2058 && TREE_CHAIN (t
) == proxy
->chain
);
2061 /* Compute a hash code for a list (chain of TREE_LIST nodes
2062 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2063 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2066 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2068 hashval_t hashcode
= 0;
2071 hashcode
+= TREE_HASH (chain
);
2074 hashcode
+= TREE_HASH (value
);
2078 hashcode
+= TREE_HASH (purpose
);
2084 /* Hash an already existing TREE_LIST. */
2087 list_hasher::hash (tree t
)
2089 return list_hash_pieces (TREE_PURPOSE (t
),
2094 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2095 object for an identical list if one already exists. Otherwise, build a
2096 new one, and record it as the canonical object. */
2099 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2103 struct list_proxy proxy
;
2105 /* Hash the list node. */
2106 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2107 /* Create a proxy for the TREE_LIST we would like to create. We
2108 don't actually create it so as to avoid creating garbage. */
2109 proxy
.purpose
= purpose
;
2110 proxy
.value
= value
;
2111 proxy
.chain
= chain
;
2112 /* See if it is already in the table. */
2113 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2114 /* If not, create a new node. */
2116 *slot
= tree_cons (purpose
, value
, chain
);
2117 return (tree
) *slot
;
2120 /* Constructor for hashed lists. */
2123 hash_tree_chain (tree value
, tree chain
)
2125 return hash_tree_cons (NULL_TREE
, value
, chain
);
2129 debug_binfo (tree elem
)
2134 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2136 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2137 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2138 debug_tree (BINFO_TYPE (elem
));
2139 if (BINFO_VTABLE (elem
))
2140 fprintf (stderr
, "vtable decl \"%s\"\n",
2141 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2143 fprintf (stderr
, "no vtable decl yet\n");
2144 fprintf (stderr
, "virtuals:\n");
2145 virtuals
= BINFO_VIRTUALS (elem
);
2150 tree fndecl
= TREE_VALUE (virtuals
);
2151 fprintf (stderr
, "%s [%ld =? %ld]\n",
2152 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2153 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2155 virtuals
= TREE_CHAIN (virtuals
);
2159 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2160 the type of the result expression, if known, or NULL_TREE if the
2161 resulting expression is type-dependent. If TEMPLATE_P is true,
2162 NAME is known to be a template because the user explicitly used the
2163 "template" keyword after the "::".
2165 All SCOPE_REFs should be built by use of this function. */
2168 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2171 if (type
== error_mark_node
2172 || scope
== error_mark_node
2173 || name
== error_mark_node
)
2174 return error_mark_node
;
2175 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2176 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2177 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2178 PTRMEM_OK_P (t
) = true;
2180 t
= convert_from_reference (t
);
2184 /* Like check_qualified_type, but also check ref-qualifier, exception
2185 specification, and whether the return type was specified after the
2189 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2190 cp_ref_qualifier rqual
, tree raises
, bool late
)
2192 return (TYPE_QUALS (cand
) == type_quals
2193 && check_base_type (cand
, base
)
2194 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2196 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2197 && type_memfn_rqual (cand
) == rqual
);
2200 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2203 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2205 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2206 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2207 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2210 /* Make a raw overload node containing FN. */
2213 ovl_make (tree fn
, tree next
)
2215 tree result
= make_node (OVERLOAD
);
2217 if (TREE_CODE (fn
) == OVERLOAD
)
2218 OVL_NESTED_P (result
) = true;
2220 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2221 ? unknown_type_node
: TREE_TYPE (fn
));
2222 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2223 OVL_DEDUP_P (result
) = true;
2224 OVL_FUNCTION (result
) = fn
;
2225 OVL_CHAIN (result
) = next
;
2229 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2230 true, if FN is via a using declaration. We also pay attention to
2231 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2235 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2237 tree result
= maybe_ovl
;
2238 tree insert_after
= NULL_TREE
;
2241 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2242 && OVL_HIDDEN_P (maybe_ovl
);
2243 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2245 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2246 insert_after
= maybe_ovl
;
2249 bool hidden_p
= DECL_HIDDEN_P (fn
);
2250 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2252 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2254 OVL_HIDDEN_P (maybe_ovl
) = true;
2256 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2263 OVL_CHAIN (insert_after
) = maybe_ovl
;
2264 TREE_TYPE (insert_after
) = unknown_type_node
;
2272 /* Skip any hidden names at the beginning of OVL. */
2275 ovl_skip_hidden (tree ovl
)
2278 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2279 ovl
= OVL_CHAIN (ovl
))
2280 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2282 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2284 /* Any hidden functions should have been wrapped in an
2285 overload, but injected friend classes will not. */
2286 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2293 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2296 ovl_iterator::reveal_node (tree overload
, tree node
)
2298 /* We cannot have returned NODE as part of a lookup overload, so we
2299 don't have to worry about preserving that. */
2301 OVL_HIDDEN_P (node
) = false;
2302 if (tree chain
= OVL_CHAIN (node
))
2303 if (TREE_CODE (chain
) == OVERLOAD
)
2305 if (OVL_HIDDEN_P (chain
))
2307 /* The node needs moving, and the simplest way is to remove it
2309 overload
= remove_node (overload
, node
);
2310 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2312 else if (OVL_DEDUP_P (chain
))
2313 OVL_DEDUP_P (node
) = true;
2318 /* NODE is on the overloads of OVL. Remove it.
2319 The removed node is unaltered and may continue to be iterated
2320 from (i.e. it is safe to remove a node from an overload one is
2321 currently iterating over). */
2324 ovl_iterator::remove_node (tree overload
, tree node
)
2326 tree
*slot
= &overload
;
2327 while (*slot
!= node
)
2330 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2332 slot
= &OVL_CHAIN (probe
);
2335 /* Stitch out NODE. We don't have to worry about now making a
2336 singleton overload (and consequently maybe setting its type),
2337 because all uses of this function will be followed by inserting a
2338 new node that must follow the place we've cut this out from. */
2339 if (TREE_CODE (node
) != OVERLOAD
)
2340 /* Cloned inherited ctors don't mark themselves as via_using. */
2343 *slot
= OVL_CHAIN (node
);
2348 /* Mark or unmark a lookup set. */
2351 lookup_mark (tree ovl
, bool val
)
2353 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2355 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2356 LOOKUP_SEEN_P (*iter
) = val
;
2360 /* Add a set of new FNS into a lookup. */
2363 lookup_add (tree fns
, tree lookup
)
2365 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2366 return error_mark_node
;
2368 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2370 lookup
= ovl_make (fns
, lookup
);
2371 OVL_LOOKUP_P (lookup
) = true;
2379 /* FNS is a new overload set, add them to LOOKUP, if they are not
2380 already present there. */
2383 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2386 for (tree next
, probe
= fns
; probe
; probe
= next
)
2391 if (TREE_CODE (probe
) == OVERLOAD
)
2393 fn
= OVL_FUNCTION (probe
);
2394 next
= OVL_CHAIN (probe
);
2397 if (!LOOKUP_SEEN_P (fn
))
2398 LOOKUP_SEEN_P (fn
) = true;
2401 /* This function was already seen. Insert all the
2402 predecessors onto the lookup. */
2403 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2405 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2406 /* Propagate OVL_USING, but OVL_HIDDEN &
2407 OVL_DEDUP_P don't matter. */
2408 if (OVL_USING_P (fns
))
2409 OVL_USING_P (lookup
) = true;
2412 /* And now skip this function. */
2418 /* We ended in a set of new functions. Add them all in one go. */
2419 lookup
= lookup_add (fns
, lookup
);
2424 /* Returns nonzero if X is an expression for a (possibly overloaded)
2425 function. If "f" is a function or function template, "f", "c->f",
2426 "c.f", "C::f", and "f<int>" will all be considered possibly
2427 overloaded functions. Returns 2 if the function is actually
2428 overloaded, i.e., if it is impossible to know the type of the
2429 function without performing overload resolution. */
2432 is_overloaded_fn (tree x
)
2434 STRIP_ANY_LOCATION_WRAPPER (x
);
2436 /* A baselink is also considered an overloaded function. */
2437 if (TREE_CODE (x
) == OFFSET_REF
2438 || TREE_CODE (x
) == COMPONENT_REF
)
2439 x
= TREE_OPERAND (x
, 1);
2440 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2441 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2442 x
= TREE_OPERAND (x
, 0);
2444 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2445 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2451 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2452 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2456 dependent_name (tree x
)
2458 if (identifier_p (x
))
2460 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2461 x
= TREE_OPERAND (x
, 0);
2463 return OVL_NAME (x
);
2467 /* Returns true iff X is an expression for an overloaded function
2468 whose type cannot be known without performing overload
2472 really_overloaded_fn (tree x
)
2474 return is_overloaded_fn (x
) == 2;
2477 /* Get the overload set FROM refers to. Returns NULL if it's not an
2481 maybe_get_fns (tree from
)
2483 STRIP_ANY_LOCATION_WRAPPER (from
);
2485 /* A baselink is also considered an overloaded function. */
2486 if (TREE_CODE (from
) == OFFSET_REF
2487 || TREE_CODE (from
) == COMPONENT_REF
)
2488 from
= TREE_OPERAND (from
, 1);
2489 if (BASELINK_P (from
))
2490 from
= BASELINK_FUNCTIONS (from
);
2491 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2492 from
= TREE_OPERAND (from
, 0);
2500 /* FROM refers to an overload set. Return that set (or die). */
2505 tree res
= maybe_get_fns (from
);
2511 /* Return the first function of the overload set FROM refers to. */
2514 get_first_fn (tree from
)
2516 return OVL_FIRST (get_fns (from
));
2519 /* Return the scope where the overloaded functions OVL were found. */
2522 ovl_scope (tree ovl
)
2524 if (TREE_CODE (ovl
) == OFFSET_REF
2525 || TREE_CODE (ovl
) == COMPONENT_REF
)
2526 ovl
= TREE_OPERAND (ovl
, 1);
2527 if (TREE_CODE (ovl
) == BASELINK
)
2528 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2529 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2530 ovl
= TREE_OPERAND (ovl
, 0);
2531 /* Skip using-declarations. */
2532 lkp_iterator
iter (ovl
);
2535 while (iter
.using_p () && ++iter
);
2537 return CP_DECL_CONTEXT (ovl
);
2540 #define PRINT_RING_SIZE 4
2543 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2545 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2546 static char *print_ring
[PRINT_RING_SIZE
];
2547 static bool trans_ring
[PRINT_RING_SIZE
];
2548 static int ring_counter
;
2551 /* Only cache functions. */
2553 || TREE_CODE (decl
) != FUNCTION_DECL
2554 || DECL_LANG_SPECIFIC (decl
) == 0)
2555 return lang_decl_name (decl
, v
, translate
);
2557 /* See if this print name is lying around. */
2558 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2559 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2560 /* yes, so return it. */
2561 return print_ring
[i
];
2563 if (++ring_counter
== PRINT_RING_SIZE
)
2566 if (current_function_decl
!= NULL_TREE
)
2568 /* There may be both translated and untranslated versions of the
2570 for (i
= 0; i
< 2; i
++)
2572 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2574 if (ring_counter
== PRINT_RING_SIZE
)
2577 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2580 free (print_ring
[ring_counter
]);
2582 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2583 uid_ring
[ring_counter
] = DECL_UID (decl
);
2584 trans_ring
[ring_counter
] = translate
;
2585 return print_ring
[ring_counter
];
2589 cxx_printable_name (tree decl
, int v
)
2591 return cxx_printable_name_internal (decl
, v
, false);
2595 cxx_printable_name_translate (tree decl
, int v
)
2597 return cxx_printable_name_internal (decl
, v
, true);
2600 /* Return the canonical version of exception-specification RAISES for a C++17
2601 function type, for use in type comparison and building TYPE_CANONICAL. */
2604 canonical_eh_spec (tree raises
)
2606 if (raises
== NULL_TREE
)
2608 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2609 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2610 || uses_template_parms (raises
)
2611 || uses_template_parms (TREE_PURPOSE (raises
)))
2612 /* Keep a dependent or deferred exception specification. */
2614 else if (nothrow_spec_p (raises
))
2615 /* throw() -> noexcept. */
2616 return noexcept_true_spec
;
2618 /* For C++17 type matching, anything else -> nothing. */
2623 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2624 tree raises
, bool late
)
2626 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2628 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2631 tree v
= TYPE_MAIN_VARIANT (type
);
2632 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2633 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2636 /* Need to build a new variant. */
2637 v
= build_variant_type_copy (type
);
2638 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2639 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2642 case REF_QUAL_RVALUE
:
2643 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2644 FUNCTION_REF_QUALIFIED (v
) = 1;
2646 case REF_QUAL_LVALUE
:
2647 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2648 FUNCTION_REF_QUALIFIED (v
) = 1;
2651 FUNCTION_REF_QUALIFIED (v
) = 0;
2655 /* Canonicalize the exception specification. */
2656 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2658 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2659 /* Propagate structural equality. */
2660 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2661 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2662 /* Build the underlying canonical type, since it is different
2664 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2667 /* T is its own canonical type. */
2668 TYPE_CANONICAL (v
) = v
;
2673 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2674 listed in RAISES. */
2677 build_exception_variant (tree type
, tree raises
)
2679 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2680 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2681 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2684 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2685 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2689 bind_template_template_parm (tree t
, tree newargs
)
2691 tree decl
= TYPE_NAME (t
);
2694 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2695 decl
= build_decl (input_location
,
2696 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2698 /* These nodes have to be created to reflect new TYPE_DECL and template
2700 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2701 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2702 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2703 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2705 TREE_TYPE (decl
) = t2
;
2706 TYPE_NAME (t2
) = decl
;
2707 TYPE_STUB_DECL (t2
) = decl
;
2709 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2714 /* Called from count_trees via walk_tree. */
2717 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2727 /* Debugging function for measuring the rough complexity of a tree
2731 count_trees (tree t
)
2734 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2738 /* Called from verify_stmt_tree via walk_tree. */
2741 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2744 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2745 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2748 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2751 /* If this statement is already present in the hash table, then
2752 there is a circularity in the statement tree. */
2753 gcc_assert (!statements
->find (t
));
2755 slot
= statements
->find_slot (t
, INSERT
);
2761 /* Debugging function to check that the statement T has not been
2762 corrupted. For now, this function simply checks that T contains no
2766 verify_stmt_tree (tree t
)
2768 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2769 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2772 /* Check if the type T depends on a type with no linkage and if so, return
2773 it. If RELAXED_P then do not consider a class type declared within
2774 a vague-linkage function to have no linkage. */
2777 no_linkage_check (tree t
, bool relaxed_p
)
2781 /* Lambda types that don't have mangling scope have no linkage. We
2782 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2783 when we get here from pushtag none of the lambda information is
2784 set up yet, so we want to assume that the lambda has linkage and
2785 fix it up later if not. We need to check this even in templates so
2786 that we properly handle a lambda-expression in the signature. */
2787 if (LAMBDA_TYPE_P (t
)
2788 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2789 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2792 /* Otherwise there's no point in checking linkage on template functions; we
2793 can't know their complete types. */
2794 if (processing_template_decl
)
2797 switch (TREE_CODE (t
))
2800 if (TYPE_PTRMEMFUNC_P (t
))
2804 if (!CLASS_TYPE_P (t
))
2808 /* Only treat unnamed types as having no linkage if they're at
2809 namespace scope. This is core issue 966. */
2810 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2813 for (r
= CP_TYPE_CONTEXT (t
); ; )
2815 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2816 have linkage, or we might just be in an anonymous namespace.
2817 If we're in a TREE_PUBLIC class, we have linkage. */
2818 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2819 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2820 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2822 if (!relaxed_p
|| !vague_linkage_p (r
))
2825 r
= CP_DECL_CONTEXT (r
);
2835 case REFERENCE_TYPE
:
2837 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2841 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2845 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2850 tree parm
= TYPE_ARG_TYPES (t
);
2851 if (TREE_CODE (t
) == METHOD_TYPE
)
2852 /* The 'this' pointer isn't interesting; a method has the same
2853 linkage (or lack thereof) as its enclosing class. */
2854 parm
= TREE_CHAIN (parm
);
2856 parm
&& parm
!= void_list_node
;
2857 parm
= TREE_CHAIN (parm
))
2859 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2863 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2871 extern int depth_reached
;
2874 cxx_print_statistics (void)
2876 print_template_statistics ();
2877 if (GATHER_STATISTICS
)
2878 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2882 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2883 (which is an ARRAY_TYPE). This counts only elements of the top
2887 array_type_nelts_top (tree type
)
2889 return fold_build2_loc (input_location
,
2890 PLUS_EXPR
, sizetype
,
2891 array_type_nelts (type
),
2895 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2896 (which is an ARRAY_TYPE). This one is a recursive count of all
2897 ARRAY_TYPEs that are clumped together. */
2900 array_type_nelts_total (tree type
)
2902 tree sz
= array_type_nelts_top (type
);
2903 type
= TREE_TYPE (type
);
2904 while (TREE_CODE (type
) == ARRAY_TYPE
)
2906 tree n
= array_type_nelts_top (type
);
2907 sz
= fold_build2_loc (input_location
,
2908 MULT_EXPR
, sizetype
, sz
, n
);
2909 type
= TREE_TYPE (type
);
2916 splay_tree target_remap
;
2917 bool clear_location
;
2920 /* Called from break_out_target_exprs via mapcar. */
2923 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2925 bot_data
&data
= *(bot_data
*)data_
;
2926 splay_tree target_remap
= data
.target_remap
;
2929 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2931 /* There can't be any TARGET_EXPRs or their slot variables below this
2932 point. But we must make a copy, in case subsequent processing
2933 alters any part of it. For example, during gimplification a cast
2934 of the form (T) &X::f (where "f" is a member function) will lead
2935 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2937 *tp
= unshare_expr (t
);
2940 if (TREE_CODE (t
) == TARGET_EXPR
)
2944 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2946 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2947 tf_warning_or_error
);
2948 if (u
== error_mark_node
)
2950 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2951 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2954 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2955 tf_warning_or_error
);
2957 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2958 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2959 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2961 /* Map the old variable to the new one. */
2962 splay_tree_insert (target_remap
,
2963 (splay_tree_key
) TREE_OPERAND (t
, 0),
2964 (splay_tree_value
) TREE_OPERAND (u
, 0));
2966 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2967 data
.clear_location
);
2968 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2969 return error_mark_node
;
2971 /* Replace the old expression with the new version. */
2973 /* We don't have to go below this point; the recursive call to
2974 break_out_target_exprs will have handled anything below this
2979 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2982 splay_tree_node n
= splay_tree_lookup (target_remap
,
2983 (splay_tree_key
) t
);
2986 *tp
= (tree
)n
->value
;
2991 copy_tree_r (tp
, walk_subtrees
, NULL
);
2992 splay_tree_insert (target_remap
,
2994 (splay_tree_value
)*tp
);
2995 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2996 splay_tree_insert (target_remap
,
2997 (splay_tree_key
)*tp
,
2998 (splay_tree_value
)*tp
);
3003 /* Make a copy of this node. */
3004 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3005 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3006 if (!processing_template_decl
)
3007 set_flags_from_callee (*tp
);
3008 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3009 SET_EXPR_LOCATION (*tp
, input_location
);
3013 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3014 DATA is really a splay-tree mapping old variables to new
3018 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3020 bot_data
&data
= *(bot_data
*)data_
;
3021 splay_tree target_remap
= data
.target_remap
;
3025 splay_tree_node n
= splay_tree_lookup (target_remap
,
3026 (splay_tree_key
) *t
);
3028 *t
= (tree
) n
->value
;
3030 else if (TREE_CODE (*t
) == PARM_DECL
3031 && DECL_NAME (*t
) == this_identifier
3032 && !DECL_CONTEXT (*t
))
3034 /* In an NSDMI we need to replace the 'this' parameter we used for
3035 parsing with the real one for this function. */
3036 *t
= current_class_ptr
;
3038 else if (TREE_CODE (*t
) == CONVERT_EXPR
3039 && CONVERT_EXPR_VBASE_PATH (*t
))
3041 /* In an NSDMI build_base_path defers building conversions to virtual
3042 bases, and we handle it here. */
3043 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3044 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3046 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3047 if (BINFO_TYPE (binfo
) == basetype
)
3049 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3050 tf_warning_or_error
);
3056 /* When we parse a default argument expression, we may create
3057 temporary variables via TARGET_EXPRs. When we actually use the
3058 default-argument expression, we make a copy of the expression
3059 and replace the temporaries with appropriate local versions.
3061 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3065 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3067 static int target_remap_count
;
3068 static splay_tree target_remap
;
3070 if (!target_remap_count
++)
3071 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3072 /*splay_tree_delete_key_fn=*/NULL
,
3073 /*splay_tree_delete_value_fn=*/NULL
);
3074 bot_data data
= { target_remap
, clear_location
};
3075 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3076 t
= error_mark_node
;
3077 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3079 if (!--target_remap_count
)
3081 splay_tree_delete (target_remap
);
3082 target_remap
= NULL
;
3088 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3089 which we expect to have type TYPE. */
3092 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3094 if (index
== NULL_TREE
)
3095 /* Can't refer to a particular member of a vector. */
3097 else if (TREE_CODE (index
) == INTEGER_CST
)
3098 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3100 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3101 /*reference*/false, tf_none
);
3104 tree objtype
= TREE_TYPE (obj
);
3105 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3107 /* When the destination object refers to a flexible array member
3108 verify that it matches the type of the source object except
3109 for its domain and qualifiers. */
3110 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3111 TYPE_MAIN_VARIANT (objtype
),
3112 COMPARE_REDECLARATION
));
3115 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3121 struct replace_placeholders_t
3123 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3124 tree exp
; /* The outermost exp. */
3125 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3126 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3129 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3130 build up subexpressions as we go deeper. */
3133 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3135 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3138 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3140 *walk_subtrees
= false;
3144 switch (TREE_CODE (*t
))
3146 case PLACEHOLDER_EXPR
:
3149 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3151 x
= TREE_OPERAND (x
, 0))
3152 gcc_assert (handled_component_p (x
));
3153 *t
= unshare_expr (x
);
3154 *walk_subtrees
= false;
3161 constructor_elt
*ce
;
3162 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3163 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3164 other than the d->exp one, those have PLACEHOLDER_EXPRs
3165 related to another object. */
3166 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3168 || d
->pset
->add (*t
))
3170 *walk_subtrees
= false;
3173 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3175 tree
*valp
= &ce
->value
;
3176 tree type
= TREE_TYPE (*valp
);
3179 /* Elements with RANGE_EXPR index shouldn't have any
3180 placeholders in them. */
3181 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3184 if (TREE_CODE (*valp
) == CONSTRUCTOR
3185 && AGGREGATE_TYPE_P (type
))
3187 /* If we're looking at the initializer for OBJ, then build
3188 a sub-object reference. If we're looking at an
3189 initializer for another object, just pass OBJ down. */
3190 if (same_type_ignoring_top_level_qualifiers_p
3191 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3192 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3193 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3194 valp
= &TARGET_EXPR_INITIAL (*valp
);
3197 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3200 *walk_subtrees
= false;
3205 if (d
->pset
->add (*t
))
3206 *walk_subtrees
= false;
3213 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3214 a PLACEHOLDER_EXPR has been encountered. */
3217 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3219 /* This is only relevant for C++14. */
3220 if (cxx_dialect
< cxx14
)
3223 /* If the object isn't a (member of a) class, do nothing. */
3225 while (TREE_CODE (op0
) == COMPONENT_REF
)
3226 op0
= TREE_OPERAND (op0
, 0);
3227 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3231 if (TREE_CODE (exp
) == TARGET_EXPR
)
3232 tp
= &TARGET_EXPR_INITIAL (exp
);
3233 hash_set
<tree
> pset
;
3234 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3235 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3237 *seen_p
= data
.seen
;
3241 /* Callback function for find_placeholders. */
3244 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3246 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3248 *walk_subtrees
= false;
3252 switch (TREE_CODE (*t
))
3254 case PLACEHOLDER_EXPR
:
3258 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3259 *walk_subtrees
= false;
3269 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3270 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3273 find_placeholders (tree exp
)
3275 /* This is only relevant for C++14. */
3276 if (cxx_dialect
< cxx14
)
3279 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3282 /* Similar to `build_nt', but for template definitions of dependent
3286 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3293 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3297 t
= make_node (code
);
3298 SET_EXPR_LOCATION (t
, loc
);
3299 length
= TREE_CODE_LENGTH (code
);
3301 for (i
= 0; i
< length
; i
++)
3302 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3308 /* Similar to `build', but for template definitions. */
3311 build_min (enum tree_code code
, tree tt
, ...)
3318 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3322 t
= make_node (code
);
3323 length
= TREE_CODE_LENGTH (code
);
3326 for (i
= 0; i
< length
; i
++)
3328 tree x
= va_arg (p
, tree
);
3329 TREE_OPERAND (t
, i
) = x
;
3330 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3331 TREE_SIDE_EFFECTS (t
) = 1;
3339 /* Similar to `build', but for template definitions of non-dependent
3340 expressions. NON_DEP is the non-dependent expression that has been
3344 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3351 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3353 va_start (p
, non_dep
);
3355 if (REFERENCE_REF_P (non_dep
))
3356 non_dep
= TREE_OPERAND (non_dep
, 0);
3358 t
= make_node (code
);
3359 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3360 length
= TREE_CODE_LENGTH (code
);
3361 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3362 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3364 for (i
= 0; i
< length
; i
++)
3365 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3367 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3368 /* This should not be considered a COMPOUND_EXPR, because it
3369 resolves to an overload. */
3370 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3373 return convert_from_reference (t
);
3376 /* Similar to build_min_nt, but call expressions */
3379 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3384 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3385 CALL_EXPR_FN (ret
) = fn
;
3386 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3387 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3388 CALL_EXPR_ARG (ret
, ix
) = t
;
3393 /* Similar to `build_min_nt_call_vec', but for template definitions of
3394 non-dependent expressions. NON_DEP is the non-dependent expression
3395 that has been built. */
3398 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3400 tree t
= build_min_nt_call_vec (fn
, argvec
);
3401 if (REFERENCE_REF_P (non_dep
))
3402 non_dep
= TREE_OPERAND (non_dep
, 0);
3403 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3404 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3405 return convert_from_reference (t
);
3408 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3409 a call to an operator overload. OP is the operator that has been
3410 overloaded. NON_DEP is the non-dependent expression that's been built,
3411 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3412 the overload that NON_DEP is calling. */
3415 build_min_non_dep_op_overload (enum tree_code op
,
3420 int nargs
, expected_nargs
;
3423 non_dep
= extract_call_expr (non_dep
);
3425 nargs
= call_expr_nargs (non_dep
);
3427 expected_nargs
= cp_tree_code_length (op
);
3428 if ((op
== POSTINCREMENT_EXPR
3429 || op
== POSTDECREMENT_EXPR
)
3430 /* With -fpermissive non_dep could be operator++(). */
3431 && (!flag_permissive
|| nargs
!= expected_nargs
))
3432 expected_nargs
+= 1;
3433 gcc_assert (nargs
== expected_nargs
);
3436 va_start (p
, overload
);
3438 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3441 for (int i
= 0; i
< nargs
; i
++)
3443 tree arg
= va_arg (p
, tree
);
3444 vec_safe_push (args
, arg
);
3447 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3449 tree object
= va_arg (p
, tree
);
3450 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3451 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3452 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3453 object
, method
, NULL_TREE
);
3454 for (int i
= 1; i
< nargs
; i
++)
3456 tree arg
= va_arg (p
, tree
);
3457 vec_safe_push (args
, arg
);
3464 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3466 tree call_expr
= extract_call_expr (call
);
3467 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3468 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3469 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3470 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3475 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3478 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3480 unsigned len
= vec_safe_length (old_vec
);
3481 gcc_assert (idx
<= len
);
3483 vec
<tree
, va_gc
> *new_vec
= NULL
;
3484 vec_alloc (new_vec
, len
+ 1);
3487 for (i
= 0; i
< len
; ++i
)
3490 new_vec
->quick_push (elt
);
3491 new_vec
->quick_push ((*old_vec
)[i
]);
3494 new_vec
->quick_push (elt
);
3500 get_type_decl (tree t
)
3502 if (TREE_CODE (t
) == TYPE_DECL
)
3505 return TYPE_STUB_DECL (t
);
3506 gcc_assert (t
== error_mark_node
);
3510 /* Returns the namespace that contains DECL, whether directly or
3514 decl_namespace_context (tree decl
)
3518 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3520 else if (TYPE_P (decl
))
3521 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3523 decl
= CP_DECL_CONTEXT (decl
);
3527 /* Returns true if decl is within an anonymous namespace, however deeply
3528 nested, or false otherwise. */
3531 decl_anon_ns_mem_p (const_tree decl
)
3533 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3535 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3537 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3539 decl
= CP_DECL_CONTEXT (decl
);
3541 return !TREE_PUBLIC (decl
);
3544 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3545 CALL_EXPRS. Return whether they are equivalent. */
3548 called_fns_equal (tree t1
, tree t2
)
3550 /* Core 1321: dependent names are equivalent even if the overload sets
3551 are different. But do compare explicit template arguments. */
3552 tree name1
= dependent_name (t1
);
3553 tree name2
= dependent_name (t2
);
3556 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3561 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3562 targs1
= TREE_OPERAND (t1
, 1);
3563 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3564 targs2
= TREE_OPERAND (t2
, 1);
3565 return cp_tree_equal (targs1
, targs2
);
3568 return cp_tree_equal (t1
, t2
);
3571 /* Return truthvalue of whether T1 is the same tree structure as T2.
3572 Return 1 if they are the same. Return 0 if they are different. */
3575 cp_tree_equal (tree t1
, tree t2
)
3577 enum tree_code code1
, code2
;
3584 code1
= TREE_CODE (t1
);
3585 code2
= TREE_CODE (t2
);
3590 if (CONSTANT_CLASS_P (t1
)
3591 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3597 /* There's only a single VOID_CST node, so we should never reach
3602 return tree_int_cst_equal (t1
, t2
);
3605 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3608 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3609 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3610 TREE_STRING_LENGTH (t1
));
3613 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3614 TREE_FIXED_CST (t2
));
3617 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3618 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3621 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3624 /* We need to do this when determining whether or not two
3625 non-type pointer to member function template arguments
3627 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3628 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3633 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3635 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3636 if (!cp_tree_equal (field
, elt2
->index
)
3637 || !cp_tree_equal (value
, elt2
->value
))
3644 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3646 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3648 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3651 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3656 call_expr_arg_iterator iter1
, iter2
;
3657 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3659 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3660 arg2
= first_call_expr_arg (t2
, &iter2
);
3662 arg1
= next_call_expr_arg (&iter1
),
3663 arg2
= next_call_expr_arg (&iter2
))
3664 if (!cp_tree_equal (arg1
, arg2
))
3673 tree o1
= TREE_OPERAND (t1
, 0);
3674 tree o2
= TREE_OPERAND (t2
, 0);
3676 /* Special case: if either target is an unallocated VAR_DECL,
3677 it means that it's going to be unified with whatever the
3678 TARGET_EXPR is really supposed to initialize, so treat it
3679 as being equivalent to anything. */
3680 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3681 && !DECL_RTL_SET_P (o1
))
3683 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3684 && !DECL_RTL_SET_P (o2
))
3686 else if (!cp_tree_equal (o1
, o2
))
3689 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3693 /* For comparing uses of parameters in late-specified return types
3694 with an out-of-class definition of the function, but can also come
3695 up for expressions that involve 'this' in a member function
3698 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3699 /* When comparing hash table entries, only an exact match is
3700 good enough; we don't want to replace 'this' with the
3701 version from another function. But be more flexible
3702 with local parameters in a requires-expression. */
3705 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3707 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3709 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3711 if (DECL_ARTIFICIAL (t1
)
3712 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3713 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3723 case IDENTIFIER_NODE
:
3726 case DEFERRED_PARSE
:
3730 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3731 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3732 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3733 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3734 BASELINK_FUNCTIONS (t2
)));
3736 case TEMPLATE_PARM_INDEX
:
3737 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3738 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3739 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3740 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3741 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3742 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3744 case TEMPLATE_ID_EXPR
:
3745 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3746 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3748 case CONSTRAINT_INFO
:
3749 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3750 CI_ASSOCIATED_CONSTRAINTS (t2
));
3753 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3754 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3755 CHECK_CONSTR_ARGS (t2
)));
3760 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3762 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3763 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3764 TREE_VEC_ELT (t2
, ix
)))
3772 tree o1
= TREE_OPERAND (t1
, 0);
3773 tree o2
= TREE_OPERAND (t2
, 0);
3775 if (code1
== SIZEOF_EXPR
)
3777 if (SIZEOF_EXPR_TYPE_P (t1
))
3778 o1
= TREE_TYPE (o1
);
3779 if (SIZEOF_EXPR_TYPE_P (t2
))
3780 o2
= TREE_TYPE (o2
);
3782 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3785 return same_type_p (o1
, o2
);
3787 return cp_tree_equal (o1
, o2
);
3792 tree t1_op1
, t2_op1
;
3794 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3797 t1_op1
= TREE_OPERAND (t1
, 1);
3798 t2_op1
= TREE_OPERAND (t2
, 1);
3799 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3802 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3806 /* Two pointer-to-members are the same if they point to the same
3807 field or function in the same class. */
3808 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3811 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3815 /* Two overloads. Must be exactly the same set of decls. */
3816 lkp_iterator
first (t1
);
3817 lkp_iterator
second (t2
);
3819 for (; first
&& second
; ++first
, ++second
)
3820 if (*first
!= *second
)
3822 return !(first
|| second
);
3826 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3828 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3829 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3832 case STATIC_CAST_EXPR
:
3833 case REINTERPRET_CAST_EXPR
:
3834 case CONST_CAST_EXPR
:
3835 case DYNAMIC_CAST_EXPR
:
3836 case IMPLICIT_CONV_EXPR
:
3839 case NON_LVALUE_EXPR
:
3840 case VIEW_CONVERT_EXPR
:
3841 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3843 /* Now compare operands as usual. */
3846 case DEFERRED_NOEXCEPT
:
3847 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3848 DEFERRED_NOEXCEPT_PATTERN (t2
))
3849 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3850 DEFERRED_NOEXCEPT_ARGS (t2
)));
3854 /* Two lambda-expressions are never considered equivalent. */
3861 switch (TREE_CODE_CLASS (code1
))
3865 case tcc_comparison
:
3866 case tcc_expression
:
3873 n
= cp_tree_operand_length (t1
);
3874 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3875 && n
!= TREE_OPERAND_LENGTH (t2
))
3878 for (i
= 0; i
< n
; ++i
)
3879 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3886 return same_type_p (t1
, t2
);
3890 /* We can get here with --disable-checking. */
3894 /* The type of ARG when used as an lvalue. */
3897 lvalue_type (tree arg
)
3899 tree type
= TREE_TYPE (arg
);
3903 /* The type of ARG for printing error messages; denote lvalues with
3907 error_type (tree arg
)
3909 tree type
= TREE_TYPE (arg
);
3911 if (TREE_CODE (type
) == ARRAY_TYPE
)
3913 else if (TREE_CODE (type
) == ERROR_MARK
)
3915 else if (lvalue_p (arg
))
3916 type
= build_reference_type (lvalue_type (arg
));
3917 else if (MAYBE_CLASS_TYPE_P (type
))
3918 type
= lvalue_type (arg
);
3923 /* Does FUNCTION use a variable-length argument list? */
3926 varargs_function_p (const_tree function
)
3928 return stdarg_p (TREE_TYPE (function
));
3931 /* Returns 1 if decl is a member of a class. */
3934 member_p (const_tree decl
)
3936 const_tree
const ctx
= DECL_CONTEXT (decl
);
3937 return (ctx
&& TYPE_P (ctx
));
3940 /* Create a placeholder for member access where we don't actually have an
3941 object that the access is against. */
3944 build_dummy_object (tree type
)
3946 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3947 return cp_build_fold_indirect_ref (decl
);
3950 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3951 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3952 binfo path from current_class_type to TYPE, or 0. */
3955 maybe_dummy_object (tree type
, tree
* binfop
)
3959 tree current
= current_nonlambda_class_type ();
3962 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3963 tf_warning_or_error
)))
3967 /* Reference from a nested class member function. */
3969 binfo
= TYPE_BINFO (type
);
3975 if (current_class_ref
3976 /* current_class_ref might not correspond to current_class_type if
3977 we're in tsubst_default_argument or a lambda-declarator; in either
3978 case, we want to use current_class_ref if it matches CONTEXT. */
3979 && (same_type_ignoring_top_level_qualifiers_p
3980 (TREE_TYPE (current_class_ref
), context
)))
3981 decl
= current_class_ref
;
3983 decl
= build_dummy_object (context
);
3988 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3991 is_dummy_object (const_tree ob
)
3993 if (INDIRECT_REF_P (ob
))
3994 ob
= TREE_OPERAND (ob
, 0);
3995 return (TREE_CODE (ob
) == CONVERT_EXPR
3996 && TREE_OPERAND (ob
, 0) == void_node
);
3999 /* Returns 1 iff type T is something we want to treat as a scalar type for
4000 the purpose of deciding whether it is trivial/POD/standard-layout. */
4003 scalarish_type_p (const_tree t
)
4005 if (t
== error_mark_node
)
4008 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4011 /* Returns true iff T requires non-trivial default initialization. */
4014 type_has_nontrivial_default_init (const_tree t
)
4016 t
= strip_array_types (CONST_CAST_TREE (t
));
4018 if (CLASS_TYPE_P (t
))
4019 return TYPE_HAS_COMPLEX_DFLT (t
);
4024 /* Track classes with only deleted copy/move constructors so that we can warn
4025 if they are used in call/return by value. */
4027 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4029 remember_deleted_copy (const_tree t
)
4031 if (!deleted_copy_types
)
4032 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4033 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4036 maybe_warn_parm_abi (tree t
, location_t loc
)
4038 if (!deleted_copy_types
4039 || !deleted_copy_types
->contains (t
))
4042 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4043 && classtype_has_non_deleted_move_ctor (t
))
4046 auto_diagnostic_group d
;
4047 if (flag_abi_version
> 12)
4048 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4049 "the calling convention for %qT, which was "
4050 "accidentally changed in 8.1", t
);
4052 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4053 "ally changes the calling convention for %qT", t
);
4055 inform (location_of (t
), " declared here");
4059 auto_diagnostic_group d
;
4060 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4061 "%<-fabi-version=13%> (GCC 8.2)", t
))
4062 inform (location_of (t
), " because all of its copy and move "
4063 "constructors are deleted");
4066 /* Returns true iff copying an object of type T (including via move
4067 constructor) is non-trivial. That is, T has no non-trivial copy
4068 constructors and no non-trivial move constructors, and not all copy/move
4069 constructors are deleted. This function implements the ABI notion of
4070 non-trivial copy, which has diverged from the one in the standard. */
4073 type_has_nontrivial_copy_init (const_tree type
)
4075 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4077 if (CLASS_TYPE_P (t
))
4079 gcc_assert (COMPLETE_TYPE_P (t
));
4081 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4082 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4086 if (cxx_dialect
< cxx11
)
4087 /* No deleted functions before C++11. */
4090 /* Before ABI v12 we did a bitwise copy of types with only deleted
4091 copy/move constructors. */
4092 if (!abi_version_at_least (12)
4093 && !(warn_abi
&& abi_version_crosses (12)))
4096 bool saw_copy
= false;
4097 bool saw_non_deleted
= false;
4098 bool saw_non_deleted_move
= false;
4100 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4101 saw_copy
= saw_non_deleted
= true;
4102 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4105 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4106 /* [class.copy]/8 If the class definition declares a move
4107 constructor or move assignment operator, the implicitly declared
4108 copy constructor is defined as deleted.... */;
4110 /* Any other reason the implicitly-declared function would be
4111 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4113 saw_non_deleted
= true;
4116 if (!saw_non_deleted
)
4117 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4123 if (!DECL_DELETED_FN (fn
))
4125 /* Not deleted, therefore trivial. */
4126 saw_non_deleted
= true;
4130 else if (move_fn_p (fn
))
4131 if (!DECL_DELETED_FN (fn
))
4132 saw_non_deleted_move
= true;
4135 gcc_assert (saw_copy
);
4137 /* ABI v12 buggily ignored move constructors. */
4138 bool v11nontriv
= false;
4139 bool v12nontriv
= !saw_non_deleted
;
4140 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4141 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4142 : flag_abi_version
== 12 ? v12nontriv
4144 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4145 : warn_abi_version
== 12 ? v12nontriv
4147 if (nontriv
!= warn_nontriv
)
4148 remember_deleted_copy (t
);
4156 /* Returns 1 iff type T is a trivially copyable type, as defined in
4157 [basic.types] and [class]. */
4160 trivially_copyable_p (const_tree t
)
4162 t
= strip_array_types (CONST_CAST_TREE (t
));
4164 if (CLASS_TYPE_P (t
))
4165 return ((!TYPE_HAS_COPY_CTOR (t
)
4166 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4167 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4168 && (!TYPE_HAS_COPY_ASSIGN (t
)
4169 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4170 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4171 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4173 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4174 return scalarish_type_p (t
);
4177 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4181 trivial_type_p (const_tree t
)
4183 t
= strip_array_types (CONST_CAST_TREE (t
));
4185 if (CLASS_TYPE_P (t
))
4186 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4187 && trivially_copyable_p (t
));
4189 return scalarish_type_p (t
);
4192 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4195 pod_type_p (const_tree t
)
4197 /* This CONST_CAST is okay because strip_array_types returns its
4198 argument unmodified and we assign it to a const_tree. */
4199 t
= strip_array_types (CONST_CAST_TREE(t
));
4201 if (!CLASS_TYPE_P (t
))
4202 return scalarish_type_p (t
);
4203 else if (cxx_dialect
> cxx98
)
4204 /* [class]/10: A POD struct is a class that is both a trivial class and a
4205 standard-layout class, and has no non-static data members of type
4206 non-POD struct, non-POD union (or array of such types).
4208 We don't need to check individual members because if a member is
4209 non-std-layout or non-trivial, the class will be too. */
4210 return (std_layout_type_p (t
) && trivial_type_p (t
));
4212 /* The C++98 definition of POD is different. */
4213 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4216 /* Returns true iff T is POD for the purpose of layout, as defined in the
4220 layout_pod_type_p (const_tree t
)
4222 t
= strip_array_types (CONST_CAST_TREE (t
));
4224 if (CLASS_TYPE_P (t
))
4225 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4227 return scalarish_type_p (t
);
4230 /* Returns true iff T is a standard-layout type, as defined in
4234 std_layout_type_p (const_tree t
)
4236 t
= strip_array_types (CONST_CAST_TREE (t
));
4238 if (CLASS_TYPE_P (t
))
4239 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4241 return scalarish_type_p (t
);
4244 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4246 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4247 as defined in [meta.unary.prop]. */
4250 type_has_unique_obj_representations (const_tree t
)
4254 t
= strip_array_types (CONST_CAST_TREE (t
));
4256 if (!trivially_copyable_p (t
))
4259 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4260 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4262 switch (TREE_CODE (t
))
4266 case REFERENCE_TYPE
:
4267 /* If some backend has any paddings in these types, we should add
4268 a target hook for this and handle it there. */
4272 /* For bool values other than 0 and 1 should only appear with
4273 undefined behavior. */
4277 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4280 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4281 when storing long double values, so for that we have to return false.
4282 Other kinds of floating point values are questionable due to +.0/-.0
4283 and NaNs, let's play safe for now. */
4286 case FIXED_POINT_TYPE
:
4294 return type_has_unique_obj_representations (TREE_TYPE (t
));
4297 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4298 if (CLASS_TYPE_P (t
))
4300 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4301 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4309 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4310 if (TREE_CODE (field
) == FIELD_DECL
)
4313 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4314 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4320 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4322 if (CLASS_TYPE_P (t
))
4324 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4325 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4340 /* Helper function for type_has_unique_obj_representations. */
4343 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4345 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4346 if (TREE_CODE (field
) != FIELD_DECL
)
4348 /* For bases, can't use type_has_unique_obj_representations here, as in
4349 struct S { int i : 24; S (); };
4350 struct T : public S { int j : 8; T (); };
4351 S doesn't have unique obj representations, but T does. */
4352 else if (DECL_FIELD_IS_BASE (field
))
4354 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4358 else if (DECL_C_BIT_FIELD (field
))
4360 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4361 if (!type_has_unique_obj_representations (btype
))
4364 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4368 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4369 if (TREE_CODE (field
) == FIELD_DECL
)
4371 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4372 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4373 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4376 if (DECL_SIZE (field
))
4378 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4382 if (cur
!= wi::to_offset (sz
))
4388 /* Nonzero iff type T is a class template implicit specialization. */
4391 class_tmpl_impl_spec_p (const_tree t
)
4393 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4396 /* Returns 1 iff zero initialization of type T means actually storing
4400 zero_init_p (const_tree t
)
4402 /* This CONST_CAST is okay because strip_array_types returns its
4403 argument unmodified and we assign it to a const_tree. */
4404 t
= strip_array_types (CONST_CAST_TREE(t
));
4406 if (t
== error_mark_node
)
4409 /* NULL pointers to data members are initialized with -1. */
4410 if (TYPE_PTRDATAMEM_P (t
))
4413 /* Classes that contain types that can't be zero-initialized, cannot
4414 be zero-initialized themselves. */
4415 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4421 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4422 non-type template parameter. If EXPLAIN, explain why not. */
4425 structural_type_p (tree t
, bool explain
)
4427 t
= strip_array_types (t
);
4428 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
4430 if (NULLPTR_TYPE_P (t
))
4432 if (TYPE_PTR_P (t
) || TYPE_PTRMEM_P (t
))
4434 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4436 if (!CLASS_TYPE_P (t
))
4438 if (TREE_CODE (t
) == UNION_TYPE
)
4441 inform (location_of (t
), "%qT is a union", t
);
4444 if (!literal_type_p (t
))
4447 explain_non_literal_class (t
);
4450 if (CLASSTYPE_HAS_MUTABLE (t
))
4453 inform (location_of (t
), "%qT has a mutable member", t
);
4456 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4457 m
= next_initializable_field (DECL_CHAIN (m
)))
4459 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4463 if (DECL_FIELD_IS_BASE (m
))
4464 inform (location_of (m
), "base class %qT is not public",
4467 inform (location_of (m
), "%qD is not public", m
);
4471 if (!structural_type_p (TREE_TYPE (m
)))
4475 inform (location_of (m
), "%qD has a non-structural type", m
);
4476 structural_type_p (TREE_TYPE (m
), true);
4484 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4485 warn_unused_result attribute. */
4488 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4489 int /*flags*/, bool *no_add_attrs
)
4491 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4493 error ("%qE attribute argument must be a string constant", name
);
4494 *no_add_attrs
= true;
4496 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4498 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4499 && !DECL_CONSTRUCTOR_P (*node
))
4500 warning_at (DECL_SOURCE_LOCATION (*node
),
4501 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4502 "return type", name
, *node
);
4504 else if (OVERLOAD_TYPE_P (*node
))
4508 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4509 "functions or to class or enumeration types", name
);
4510 *no_add_attrs
= true;
4515 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4516 struct attribute_spec.handler. */
4518 handle_no_unique_addr_attribute (tree
* node
,
4524 if (TREE_CODE (*node
) != FIELD_DECL
)
4526 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4527 "non-static data members", name
);
4528 *no_add_attrs
= true;
4530 else if (DECL_C_BIT_FIELD (*node
))
4532 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4533 "a bit-field", name
);
4534 *no_add_attrs
= true;
4540 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4541 hot/cold attributes. */
4544 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4545 int flags
, bool *no_add_attrs
)
4547 *no_add_attrs
= true;
4548 if (TREE_CODE (*node
) == LABEL_DECL
4549 || TREE_CODE (*node
) == FUNCTION_DECL
)
4552 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4553 tree bname
= (is_attribute_p ("likely", name
)
4554 ? get_identifier ("hot") : get_identifier ("cold"));
4555 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4556 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4557 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4558 tree battr
= build_tree_list (bname
, NULL_TREE
);
4559 decl_attributes (node
, battr
, flags
);
4563 return error_mark_node
;
4566 /* Table of valid C++ attributes. */
4567 const struct attribute_spec cxx_attribute_table
[] =
4569 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4570 affects_type_identity, handler, exclude } */
4571 { "init_priority", 1, 1, true, false, false, false,
4572 handle_init_priority_attribute
, NULL
},
4573 { "abi_tag", 1, -1, false, false, false, true,
4574 handle_abi_tag_attribute
, NULL
},
4575 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4578 /* Table of C++ standard attributes. */
4579 const struct attribute_spec std_attribute_table
[] =
4581 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4582 affects_type_identity, handler, exclude } */
4583 { "maybe_unused", 0, 0, false, false, false, false,
4584 handle_unused_attribute
, NULL
},
4585 { "nodiscard", 0, 1, false, false, false, false,
4586 handle_nodiscard_attribute
, NULL
},
4587 { "no_unique_address", 0, 0, true, false, false, false,
4588 handle_no_unique_addr_attribute
, NULL
},
4589 { "likely", 0, 0, false, false, false, false,
4590 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4591 { "unlikely", 0, 0, false, false, false, false,
4592 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4593 { "noreturn", 0, 0, true, false, false, false,
4594 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4595 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4598 /* Handle an "init_priority" attribute; arguments as in
4599 struct attribute_spec.handler. */
4601 handle_init_priority_attribute (tree
* node
,
4607 tree initp_expr
= TREE_VALUE (args
);
4609 tree type
= TREE_TYPE (decl
);
4612 STRIP_NOPS (initp_expr
);
4613 initp_expr
= default_conversion (initp_expr
);
4615 initp_expr
= maybe_constant_value (initp_expr
);
4617 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4619 error ("requested %<init_priority%> is not an integer constant");
4620 cxx_constant_value (initp_expr
);
4621 *no_add_attrs
= true;
4625 pri
= TREE_INT_CST_LOW (initp_expr
);
4627 type
= strip_array_types (type
);
4629 if (decl
== NULL_TREE
4631 || !TREE_STATIC (decl
)
4632 || DECL_EXTERNAL (decl
)
4633 || (TREE_CODE (type
) != RECORD_TYPE
4634 && TREE_CODE (type
) != UNION_TYPE
)
4635 /* Static objects in functions are initialized the
4636 first time control passes through that
4637 function. This is not precise enough to pin down an
4638 init_priority value, so don't allow it. */
4639 || current_function_decl
)
4641 error ("can only use %qE attribute on file-scope definitions "
4642 "of objects of class type", name
);
4643 *no_add_attrs
= true;
4647 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4649 error ("requested %<init_priority%> %i is out of range [0, %i]",
4650 pri
, MAX_INIT_PRIORITY
);
4651 *no_add_attrs
= true;
4655 /* Check for init_priorities that are reserved for
4656 language and runtime support implementations.*/
4657 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4660 (0, "requested %<init_priority%> %i is reserved for internal use",
4664 if (SUPPORTS_INIT_PRIORITY
)
4666 SET_DECL_INIT_PRIORITY (decl
, pri
);
4667 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4672 error ("%qE attribute is not supported on this platform", name
);
4673 *no_add_attrs
= true;
4678 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4679 and the new one has the tags in NEW_. Give an error if there are tags
4680 in NEW_ that weren't in OLD. */
4683 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4685 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4686 old
= TREE_VALUE (old
);
4687 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4688 new_
= TREE_VALUE (new_
);
4690 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4692 tree str
= TREE_VALUE (t
);
4693 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4695 tree ostr
= TREE_VALUE (in
);
4696 if (cp_tree_equal (str
, ostr
))
4699 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4705 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4711 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4712 ill-formed, give an error and return false; otherwise, return true. */
4715 check_abi_tag_args (tree args
, tree name
)
4719 error ("the %qE attribute requires arguments", name
);
4722 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4724 tree elt
= TREE_VALUE (arg
);
4725 if (TREE_CODE (elt
) != STRING_CST
4726 || (!same_type_ignoring_top_level_qualifiers_p
4727 (strip_array_types (TREE_TYPE (elt
)),
4730 error ("arguments to the %qE attribute must be narrow string "
4734 const char *begin
= TREE_STRING_POINTER (elt
);
4735 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4736 for (const char *p
= begin
; p
!= end
; ++p
)
4741 if (!ISALPHA (c
) && c
!= '_')
4743 error ("arguments to the %qE attribute must contain valid "
4744 "identifiers", name
);
4745 inform (input_location
, "%<%c%> is not a valid first "
4746 "character for an identifier", c
);
4750 else if (p
== end
- 1)
4751 gcc_assert (c
== 0);
4754 if (!ISALNUM (c
) && c
!= '_')
4756 error ("arguments to the %qE attribute must contain valid "
4757 "identifiers", name
);
4758 inform (input_location
, "%<%c%> is not a valid character "
4759 "in an identifier", c
);
4768 /* Handle an "abi_tag" attribute; arguments as in
4769 struct attribute_spec.handler. */
4772 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4773 int flags
, bool* no_add_attrs
)
4775 if (!check_abi_tag_args (args
, name
))
4780 if (!OVERLOAD_TYPE_P (*node
))
4782 error ("%qE attribute applied to non-class, non-enum type %qT",
4786 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4788 error ("%qE attribute applied to %qT after its definition",
4792 else if (CLASS_TYPE_P (*node
)
4793 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4795 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4796 "template instantiation %qT", name
, *node
);
4799 else if (CLASS_TYPE_P (*node
)
4800 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4802 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4803 "template specialization %qT", name
, *node
);
4807 tree attributes
= TYPE_ATTRIBUTES (*node
);
4808 tree decl
= TYPE_NAME (*node
);
4810 /* Make sure all declarations have the same abi tags. */
4811 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4813 if (!check_abi_tag_redeclaration (decl
,
4814 lookup_attribute ("abi_tag",
4822 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4824 error ("%qE attribute applied to non-function, non-variable %qD",
4828 else if (DECL_LANGUAGE (*node
) == lang_c
)
4830 error ("%qE attribute applied to extern \"C\" declaration %qD",
4839 *no_add_attrs
= true;
4843 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4844 thing pointed to by the constant. */
4847 make_ptrmem_cst (tree type
, tree member
)
4849 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4850 TREE_TYPE (ptrmem_cst
) = type
;
4851 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4855 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4856 return an existing type if an appropriate type already exists. */
4859 cp_build_type_attribute_variant (tree type
, tree attributes
)
4863 new_type
= build_type_attribute_variant (type
, attributes
);
4864 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4865 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4867 /* Making a new main variant of a class type is broken. */
4868 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4873 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4874 Called only after doing all language independent checks. */
4877 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4879 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4881 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4883 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4885 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4886 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4889 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4890 C++, these are the exception-specifier and ref-qualifier. */
4893 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4895 tree type
= CONST_CAST_TREE (typea
);
4896 if (FUNC_OR_METHOD_TYPE_P (type
))
4897 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4898 TYPE_RAISES_EXCEPTIONS (typeb
),
4899 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4903 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4904 traversal. Called from walk_tree. */
4907 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4908 void *data
, hash_set
<tree
> *pset
)
4910 enum tree_code code
= TREE_CODE (*tp
);
4913 #define WALK_SUBTREE(NODE) \
4916 result = cp_walk_tree (&(NODE), func, data, pset); \
4917 if (result) goto out; \
4921 /* Not one of the easy cases. We must explicitly go through the
4926 case DEFERRED_PARSE
:
4927 case TEMPLATE_TEMPLATE_PARM
:
4928 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4929 case UNBOUND_CLASS_TEMPLATE
:
4930 case TEMPLATE_PARM_INDEX
:
4931 case TEMPLATE_TYPE_PARM
:
4934 case UNDERLYING_TYPE
:
4935 /* None of these have subtrees other than those already walked
4937 *walk_subtrees_p
= 0;
4941 if (BASELINK_QUALIFIED_P (*tp
))
4942 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4943 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4944 *walk_subtrees_p
= 0;
4948 WALK_SUBTREE (TREE_TYPE (*tp
));
4949 *walk_subtrees_p
= 0;
4953 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4957 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4958 WALK_SUBTREE (OVL_CHAIN (*tp
));
4959 *walk_subtrees_p
= 0;
4963 WALK_SUBTREE (DECL_NAME (*tp
));
4964 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4965 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4966 *walk_subtrees_p
= 0;
4970 if (TYPE_PTRMEMFUNC_P (*tp
))
4971 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4974 case TYPE_ARGUMENT_PACK
:
4975 case NONTYPE_ARGUMENT_PACK
:
4977 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4978 int i
, len
= TREE_VEC_LENGTH (args
);
4979 for (i
= 0; i
< len
; i
++)
4980 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4984 case TYPE_PACK_EXPANSION
:
4985 WALK_SUBTREE (TREE_TYPE (*tp
));
4986 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4987 *walk_subtrees_p
= 0;
4990 case EXPR_PACK_EXPANSION
:
4991 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4992 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4993 *walk_subtrees_p
= 0;
4997 case REINTERPRET_CAST_EXPR
:
4998 case STATIC_CAST_EXPR
:
4999 case CONST_CAST_EXPR
:
5000 case DYNAMIC_CAST_EXPR
:
5001 case IMPLICIT_CONV_EXPR
:
5002 if (TREE_TYPE (*tp
))
5003 WALK_SUBTREE (TREE_TYPE (*tp
));
5007 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
5008 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
5010 *walk_subtrees_p
= 0;
5014 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5015 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5016 *walk_subtrees_p
= 0;
5020 ++cp_unevaluated_operand
;
5021 /* We can't use WALK_SUBTREE here because of the goto. */
5022 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5023 --cp_unevaluated_operand
;
5024 *walk_subtrees_p
= 0;
5030 ++cp_unevaluated_operand
;
5031 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5032 --cp_unevaluated_operand
;
5033 *walk_subtrees_p
= 0;
5037 // Only recurse through the nested expression. Do not
5038 // walk the parameter list. Doing so causes false
5039 // positives in the pack expansion checker since the
5040 // requires parameters are introduced as pack expansions.
5041 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5042 *walk_subtrees_p
= 0;
5046 /* User variables should be mentioned in BIND_EXPR_VARS
5047 and their initializers and sizes walked when walking
5048 the containing BIND_EXPR. Compiler temporaries are
5049 handled here. And also normal variables in templates,
5050 since do_poplevel doesn't build a BIND_EXPR then. */
5051 if (VAR_P (TREE_OPERAND (*tp
, 0))
5052 && (processing_template_decl
5053 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5054 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5056 tree decl
= TREE_OPERAND (*tp
, 0);
5057 WALK_SUBTREE (DECL_INITIAL (decl
));
5058 WALK_SUBTREE (DECL_SIZE (decl
));
5059 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5064 /* Don't walk into the body of the lambda, but the capture initializers
5065 are part of the enclosing context. */
5066 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5067 cap
= TREE_CHAIN (cap
))
5068 WALK_SUBTREE (TREE_VALUE (cap
));
5075 /* We didn't find what we were looking for. */
5082 /* Like save_expr, but for C++. */
5085 cp_save_expr (tree expr
)
5087 /* There is no reason to create a SAVE_EXPR within a template; if
5088 needed, we can create the SAVE_EXPR when instantiating the
5089 template. Furthermore, the middle-end cannot handle C++-specific
5091 if (processing_template_decl
)
5094 /* TARGET_EXPRs are only expanded once. */
5095 if (TREE_CODE (expr
) == TARGET_EXPR
)
5098 return save_expr (expr
);
5101 /* Initialize tree.c. */
5106 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5107 register_scoped_attributes (std_attribute_table
, NULL
);
5110 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5111 is. Note that sfk_none is zero, so this function can be used as a
5112 predicate to test whether or not DECL is a special function. */
5114 special_function_kind
5115 special_function_p (const_tree decl
)
5117 /* Rather than doing all this stuff with magic names, we should
5118 probably have a field of type `special_function_kind' in
5119 DECL_LANG_SPECIFIC. */
5120 if (DECL_INHERITED_CTOR (decl
))
5121 return sfk_inheriting_constructor
;
5122 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5123 return sfk_copy_constructor
;
5124 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5125 return sfk_move_constructor
;
5126 if (DECL_CONSTRUCTOR_P (decl
))
5127 return sfk_constructor
;
5128 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5129 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5131 if (copy_fn_p (decl
))
5132 return sfk_copy_assignment
;
5133 if (move_fn_p (decl
))
5134 return sfk_move_assignment
;
5136 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5137 return sfk_destructor
;
5138 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5139 return sfk_complete_destructor
;
5140 if (DECL_BASE_DESTRUCTOR_P (decl
))
5141 return sfk_base_destructor
;
5142 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5143 return sfk_deleting_destructor
;
5144 if (DECL_CONV_FN_P (decl
))
5145 return sfk_conversion
;
5146 if (deduction_guide_p (decl
))
5147 return sfk_deduction_guide
;
5148 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5149 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5150 return sfk_comparison
;
5155 /* As above, but only if DECL is a special member function as per 11.3.3
5156 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5158 special_function_kind
5159 special_memfn_p (const_tree decl
)
5161 switch (special_function_kind sfk
= special_function_p (decl
))
5163 case sfk_constructor
:
5164 if (!default_ctor_p (decl
))
5167 case sfk_copy_constructor
:
5168 case sfk_copy_assignment
:
5169 case sfk_move_assignment
:
5170 case sfk_move_constructor
:
5171 case sfk_destructor
:
5180 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5183 char_type_p (tree type
)
5185 return (same_type_p (type
, char_type_node
)
5186 || same_type_p (type
, unsigned_char_type_node
)
5187 || same_type_p (type
, signed_char_type_node
)
5188 || same_type_p (type
, char8_type_node
)
5189 || same_type_p (type
, char16_type_node
)
5190 || same_type_p (type
, char32_type_node
)
5191 || same_type_p (type
, wchar_type_node
));
5194 /* Returns the kind of linkage associated with the indicated DECL. Th
5195 value returned is as specified by the language standard; it is
5196 independent of implementation details regarding template
5197 instantiation, etc. For example, it is possible that a declaration
5198 to which this function assigns external linkage would not show up
5199 as a global symbol when you run `nm' on the resulting object file. */
5202 decl_linkage (tree decl
)
5204 /* This function doesn't attempt to calculate the linkage from first
5205 principles as given in [basic.link]. Instead, it makes use of
5206 the fact that we have already set TREE_PUBLIC appropriately, and
5207 then handles a few special cases. Ideally, we would calculate
5208 linkage first, and then transform that into a concrete
5211 /* Things that don't have names have no linkage. */
5212 if (!DECL_NAME (decl
))
5215 /* Fields have no linkage. */
5216 if (TREE_CODE (decl
) == FIELD_DECL
)
5219 /* Things that are TREE_PUBLIC have external linkage. */
5220 if (TREE_PUBLIC (decl
))
5223 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5224 check one of the "clones" for the real linkage. */
5225 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5226 && DECL_CHAIN (decl
)
5227 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5228 return decl_linkage (DECL_CHAIN (decl
));
5230 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5233 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5235 if (TREE_CODE (decl
) == CONST_DECL
)
5236 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5238 /* Things in local scope do not have linkage, if they don't have
5240 if (decl_function_context (decl
))
5243 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5244 are considered to have external linkage for language purposes, as do
5245 template instantiations on targets without weak symbols. DECLs really
5246 meant to have internal linkage have DECL_THIS_STATIC set. */
5247 if (TREE_CODE (decl
) == TYPE_DECL
)
5249 if (VAR_OR_FUNCTION_DECL_P (decl
))
5251 if (!DECL_THIS_STATIC (decl
))
5254 /* Static data members and static member functions from classes
5255 in anonymous namespace also don't have TREE_PUBLIC set. */
5256 if (DECL_CLASS_CONTEXT (decl
))
5260 /* Everything else has internal linkage. */
5264 /* Returns the storage duration of the object or reference associated with
5265 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5268 decl_storage_duration (tree decl
)
5270 if (TREE_CODE (decl
) == PARM_DECL
)
5272 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5274 gcc_assert (VAR_P (decl
));
5275 if (!TREE_STATIC (decl
)
5276 && !DECL_EXTERNAL (decl
))
5278 if (CP_DECL_THREAD_LOCAL_P (decl
))
5283 /* EXP is an expression that we want to pre-evaluate. Returns (in
5284 *INITP) an expression that will perform the pre-evaluation. The
5285 value returned by this function is a side-effect free expression
5286 equivalent to the pre-evaluated expression. Callers must ensure
5287 that *INITP is evaluated before EXP. */
5290 stabilize_expr (tree exp
, tree
* initp
)
5294 if (!TREE_SIDE_EFFECTS (exp
))
5295 init_expr
= NULL_TREE
;
5296 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5301 /* There are no expressions with REFERENCE_TYPE, but there can be call
5302 arguments with such a type; just treat it as a pointer. */
5303 else if (TYPE_REF_P (TREE_TYPE (exp
))
5304 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5305 || !glvalue_p (exp
))
5307 init_expr
= get_target_expr (exp
);
5308 exp
= TARGET_EXPR_SLOT (init_expr
);
5309 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5316 bool xval
= !lvalue_p (exp
);
5317 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5318 init_expr
= get_target_expr (exp
);
5319 exp
= TARGET_EXPR_SLOT (init_expr
);
5320 exp
= cp_build_fold_indirect_ref (exp
);
5326 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5330 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5331 similar expression ORIG. */
5334 add_stmt_to_compound (tree orig
, tree new_expr
)
5336 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5338 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5340 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5343 /* Like stabilize_expr, but for a call whose arguments we want to
5344 pre-evaluate. CALL is modified in place to use the pre-evaluated
5345 arguments, while, upon return, *INITP contains an expression to
5346 compute the arguments. */
5349 stabilize_call (tree call
, tree
*initp
)
5351 tree inits
= NULL_TREE
;
5353 int nargs
= call_expr_nargs (call
);
5355 if (call
== error_mark_node
|| processing_template_decl
)
5361 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5363 for (i
= 0; i
< nargs
; i
++)
5366 CALL_EXPR_ARG (call
, i
) =
5367 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5368 inits
= add_stmt_to_compound (inits
, init
);
5374 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5375 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5376 arguments, while, upon return, *INITP contains an expression to
5377 compute the arguments. */
5380 stabilize_aggr_init (tree call
, tree
*initp
)
5382 tree inits
= NULL_TREE
;
5384 int nargs
= aggr_init_expr_nargs (call
);
5386 if (call
== error_mark_node
)
5389 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5391 for (i
= 0; i
< nargs
; i
++)
5394 AGGR_INIT_EXPR_ARG (call
, i
) =
5395 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5396 inits
= add_stmt_to_compound (inits
, init
);
5402 /* Like stabilize_expr, but for an initialization.
5404 If the initialization is for an object of class type, this function
5405 takes care not to introduce additional temporaries.
5407 Returns TRUE iff the expression was successfully pre-evaluated,
5408 i.e., if INIT is now side-effect free, except for, possibly, a
5409 single call to a constructor. */
5412 stabilize_init (tree init
, tree
*initp
)
5418 if (t
== error_mark_node
|| processing_template_decl
)
5421 if (TREE_CODE (t
) == INIT_EXPR
)
5422 t
= TREE_OPERAND (t
, 1);
5423 if (TREE_CODE (t
) == TARGET_EXPR
)
5424 t
= TARGET_EXPR_INITIAL (t
);
5426 /* If the RHS can be stabilized without breaking copy elision, stabilize
5427 it. We specifically don't stabilize class prvalues here because that
5428 would mean an extra copy, but they might be stabilized below. */
5429 if (TREE_CODE (init
) == INIT_EXPR
5430 && TREE_CODE (t
) != CONSTRUCTOR
5431 && TREE_CODE (t
) != AGGR_INIT_EXPR
5432 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5435 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5439 if (TREE_CODE (t
) == COMPOUND_EXPR
5440 && TREE_CODE (init
) == INIT_EXPR
)
5442 tree last
= expr_last (t
);
5443 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5444 if (!TREE_SIDE_EFFECTS (last
))
5447 TREE_OPERAND (init
, 1) = last
;
5452 if (TREE_CODE (t
) == CONSTRUCTOR
)
5454 /* Aggregate initialization: stabilize each of the field
5457 constructor_elt
*ce
;
5459 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5460 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5462 tree type
= TREE_TYPE (ce
->value
);
5464 if (TYPE_REF_P (type
)
5465 || SCALAR_TYPE_P (type
))
5466 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5467 else if (!stabilize_init (ce
->value
, &subinit
))
5469 *initp
= add_stmt_to_compound (*initp
, subinit
);
5474 if (TREE_CODE (t
) == CALL_EXPR
)
5476 stabilize_call (t
, initp
);
5480 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5482 stabilize_aggr_init (t
, initp
);
5486 /* The initialization is being performed via a bitwise copy -- and
5487 the item copied may have side effects. */
5488 return !TREE_SIDE_EFFECTS (init
);
5491 /* Returns true if a cast to TYPE may appear in an integral constant
5495 cast_valid_in_integral_constant_expression_p (tree type
)
5497 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5498 || cxx_dialect
>= cxx11
5499 || dependent_type_p (type
)
5500 || type
== error_mark_node
);
5503 /* Return true if we need to fix linkage information of DECL. */
5506 cp_fix_function_decl_p (tree decl
)
5508 /* Skip if DECL is not externally visible. */
5509 if (!TREE_PUBLIC (decl
))
5512 /* We need to fix DECL if it a appears to be exported but with no
5513 function body. Thunks do not have CFGs and we may need to
5514 handle them specially later. */
5515 if (!gimple_has_body_p (decl
)
5516 && !DECL_THUNK_P (decl
)
5517 && !DECL_EXTERNAL (decl
))
5519 struct cgraph_node
*node
= cgraph_node::get (decl
);
5521 /* Don't fix same_body aliases. Although they don't have their own
5522 CFG, they share it with what they alias to. */
5523 if (!node
|| !node
->alias
5524 || !vec_safe_length (node
->ref_list
.references
))
5531 /* Clean the C++ specific parts of the tree T. */
5534 cp_free_lang_data (tree t
)
5536 if (FUNC_OR_METHOD_TYPE_P (t
))
5538 /* Default args are not interesting anymore. */
5539 tree argtypes
= TYPE_ARG_TYPES (t
);
5542 TREE_PURPOSE (argtypes
) = 0;
5543 argtypes
= TREE_CHAIN (argtypes
);
5546 else if (TREE_CODE (t
) == FUNCTION_DECL
5547 && cp_fix_function_decl_p (t
))
5549 /* If T is used in this translation unit at all, the definition
5550 must exist somewhere else since we have decided to not emit it
5551 in this TU. So make it an external reference. */
5552 DECL_EXTERNAL (t
) = 1;
5553 TREE_STATIC (t
) = 0;
5555 if (TREE_CODE (t
) == FUNCTION_DECL
)
5556 discard_operator_bindings (t
);
5557 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5558 /* We do not need the leftover chaining of namespaces from the
5560 DECL_CHAIN (t
) = NULL_TREE
;
5563 /* Stub for c-common. Please keep in sync with c-decl.c.
5564 FIXME: If address space support is target specific, then this
5565 should be a C target hook. But currently this is not possible,
5566 because this function is called via REGISTER_TARGET_PRAGMAS. */
5568 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5572 /* Return the number of operands in T that we care about for things like
5576 cp_tree_operand_length (const_tree t
)
5578 enum tree_code code
= TREE_CODE (t
);
5580 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5581 return VL_EXP_OPERAND_LENGTH (t
);
5583 return cp_tree_code_length (code
);
5586 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5589 cp_tree_code_length (enum tree_code code
)
5591 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5595 case PREINCREMENT_EXPR
:
5596 case PREDECREMENT_EXPR
:
5597 case POSTINCREMENT_EXPR
:
5598 case POSTDECREMENT_EXPR
:
5604 case EXPR_PACK_EXPANSION
:
5608 return TREE_CODE_LENGTH (code
);
5612 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5616 cp_expr_location (const_tree t_
)
5618 tree t
= CONST_CAST_TREE (t_
);
5620 return UNKNOWN_LOCATION
;
5621 switch (TREE_CODE (t
))
5624 return LAMBDA_EXPR_LOCATION (t
);
5626 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5628 return TRAIT_EXPR_LOCATION (t
);
5630 return EXPR_LOCATION (t
);
5634 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5635 conditions for the warning hold, false otherwise. */
5637 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5639 if (c_inhibit_evaluation_warnings
== 0
5640 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5642 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5643 "zero as null pointer constant");
5649 /* Given an initializer INIT for a TYPE, return true if INIT is zero
5650 so that it can be replaced by value initialization. This function
5651 distinguishes betwen empty strings as initializers for arrays and
5652 for pointers (which make it return false). */
5655 type_initializer_zero_p (tree type
, tree init
)
5657 if (type
== error_mark_node
|| init
== error_mark_node
)
5662 if (POINTER_TYPE_P (type
))
5663 return TREE_CODE (init
) != STRING_CST
&& initializer_zerop (init
);
5665 if (TREE_CODE (init
) != CONSTRUCTOR
)
5666 return initializer_zerop (init
);
5668 if (TREE_CODE (type
) == ARRAY_TYPE
)
5670 tree elt_type
= TREE_TYPE (type
);
5671 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
5672 if (elt_type
== char_type_node
)
5673 return initializer_zerop (init
);
5676 unsigned HOST_WIDE_INT i
;
5677 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, elt_init
)
5678 if (!type_initializer_zero_p (elt_type
, elt_init
))
5683 if (TREE_CODE (type
) != RECORD_TYPE
)
5684 return initializer_zerop (init
);
5686 if (TYPE_NON_AGGREGATE_CLASS (type
))
5689 tree fld
= TYPE_FIELDS (type
);
5692 unsigned HOST_WIDE_INT i
;
5693 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, fld_init
)
5695 fld
= next_initializable_field (fld
);
5699 tree fldtype
= TREE_TYPE (fld
);
5700 if (!type_initializer_zero_p (fldtype
, fld_init
))
5703 fld
= DECL_CHAIN (fld
);
5711 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5712 /* Complain that some language-specific thing hanging off a tree
5713 node has been accessed improperly. */
5716 lang_check_failed (const char* file
, int line
, const char* function
)
5718 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5719 function
, trim_filename (file
), line
);
5721 #endif /* ENABLE_TREE_CHECKING */
5725 namespace selftest
{
5727 /* Verify that lvalue_kind () works, for various expressions,
5728 and that location wrappers don't affect the results. */
5733 location_t loc
= BUILTINS_LOCATION
;
5735 /* Verify constants and parameters, without and with
5736 location wrappers. */
5737 tree int_cst
= build_int_cst (integer_type_node
, 42);
5738 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5740 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5741 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5742 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5744 tree string_lit
= build_string (4, "foo");
5745 TREE_TYPE (string_lit
) = char_array_type_node
;
5746 string_lit
= fix_string_type (string_lit
);
5747 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5749 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5750 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5751 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5753 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5754 get_identifier ("some_parm"),
5756 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5758 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5759 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5760 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5762 /* Verify that lvalue_kind of std::move on a parm isn't
5763 affected by location wrappers. */
5764 tree rvalue_ref_of_parm
= move (parm
);
5765 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5766 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5767 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5769 /* Verify lvalue_p. */
5770 ASSERT_FALSE (lvalue_p (int_cst
));
5771 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5772 ASSERT_TRUE (lvalue_p (parm
));
5773 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5774 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5775 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5778 /* Run all of the selftests within this file. */
5783 test_lvalue_kind ();
5786 } // namespace selftest
5788 #endif /* #if CHECKING_P */
5791 #include "gt-cp-tree.h"