1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TYPE_REF_P (TREE_TYPE (ref
)))
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 /* Expressions with cv void type are prvalues. */
86 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
89 switch (TREE_CODE (ref
))
94 /* preincrements and predecrements are valid lvals, provided
95 what they refer to are valid lvals. */
96 case PREINCREMENT_EXPR
:
97 case PREDECREMENT_EXPR
:
101 case VIEW_CONVERT_EXPR
:
102 return lvalue_kind (TREE_OPERAND (ref
, 0));
106 tree op1
= TREE_OPERAND (ref
, 0);
107 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
109 op1_lvalue_kind
= lvalue_kind (op1
);
110 if (op1_lvalue_kind
== clk_class
)
111 /* in the case of an array operand, the result is an lvalue if
112 that operand is an lvalue and an xvalue otherwise */
113 op1_lvalue_kind
= clk_rvalueref
;
114 return op1_lvalue_kind
;
122 if (TREE_CODE (ref
) == MEMBER_REF
)
123 op1_lvalue_kind
= clk_ordinary
;
125 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
126 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
127 op1_lvalue_kind
= clk_none
;
128 else if (op1_lvalue_kind
== clk_class
)
129 /* The result of a .* expression whose second operand is a pointer to a
130 data member is an lvalue if the first operand is an lvalue and an
132 op1_lvalue_kind
= clk_rvalueref
;
133 return op1_lvalue_kind
;
136 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
138 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
140 /* For static member function recurse on the BASELINK, we can get
141 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
142 OVERLOAD, the overload is resolved first if possible through
143 resolve_address_of_overloaded_function. */
144 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
145 return lvalue_kind (TREE_OPERAND (ref
, 1));
147 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
148 if (op1_lvalue_kind
== clk_class
)
149 /* If E1 is an lvalue, then E1.E2 is an lvalue;
150 otherwise E1.E2 is an xvalue. */
151 op1_lvalue_kind
= clk_rvalueref
;
153 /* Look at the member designator. */
154 if (!op1_lvalue_kind
)
156 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
157 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
158 situations. If we're seeing a COMPONENT_REF, it's a non-static
159 member, so it isn't an lvalue. */
160 op1_lvalue_kind
= clk_none
;
161 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
162 /* This can be IDENTIFIER_NODE in a template. */;
163 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
165 /* Clear the ordinary bit. If this object was a class
166 rvalue we want to preserve that information. */
167 op1_lvalue_kind
&= ~clk_ordinary
;
168 /* The lvalue is for a bitfield. */
169 op1_lvalue_kind
|= clk_bitfield
;
171 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
172 op1_lvalue_kind
|= clk_packed
;
174 return op1_lvalue_kind
;
177 case COMPOUND_LITERAL_EXPR
:
181 /* CONST_DECL without TREE_STATIC are enumeration values and
182 thus not lvalues. With TREE_STATIC they are used by ObjC++
183 in objc_build_string_object and need to be considered as
185 if (! TREE_STATIC (ref
))
189 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
190 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
192 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
193 && DECL_LANG_SPECIFIC (ref
)
194 && DECL_IN_AGGR_P (ref
))
201 case PLACEHOLDER_EXPR
:
204 /* A scope ref in a template, left as SCOPE_REF to support later
207 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
209 tree op
= TREE_OPERAND (ref
, 1);
210 if (TREE_CODE (op
) == FIELD_DECL
)
211 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
213 return lvalue_kind (op
);
218 /* Disallow <? and >? as lvalues if either argument side-effects. */
219 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
220 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
222 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
223 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
227 if (processing_template_decl
)
229 /* Within templates, a REFERENCE_TYPE will indicate whether
230 the COND_EXPR result is an ordinary lvalue or rvalueref.
231 Since REFERENCE_TYPEs are handled above, if we reach this
232 point, we know we got a plain rvalue. Unless we have a
233 type-dependent expr, that is, but we shouldn't be testing
234 lvalueness if we can't even tell the types yet! */
235 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
239 tree op1
= TREE_OPERAND (ref
, 1);
240 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
241 tree op2
= TREE_OPERAND (ref
, 2);
242 op1_lvalue_kind
= lvalue_kind (op1
);
243 op2_lvalue_kind
= lvalue_kind (op2
);
244 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
246 /* The second or the third operand (but not both) is a
247 throw-expression; the result is of the type
248 and value category of the other. */
249 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
250 op2_lvalue_kind
= op1_lvalue_kind
;
251 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
252 op1_lvalue_kind
= op2_lvalue_kind
;
258 /* We expect to see unlowered MODOP_EXPRs only during
259 template processing. */
260 gcc_assert (processing_template_decl
);
268 return lvalue_kind (TREE_OPERAND (ref
, 1));
274 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
277 /* We can see calls outside of TARGET_EXPR in templates. */
278 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
283 /* All functions (except non-static-member functions) are
285 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
286 ? clk_none
: clk_ordinary
);
289 /* We now represent a reference to a single static member function
291 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
292 its argument unmodified and we assign it to a const_tree. */
293 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
295 case NON_DEPENDENT_EXPR
:
297 return lvalue_kind (TREE_OPERAND (ref
, 0));
299 case TEMPLATE_PARM_INDEX
:
300 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
301 /* A template parameter object is an lvalue. */
307 if (!TREE_TYPE (ref
))
309 if (CLASS_TYPE_P (TREE_TYPE (ref
))
310 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
315 /* If one operand is not an lvalue at all, then this expression is
317 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
320 /* Otherwise, it's an lvalue, and it has all the odd properties
321 contributed by either operand. */
322 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
323 /* It's not an ordinary lvalue if it involves any other kind. */
324 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
325 op1_lvalue_kind
&= ~clk_ordinary
;
326 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
327 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
328 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
329 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
330 op1_lvalue_kind
= clk_none
;
331 return op1_lvalue_kind
;
334 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
337 real_lvalue_p (const_tree ref
)
339 cp_lvalue_kind kind
= lvalue_kind (ref
);
340 if (kind
& (clk_rvalueref
|clk_class
))
346 /* c-common wants us to return bool. */
349 lvalue_p (const_tree t
)
351 return real_lvalue_p (t
);
354 /* This differs from lvalue_p in that xvalues are included. */
357 glvalue_p (const_tree ref
)
359 cp_lvalue_kind kind
= lvalue_kind (ref
);
360 if (kind
& clk_class
)
363 return (kind
!= clk_none
);
366 /* This differs from glvalue_p in that class prvalues are included. */
369 obvalue_p (const_tree ref
)
371 return (lvalue_kind (ref
) != clk_none
);
374 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
375 reference), false otherwise. */
378 xvalue_p (const_tree ref
)
380 return (lvalue_kind (ref
) == clk_rvalueref
);
383 /* True if REF is a bit-field. */
386 bitfield_p (const_tree ref
)
388 return (lvalue_kind (ref
) & clk_bitfield
);
391 /* C++-specific version of stabilize_reference. */
394 cp_stabilize_reference (tree ref
)
396 STRIP_ANY_LOCATION_WRAPPER (ref
);
397 switch (TREE_CODE (ref
))
399 case NON_DEPENDENT_EXPR
:
400 /* We aren't actually evaluating this. */
403 /* We need to treat specially anything stabilize_reference doesn't
404 handle specifically. */
415 case ARRAY_RANGE_REF
:
419 cp_lvalue_kind kind
= lvalue_kind (ref
);
420 if ((kind
& ~clk_class
) != clk_none
)
422 tree type
= unlowered_expr_type (ref
);
423 bool rval
= !!(kind
& clk_rvalueref
);
424 type
= cp_build_reference_type (type
, rval
);
425 /* This inhibits warnings in, eg, cxx_mark_addressable
427 warning_sentinel
s (extra_warnings
);
428 ref
= build_static_cast (type
, ref
, tf_error
);
432 return stabilize_reference (ref
);
435 /* Test whether DECL is a builtin that may appear in a
436 constant-expression. */
439 builtin_valid_in_constant_expr_p (const_tree decl
)
441 STRIP_ANY_LOCATION_WRAPPER (decl
);
442 if (TREE_CODE (decl
) != FUNCTION_DECL
)
443 /* Not a function. */
445 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
447 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
450 /* Not a built-in. */
453 switch (DECL_FUNCTION_CODE (decl
))
455 /* These always have constant results like the corresponding
458 case BUILT_IN_FUNCTION
:
461 /* The following built-ins are valid in constant expressions
462 when their arguments are. */
463 case BUILT_IN_ADD_OVERFLOW_P
:
464 case BUILT_IN_SUB_OVERFLOW_P
:
465 case BUILT_IN_MUL_OVERFLOW_P
:
467 /* These have constant results even if their operands are
469 case BUILT_IN_CONSTANT_P
:
470 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
477 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
480 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
483 tree type
= TREE_TYPE (decl
);
485 value
= mark_rvalue_use (value
);
487 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
488 || TREE_TYPE (decl
) == TREE_TYPE (value
)
489 /* On ARM ctors return 'this'. */
490 || (TYPE_PTR_P (TREE_TYPE (value
))
491 && TREE_CODE (value
) == CALL_EXPR
)
492 || useless_type_conversion_p (TREE_TYPE (decl
),
495 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
496 moving a constant aggregate into .rodata. */
497 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
498 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
499 && !VOID_TYPE_P (TREE_TYPE (value
))
500 && reduced_constant_expression_p (value
))
501 TREE_READONLY (decl
) = true;
503 if (complain
& tf_no_cleanup
)
504 /* The caller is building a new-expr and does not need a cleanup. */
508 t
= cxx_maybe_build_cleanup (decl
, complain
);
509 if (t
== error_mark_node
)
510 return error_mark_node
;
512 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
513 if (location_t eloc
= cp_expr_location (value
))
514 SET_EXPR_LOCATION (t
, eloc
);
515 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
516 ignore the TARGET_EXPR. If there really turn out to be no
517 side-effects, then the optimizer should be able to get rid of
518 whatever code is generated anyhow. */
519 TREE_SIDE_EFFECTS (t
) = 1;
524 /* Return an undeclared local temporary of type TYPE for use in building a
528 build_local_temp (tree type
)
530 tree slot
= build_decl (input_location
,
531 VAR_DECL
, NULL_TREE
, type
);
532 DECL_ARTIFICIAL (slot
) = 1;
533 DECL_IGNORED_P (slot
) = 1;
534 DECL_CONTEXT (slot
) = current_function_decl
;
535 layout_decl (slot
, 0);
539 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
542 process_aggr_init_operands (tree t
)
546 side_effects
= TREE_SIDE_EFFECTS (t
);
550 n
= TREE_OPERAND_LENGTH (t
);
551 for (i
= 1; i
< n
; i
++)
553 tree op
= TREE_OPERAND (t
, i
);
554 if (op
&& TREE_SIDE_EFFECTS (op
))
561 TREE_SIDE_EFFECTS (t
) = side_effects
;
564 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
565 FN, and SLOT. NARGS is the number of call arguments which are specified
566 as a tree array ARGS. */
569 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
575 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
576 TREE_TYPE (t
) = return_type
;
577 AGGR_INIT_EXPR_FN (t
) = fn
;
578 AGGR_INIT_EXPR_SLOT (t
) = slot
;
579 for (i
= 0; i
< nargs
; i
++)
580 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
581 process_aggr_init_operands (t
);
585 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
586 target. TYPE is the type to be initialized.
588 Build an AGGR_INIT_EXPR to represent the initialization. This function
589 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
590 to initialize another object, whereas a TARGET_EXPR can either
591 initialize another object or create its own temporary object, and as a
592 result building up a TARGET_EXPR requires that the type's destructor be
596 build_aggr_init_expr (tree type
, tree init
)
603 gcc_assert (!VOID_TYPE_P (type
));
605 /* Don't build AGGR_INIT_EXPR in a template. */
606 if (processing_template_decl
)
609 fn
= cp_get_callee (init
);
611 return convert (type
, init
);
613 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
614 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
615 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
617 /* We split the CALL_EXPR into its function and its arguments here.
618 Then, in expand_expr, we put them back together. The reason for
619 this is that this expression might be a default argument
620 expression. In that case, we need a new temporary every time the
621 expression is used. That's what break_out_target_exprs does; it
622 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
623 temporary slot. Then, expand_expr builds up a call-expression
624 using the new slot. */
626 /* If we don't need to use a constructor to create an object of this
627 type, don't mess with AGGR_INIT_EXPR. */
628 if (is_ctor
|| TREE_ADDRESSABLE (type
))
630 slot
= build_local_temp (type
);
632 if (TREE_CODE (init
) == CALL_EXPR
)
634 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
635 call_expr_nargs (init
),
636 CALL_EXPR_ARGP (init
));
637 AGGR_INIT_FROM_THUNK_P (rval
)
638 = CALL_FROM_THUNK_P (init
);
642 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
643 aggr_init_expr_nargs (init
),
644 AGGR_INIT_EXPR_ARGP (init
));
645 AGGR_INIT_FROM_THUNK_P (rval
)
646 = AGGR_INIT_FROM_THUNK_P (init
);
648 TREE_SIDE_EFFECTS (rval
) = 1;
649 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
650 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
651 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
652 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
653 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
661 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
662 target. TYPE is the type that this initialization should appear to
665 Build an encapsulation of the initialization to perform
666 and return it so that it can be processed by language-independent
667 and language-specific expression expanders. */
670 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
672 /* This function should cope with what build_special_member_call
673 can produce. When performing parenthesized aggregate initialization,
674 it can produce a { }. */
675 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
677 gcc_assert (cxx_dialect
>= cxx2a
);
678 return finish_compound_literal (type
, init
, complain
);
681 tree rval
= build_aggr_init_expr (type
, init
);
684 if (init
== error_mark_node
)
685 return error_mark_node
;
687 if (!complete_type_or_maybe_complain (type
, init
, complain
))
688 return error_mark_node
;
690 /* Make sure that we're not trying to create an instance of an
692 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
693 return error_mark_node
;
695 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
696 slot
= AGGR_INIT_EXPR_SLOT (rval
);
697 else if (TREE_CODE (rval
) == CALL_EXPR
698 || TREE_CODE (rval
) == CONSTRUCTOR
)
699 slot
= build_local_temp (type
);
703 rval
= build_target_expr (slot
, rval
, complain
);
705 if (rval
!= error_mark_node
)
706 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
711 /* Subroutine of build_vec_init_expr: Build up a single element
712 intialization as a proxy for the full array initialization to get things
713 marked as used and any appropriate diagnostics.
715 Since we're deferring building the actual constructor calls until
716 gimplification time, we need to build one now and throw it away so
717 that the relevant constructor gets mark_used before cgraph decides
718 what functions are needed. Here we assume that init is either
719 NULL_TREE, void_type_node (indicating value-initialization), or
720 another array to copy. */
723 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
725 tree inner_type
= strip_array_types (type
);
727 if (integer_zerop (array_type_nelts_total (type
))
728 || !CLASS_TYPE_P (inner_type
))
729 /* No interesting initialization to do. */
730 return integer_zero_node
;
731 else if (init
== void_type_node
)
732 return build_value_init (inner_type
, complain
);
734 gcc_assert (init
== NULL_TREE
735 || (same_type_ignoring_top_level_qualifiers_p
736 (type
, TREE_TYPE (init
))));
738 releasing_vec argvec
;
741 tree init_type
= strip_array_types (TREE_TYPE (init
));
742 tree dummy
= build_dummy_object (init_type
);
743 if (!lvalue_p (init
))
744 dummy
= move (dummy
);
745 argvec
->quick_push (dummy
);
747 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
748 &argvec
, inner_type
, LOOKUP_NORMAL
,
751 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
752 we don't want one here because we aren't creating a temporary. */
753 if (TREE_CODE (init
) == TARGET_EXPR
)
754 init
= TARGET_EXPR_INITIAL (init
);
759 /* Return a TARGET_EXPR which expresses the initialization of an array to
760 be named later, either default-initialization or copy-initialization
761 from another array of the same type. */
764 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
767 bool value_init
= false;
768 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
770 if (init
== void_type_node
)
776 slot
= build_local_temp (type
);
777 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
778 TREE_SIDE_EFFECTS (init
) = true;
779 SET_EXPR_LOCATION (init
, input_location
);
781 if (cxx_dialect
>= cxx11
782 && potential_constant_expression (elt_init
))
783 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
784 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
789 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
790 that requires a constant expression. */
793 diagnose_non_constexpr_vec_init (tree expr
)
795 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
797 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
798 init
= void_type_node
;
800 init
= VEC_INIT_EXPR_INIT (expr
);
802 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
803 require_potential_constant_expression (elt_init
);
807 build_array_copy (tree init
)
809 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
812 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
816 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
818 gcc_assert (!VOID_TYPE_P (type
));
820 if (TREE_CODE (init
) == TARGET_EXPR
821 || init
== error_mark_node
)
823 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
824 && !VOID_TYPE_P (TREE_TYPE (init
))
825 && TREE_CODE (init
) != COND_EXPR
826 && TREE_CODE (init
) != CONSTRUCTOR
827 && TREE_CODE (init
) != VA_ARG_EXPR
)
828 /* We need to build up a copy constructor call. A void initializer
829 means we're being called from bot_manip. COND_EXPR is a special
830 case because we already have copies on the arms and we don't want
831 another one here. A CONSTRUCTOR is aggregate initialization, which
832 is handled separately. A VA_ARG_EXPR is magic creation of an
833 aggregate; there's no additional work to be done. */
834 return force_rvalue (init
, complain
);
836 return force_target_expr (type
, init
, complain
);
839 /* Like the above function, but without the checking. This function should
840 only be used by code which is deliberately trying to subvert the type
841 system, such as call_builtin_trap. Or build_over_call, to avoid
842 infinite recursion. */
845 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
849 gcc_assert (!VOID_TYPE_P (type
));
851 slot
= build_local_temp (type
);
852 return build_target_expr (slot
, init
, complain
);
855 /* Like build_target_expr_with_type, but use the type of INIT. */
858 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
860 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
861 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
862 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
863 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
866 init
= convert_bitfield_to_declared_type (init
);
867 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
872 get_target_expr (tree init
)
874 return get_target_expr_sfinae (init
, tf_warning_or_error
);
877 /* If EXPR is a bitfield reference, convert it to the declared type of
878 the bitfield, and return the resulting expression. Otherwise,
879 return EXPR itself. */
882 convert_bitfield_to_declared_type (tree expr
)
886 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
888 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
893 /* EXPR is being used in an rvalue context. Return a version of EXPR
894 that is marked as an rvalue. */
901 if (error_operand_p (expr
))
904 expr
= mark_rvalue_use (expr
);
908 Non-class rvalues always have cv-unqualified types. */
909 type
= TREE_TYPE (expr
);
910 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
911 type
= cv_unqualified (type
);
913 /* We need to do this for rvalue refs as well to get the right answer
914 from decltype; see c++/36628. */
915 if (!processing_template_decl
&& glvalue_p (expr
))
916 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
917 else if (type
!= TREE_TYPE (expr
))
918 expr
= build_nop (type
, expr
);
924 struct cplus_array_info
930 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
932 typedef cplus_array_info
*compare_type
;
934 static hashval_t
hash (tree t
);
935 static bool equal (tree
, cplus_array_info
*);
938 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
941 cplus_array_hasher::hash (tree t
)
945 hash
= TYPE_UID (TREE_TYPE (t
));
947 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
951 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
952 of type `cplus_array_info*'. */
955 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
957 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
960 /* Hash table containing dependent array types, which are unsuitable for
961 the language-independent type hash table. */
962 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
964 /* Build an ARRAY_TYPE without laying it out. */
967 build_min_array_type (tree elt_type
, tree index_type
)
969 tree t
= cxx_make_type (ARRAY_TYPE
);
970 TREE_TYPE (t
) = elt_type
;
971 TYPE_DOMAIN (t
) = index_type
;
975 /* Set TYPE_CANONICAL like build_array_type_1, but using
976 build_cplus_array_type. */
979 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
981 /* Set the canonical type for this new node. */
982 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
983 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
984 SET_TYPE_STRUCTURAL_EQUALITY (t
);
985 else if (TYPE_CANONICAL (elt_type
) != elt_type
986 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
988 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
990 ? TYPE_CANONICAL (index_type
) : index_type
);
992 TYPE_CANONICAL (t
) = t
;
995 /* Like build_array_type, but handle special C++ semantics: an array of a
996 variant element type is a variant of the array of the main variant of
1000 build_cplus_array_type (tree elt_type
, tree index_type
)
1004 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1005 return error_mark_node
;
1007 bool dependent
= (uses_template_parms (elt_type
)
1008 || (index_type
&& uses_template_parms (index_type
)));
1010 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1011 /* Start with an array of the TYPE_MAIN_VARIANT. */
1012 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1016 /* Since type_hash_canon calls layout_type, we need to use our own
1018 cplus_array_info cai
;
1021 if (cplus_array_htab
== NULL
)
1022 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1024 hash
= TYPE_UID (elt_type
);
1026 hash
^= TYPE_UID (index_type
);
1027 cai
.type
= elt_type
;
1028 cai
.domain
= index_type
;
1030 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1032 /* We have found the type: we're done. */
1036 /* Build a new array type. */
1037 t
= build_min_array_type (elt_type
, index_type
);
1039 /* Store it in the hash table. */
1042 /* Set the canonical type for this new node. */
1043 set_array_type_canon (t
, elt_type
, index_type
);
1048 bool typeless_storage
1049 = (elt_type
== unsigned_char_type_node
1050 || elt_type
== signed_char_type_node
1051 || elt_type
== char_type_node
1052 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1053 && TYPE_CONTEXT (elt_type
) == std_node
1054 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1055 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1058 /* Now check whether we already have this array variant. */
1059 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1062 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1063 if (TREE_TYPE (t
) == elt_type
1064 && TYPE_NAME (t
) == NULL_TREE
1065 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1069 t
= build_min_array_type (elt_type
, index_type
);
1070 set_array_type_canon (t
, elt_type
, index_type
);
1074 /* Make sure sizes are shared with the main variant.
1075 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1076 as it will overwrite alignment etc. of all variants. */
1077 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1078 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1079 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1082 TYPE_MAIN_VARIANT (t
) = m
;
1083 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1084 TYPE_NEXT_VARIANT (m
) = t
;
1088 /* Avoid spurious warnings with VLAs (c++/54583). */
1089 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1090 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1092 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1093 place more easily. */
1094 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1095 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1096 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1097 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1099 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1100 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1102 /* The element type has been completed since the last time we saw
1103 this array type; update the layout and 'tor flags for any variants
1106 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1108 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1109 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1116 /* Return an ARRAY_TYPE with element type ELT and length N. */
1119 build_array_of_n_type (tree elt
, int n
)
1121 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1124 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1125 for C++14 but then removed. This should only be used for N3639
1126 specifically; code wondering more generally if something is a VLA should use
1130 array_of_runtime_bound_p (tree t
)
1132 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1134 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1136 tree dom
= TYPE_DOMAIN (t
);
1139 tree max
= TYPE_MAX_VALUE (dom
);
1140 return (!potential_rvalue_constant_expression (max
)
1141 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1144 /* True iff T is a variable length array. */
1149 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1151 if (tree dom
= TYPE_DOMAIN (t
))
1153 tree max
= TYPE_MAX_VALUE (dom
);
1154 if (!potential_rvalue_constant_expression (max
)
1155 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1161 /* Return a reference type node referring to TO_TYPE. If RVAL is
1162 true, return an rvalue reference type, otherwise return an lvalue
1163 reference type. If a type node exists, reuse it, otherwise create
1166 cp_build_reference_type (tree to_type
, bool rval
)
1170 if (to_type
== error_mark_node
)
1171 return error_mark_node
;
1173 if (TYPE_REF_P (to_type
))
1175 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1176 to_type
= TREE_TYPE (to_type
);
1179 lvalue_ref
= build_reference_type (to_type
);
1183 /* This code to create rvalue reference types is based on and tied
1184 to the code creating lvalue reference types in the middle-end
1185 functions build_reference_type_for_mode and build_reference_type.
1187 It works by putting the rvalue reference type nodes after the
1188 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1189 they will effectively be ignored by the middle end. */
1191 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1192 if (TYPE_REF_IS_RVALUE (t
))
1195 t
= build_distinct_type_copy (lvalue_ref
);
1197 TYPE_REF_IS_RVALUE (t
) = true;
1198 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1199 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1201 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1202 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1203 else if (TYPE_CANONICAL (to_type
) != to_type
)
1205 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1207 TYPE_CANONICAL (t
) = t
;
1215 /* Returns EXPR cast to rvalue reference type, like std::move. */
1220 tree type
= TREE_TYPE (expr
);
1221 gcc_assert (!TYPE_REF_P (type
));
1222 type
= cp_build_reference_type (type
, /*rval*/true);
1223 return build_static_cast (type
, expr
, tf_warning_or_error
);
1226 /* Used by the C++ front end to build qualified array types. However,
1227 the C version of this function does not properly maintain canonical
1228 types (which are not used in C). */
1230 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1231 size_t /* orig_qual_indirect */)
1233 return cp_build_qualified_type (type
, type_quals
);
1237 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1238 arrays correctly. In particular, if TYPE is an array of T's, and
1239 TYPE_QUALS is non-empty, returns an array of qualified T's.
1241 FLAGS determines how to deal with ill-formed qualifications. If
1242 tf_ignore_bad_quals is set, then bad qualifications are dropped
1243 (this is permitted if TYPE was introduced via a typedef or template
1244 type parameter). If bad qualifications are dropped and tf_warning
1245 is set, then a warning is issued for non-const qualifications. If
1246 tf_ignore_bad_quals is not set and tf_error is not set, we
1247 return error_mark_node. Otherwise, we issue an error, and ignore
1250 Qualification of a reference type is valid when the reference came
1251 via a typedef or template type argument. [dcl.ref] No such
1252 dispensation is provided for qualifying a function type. [dcl.fct]
1253 DR 295 queries this and the proposed resolution brings it into line
1254 with qualifying a reference. We implement the DR. We also behave
1255 in a similar manner for restricting non-pointer types. */
1258 cp_build_qualified_type_real (tree type
,
1260 tsubst_flags_t complain
)
1263 int bad_quals
= TYPE_UNQUALIFIED
;
1265 if (type
== error_mark_node
)
1268 if (type_quals
== cp_type_quals (type
))
1271 if (TREE_CODE (type
) == ARRAY_TYPE
)
1273 /* In C++, the qualification really applies to the array element
1274 type. Obtain the appropriately qualified element type. */
1277 = cp_build_qualified_type_real (TREE_TYPE (type
),
1281 if (element_type
== error_mark_node
)
1282 return error_mark_node
;
1284 /* See if we already have an identically qualified type. Tests
1285 should be equivalent to those in check_qualified_type. */
1286 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1287 if (TREE_TYPE (t
) == element_type
1288 && TYPE_NAME (t
) == TYPE_NAME (type
)
1289 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1290 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1291 TYPE_ATTRIBUTES (type
)))
1296 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1298 /* Keep the typedef name. */
1299 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1301 t
= build_variant_type_copy (t
);
1302 TYPE_NAME (t
) = TYPE_NAME (type
);
1303 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1304 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1308 /* Even if we already had this variant, we update
1309 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1310 they changed since the variant was originally created.
1312 This seems hokey; if there is some way to use a previous
1313 variant *without* coming through here,
1314 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1315 TYPE_NEEDS_CONSTRUCTING (t
)
1316 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1317 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1318 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1321 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1323 tree t
= PACK_EXPANSION_PATTERN (type
);
1325 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1326 return make_pack_expansion (t
, complain
);
1329 /* A reference or method type shall not be cv-qualified.
1330 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1331 (in CD1) we always ignore extra cv-quals on functions. */
1332 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1333 && (TYPE_REF_P (type
)
1334 || FUNC_OR_METHOD_TYPE_P (type
)))
1336 if (TYPE_REF_P (type
))
1337 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1338 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1341 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1342 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1343 type_quals
|= type_memfn_quals (type
);
1345 /* A restrict-qualified type must be a pointer (or reference)
1346 to object or incomplete type. */
1347 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1348 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1349 && TREE_CODE (type
) != TYPENAME_TYPE
1350 && !INDIRECT_TYPE_P (type
))
1352 bad_quals
|= TYPE_QUAL_RESTRICT
;
1353 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1356 if (bad_quals
== TYPE_UNQUALIFIED
1357 || (complain
& tf_ignore_bad_quals
))
1359 else if (!(complain
& tf_error
))
1360 return error_mark_node
;
1363 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1364 error ("%qV qualifiers cannot be applied to %qT",
1368 /* Retrieve (or create) the appropriately qualified variant. */
1369 result
= build_qualified_type (type
, type_quals
);
1374 /* Return TYPE with const and volatile removed. */
1377 cv_unqualified (tree type
)
1381 if (type
== error_mark_node
)
1384 quals
= cp_type_quals (type
);
1385 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1386 return cp_build_qualified_type (type
, quals
);
1389 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1390 from ATTRIBS that affect type identity, and no others. If any are not
1391 applied, set *remove_attributes to true. */
1394 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1396 tree first_ident
= NULL_TREE
;
1397 tree new_attribs
= NULL_TREE
;
1398 tree
*p
= &new_attribs
;
1400 if (OVERLOAD_TYPE_P (result
))
1402 /* On classes and enums all attributes are ingrained. */
1403 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1407 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1409 const attribute_spec
*as
1410 = lookup_attribute_spec (get_attribute_name (a
));
1411 if (as
&& as
->affects_type_identity
)
1415 else if (first_ident
== error_mark_node
)
1417 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1418 p
= &TREE_CHAIN (*p
);
1421 else if (first_ident
)
1423 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1425 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1426 p
= &TREE_CHAIN (*p
);
1428 first_ident
= error_mark_node
;
1431 if (first_ident
!= error_mark_node
)
1432 new_attribs
= first_ident
;
1434 if (first_ident
== attribs
)
1435 /* All attributes affected type identity. */;
1437 *remove_attributes
= true;
1439 return cp_build_type_attribute_variant (result
, new_attribs
);
1442 /* Builds a qualified variant of T that is either not a typedef variant
1443 (the default behavior) or not a typedef variant of a user-facing type
1444 (if FLAGS contains STF_USER_FACING).
1446 E.g. consider the following declarations:
1447 typedef const int ConstInt;
1448 typedef ConstInt* PtrConstInt;
1449 If T is PtrConstInt, this function returns a type representing
1451 In other words, if T is a typedef, the function returns the underlying type.
1452 The cv-qualification and attributes of the type returned match the
1454 They will always be compatible types.
1455 The returned type is built so that all of its subtypes
1456 recursively have their typedefs stripped as well.
1458 This is different from just returning TYPE_CANONICAL (T)
1459 Because of several reasons:
1460 * If T is a type that needs structural equality
1461 its TYPE_CANONICAL (T) will be NULL.
1462 * TYPE_CANONICAL (T) desn't carry type attributes
1463 and loses template parameter names.
1465 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1466 affect type identity, and set the referent to true if any were
1470 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1472 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1474 if (!t
|| t
== error_mark_node
)
1477 if (TREE_CODE (t
) == TREE_LIST
)
1479 bool changed
= false;
1482 for (; t
; t
= TREE_CHAIN (t
))
1484 gcc_assert (!TREE_PURPOSE (t
));
1485 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1486 if (elt
!= TREE_VALUE (t
))
1488 vec_safe_push (vec
, elt
);
1491 r
= build_tree_list_vec (vec
);
1495 gcc_assert (TYPE_P (t
));
1497 if (t
== TYPE_CANONICAL (t
))
1500 if (!(flags
& STF_STRIP_DEPENDENT
)
1501 && dependent_alias_template_spec_p (t
, nt_opaque
))
1502 /* DR 1558: However, if the template-id is dependent, subsequent
1503 template argument substitution still applies to the template-id. */
1506 switch (TREE_CODE (t
))
1509 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1510 result
= build_pointer_type (type
);
1512 case REFERENCE_TYPE
:
1513 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1514 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1517 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1518 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1519 result
= build_offset_type (t0
, type
);
1522 if (TYPE_PTRMEMFUNC_P (t
))
1524 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1525 remove_attributes
, flags
);
1526 result
= build_ptrmemfunc_type (t0
);
1530 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1531 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1532 result
= build_cplus_array_type (type
, t0
);
1537 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1540 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1541 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1542 can't expect that re-hashing a function type will find a previous
1543 equivalent type, so try to reuse the input type if nothing has
1544 changed. If the type is itself a variant, that will change. */
1545 bool is_variant
= typedef_variant_p (t
);
1546 if (remove_attributes
1547 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1550 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1551 tree canon_spec
= (flag_noexcept_type
1552 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1554 changed
= (type
!= TREE_TYPE (t
) || is_variant
1555 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1557 for (arg_node
= TYPE_ARG_TYPES (t
);
1559 arg_node
= TREE_CHAIN (arg_node
))
1561 if (arg_node
== void_list_node
)
1563 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1564 remove_attributes
, flags
);
1565 gcc_assert (arg_type
);
1566 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1572 for (arg_node2
= TYPE_ARG_TYPES (t
);
1573 arg_node2
!= arg_node
;
1574 arg_node2
= TREE_CHAIN (arg_node2
))
1576 = tree_cons (TREE_PURPOSE (arg_node2
),
1577 TREE_VALUE (arg_node2
), arg_types
);
1581 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1588 arg_types
= nreverse (arg_types
);
1590 /* A list of parameters not ending with an ellipsis
1591 must end with void_list_node. */
1593 arg_types
= chainon (arg_types
, void_list_node
);
1595 if (TREE_CODE (t
) == METHOD_TYPE
)
1597 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1598 gcc_assert (class_type
);
1600 build_method_type_directly (class_type
, type
,
1601 TREE_CHAIN (arg_types
));
1605 result
= build_function_type (type
, arg_types
);
1606 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1609 result
= build_cp_fntype_variant (result
,
1610 type_memfn_rqual (t
), canon_spec
,
1611 TYPE_HAS_LATE_RETURN_TYPE (t
));
1616 bool changed
= false;
1617 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1618 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1619 && TREE_OPERAND (fullname
, 1))
1621 tree args
= TREE_OPERAND (fullname
, 1);
1622 tree new_args
= copy_node (args
);
1623 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1625 tree arg
= TREE_VEC_ELT (args
, i
);
1628 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1630 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1632 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1633 if (strip_arg
!= arg
)
1638 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1639 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1641 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1645 ggc_free (new_args
);
1647 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1648 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1650 tree name
= fullname
;
1651 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1652 name
= TREE_OPERAND (fullname
, 0);
1653 /* Use build_typename_type rather than make_typename_type because we
1654 don't want to resolve it here, just strip typedefs. */
1655 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1659 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1660 remove_attributes
, flags
);
1661 if (result
== DECLTYPE_TYPE_EXPR (t
))
1664 result
= (finish_decltype_type
1666 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1669 case UNDERLYING_TYPE
:
1670 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1671 remove_attributes
, flags
);
1672 result
= finish_underlying_type (type
);
1680 if (typedef_variant_p (t
))
1682 if ((flags
& STF_USER_VISIBLE
)
1683 && !user_facing_original_type_p (t
))
1685 /* If T is a non-template alias or typedef, we can assume that
1686 instantiating its definition will hit any substitution failure,
1687 so we don't need to retain it here as well. */
1688 if (!alias_template_specialization_p (t
, nt_opaque
))
1689 flags
|= STF_STRIP_DEPENDENT
;
1690 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1691 remove_attributes
, flags
);
1694 result
= TYPE_MAIN_VARIANT (t
);
1696 gcc_assert (!typedef_variant_p (result
)
1697 || dependent_alias_template_spec_p (result
, nt_opaque
)
1698 || ((flags
& STF_USER_VISIBLE
)
1699 && !user_facing_original_type_p (result
)));
1701 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1702 /* If RESULT is complete and T isn't, it's likely the case that T
1703 is a variant of RESULT which hasn't been updated yet. Skip the
1704 attribute handling. */;
1707 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1708 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1710 gcc_assert (TYPE_USER_ALIGN (t
));
1711 if (remove_attributes
)
1712 *remove_attributes
= true;
1715 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1716 result
= build_variant_type_copy (result
);
1718 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1719 TYPE_USER_ALIGN (result
) = true;
1723 if (TYPE_ATTRIBUTES (t
))
1725 if (remove_attributes
)
1726 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1729 result
= cp_build_type_attribute_variant (result
,
1730 TYPE_ATTRIBUTES (t
));
1734 return cp_build_qualified_type (result
, cp_type_quals (t
));
1737 /* Like strip_typedefs above, but works on expressions, so that in
1739 template<class T> struct A
1745 sizeof(TT) is replaced by sizeof(T). */
1748 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1752 enum tree_code code
;
1754 if (t
== NULL_TREE
|| t
== error_mark_node
)
1757 STRIP_ANY_LOCATION_WRAPPER (t
);
1759 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1762 /* Some expressions have type operands, so let's handle types here rather
1763 than check TYPE_P in multiple places below. */
1765 return strip_typedefs (t
, remove_attributes
, flags
);
1767 code
= TREE_CODE (t
);
1770 case IDENTIFIER_NODE
:
1771 case TEMPLATE_PARM_INDEX
:
1774 case ARGUMENT_PACK_SELECT
:
1779 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1780 remove_attributes
, flags
);
1781 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1782 remove_attributes
, flags
);
1783 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1784 && type2
== TRAIT_EXPR_TYPE2 (t
))
1787 TRAIT_EXPR_TYPE1 (r
) = type1
;
1788 TRAIT_EXPR_TYPE2 (r
) = type2
;
1795 bool changed
= false;
1797 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1799 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1800 remove_attributes
, flags
);
1801 vec_safe_push (vec
, val
);
1802 if (val
!= TREE_VALUE (it
))
1804 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1809 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1810 r
= tree_cons (NULL_TREE
, it
, r
);
1819 bool changed
= false;
1821 n
= TREE_VEC_LENGTH (t
);
1822 vec_safe_reserve (vec
, n
);
1823 for (i
= 0; i
< n
; ++i
)
1825 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1826 remove_attributes
, flags
);
1827 vec
->quick_push (op
);
1828 if (op
!= TREE_VEC_ELT (t
, i
))
1834 for (i
= 0; i
< n
; ++i
)
1835 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1836 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1837 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1846 bool changed
= false;
1847 vec
<constructor_elt
, va_gc
> *vec
1848 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1849 n
= CONSTRUCTOR_NELTS (t
);
1850 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1851 for (i
= 0; i
< n
; ++i
)
1853 constructor_elt
*e
= &(*vec
)[i
];
1854 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1861 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1865 if (!changed
&& type
== TREE_TYPE (t
))
1873 TREE_TYPE (r
) = type
;
1874 CONSTRUCTOR_ELTS (r
) = vec
;
1882 case STATEMENT_LIST
:
1883 error ("statement-expression in a constant expression");
1884 return error_mark_node
;
1890 gcc_assert (EXPR_P (t
));
1892 n
= cp_tree_operand_length (t
);
1893 ops
= XALLOCAVEC (tree
, n
);
1894 type
= TREE_TYPE (t
);
1899 case IMPLICIT_CONV_EXPR
:
1900 case DYNAMIC_CAST_EXPR
:
1901 case STATIC_CAST_EXPR
:
1902 case CONST_CAST_EXPR
:
1903 case REINTERPRET_CAST_EXPR
:
1906 type
= strip_typedefs (type
, remove_attributes
, flags
);
1910 for (i
= 0; i
< n
; ++i
)
1911 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1912 remove_attributes
, flags
);
1916 /* If nothing changed, return t. */
1917 for (i
= 0; i
< n
; ++i
)
1918 if (ops
[i
] != TREE_OPERAND (t
, i
))
1920 if (i
== n
&& type
== TREE_TYPE (t
))
1924 TREE_TYPE (r
) = type
;
1925 for (i
= 0; i
< n
; ++i
)
1926 TREE_OPERAND (r
, i
) = ops
[i
];
1930 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1931 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1932 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1933 VIRT indicates whether TYPE is inherited virtually or not.
1934 IGO_PREV points at the previous binfo of the inheritance graph
1935 order chain. The newly copied binfo's TREE_CHAIN forms this
1938 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1939 correct order. That is in the order the bases themselves should be
1942 The BINFO_INHERITANCE of a virtual base class points to the binfo
1943 of the most derived type. ??? We could probably change this so that
1944 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1945 remove a field. They currently can only differ for primary virtual
1949 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1955 /* See if we've already made this virtual base. */
1956 new_binfo
= binfo_for_vbase (type
, t
);
1961 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1962 BINFO_TYPE (new_binfo
) = type
;
1964 /* Chain it into the inheritance graph. */
1965 TREE_CHAIN (*igo_prev
) = new_binfo
;
1966 *igo_prev
= new_binfo
;
1968 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1973 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1975 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1976 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1978 /* We do not need to copy the accesses, as they are read only. */
1979 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1981 /* Recursively copy base binfos of BINFO. */
1982 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1984 tree new_base_binfo
;
1985 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1987 BINFO_VIRTUAL_P (base_binfo
));
1989 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1990 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1991 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1995 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1999 /* Push it onto the list after any virtual bases it contains
2000 will have been pushed. */
2001 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2002 BINFO_VIRTUAL_P (new_binfo
) = 1;
2003 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2009 /* Hashing of lists so that we don't make duplicates.
2010 The entry point is `list_hash_canon'. */
2019 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2021 typedef list_proxy
*compare_type
;
2023 static hashval_t
hash (tree
);
2024 static bool equal (tree
, list_proxy
*);
2027 /* Now here is the hash table. When recording a list, it is added
2028 to the slot whose index is the hash code mod the table size.
2029 Note that the hash table is used for several kinds of lists.
2030 While all these live in the same table, they are completely independent,
2031 and the hash code is computed differently for each of these. */
2033 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2035 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2036 for a node we are thinking about adding). */
2039 list_hasher::equal (tree t
, list_proxy
*proxy
)
2041 return (TREE_VALUE (t
) == proxy
->value
2042 && TREE_PURPOSE (t
) == proxy
->purpose
2043 && TREE_CHAIN (t
) == proxy
->chain
);
2046 /* Compute a hash code for a list (chain of TREE_LIST nodes
2047 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2048 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2051 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2053 hashval_t hashcode
= 0;
2056 hashcode
+= TREE_HASH (chain
);
2059 hashcode
+= TREE_HASH (value
);
2063 hashcode
+= TREE_HASH (purpose
);
2069 /* Hash an already existing TREE_LIST. */
2072 list_hasher::hash (tree t
)
2074 return list_hash_pieces (TREE_PURPOSE (t
),
2079 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2080 object for an identical list if one already exists. Otherwise, build a
2081 new one, and record it as the canonical object. */
2084 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2088 struct list_proxy proxy
;
2090 /* Hash the list node. */
2091 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2092 /* Create a proxy for the TREE_LIST we would like to create. We
2093 don't actually create it so as to avoid creating garbage. */
2094 proxy
.purpose
= purpose
;
2095 proxy
.value
= value
;
2096 proxy
.chain
= chain
;
2097 /* See if it is already in the table. */
2098 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2099 /* If not, create a new node. */
2101 *slot
= tree_cons (purpose
, value
, chain
);
2102 return (tree
) *slot
;
2105 /* Constructor for hashed lists. */
2108 hash_tree_chain (tree value
, tree chain
)
2110 return hash_tree_cons (NULL_TREE
, value
, chain
);
2114 debug_binfo (tree elem
)
2119 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2121 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2122 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2123 debug_tree (BINFO_TYPE (elem
));
2124 if (BINFO_VTABLE (elem
))
2125 fprintf (stderr
, "vtable decl \"%s\"\n",
2126 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2128 fprintf (stderr
, "no vtable decl yet\n");
2129 fprintf (stderr
, "virtuals:\n");
2130 virtuals
= BINFO_VIRTUALS (elem
);
2135 tree fndecl
= TREE_VALUE (virtuals
);
2136 fprintf (stderr
, "%s [%ld =? %ld]\n",
2137 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2138 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2140 virtuals
= TREE_CHAIN (virtuals
);
2144 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2145 the type of the result expression, if known, or NULL_TREE if the
2146 resulting expression is type-dependent. If TEMPLATE_P is true,
2147 NAME is known to be a template because the user explicitly used the
2148 "template" keyword after the "::".
2150 All SCOPE_REFs should be built by use of this function. */
2153 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2156 if (type
== error_mark_node
2157 || scope
== error_mark_node
2158 || name
== error_mark_node
)
2159 return error_mark_node
;
2160 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2161 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2162 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2163 PTRMEM_OK_P (t
) = true;
2165 t
= convert_from_reference (t
);
2169 /* Like check_qualified_type, but also check ref-qualifier, exception
2170 specification, and whether the return type was specified after the
2174 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2175 cp_ref_qualifier rqual
, tree raises
, bool late
)
2177 return (TYPE_QUALS (cand
) == type_quals
2178 && check_base_type (cand
, base
)
2179 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2181 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2182 && type_memfn_rqual (cand
) == rqual
);
2185 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2188 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2190 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2191 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2192 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2195 /* Make a raw overload node containing FN. */
2198 ovl_make (tree fn
, tree next
)
2200 tree result
= make_node (OVERLOAD
);
2202 if (TREE_CODE (fn
) == OVERLOAD
)
2203 OVL_NESTED_P (result
) = true;
2205 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2206 ? unknown_type_node
: TREE_TYPE (fn
));
2207 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2208 OVL_DEDUP_P (result
) = true;
2209 OVL_FUNCTION (result
) = fn
;
2210 OVL_CHAIN (result
) = next
;
2214 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2215 true, if FN is via a using declaration. We also pay attention to
2216 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2220 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2222 tree result
= maybe_ovl
;
2223 tree insert_after
= NULL_TREE
;
2226 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2227 && OVL_HIDDEN_P (maybe_ovl
);
2228 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2230 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2231 insert_after
= maybe_ovl
;
2234 bool hidden_p
= DECL_HIDDEN_P (fn
);
2235 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2237 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2239 OVL_HIDDEN_P (maybe_ovl
) = true;
2241 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2248 OVL_CHAIN (insert_after
) = maybe_ovl
;
2249 TREE_TYPE (insert_after
) = unknown_type_node
;
2257 /* Skip any hidden names at the beginning of OVL. */
2260 ovl_skip_hidden (tree ovl
)
2263 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2264 ovl
= OVL_CHAIN (ovl
))
2265 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2267 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2269 /* Any hidden functions should have been wrapped in an
2270 overload, but injected friend classes will not. */
2271 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2278 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2281 ovl_iterator::reveal_node (tree overload
, tree node
)
2283 /* We cannot have returned NODE as part of a lookup overload, so we
2284 don't have to worry about preserving that. */
2286 OVL_HIDDEN_P (node
) = false;
2287 if (tree chain
= OVL_CHAIN (node
))
2288 if (TREE_CODE (chain
) == OVERLOAD
)
2290 if (OVL_HIDDEN_P (chain
))
2292 /* The node needs moving, and the simplest way is to remove it
2294 overload
= remove_node (overload
, node
);
2295 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2297 else if (OVL_DEDUP_P (chain
))
2298 OVL_DEDUP_P (node
) = true;
2303 /* NODE is on the overloads of OVL. Remove it.
2304 The removed node is unaltered and may continue to be iterated
2305 from (i.e. it is safe to remove a node from an overload one is
2306 currently iterating over). */
2309 ovl_iterator::remove_node (tree overload
, tree node
)
2311 tree
*slot
= &overload
;
2312 while (*slot
!= node
)
2315 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2317 slot
= &OVL_CHAIN (probe
);
2320 /* Stitch out NODE. We don't have to worry about now making a
2321 singleton overload (and consequently maybe setting its type),
2322 because all uses of this function will be followed by inserting a
2323 new node that must follow the place we've cut this out from. */
2324 if (TREE_CODE (node
) != OVERLOAD
)
2325 /* Cloned inherited ctors don't mark themselves as via_using. */
2328 *slot
= OVL_CHAIN (node
);
2333 /* Mark or unmark a lookup set. */
2336 lookup_mark (tree ovl
, bool val
)
2338 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2340 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2341 LOOKUP_SEEN_P (*iter
) = val
;
2345 /* Add a set of new FNS into a lookup. */
2348 lookup_add (tree fns
, tree lookup
)
2350 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2351 return error_mark_node
;
2353 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2355 lookup
= ovl_make (fns
, lookup
);
2356 OVL_LOOKUP_P (lookup
) = true;
2364 /* FNS is a new overload set, add them to LOOKUP, if they are not
2365 already present there. */
2368 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2371 for (tree next
, probe
= fns
; probe
; probe
= next
)
2376 if (TREE_CODE (probe
) == OVERLOAD
)
2378 fn
= OVL_FUNCTION (probe
);
2379 next
= OVL_CHAIN (probe
);
2382 if (!LOOKUP_SEEN_P (fn
))
2383 LOOKUP_SEEN_P (fn
) = true;
2386 /* This function was already seen. Insert all the
2387 predecessors onto the lookup. */
2388 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2390 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2391 /* Propagate OVL_USING, but OVL_HIDDEN &
2392 OVL_DEDUP_P don't matter. */
2393 if (OVL_USING_P (fns
))
2394 OVL_USING_P (lookup
) = true;
2397 /* And now skip this function. */
2403 /* We ended in a set of new functions. Add them all in one go. */
2404 lookup
= lookup_add (fns
, lookup
);
2409 /* Returns nonzero if X is an expression for a (possibly overloaded)
2410 function. If "f" is a function or function template, "f", "c->f",
2411 "c.f", "C::f", and "f<int>" will all be considered possibly
2412 overloaded functions. Returns 2 if the function is actually
2413 overloaded, i.e., if it is impossible to know the type of the
2414 function without performing overload resolution. */
2417 is_overloaded_fn (tree x
)
2419 STRIP_ANY_LOCATION_WRAPPER (x
);
2421 /* A baselink is also considered an overloaded function. */
2422 if (TREE_CODE (x
) == OFFSET_REF
2423 || TREE_CODE (x
) == COMPONENT_REF
)
2424 x
= TREE_OPERAND (x
, 1);
2425 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2426 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2427 x
= TREE_OPERAND (x
, 0);
2429 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2430 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2436 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2437 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2441 dependent_name (tree x
)
2443 if (identifier_p (x
))
2445 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2446 x
= TREE_OPERAND (x
, 0);
2448 return OVL_NAME (x
);
2452 /* Returns true iff X is an expression for an overloaded function
2453 whose type cannot be known without performing overload
2457 really_overloaded_fn (tree x
)
2459 return is_overloaded_fn (x
) == 2;
2462 /* Get the overload set FROM refers to. Returns NULL if it's not an
2466 maybe_get_fns (tree from
)
2468 STRIP_ANY_LOCATION_WRAPPER (from
);
2470 /* A baselink is also considered an overloaded function. */
2471 if (TREE_CODE (from
) == OFFSET_REF
2472 || TREE_CODE (from
) == COMPONENT_REF
)
2473 from
= TREE_OPERAND (from
, 1);
2474 if (BASELINK_P (from
))
2475 from
= BASELINK_FUNCTIONS (from
);
2476 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2477 from
= TREE_OPERAND (from
, 0);
2485 /* FROM refers to an overload set. Return that set (or die). */
2490 tree res
= maybe_get_fns (from
);
2496 /* Return the first function of the overload set FROM refers to. */
2499 get_first_fn (tree from
)
2501 return OVL_FIRST (get_fns (from
));
2504 /* Return the scope where the overloaded functions OVL were found. */
2507 ovl_scope (tree ovl
)
2509 if (TREE_CODE (ovl
) == OFFSET_REF
2510 || TREE_CODE (ovl
) == COMPONENT_REF
)
2511 ovl
= TREE_OPERAND (ovl
, 1);
2512 if (TREE_CODE (ovl
) == BASELINK
)
2513 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2514 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2515 ovl
= TREE_OPERAND (ovl
, 0);
2516 /* Skip using-declarations. */
2517 lkp_iterator
iter (ovl
);
2520 while (iter
.using_p () && ++iter
);
2522 return CP_DECL_CONTEXT (ovl
);
2525 #define PRINT_RING_SIZE 4
2528 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2530 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2531 static char *print_ring
[PRINT_RING_SIZE
];
2532 static bool trans_ring
[PRINT_RING_SIZE
];
2533 static int ring_counter
;
2536 /* Only cache functions. */
2538 || TREE_CODE (decl
) != FUNCTION_DECL
2539 || DECL_LANG_SPECIFIC (decl
) == 0)
2540 return lang_decl_name (decl
, v
, translate
);
2542 /* See if this print name is lying around. */
2543 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2544 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2545 /* yes, so return it. */
2546 return print_ring
[i
];
2548 if (++ring_counter
== PRINT_RING_SIZE
)
2551 if (current_function_decl
!= NULL_TREE
)
2553 /* There may be both translated and untranslated versions of the
2555 for (i
= 0; i
< 2; i
++)
2557 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2559 if (ring_counter
== PRINT_RING_SIZE
)
2562 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2565 free (print_ring
[ring_counter
]);
2567 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2568 uid_ring
[ring_counter
] = DECL_UID (decl
);
2569 trans_ring
[ring_counter
] = translate
;
2570 return print_ring
[ring_counter
];
2574 cxx_printable_name (tree decl
, int v
)
2576 return cxx_printable_name_internal (decl
, v
, false);
2580 cxx_printable_name_translate (tree decl
, int v
)
2582 return cxx_printable_name_internal (decl
, v
, true);
2585 /* Return the canonical version of exception-specification RAISES for a C++17
2586 function type, for use in type comparison and building TYPE_CANONICAL. */
2589 canonical_eh_spec (tree raises
)
2591 if (raises
== NULL_TREE
)
2593 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2594 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2595 || uses_template_parms (raises
)
2596 || uses_template_parms (TREE_PURPOSE (raises
)))
2597 /* Keep a dependent or deferred exception specification. */
2599 else if (nothrow_spec_p (raises
))
2600 /* throw() -> noexcept. */
2601 return noexcept_true_spec
;
2603 /* For C++17 type matching, anything else -> nothing. */
2608 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2609 tree raises
, bool late
)
2611 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2613 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2616 tree v
= TYPE_MAIN_VARIANT (type
);
2617 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2618 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2621 /* Need to build a new variant. */
2622 v
= build_variant_type_copy (type
);
2623 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2624 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2627 case REF_QUAL_RVALUE
:
2628 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2629 FUNCTION_REF_QUALIFIED (v
) = 1;
2631 case REF_QUAL_LVALUE
:
2632 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2633 FUNCTION_REF_QUALIFIED (v
) = 1;
2636 FUNCTION_REF_QUALIFIED (v
) = 0;
2640 /* Canonicalize the exception specification. */
2641 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2643 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2644 /* Propagate structural equality. */
2645 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2646 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2647 /* Build the underlying canonical type, since it is different
2649 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2652 /* T is its own canonical type. */
2653 TYPE_CANONICAL (v
) = v
;
2658 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2659 listed in RAISES. */
2662 build_exception_variant (tree type
, tree raises
)
2664 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2665 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2666 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2669 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2670 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2674 bind_template_template_parm (tree t
, tree newargs
)
2676 tree decl
= TYPE_NAME (t
);
2679 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2680 decl
= build_decl (input_location
,
2681 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2683 /* These nodes have to be created to reflect new TYPE_DECL and template
2685 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2686 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2687 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2688 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2690 TREE_TYPE (decl
) = t2
;
2691 TYPE_NAME (t2
) = decl
;
2692 TYPE_STUB_DECL (t2
) = decl
;
2694 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2699 /* Called from count_trees via walk_tree. */
2702 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2712 /* Debugging function for measuring the rough complexity of a tree
2716 count_trees (tree t
)
2719 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2723 /* Called from verify_stmt_tree via walk_tree. */
2726 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2729 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2730 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2733 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2736 /* If this statement is already present in the hash table, then
2737 there is a circularity in the statement tree. */
2738 gcc_assert (!statements
->find (t
));
2740 slot
= statements
->find_slot (t
, INSERT
);
2746 /* Debugging function to check that the statement T has not been
2747 corrupted. For now, this function simply checks that T contains no
2751 verify_stmt_tree (tree t
)
2753 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2754 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2757 /* Check if the type T depends on a type with no linkage and if so, return
2758 it. If RELAXED_P then do not consider a class type declared within
2759 a vague-linkage function to have no linkage. */
2762 no_linkage_check (tree t
, bool relaxed_p
)
2766 /* Lambda types that don't have mangling scope have no linkage. We
2767 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2768 when we get here from pushtag none of the lambda information is
2769 set up yet, so we want to assume that the lambda has linkage and
2770 fix it up later if not. We need to check this even in templates so
2771 that we properly handle a lambda-expression in the signature. */
2772 if (LAMBDA_TYPE_P (t
)
2773 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2774 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2777 /* Otherwise there's no point in checking linkage on template functions; we
2778 can't know their complete types. */
2779 if (processing_template_decl
)
2782 switch (TREE_CODE (t
))
2785 if (TYPE_PTRMEMFUNC_P (t
))
2789 if (!CLASS_TYPE_P (t
))
2793 /* Only treat unnamed types as having no linkage if they're at
2794 namespace scope. This is core issue 966. */
2795 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2798 for (r
= CP_TYPE_CONTEXT (t
); ; )
2800 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2801 have linkage, or we might just be in an anonymous namespace.
2802 If we're in a TREE_PUBLIC class, we have linkage. */
2803 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2804 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2805 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2807 if (!relaxed_p
|| !vague_linkage_p (r
))
2810 r
= CP_DECL_CONTEXT (r
);
2820 case REFERENCE_TYPE
:
2822 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2826 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2830 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2835 tree parm
= TYPE_ARG_TYPES (t
);
2836 if (TREE_CODE (t
) == METHOD_TYPE
)
2837 /* The 'this' pointer isn't interesting; a method has the same
2838 linkage (or lack thereof) as its enclosing class. */
2839 parm
= TREE_CHAIN (parm
);
2841 parm
&& parm
!= void_list_node
;
2842 parm
= TREE_CHAIN (parm
))
2844 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2848 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2856 extern int depth_reached
;
2859 cxx_print_statistics (void)
2861 print_template_statistics ();
2862 if (GATHER_STATISTICS
)
2863 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2867 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2868 (which is an ARRAY_TYPE). This counts only elements of the top
2872 array_type_nelts_top (tree type
)
2874 return fold_build2_loc (input_location
,
2875 PLUS_EXPR
, sizetype
,
2876 array_type_nelts (type
),
2880 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2881 (which is an ARRAY_TYPE). This one is a recursive count of all
2882 ARRAY_TYPEs that are clumped together. */
2885 array_type_nelts_total (tree type
)
2887 tree sz
= array_type_nelts_top (type
);
2888 type
= TREE_TYPE (type
);
2889 while (TREE_CODE (type
) == ARRAY_TYPE
)
2891 tree n
= array_type_nelts_top (type
);
2892 sz
= fold_build2_loc (input_location
,
2893 MULT_EXPR
, sizetype
, sz
, n
);
2894 type
= TREE_TYPE (type
);
2901 splay_tree target_remap
;
2902 bool clear_location
;
2905 /* Called from break_out_target_exprs via mapcar. */
2908 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2910 bot_data
&data
= *(bot_data
*)data_
;
2911 splay_tree target_remap
= data
.target_remap
;
2914 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2916 /* There can't be any TARGET_EXPRs or their slot variables below this
2917 point. But we must make a copy, in case subsequent processing
2918 alters any part of it. For example, during gimplification a cast
2919 of the form (T) &X::f (where "f" is a member function) will lead
2920 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2922 *tp
= unshare_expr (t
);
2925 if (TREE_CODE (t
) == TARGET_EXPR
)
2929 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2931 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2932 tf_warning_or_error
);
2933 if (u
== error_mark_node
)
2935 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2936 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2939 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2940 tf_warning_or_error
);
2942 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2943 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2944 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2946 /* Map the old variable to the new one. */
2947 splay_tree_insert (target_remap
,
2948 (splay_tree_key
) TREE_OPERAND (t
, 0),
2949 (splay_tree_value
) TREE_OPERAND (u
, 0));
2951 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2952 data
.clear_location
);
2953 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2954 return error_mark_node
;
2956 /* Replace the old expression with the new version. */
2958 /* We don't have to go below this point; the recursive call to
2959 break_out_target_exprs will have handled anything below this
2964 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2967 splay_tree_node n
= splay_tree_lookup (target_remap
,
2968 (splay_tree_key
) t
);
2971 *tp
= (tree
)n
->value
;
2976 copy_tree_r (tp
, walk_subtrees
, NULL
);
2977 splay_tree_insert (target_remap
,
2979 (splay_tree_value
)*tp
);
2980 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2981 splay_tree_insert (target_remap
,
2982 (splay_tree_key
)*tp
,
2983 (splay_tree_value
)*tp
);
2988 /* Make a copy of this node. */
2989 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2990 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2991 if (!processing_template_decl
)
2992 set_flags_from_callee (*tp
);
2993 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2994 SET_EXPR_LOCATION (*tp
, input_location
);
2998 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2999 DATA is really a splay-tree mapping old variables to new
3003 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3005 bot_data
&data
= *(bot_data
*)data_
;
3006 splay_tree target_remap
= data
.target_remap
;
3010 splay_tree_node n
= splay_tree_lookup (target_remap
,
3011 (splay_tree_key
) *t
);
3013 *t
= (tree
) n
->value
;
3015 else if (TREE_CODE (*t
) == PARM_DECL
3016 && DECL_NAME (*t
) == this_identifier
3017 && !DECL_CONTEXT (*t
))
3019 /* In an NSDMI we need to replace the 'this' parameter we used for
3020 parsing with the real one for this function. */
3021 *t
= current_class_ptr
;
3023 else if (TREE_CODE (*t
) == CONVERT_EXPR
3024 && CONVERT_EXPR_VBASE_PATH (*t
))
3026 /* In an NSDMI build_base_path defers building conversions to virtual
3027 bases, and we handle it here. */
3028 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3029 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3031 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3032 if (BINFO_TYPE (binfo
) == basetype
)
3034 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3035 tf_warning_or_error
);
3041 /* When we parse a default argument expression, we may create
3042 temporary variables via TARGET_EXPRs. When we actually use the
3043 default-argument expression, we make a copy of the expression
3044 and replace the temporaries with appropriate local versions.
3046 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3050 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3052 static int target_remap_count
;
3053 static splay_tree target_remap
;
3055 if (!target_remap_count
++)
3056 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3057 /*splay_tree_delete_key_fn=*/NULL
,
3058 /*splay_tree_delete_value_fn=*/NULL
);
3059 bot_data data
= { target_remap
, clear_location
};
3060 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3061 t
= error_mark_node
;
3062 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3064 if (!--target_remap_count
)
3066 splay_tree_delete (target_remap
);
3067 target_remap
= NULL
;
3073 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3074 which we expect to have type TYPE. */
3077 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3079 if (index
== NULL_TREE
)
3080 /* Can't refer to a particular member of a vector. */
3082 else if (TREE_CODE (index
) == INTEGER_CST
)
3083 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3085 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3086 /*reference*/false, tf_none
);
3089 tree objtype
= TREE_TYPE (obj
);
3090 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3092 /* When the destination object refers to a flexible array member
3093 verify that it matches the type of the source object except
3094 for its domain and qualifiers. */
3095 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3096 TYPE_MAIN_VARIANT (objtype
),
3097 COMPARE_REDECLARATION
));
3100 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3106 struct replace_placeholders_t
3108 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3109 tree exp
; /* The outermost exp. */
3110 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3111 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3114 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3115 build up subexpressions as we go deeper. */
3118 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3120 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3123 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3125 *walk_subtrees
= false;
3129 switch (TREE_CODE (*t
))
3131 case PLACEHOLDER_EXPR
:
3134 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3136 x
= TREE_OPERAND (x
, 0))
3137 gcc_assert (handled_component_p (x
));
3138 *t
= unshare_expr (x
);
3139 *walk_subtrees
= false;
3146 constructor_elt
*ce
;
3147 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3148 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3149 other than the d->exp one, those have PLACEHOLDER_EXPRs
3150 related to another object. */
3151 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3153 || d
->pset
->add (*t
))
3155 *walk_subtrees
= false;
3158 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3160 tree
*valp
= &ce
->value
;
3161 tree type
= TREE_TYPE (*valp
);
3164 /* Elements with RANGE_EXPR index shouldn't have any
3165 placeholders in them. */
3166 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3169 if (TREE_CODE (*valp
) == CONSTRUCTOR
3170 && AGGREGATE_TYPE_P (type
))
3172 /* If we're looking at the initializer for OBJ, then build
3173 a sub-object reference. If we're looking at an
3174 initializer for another object, just pass OBJ down. */
3175 if (same_type_ignoring_top_level_qualifiers_p
3176 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3177 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3178 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3179 valp
= &TARGET_EXPR_INITIAL (*valp
);
3182 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3185 *walk_subtrees
= false;
3190 if (d
->pset
->add (*t
))
3191 *walk_subtrees
= false;
3198 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3199 a PLACEHOLDER_EXPR has been encountered. */
3202 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3204 /* This is only relevant for C++14. */
3205 if (cxx_dialect
< cxx14
)
3208 /* If the object isn't a (member of a) class, do nothing. */
3210 while (TREE_CODE (op0
) == COMPONENT_REF
)
3211 op0
= TREE_OPERAND (op0
, 0);
3212 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3216 if (TREE_CODE (exp
) == TARGET_EXPR
)
3217 tp
= &TARGET_EXPR_INITIAL (exp
);
3218 hash_set
<tree
> pset
;
3219 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3220 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3222 *seen_p
= data
.seen
;
3226 /* Callback function for find_placeholders. */
3229 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3231 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3233 *walk_subtrees
= false;
3237 switch (TREE_CODE (*t
))
3239 case PLACEHOLDER_EXPR
:
3243 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3244 *walk_subtrees
= false;
3254 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3255 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3258 find_placeholders (tree exp
)
3260 /* This is only relevant for C++14. */
3261 if (cxx_dialect
< cxx14
)
3264 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3267 /* Similar to `build_nt', but for template definitions of dependent
3271 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3278 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3282 t
= make_node (code
);
3283 SET_EXPR_LOCATION (t
, loc
);
3284 length
= TREE_CODE_LENGTH (code
);
3286 for (i
= 0; i
< length
; i
++)
3287 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3293 /* Similar to `build', but for template definitions. */
3296 build_min (enum tree_code code
, tree tt
, ...)
3303 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3307 t
= make_node (code
);
3308 length
= TREE_CODE_LENGTH (code
);
3311 for (i
= 0; i
< length
; i
++)
3313 tree x
= va_arg (p
, tree
);
3314 TREE_OPERAND (t
, i
) = x
;
3315 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3316 TREE_SIDE_EFFECTS (t
) = 1;
3324 /* Similar to `build', but for template definitions of non-dependent
3325 expressions. NON_DEP is the non-dependent expression that has been
3329 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3336 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3338 va_start (p
, non_dep
);
3340 if (REFERENCE_REF_P (non_dep
))
3341 non_dep
= TREE_OPERAND (non_dep
, 0);
3343 t
= make_node (code
);
3344 length
= TREE_CODE_LENGTH (code
);
3345 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3346 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3348 for (i
= 0; i
< length
; i
++)
3349 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3351 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3352 /* This should not be considered a COMPOUND_EXPR, because it
3353 resolves to an overload. */
3354 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3357 return convert_from_reference (t
);
3360 /* Similar to build_min_nt, but call expressions */
3363 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3368 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3369 CALL_EXPR_FN (ret
) = fn
;
3370 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3371 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3372 CALL_EXPR_ARG (ret
, ix
) = t
;
3377 /* Similar to `build_min_nt_call_vec', but for template definitions of
3378 non-dependent expressions. NON_DEP is the non-dependent expression
3379 that has been built. */
3382 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3384 tree t
= build_min_nt_call_vec (fn
, argvec
);
3385 if (REFERENCE_REF_P (non_dep
))
3386 non_dep
= TREE_OPERAND (non_dep
, 0);
3387 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3388 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3389 return convert_from_reference (t
);
3392 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3393 a call to an operator overload. OP is the operator that has been
3394 overloaded. NON_DEP is the non-dependent expression that's been built,
3395 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3396 the overload that NON_DEP is calling. */
3399 build_min_non_dep_op_overload (enum tree_code op
,
3404 int nargs
, expected_nargs
;
3407 non_dep
= extract_call_expr (non_dep
);
3409 nargs
= call_expr_nargs (non_dep
);
3411 expected_nargs
= cp_tree_code_length (op
);
3412 if ((op
== POSTINCREMENT_EXPR
3413 || op
== POSTDECREMENT_EXPR
)
3414 /* With -fpermissive non_dep could be operator++(). */
3415 && (!flag_permissive
|| nargs
!= expected_nargs
))
3416 expected_nargs
+= 1;
3417 gcc_assert (nargs
== expected_nargs
);
3420 va_start (p
, overload
);
3422 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3425 for (int i
= 0; i
< nargs
; i
++)
3427 tree arg
= va_arg (p
, tree
);
3428 vec_safe_push (args
, arg
);
3431 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3433 tree object
= va_arg (p
, tree
);
3434 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3435 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3436 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3437 object
, method
, NULL_TREE
);
3438 for (int i
= 1; i
< nargs
; i
++)
3440 tree arg
= va_arg (p
, tree
);
3441 vec_safe_push (args
, arg
);
3448 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3450 tree call_expr
= extract_call_expr (call
);
3451 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3452 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3453 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3454 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3459 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3462 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3464 unsigned len
= vec_safe_length (old_vec
);
3465 gcc_assert (idx
<= len
);
3467 vec
<tree
, va_gc
> *new_vec
= NULL
;
3468 vec_alloc (new_vec
, len
+ 1);
3471 for (i
= 0; i
< len
; ++i
)
3474 new_vec
->quick_push (elt
);
3475 new_vec
->quick_push ((*old_vec
)[i
]);
3478 new_vec
->quick_push (elt
);
3484 get_type_decl (tree t
)
3486 if (TREE_CODE (t
) == TYPE_DECL
)
3489 return TYPE_STUB_DECL (t
);
3490 gcc_assert (t
== error_mark_node
);
3494 /* Returns the namespace that contains DECL, whether directly or
3498 decl_namespace_context (tree decl
)
3502 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3504 else if (TYPE_P (decl
))
3505 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3507 decl
= CP_DECL_CONTEXT (decl
);
3511 /* Returns true if decl is within an anonymous namespace, however deeply
3512 nested, or false otherwise. */
3515 decl_anon_ns_mem_p (const_tree decl
)
3517 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3519 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3521 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3523 decl
= CP_DECL_CONTEXT (decl
);
3525 return !TREE_PUBLIC (decl
);
3528 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3529 CALL_EXPRS. Return whether they are equivalent. */
3532 called_fns_equal (tree t1
, tree t2
)
3534 /* Core 1321: dependent names are equivalent even if the overload sets
3535 are different. But do compare explicit template arguments. */
3536 tree name1
= dependent_name (t1
);
3537 tree name2
= dependent_name (t2
);
3540 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3545 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3546 targs1
= TREE_OPERAND (t1
, 1);
3547 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3548 targs2
= TREE_OPERAND (t2
, 1);
3549 return cp_tree_equal (targs1
, targs2
);
3552 return cp_tree_equal (t1
, t2
);
3555 /* Return truthvalue of whether T1 is the same tree structure as T2.
3556 Return 1 if they are the same. Return 0 if they are different. */
3559 cp_tree_equal (tree t1
, tree t2
)
3561 enum tree_code code1
, code2
;
3568 code1
= TREE_CODE (t1
);
3569 code2
= TREE_CODE (t2
);
3574 if (CONSTANT_CLASS_P (t1
)
3575 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3581 /* There's only a single VOID_CST node, so we should never reach
3586 return tree_int_cst_equal (t1
, t2
);
3589 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3592 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3593 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3594 TREE_STRING_LENGTH (t1
));
3597 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3598 TREE_FIXED_CST (t2
));
3601 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3602 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3605 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3608 /* We need to do this when determining whether or not two
3609 non-type pointer to member function template arguments
3611 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3612 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3617 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3619 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3620 if (!cp_tree_equal (field
, elt2
->index
)
3621 || !cp_tree_equal (value
, elt2
->value
))
3628 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3630 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3632 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3635 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3640 call_expr_arg_iterator iter1
, iter2
;
3641 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3643 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3644 arg2
= first_call_expr_arg (t2
, &iter2
);
3646 arg1
= next_call_expr_arg (&iter1
),
3647 arg2
= next_call_expr_arg (&iter2
))
3648 if (!cp_tree_equal (arg1
, arg2
))
3657 tree o1
= TREE_OPERAND (t1
, 0);
3658 tree o2
= TREE_OPERAND (t2
, 0);
3660 /* Special case: if either target is an unallocated VAR_DECL,
3661 it means that it's going to be unified with whatever the
3662 TARGET_EXPR is really supposed to initialize, so treat it
3663 as being equivalent to anything. */
3664 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3665 && !DECL_RTL_SET_P (o1
))
3667 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3668 && !DECL_RTL_SET_P (o2
))
3670 else if (!cp_tree_equal (o1
, o2
))
3673 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3677 /* For comparing uses of parameters in late-specified return types
3678 with an out-of-class definition of the function, but can also come
3679 up for expressions that involve 'this' in a member function
3682 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3683 /* When comparing hash table entries, only an exact match is
3684 good enough; we don't want to replace 'this' with the
3685 version from another function. But be more flexible
3686 with local parameters in a requires-expression. */
3689 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3691 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3693 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3695 if (DECL_ARTIFICIAL (t1
)
3696 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3697 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3707 case IDENTIFIER_NODE
:
3710 case DEFERRED_PARSE
:
3714 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3715 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3716 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3717 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3718 BASELINK_FUNCTIONS (t2
)));
3720 case TEMPLATE_PARM_INDEX
:
3721 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3722 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3723 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3724 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3725 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3726 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3728 case TEMPLATE_ID_EXPR
:
3729 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3730 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3732 case CONSTRAINT_INFO
:
3733 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3734 CI_ASSOCIATED_CONSTRAINTS (t2
));
3737 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3738 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3739 CHECK_CONSTR_ARGS (t2
)));
3744 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3746 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3747 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3748 TREE_VEC_ELT (t2
, ix
)))
3756 tree o1
= TREE_OPERAND (t1
, 0);
3757 tree o2
= TREE_OPERAND (t2
, 0);
3759 if (code1
== SIZEOF_EXPR
)
3761 if (SIZEOF_EXPR_TYPE_P (t1
))
3762 o1
= TREE_TYPE (o1
);
3763 if (SIZEOF_EXPR_TYPE_P (t2
))
3764 o2
= TREE_TYPE (o2
);
3766 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3769 return same_type_p (o1
, o2
);
3771 return cp_tree_equal (o1
, o2
);
3776 tree t1_op1
, t2_op1
;
3778 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3781 t1_op1
= TREE_OPERAND (t1
, 1);
3782 t2_op1
= TREE_OPERAND (t2
, 1);
3783 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3786 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3790 /* Two pointer-to-members are the same if they point to the same
3791 field or function in the same class. */
3792 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3795 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3799 /* Two overloads. Must be exactly the same set of decls. */
3800 lkp_iterator
first (t1
);
3801 lkp_iterator
second (t2
);
3803 for (; first
&& second
; ++first
, ++second
)
3804 if (*first
!= *second
)
3806 return !(first
|| second
);
3810 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3812 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3813 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3816 case STATIC_CAST_EXPR
:
3817 case REINTERPRET_CAST_EXPR
:
3818 case CONST_CAST_EXPR
:
3819 case DYNAMIC_CAST_EXPR
:
3820 case IMPLICIT_CONV_EXPR
:
3823 case NON_LVALUE_EXPR
:
3824 case VIEW_CONVERT_EXPR
:
3825 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3827 /* Now compare operands as usual. */
3830 case DEFERRED_NOEXCEPT
:
3831 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3832 DEFERRED_NOEXCEPT_PATTERN (t2
))
3833 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3834 DEFERRED_NOEXCEPT_ARGS (t2
)));
3838 /* Two lambda-expressions are never considered equivalent. */
3845 switch (TREE_CODE_CLASS (code1
))
3849 case tcc_comparison
:
3850 case tcc_expression
:
3857 n
= cp_tree_operand_length (t1
);
3858 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3859 && n
!= TREE_OPERAND_LENGTH (t2
))
3862 for (i
= 0; i
< n
; ++i
)
3863 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3870 return same_type_p (t1
, t2
);
3874 /* We can get here with --disable-checking. */
3878 /* The type of ARG when used as an lvalue. */
3881 lvalue_type (tree arg
)
3883 tree type
= TREE_TYPE (arg
);
3887 /* The type of ARG for printing error messages; denote lvalues with
3891 error_type (tree arg
)
3893 tree type
= TREE_TYPE (arg
);
3895 if (TREE_CODE (type
) == ARRAY_TYPE
)
3897 else if (TREE_CODE (type
) == ERROR_MARK
)
3899 else if (lvalue_p (arg
))
3900 type
= build_reference_type (lvalue_type (arg
));
3901 else if (MAYBE_CLASS_TYPE_P (type
))
3902 type
= lvalue_type (arg
);
3907 /* Does FUNCTION use a variable-length argument list? */
3910 varargs_function_p (const_tree function
)
3912 return stdarg_p (TREE_TYPE (function
));
3915 /* Returns 1 if decl is a member of a class. */
3918 member_p (const_tree decl
)
3920 const_tree
const ctx
= DECL_CONTEXT (decl
);
3921 return (ctx
&& TYPE_P (ctx
));
3924 /* Create a placeholder for member access where we don't actually have an
3925 object that the access is against. */
3928 build_dummy_object (tree type
)
3930 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3931 return cp_build_fold_indirect_ref (decl
);
3934 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3935 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3936 binfo path from current_class_type to TYPE, or 0. */
3939 maybe_dummy_object (tree type
, tree
* binfop
)
3943 tree current
= current_nonlambda_class_type ();
3946 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3947 tf_warning_or_error
)))
3951 /* Reference from a nested class member function. */
3953 binfo
= TYPE_BINFO (type
);
3959 if (current_class_ref
3960 /* current_class_ref might not correspond to current_class_type if
3961 we're in tsubst_default_argument or a lambda-declarator; in either
3962 case, we want to use current_class_ref if it matches CONTEXT. */
3963 && (same_type_ignoring_top_level_qualifiers_p
3964 (TREE_TYPE (current_class_ref
), context
)))
3965 decl
= current_class_ref
;
3967 decl
= build_dummy_object (context
);
3972 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3975 is_dummy_object (const_tree ob
)
3977 if (INDIRECT_REF_P (ob
))
3978 ob
= TREE_OPERAND (ob
, 0);
3979 return (TREE_CODE (ob
) == CONVERT_EXPR
3980 && TREE_OPERAND (ob
, 0) == void_node
);
3983 /* Returns 1 iff type T is something we want to treat as a scalar type for
3984 the purpose of deciding whether it is trivial/POD/standard-layout. */
3987 scalarish_type_p (const_tree t
)
3989 if (t
== error_mark_node
)
3992 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3995 /* Returns true iff T requires non-trivial default initialization. */
3998 type_has_nontrivial_default_init (const_tree t
)
4000 t
= strip_array_types (CONST_CAST_TREE (t
));
4002 if (CLASS_TYPE_P (t
))
4003 return TYPE_HAS_COMPLEX_DFLT (t
);
4008 /* Track classes with only deleted copy/move constructors so that we can warn
4009 if they are used in call/return by value. */
4011 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4013 remember_deleted_copy (const_tree t
)
4015 if (!deleted_copy_types
)
4016 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4017 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4020 maybe_warn_parm_abi (tree t
, location_t loc
)
4022 if (!deleted_copy_types
4023 || !deleted_copy_types
->contains (t
))
4026 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4027 && classtype_has_non_deleted_move_ctor (t
))
4030 auto_diagnostic_group d
;
4031 if (flag_abi_version
> 12)
4032 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4033 "the calling convention for %qT, which was "
4034 "accidentally changed in 8.1", t
);
4036 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4037 "ally changes the calling convention for %qT", t
);
4039 inform (location_of (t
), " declared here");
4043 auto_diagnostic_group d
;
4044 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4045 "%<-fabi-version=13%> (GCC 8.2)", t
))
4046 inform (location_of (t
), " because all of its copy and move "
4047 "constructors are deleted");
4050 /* Returns true iff copying an object of type T (including via move
4051 constructor) is non-trivial. That is, T has no non-trivial copy
4052 constructors and no non-trivial move constructors, and not all copy/move
4053 constructors are deleted. This function implements the ABI notion of
4054 non-trivial copy, which has diverged from the one in the standard. */
4057 type_has_nontrivial_copy_init (const_tree type
)
4059 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4061 if (CLASS_TYPE_P (t
))
4063 gcc_assert (COMPLETE_TYPE_P (t
));
4065 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4066 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4070 if (cxx_dialect
< cxx11
)
4071 /* No deleted functions before C++11. */
4074 /* Before ABI v12 we did a bitwise copy of types with only deleted
4075 copy/move constructors. */
4076 if (!abi_version_at_least (12)
4077 && !(warn_abi
&& abi_version_crosses (12)))
4080 bool saw_copy
= false;
4081 bool saw_non_deleted
= false;
4082 bool saw_non_deleted_move
= false;
4084 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4085 saw_copy
= saw_non_deleted
= true;
4086 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4089 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4090 /* [class.copy]/8 If the class definition declares a move
4091 constructor or move assignment operator, the implicitly declared
4092 copy constructor is defined as deleted.... */;
4094 /* Any other reason the implicitly-declared function would be
4095 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4097 saw_non_deleted
= true;
4100 if (!saw_non_deleted
)
4101 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4107 if (!DECL_DELETED_FN (fn
))
4109 /* Not deleted, therefore trivial. */
4110 saw_non_deleted
= true;
4114 else if (move_fn_p (fn
))
4115 if (!DECL_DELETED_FN (fn
))
4116 saw_non_deleted_move
= true;
4119 gcc_assert (saw_copy
);
4121 /* ABI v12 buggily ignored move constructors. */
4122 bool v11nontriv
= false;
4123 bool v12nontriv
= !saw_non_deleted
;
4124 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4125 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4126 : flag_abi_version
== 12 ? v12nontriv
4128 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4129 : warn_abi_version
== 12 ? v12nontriv
4131 if (nontriv
!= warn_nontriv
)
4132 remember_deleted_copy (t
);
4140 /* Returns 1 iff type T is a trivially copyable type, as defined in
4141 [basic.types] and [class]. */
4144 trivially_copyable_p (const_tree t
)
4146 t
= strip_array_types (CONST_CAST_TREE (t
));
4148 if (CLASS_TYPE_P (t
))
4149 return ((!TYPE_HAS_COPY_CTOR (t
)
4150 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4151 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4152 && (!TYPE_HAS_COPY_ASSIGN (t
)
4153 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4154 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4155 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4157 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4158 return scalarish_type_p (t
);
4161 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4165 trivial_type_p (const_tree t
)
4167 t
= strip_array_types (CONST_CAST_TREE (t
));
4169 if (CLASS_TYPE_P (t
))
4170 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4171 && trivially_copyable_p (t
));
4173 return scalarish_type_p (t
);
4176 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4179 pod_type_p (const_tree t
)
4181 /* This CONST_CAST is okay because strip_array_types returns its
4182 argument unmodified and we assign it to a const_tree. */
4183 t
= strip_array_types (CONST_CAST_TREE(t
));
4185 if (!CLASS_TYPE_P (t
))
4186 return scalarish_type_p (t
);
4187 else if (cxx_dialect
> cxx98
)
4188 /* [class]/10: A POD struct is a class that is both a trivial class and a
4189 standard-layout class, and has no non-static data members of type
4190 non-POD struct, non-POD union (or array of such types).
4192 We don't need to check individual members because if a member is
4193 non-std-layout or non-trivial, the class will be too. */
4194 return (std_layout_type_p (t
) && trivial_type_p (t
));
4196 /* The C++98 definition of POD is different. */
4197 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4200 /* Returns true iff T is POD for the purpose of layout, as defined in the
4204 layout_pod_type_p (const_tree t
)
4206 t
= strip_array_types (CONST_CAST_TREE (t
));
4208 if (CLASS_TYPE_P (t
))
4209 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4211 return scalarish_type_p (t
);
4214 /* Returns true iff T is a standard-layout type, as defined in
4218 std_layout_type_p (const_tree t
)
4220 t
= strip_array_types (CONST_CAST_TREE (t
));
4222 if (CLASS_TYPE_P (t
))
4223 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4225 return scalarish_type_p (t
);
4228 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4230 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4231 as defined in [meta.unary.prop]. */
4234 type_has_unique_obj_representations (const_tree t
)
4238 t
= strip_array_types (CONST_CAST_TREE (t
));
4240 if (!trivially_copyable_p (t
))
4243 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4244 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4246 switch (TREE_CODE (t
))
4250 case REFERENCE_TYPE
:
4251 /* If some backend has any paddings in these types, we should add
4252 a target hook for this and handle it there. */
4256 /* For bool values other than 0 and 1 should only appear with
4257 undefined behavior. */
4261 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4264 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4265 when storing long double values, so for that we have to return false.
4266 Other kinds of floating point values are questionable due to +.0/-.0
4267 and NaNs, let's play safe for now. */
4270 case FIXED_POINT_TYPE
:
4278 return type_has_unique_obj_representations (TREE_TYPE (t
));
4281 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4282 if (CLASS_TYPE_P (t
))
4284 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4285 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4293 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4294 if (TREE_CODE (field
) == FIELD_DECL
)
4297 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4298 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4304 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4306 if (CLASS_TYPE_P (t
))
4308 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4309 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4324 /* Helper function for type_has_unique_obj_representations. */
4327 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4329 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4330 if (TREE_CODE (field
) != FIELD_DECL
)
4332 /* For bases, can't use type_has_unique_obj_representations here, as in
4333 struct S { int i : 24; S (); };
4334 struct T : public S { int j : 8; T (); };
4335 S doesn't have unique obj representations, but T does. */
4336 else if (DECL_FIELD_IS_BASE (field
))
4338 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4342 else if (DECL_C_BIT_FIELD (field
))
4344 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4345 if (!type_has_unique_obj_representations (btype
))
4348 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4352 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4353 if (TREE_CODE (field
) == FIELD_DECL
)
4355 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4356 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4357 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4360 if (DECL_SIZE (field
))
4362 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4366 if (cur
!= wi::to_offset (sz
))
4372 /* Nonzero iff type T is a class template implicit specialization. */
4375 class_tmpl_impl_spec_p (const_tree t
)
4377 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4380 /* Returns 1 iff zero initialization of type T means actually storing
4384 zero_init_p (const_tree t
)
4386 /* This CONST_CAST is okay because strip_array_types returns its
4387 argument unmodified and we assign it to a const_tree. */
4388 t
= strip_array_types (CONST_CAST_TREE(t
));
4390 if (t
== error_mark_node
)
4393 /* NULL pointers to data members are initialized with -1. */
4394 if (TYPE_PTRDATAMEM_P (t
))
4397 /* Classes that contain types that can't be zero-initialized, cannot
4398 be zero-initialized themselves. */
4399 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4405 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4406 non-type template parameter. If EXPLAIN, explain why not. */
4409 structural_type_p (tree t
, bool explain
)
4411 t
= strip_array_types (t
);
4412 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
4414 if (NULLPTR_TYPE_P (t
))
4416 if (TYPE_PTR_P (t
) || TYPE_PTRMEM_P (t
))
4418 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4420 if (!CLASS_TYPE_P (t
))
4422 if (TREE_CODE (t
) == UNION_TYPE
)
4425 inform (location_of (t
), "%qT is a union", t
);
4428 if (!literal_type_p (t
))
4431 explain_non_literal_class (t
);
4434 if (CLASSTYPE_HAS_MUTABLE (t
))
4437 inform (location_of (t
), "%qT has a mutable member", t
);
4440 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4441 m
= next_initializable_field (DECL_CHAIN (m
)))
4443 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4446 inform (location_of (m
), "%qD is not public", m
);
4449 if (!structural_type_p (TREE_TYPE (m
)))
4453 inform (location_of (m
), "%qD has a non-structural type", m
);
4454 structural_type_p (TREE_TYPE (m
), true);
4462 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4463 warn_unused_result attribute. */
4466 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4467 int /*flags*/, bool *no_add_attrs
)
4469 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4471 error ("%qE attribute argument must be a string constant", name
);
4472 *no_add_attrs
= true;
4474 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4476 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4477 && !DECL_CONSTRUCTOR_P (*node
))
4478 warning_at (DECL_SOURCE_LOCATION (*node
),
4479 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4480 "return type", name
, *node
);
4482 else if (OVERLOAD_TYPE_P (*node
))
4486 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4487 "functions or to class or enumeration types", name
);
4488 *no_add_attrs
= true;
4493 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4494 struct attribute_spec.handler. */
4496 handle_no_unique_addr_attribute (tree
* node
,
4502 if (TREE_CODE (*node
) != FIELD_DECL
)
4504 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4505 "non-static data members", name
);
4506 *no_add_attrs
= true;
4508 else if (DECL_C_BIT_FIELD (*node
))
4510 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4511 "a bit-field", name
);
4512 *no_add_attrs
= true;
4518 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4519 hot/cold attributes. */
4522 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4523 int flags
, bool *no_add_attrs
)
4525 *no_add_attrs
= true;
4526 if (TREE_CODE (*node
) == LABEL_DECL
4527 || TREE_CODE (*node
) == FUNCTION_DECL
)
4530 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4531 tree bname
= (is_attribute_p ("likely", name
)
4532 ? get_identifier ("hot") : get_identifier ("cold"));
4533 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4534 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4535 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4536 tree battr
= build_tree_list (bname
, NULL_TREE
);
4537 decl_attributes (node
, battr
, flags
);
4541 return error_mark_node
;
4544 /* Table of valid C++ attributes. */
4545 const struct attribute_spec cxx_attribute_table
[] =
4547 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4548 affects_type_identity, handler, exclude } */
4549 { "init_priority", 1, 1, true, false, false, false,
4550 handle_init_priority_attribute
, NULL
},
4551 { "abi_tag", 1, -1, false, false, false, true,
4552 handle_abi_tag_attribute
, NULL
},
4553 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4556 /* Table of C++ standard attributes. */
4557 const struct attribute_spec std_attribute_table
[] =
4559 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4560 affects_type_identity, handler, exclude } */
4561 { "maybe_unused", 0, 0, false, false, false, false,
4562 handle_unused_attribute
, NULL
},
4563 { "nodiscard", 0, 1, false, false, false, false,
4564 handle_nodiscard_attribute
, NULL
},
4565 { "no_unique_address", 0, 0, true, false, false, false,
4566 handle_no_unique_addr_attribute
, NULL
},
4567 { "likely", 0, 0, false, false, false, false,
4568 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4569 { "unlikely", 0, 0, false, false, false, false,
4570 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4571 { "noreturn", 0, 0, true, false, false, false,
4572 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4573 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4576 /* Handle an "init_priority" attribute; arguments as in
4577 struct attribute_spec.handler. */
4579 handle_init_priority_attribute (tree
* node
,
4585 tree initp_expr
= TREE_VALUE (args
);
4587 tree type
= TREE_TYPE (decl
);
4590 STRIP_NOPS (initp_expr
);
4591 initp_expr
= default_conversion (initp_expr
);
4593 initp_expr
= maybe_constant_value (initp_expr
);
4595 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4597 error ("requested %<init_priority%> is not an integer constant");
4598 cxx_constant_value (initp_expr
);
4599 *no_add_attrs
= true;
4603 pri
= TREE_INT_CST_LOW (initp_expr
);
4605 type
= strip_array_types (type
);
4607 if (decl
== NULL_TREE
4609 || !TREE_STATIC (decl
)
4610 || DECL_EXTERNAL (decl
)
4611 || (TREE_CODE (type
) != RECORD_TYPE
4612 && TREE_CODE (type
) != UNION_TYPE
)
4613 /* Static objects in functions are initialized the
4614 first time control passes through that
4615 function. This is not precise enough to pin down an
4616 init_priority value, so don't allow it. */
4617 || current_function_decl
)
4619 error ("can only use %qE attribute on file-scope definitions "
4620 "of objects of class type", name
);
4621 *no_add_attrs
= true;
4625 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4627 error ("requested %<init_priority%> %i is out of range [0, %i]",
4628 pri
, MAX_INIT_PRIORITY
);
4629 *no_add_attrs
= true;
4633 /* Check for init_priorities that are reserved for
4634 language and runtime support implementations.*/
4635 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4638 (0, "requested %<init_priority%> %i is reserved for internal use",
4642 if (SUPPORTS_INIT_PRIORITY
)
4644 SET_DECL_INIT_PRIORITY (decl
, pri
);
4645 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4650 error ("%qE attribute is not supported on this platform", name
);
4651 *no_add_attrs
= true;
4656 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4657 and the new one has the tags in NEW_. Give an error if there are tags
4658 in NEW_ that weren't in OLD. */
4661 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4663 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4664 old
= TREE_VALUE (old
);
4665 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4666 new_
= TREE_VALUE (new_
);
4668 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4670 tree str
= TREE_VALUE (t
);
4671 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4673 tree ostr
= TREE_VALUE (in
);
4674 if (cp_tree_equal (str
, ostr
))
4677 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4683 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4689 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4690 ill-formed, give an error and return false; otherwise, return true. */
4693 check_abi_tag_args (tree args
, tree name
)
4697 error ("the %qE attribute requires arguments", name
);
4700 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4702 tree elt
= TREE_VALUE (arg
);
4703 if (TREE_CODE (elt
) != STRING_CST
4704 || (!same_type_ignoring_top_level_qualifiers_p
4705 (strip_array_types (TREE_TYPE (elt
)),
4708 error ("arguments to the %qE attribute must be narrow string "
4712 const char *begin
= TREE_STRING_POINTER (elt
);
4713 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4714 for (const char *p
= begin
; p
!= end
; ++p
)
4719 if (!ISALPHA (c
) && c
!= '_')
4721 error ("arguments to the %qE attribute must contain valid "
4722 "identifiers", name
);
4723 inform (input_location
, "%<%c%> is not a valid first "
4724 "character for an identifier", c
);
4728 else if (p
== end
- 1)
4729 gcc_assert (c
== 0);
4732 if (!ISALNUM (c
) && c
!= '_')
4734 error ("arguments to the %qE attribute must contain valid "
4735 "identifiers", name
);
4736 inform (input_location
, "%<%c%> is not a valid character "
4737 "in an identifier", c
);
4746 /* Handle an "abi_tag" attribute; arguments as in
4747 struct attribute_spec.handler. */
4750 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4751 int flags
, bool* no_add_attrs
)
4753 if (!check_abi_tag_args (args
, name
))
4758 if (!OVERLOAD_TYPE_P (*node
))
4760 error ("%qE attribute applied to non-class, non-enum type %qT",
4764 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4766 error ("%qE attribute applied to %qT after its definition",
4770 else if (CLASS_TYPE_P (*node
)
4771 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4773 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4774 "template instantiation %qT", name
, *node
);
4777 else if (CLASS_TYPE_P (*node
)
4778 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4780 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4781 "template specialization %qT", name
, *node
);
4785 tree attributes
= TYPE_ATTRIBUTES (*node
);
4786 tree decl
= TYPE_NAME (*node
);
4788 /* Make sure all declarations have the same abi tags. */
4789 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4791 if (!check_abi_tag_redeclaration (decl
,
4792 lookup_attribute ("abi_tag",
4800 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4802 error ("%qE attribute applied to non-function, non-variable %qD",
4806 else if (DECL_LANGUAGE (*node
) == lang_c
)
4808 error ("%qE attribute applied to extern \"C\" declaration %qD",
4817 *no_add_attrs
= true;
4821 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4822 thing pointed to by the constant. */
4825 make_ptrmem_cst (tree type
, tree member
)
4827 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4828 TREE_TYPE (ptrmem_cst
) = type
;
4829 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4833 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4834 return an existing type if an appropriate type already exists. */
4837 cp_build_type_attribute_variant (tree type
, tree attributes
)
4841 new_type
= build_type_attribute_variant (type
, attributes
);
4842 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4843 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4845 /* Making a new main variant of a class type is broken. */
4846 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4851 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4852 Called only after doing all language independent checks. */
4855 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4857 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4859 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4861 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4863 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4864 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4867 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4868 C++, these are the exception-specifier and ref-qualifier. */
4871 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4873 tree type
= CONST_CAST_TREE (typea
);
4874 if (FUNC_OR_METHOD_TYPE_P (type
))
4875 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4876 TYPE_RAISES_EXCEPTIONS (typeb
),
4877 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4881 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4882 traversal. Called from walk_tree. */
4885 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4886 void *data
, hash_set
<tree
> *pset
)
4888 enum tree_code code
= TREE_CODE (*tp
);
4891 #define WALK_SUBTREE(NODE) \
4894 result = cp_walk_tree (&(NODE), func, data, pset); \
4895 if (result) goto out; \
4899 /* Not one of the easy cases. We must explicitly go through the
4904 case DEFERRED_PARSE
:
4905 case TEMPLATE_TEMPLATE_PARM
:
4906 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4907 case UNBOUND_CLASS_TEMPLATE
:
4908 case TEMPLATE_PARM_INDEX
:
4909 case TEMPLATE_TYPE_PARM
:
4912 case UNDERLYING_TYPE
:
4913 /* None of these have subtrees other than those already walked
4915 *walk_subtrees_p
= 0;
4919 if (BASELINK_QUALIFIED_P (*tp
))
4920 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4921 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4922 *walk_subtrees_p
= 0;
4926 WALK_SUBTREE (TREE_TYPE (*tp
));
4927 *walk_subtrees_p
= 0;
4931 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4935 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4936 WALK_SUBTREE (OVL_CHAIN (*tp
));
4937 *walk_subtrees_p
= 0;
4941 WALK_SUBTREE (DECL_NAME (*tp
));
4942 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4943 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4944 *walk_subtrees_p
= 0;
4948 if (TYPE_PTRMEMFUNC_P (*tp
))
4949 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4952 case TYPE_ARGUMENT_PACK
:
4953 case NONTYPE_ARGUMENT_PACK
:
4955 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4956 int i
, len
= TREE_VEC_LENGTH (args
);
4957 for (i
= 0; i
< len
; i
++)
4958 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4962 case TYPE_PACK_EXPANSION
:
4963 WALK_SUBTREE (TREE_TYPE (*tp
));
4964 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4965 *walk_subtrees_p
= 0;
4968 case EXPR_PACK_EXPANSION
:
4969 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4970 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4971 *walk_subtrees_p
= 0;
4975 case REINTERPRET_CAST_EXPR
:
4976 case STATIC_CAST_EXPR
:
4977 case CONST_CAST_EXPR
:
4978 case DYNAMIC_CAST_EXPR
:
4979 case IMPLICIT_CONV_EXPR
:
4980 if (TREE_TYPE (*tp
))
4981 WALK_SUBTREE (TREE_TYPE (*tp
));
4985 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4986 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4988 *walk_subtrees_p
= 0;
4992 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4993 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4994 *walk_subtrees_p
= 0;
4998 ++cp_unevaluated_operand
;
4999 /* We can't use WALK_SUBTREE here because of the goto. */
5000 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5001 --cp_unevaluated_operand
;
5002 *walk_subtrees_p
= 0;
5008 ++cp_unevaluated_operand
;
5009 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5010 --cp_unevaluated_operand
;
5011 *walk_subtrees_p
= 0;
5015 // Only recurse through the nested expression. Do not
5016 // walk the parameter list. Doing so causes false
5017 // positives in the pack expansion checker since the
5018 // requires parameters are introduced as pack expansions.
5019 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5020 *walk_subtrees_p
= 0;
5024 /* User variables should be mentioned in BIND_EXPR_VARS
5025 and their initializers and sizes walked when walking
5026 the containing BIND_EXPR. Compiler temporaries are
5027 handled here. And also normal variables in templates,
5028 since do_poplevel doesn't build a BIND_EXPR then. */
5029 if (VAR_P (TREE_OPERAND (*tp
, 0))
5030 && (processing_template_decl
5031 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5032 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5034 tree decl
= TREE_OPERAND (*tp
, 0);
5035 WALK_SUBTREE (DECL_INITIAL (decl
));
5036 WALK_SUBTREE (DECL_SIZE (decl
));
5037 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5042 /* Don't walk into the body of the lambda, but the capture initializers
5043 are part of the enclosing context. */
5044 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5045 cap
= TREE_CHAIN (cap
))
5046 WALK_SUBTREE (TREE_VALUE (cap
));
5053 /* We didn't find what we were looking for. */
5060 /* Like save_expr, but for C++. */
5063 cp_save_expr (tree expr
)
5065 /* There is no reason to create a SAVE_EXPR within a template; if
5066 needed, we can create the SAVE_EXPR when instantiating the
5067 template. Furthermore, the middle-end cannot handle C++-specific
5069 if (processing_template_decl
)
5072 /* TARGET_EXPRs are only expanded once. */
5073 if (TREE_CODE (expr
) == TARGET_EXPR
)
5076 return save_expr (expr
);
5079 /* Initialize tree.c. */
5084 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5085 register_scoped_attributes (std_attribute_table
, NULL
);
5088 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5089 is. Note that sfk_none is zero, so this function can be used as a
5090 predicate to test whether or not DECL is a special function. */
5092 special_function_kind
5093 special_function_p (const_tree decl
)
5095 /* Rather than doing all this stuff with magic names, we should
5096 probably have a field of type `special_function_kind' in
5097 DECL_LANG_SPECIFIC. */
5098 if (DECL_INHERITED_CTOR (decl
))
5099 return sfk_inheriting_constructor
;
5100 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5101 return sfk_copy_constructor
;
5102 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5103 return sfk_move_constructor
;
5104 if (DECL_CONSTRUCTOR_P (decl
))
5105 return sfk_constructor
;
5106 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5107 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5109 if (copy_fn_p (decl
))
5110 return sfk_copy_assignment
;
5111 if (move_fn_p (decl
))
5112 return sfk_move_assignment
;
5114 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5115 return sfk_destructor
;
5116 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5117 return sfk_complete_destructor
;
5118 if (DECL_BASE_DESTRUCTOR_P (decl
))
5119 return sfk_base_destructor
;
5120 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5121 return sfk_deleting_destructor
;
5122 if (DECL_CONV_FN_P (decl
))
5123 return sfk_conversion
;
5124 if (deduction_guide_p (decl
))
5125 return sfk_deduction_guide
;
5126 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5127 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5128 return sfk_comparison
;
5133 /* As above, but only if DECL is a special member function as per 11.3.3
5134 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5136 special_function_kind
5137 special_memfn_p (const_tree decl
)
5139 switch (special_function_kind sfk
= special_function_p (decl
))
5141 case sfk_constructor
:
5142 if (!default_ctor_p (decl
))
5145 case sfk_copy_constructor
:
5146 case sfk_copy_assignment
:
5147 case sfk_move_assignment
:
5148 case sfk_move_constructor
:
5149 case sfk_destructor
:
5158 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5161 char_type_p (tree type
)
5163 return (same_type_p (type
, char_type_node
)
5164 || same_type_p (type
, unsigned_char_type_node
)
5165 || same_type_p (type
, signed_char_type_node
)
5166 || same_type_p (type
, char8_type_node
)
5167 || same_type_p (type
, char16_type_node
)
5168 || same_type_p (type
, char32_type_node
)
5169 || same_type_p (type
, wchar_type_node
));
5172 /* Returns the kind of linkage associated with the indicated DECL. Th
5173 value returned is as specified by the language standard; it is
5174 independent of implementation details regarding template
5175 instantiation, etc. For example, it is possible that a declaration
5176 to which this function assigns external linkage would not show up
5177 as a global symbol when you run `nm' on the resulting object file. */
5180 decl_linkage (tree decl
)
5182 /* This function doesn't attempt to calculate the linkage from first
5183 principles as given in [basic.link]. Instead, it makes use of
5184 the fact that we have already set TREE_PUBLIC appropriately, and
5185 then handles a few special cases. Ideally, we would calculate
5186 linkage first, and then transform that into a concrete
5189 /* Things that don't have names have no linkage. */
5190 if (!DECL_NAME (decl
))
5193 /* Fields have no linkage. */
5194 if (TREE_CODE (decl
) == FIELD_DECL
)
5197 /* Things that are TREE_PUBLIC have external linkage. */
5198 if (TREE_PUBLIC (decl
))
5201 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5202 check one of the "clones" for the real linkage. */
5203 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5204 && DECL_CHAIN (decl
)
5205 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5206 return decl_linkage (DECL_CHAIN (decl
));
5208 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5211 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5213 if (TREE_CODE (decl
) == CONST_DECL
)
5214 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5216 /* Things in local scope do not have linkage, if they don't have
5218 if (decl_function_context (decl
))
5221 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5222 are considered to have external linkage for language purposes, as do
5223 template instantiations on targets without weak symbols. DECLs really
5224 meant to have internal linkage have DECL_THIS_STATIC set. */
5225 if (TREE_CODE (decl
) == TYPE_DECL
)
5227 if (VAR_OR_FUNCTION_DECL_P (decl
))
5229 if (!DECL_THIS_STATIC (decl
))
5232 /* Static data members and static member functions from classes
5233 in anonymous namespace also don't have TREE_PUBLIC set. */
5234 if (DECL_CLASS_CONTEXT (decl
))
5238 /* Everything else has internal linkage. */
5242 /* Returns the storage duration of the object or reference associated with
5243 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5246 decl_storage_duration (tree decl
)
5248 if (TREE_CODE (decl
) == PARM_DECL
)
5250 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5252 gcc_assert (VAR_P (decl
));
5253 if (!TREE_STATIC (decl
)
5254 && !DECL_EXTERNAL (decl
))
5256 if (CP_DECL_THREAD_LOCAL_P (decl
))
5261 /* EXP is an expression that we want to pre-evaluate. Returns (in
5262 *INITP) an expression that will perform the pre-evaluation. The
5263 value returned by this function is a side-effect free expression
5264 equivalent to the pre-evaluated expression. Callers must ensure
5265 that *INITP is evaluated before EXP. */
5268 stabilize_expr (tree exp
, tree
* initp
)
5272 if (!TREE_SIDE_EFFECTS (exp
))
5273 init_expr
= NULL_TREE
;
5274 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5279 /* There are no expressions with REFERENCE_TYPE, but there can be call
5280 arguments with such a type; just treat it as a pointer. */
5281 else if (TYPE_REF_P (TREE_TYPE (exp
))
5282 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5283 || !glvalue_p (exp
))
5285 init_expr
= get_target_expr (exp
);
5286 exp
= TARGET_EXPR_SLOT (init_expr
);
5287 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5294 bool xval
= !lvalue_p (exp
);
5295 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5296 init_expr
= get_target_expr (exp
);
5297 exp
= TARGET_EXPR_SLOT (init_expr
);
5298 exp
= cp_build_fold_indirect_ref (exp
);
5304 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5308 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5309 similar expression ORIG. */
5312 add_stmt_to_compound (tree orig
, tree new_expr
)
5314 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5316 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5318 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5321 /* Like stabilize_expr, but for a call whose arguments we want to
5322 pre-evaluate. CALL is modified in place to use the pre-evaluated
5323 arguments, while, upon return, *INITP contains an expression to
5324 compute the arguments. */
5327 stabilize_call (tree call
, tree
*initp
)
5329 tree inits
= NULL_TREE
;
5331 int nargs
= call_expr_nargs (call
);
5333 if (call
== error_mark_node
|| processing_template_decl
)
5339 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5341 for (i
= 0; i
< nargs
; i
++)
5344 CALL_EXPR_ARG (call
, i
) =
5345 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5346 inits
= add_stmt_to_compound (inits
, init
);
5352 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5353 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5354 arguments, while, upon return, *INITP contains an expression to
5355 compute the arguments. */
5358 stabilize_aggr_init (tree call
, tree
*initp
)
5360 tree inits
= NULL_TREE
;
5362 int nargs
= aggr_init_expr_nargs (call
);
5364 if (call
== error_mark_node
)
5367 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5369 for (i
= 0; i
< nargs
; i
++)
5372 AGGR_INIT_EXPR_ARG (call
, i
) =
5373 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5374 inits
= add_stmt_to_compound (inits
, init
);
5380 /* Like stabilize_expr, but for an initialization.
5382 If the initialization is for an object of class type, this function
5383 takes care not to introduce additional temporaries.
5385 Returns TRUE iff the expression was successfully pre-evaluated,
5386 i.e., if INIT is now side-effect free, except for, possibly, a
5387 single call to a constructor. */
5390 stabilize_init (tree init
, tree
*initp
)
5396 if (t
== error_mark_node
|| processing_template_decl
)
5399 if (TREE_CODE (t
) == INIT_EXPR
)
5400 t
= TREE_OPERAND (t
, 1);
5401 if (TREE_CODE (t
) == TARGET_EXPR
)
5402 t
= TARGET_EXPR_INITIAL (t
);
5404 /* If the RHS can be stabilized without breaking copy elision, stabilize
5405 it. We specifically don't stabilize class prvalues here because that
5406 would mean an extra copy, but they might be stabilized below. */
5407 if (TREE_CODE (init
) == INIT_EXPR
5408 && TREE_CODE (t
) != CONSTRUCTOR
5409 && TREE_CODE (t
) != AGGR_INIT_EXPR
5410 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5413 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5417 if (TREE_CODE (t
) == COMPOUND_EXPR
5418 && TREE_CODE (init
) == INIT_EXPR
)
5420 tree last
= expr_last (t
);
5421 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5422 if (!TREE_SIDE_EFFECTS (last
))
5425 TREE_OPERAND (init
, 1) = last
;
5430 if (TREE_CODE (t
) == CONSTRUCTOR
)
5432 /* Aggregate initialization: stabilize each of the field
5435 constructor_elt
*ce
;
5437 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5438 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5440 tree type
= TREE_TYPE (ce
->value
);
5442 if (TYPE_REF_P (type
)
5443 || SCALAR_TYPE_P (type
))
5444 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5445 else if (!stabilize_init (ce
->value
, &subinit
))
5447 *initp
= add_stmt_to_compound (*initp
, subinit
);
5452 if (TREE_CODE (t
) == CALL_EXPR
)
5454 stabilize_call (t
, initp
);
5458 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5460 stabilize_aggr_init (t
, initp
);
5464 /* The initialization is being performed via a bitwise copy -- and
5465 the item copied may have side effects. */
5466 return !TREE_SIDE_EFFECTS (init
);
5469 /* Returns true if a cast to TYPE may appear in an integral constant
5473 cast_valid_in_integral_constant_expression_p (tree type
)
5475 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5476 || cxx_dialect
>= cxx11
5477 || dependent_type_p (type
)
5478 || type
== error_mark_node
);
5481 /* Return true if we need to fix linkage information of DECL. */
5484 cp_fix_function_decl_p (tree decl
)
5486 /* Skip if DECL is not externally visible. */
5487 if (!TREE_PUBLIC (decl
))
5490 /* We need to fix DECL if it a appears to be exported but with no
5491 function body. Thunks do not have CFGs and we may need to
5492 handle them specially later. */
5493 if (!gimple_has_body_p (decl
)
5494 && !DECL_THUNK_P (decl
)
5495 && !DECL_EXTERNAL (decl
))
5497 struct cgraph_node
*node
= cgraph_node::get (decl
);
5499 /* Don't fix same_body aliases. Although they don't have their own
5500 CFG, they share it with what they alias to. */
5501 if (!node
|| !node
->alias
5502 || !vec_safe_length (node
->ref_list
.references
))
5509 /* Clean the C++ specific parts of the tree T. */
5512 cp_free_lang_data (tree t
)
5514 if (FUNC_OR_METHOD_TYPE_P (t
))
5516 /* Default args are not interesting anymore. */
5517 tree argtypes
= TYPE_ARG_TYPES (t
);
5520 TREE_PURPOSE (argtypes
) = 0;
5521 argtypes
= TREE_CHAIN (argtypes
);
5524 else if (TREE_CODE (t
) == FUNCTION_DECL
5525 && cp_fix_function_decl_p (t
))
5527 /* If T is used in this translation unit at all, the definition
5528 must exist somewhere else since we have decided to not emit it
5529 in this TU. So make it an external reference. */
5530 DECL_EXTERNAL (t
) = 1;
5531 TREE_STATIC (t
) = 0;
5533 if (TREE_CODE (t
) == FUNCTION_DECL
)
5534 discard_operator_bindings (t
);
5535 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5536 /* We do not need the leftover chaining of namespaces from the
5538 DECL_CHAIN (t
) = NULL_TREE
;
5541 /* Stub for c-common. Please keep in sync with c-decl.c.
5542 FIXME: If address space support is target specific, then this
5543 should be a C target hook. But currently this is not possible,
5544 because this function is called via REGISTER_TARGET_PRAGMAS. */
5546 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5550 /* Return the number of operands in T that we care about for things like
5554 cp_tree_operand_length (const_tree t
)
5556 enum tree_code code
= TREE_CODE (t
);
5558 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5559 return VL_EXP_OPERAND_LENGTH (t
);
5561 return cp_tree_code_length (code
);
5564 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5567 cp_tree_code_length (enum tree_code code
)
5569 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5573 case PREINCREMENT_EXPR
:
5574 case PREDECREMENT_EXPR
:
5575 case POSTINCREMENT_EXPR
:
5576 case POSTDECREMENT_EXPR
:
5582 case EXPR_PACK_EXPANSION
:
5586 return TREE_CODE_LENGTH (code
);
5590 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5594 cp_expr_location (const_tree t_
)
5596 tree t
= CONST_CAST_TREE (t_
);
5598 return UNKNOWN_LOCATION
;
5599 switch (TREE_CODE (t
))
5602 return LAMBDA_EXPR_LOCATION (t
);
5604 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5606 return TRAIT_EXPR_LOCATION (t
);
5608 return EXPR_LOCATION (t
);
5612 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5613 conditions for the warning hold, false otherwise. */
5615 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5617 if (c_inhibit_evaluation_warnings
== 0
5618 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5620 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5621 "zero as null pointer constant");
5627 /* Given an initializer INIT for a TYPE, return true if INIT is zero
5628 so that it can be replaced by value initialization. This function
5629 distinguishes betwen empty strings as initializers for arrays and
5630 for pointers (which make it return false). */
5633 type_initializer_zero_p (tree type
, tree init
)
5635 if (type
== error_mark_node
|| init
== error_mark_node
)
5640 if (POINTER_TYPE_P (type
))
5641 return TREE_CODE (init
) != STRING_CST
&& initializer_zerop (init
);
5643 if (TREE_CODE (init
) != CONSTRUCTOR
)
5644 return initializer_zerop (init
);
5646 if (TREE_CODE (type
) == ARRAY_TYPE
)
5648 tree elt_type
= TREE_TYPE (type
);
5649 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
5650 if (elt_type
== char_type_node
)
5651 return initializer_zerop (init
);
5654 unsigned HOST_WIDE_INT i
;
5655 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, elt_init
)
5656 if (!type_initializer_zero_p (elt_type
, elt_init
))
5661 if (TREE_CODE (type
) != RECORD_TYPE
)
5662 return initializer_zerop (init
);
5664 if (TYPE_NON_AGGREGATE_CLASS (type
))
5667 tree fld
= TYPE_FIELDS (type
);
5670 unsigned HOST_WIDE_INT i
;
5671 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init
), i
, fld_init
)
5673 fld
= next_initializable_field (fld
);
5677 tree fldtype
= TREE_TYPE (fld
);
5678 if (!type_initializer_zero_p (fldtype
, fld_init
))
5681 fld
= DECL_CHAIN (fld
);
5689 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5690 /* Complain that some language-specific thing hanging off a tree
5691 node has been accessed improperly. */
5694 lang_check_failed (const char* file
, int line
, const char* function
)
5696 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5697 function
, trim_filename (file
), line
);
5699 #endif /* ENABLE_TREE_CHECKING */
5703 namespace selftest
{
5705 /* Verify that lvalue_kind () works, for various expressions,
5706 and that location wrappers don't affect the results. */
5711 location_t loc
= BUILTINS_LOCATION
;
5713 /* Verify constants and parameters, without and with
5714 location wrappers. */
5715 tree int_cst
= build_int_cst (integer_type_node
, 42);
5716 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5718 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5719 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5720 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5722 tree string_lit
= build_string (4, "foo");
5723 TREE_TYPE (string_lit
) = char_array_type_node
;
5724 string_lit
= fix_string_type (string_lit
);
5725 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5727 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5728 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5729 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5731 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5732 get_identifier ("some_parm"),
5734 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5736 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5737 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5738 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5740 /* Verify that lvalue_kind of std::move on a parm isn't
5741 affected by location wrappers. */
5742 tree rvalue_ref_of_parm
= move (parm
);
5743 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5744 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5745 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5747 /* Verify lvalue_p. */
5748 ASSERT_FALSE (lvalue_p (int_cst
));
5749 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5750 ASSERT_TRUE (lvalue_p (parm
));
5751 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5752 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5753 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5756 /* Run all of the selftests within this file. */
5761 test_lvalue_kind ();
5764 } // namespace selftest
5766 #endif /* #if CHECKING_P */
5769 #include "gt-cp-tree.h"