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 *);
46 static tree
build_local_temp (tree
);
48 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
55 lvalue_kind (const_tree ref
)
57 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
58 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
64 if (REFERENCE_REF_P (ref
))
65 return lvalue_kind (TREE_OPERAND (ref
, 0));
68 && TYPE_REF_P (TREE_TYPE (ref
)))
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
72 && TREE_CODE (ref
) != PARM_DECL
74 && TREE_CODE (ref
) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
79 /* lvalue references and named rvalue references are lvalues. */
83 if (ref
== current_class_ptr
)
86 /* Expressions with cv void type are prvalues. */
87 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
90 switch (TREE_CODE (ref
))
95 /* preincrements and predecrements are valid lvals, provided
96 what they refer to are valid lvals. */
97 case PREINCREMENT_EXPR
:
98 case PREDECREMENT_EXPR
:
102 case VIEW_CONVERT_EXPR
:
103 return lvalue_kind (TREE_OPERAND (ref
, 0));
107 tree op1
= TREE_OPERAND (ref
, 0);
108 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
110 op1_lvalue_kind
= lvalue_kind (op1
);
111 if (op1_lvalue_kind
== clk_class
)
112 /* in the case of an array operand, the result is an lvalue if
113 that operand is an lvalue and an xvalue otherwise */
114 op1_lvalue_kind
= clk_rvalueref
;
115 return op1_lvalue_kind
;
123 if (TREE_CODE (ref
) == MEMBER_REF
)
124 op1_lvalue_kind
= clk_ordinary
;
126 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
127 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
128 op1_lvalue_kind
= clk_none
;
129 else if (op1_lvalue_kind
== clk_class
)
130 /* The result of a .* expression whose second operand is a pointer to a
131 data member is an lvalue if the first operand is an lvalue and an
133 op1_lvalue_kind
= clk_rvalueref
;
134 return op1_lvalue_kind
;
137 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
139 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
141 /* For static member function recurse on the BASELINK, we can get
142 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
143 OVERLOAD, the overload is resolved first if possible through
144 resolve_address_of_overloaded_function. */
145 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
146 return lvalue_kind (TREE_OPERAND (ref
, 1));
148 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
149 if (op1_lvalue_kind
== clk_class
)
150 /* If E1 is an lvalue, then E1.E2 is an lvalue;
151 otherwise E1.E2 is an xvalue. */
152 op1_lvalue_kind
= clk_rvalueref
;
154 /* Look at the member designator. */
155 if (!op1_lvalue_kind
)
157 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
158 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
159 situations. If we're seeing a COMPONENT_REF, it's a non-static
160 member, so it isn't an lvalue. */
161 op1_lvalue_kind
= clk_none
;
162 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
163 /* This can be IDENTIFIER_NODE in a template. */;
164 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
166 /* Clear the ordinary bit. If this object was a class
167 rvalue we want to preserve that information. */
168 op1_lvalue_kind
&= ~clk_ordinary
;
169 /* The lvalue is for a bitfield. */
170 op1_lvalue_kind
|= clk_bitfield
;
172 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
173 op1_lvalue_kind
|= clk_packed
;
175 return op1_lvalue_kind
;
178 case COMPOUND_LITERAL_EXPR
:
182 /* CONST_DECL without TREE_STATIC are enumeration values and
183 thus not lvalues. With TREE_STATIC they are used by ObjC++
184 in objc_build_string_object and need to be considered as
186 if (! TREE_STATIC (ref
))
190 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
191 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
193 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
194 && DECL_LANG_SPECIFIC (ref
)
195 && DECL_IN_AGGR_P (ref
))
202 case PLACEHOLDER_EXPR
:
205 /* A scope ref in a template, left as SCOPE_REF to support later
208 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
210 tree op
= TREE_OPERAND (ref
, 1);
211 if (TREE_CODE (op
) == FIELD_DECL
)
212 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
214 return lvalue_kind (op
);
219 /* Disallow <? and >? as lvalues if either argument side-effects. */
220 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
221 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
223 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
224 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
228 if (processing_template_decl
)
230 /* Within templates, a REFERENCE_TYPE will indicate whether
231 the COND_EXPR result is an ordinary lvalue or rvalueref.
232 Since REFERENCE_TYPEs are handled above, if we reach this
233 point, we know we got a plain rvalue. Unless we have a
234 type-dependent expr, that is, but we shouldn't be testing
235 lvalueness if we can't even tell the types yet! */
236 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
239 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
240 ? TREE_OPERAND (ref
, 1)
241 : TREE_OPERAND (ref
, 0));
242 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
246 /* We expect to see unlowered MODOP_EXPRs only during
247 template processing. */
248 gcc_assert (processing_template_decl
);
256 return lvalue_kind (TREE_OPERAND (ref
, 1));
262 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
265 /* We can see calls outside of TARGET_EXPR in templates. */
266 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
271 /* All functions (except non-static-member functions) are
273 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
274 ? clk_none
: clk_ordinary
);
277 /* We now represent a reference to a single static member function
279 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
280 its argument unmodified and we assign it to a const_tree. */
281 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
283 case NON_DEPENDENT_EXPR
:
285 return lvalue_kind (TREE_OPERAND (ref
, 0));
287 case TEMPLATE_PARM_INDEX
:
288 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
289 /* A template parameter object is an lvalue. */
295 if (!TREE_TYPE (ref
))
297 if (CLASS_TYPE_P (TREE_TYPE (ref
))
298 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
303 /* If one operand is not an lvalue at all, then this expression is
305 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
308 /* Otherwise, it's an lvalue, and it has all the odd properties
309 contributed by either operand. */
310 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
311 /* It's not an ordinary lvalue if it involves any other kind. */
312 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
313 op1_lvalue_kind
&= ~clk_ordinary
;
314 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
315 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
316 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
317 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
318 op1_lvalue_kind
= clk_none
;
319 return op1_lvalue_kind
;
322 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
325 real_lvalue_p (const_tree ref
)
327 cp_lvalue_kind kind
= lvalue_kind (ref
);
328 if (kind
& (clk_rvalueref
|clk_class
))
334 /* c-common wants us to return bool. */
337 lvalue_p (const_tree t
)
339 return real_lvalue_p (t
);
342 /* This differs from lvalue_p in that xvalues are included. */
345 glvalue_p (const_tree ref
)
347 cp_lvalue_kind kind
= lvalue_kind (ref
);
348 if (kind
& clk_class
)
351 return (kind
!= clk_none
);
354 /* This differs from glvalue_p in that class prvalues are included. */
357 obvalue_p (const_tree ref
)
359 return (lvalue_kind (ref
) != clk_none
);
362 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
363 reference), false otherwise. */
366 xvalue_p (const_tree ref
)
368 return (lvalue_kind (ref
) == clk_rvalueref
);
371 /* True if REF is a bit-field. */
374 bitfield_p (const_tree ref
)
376 return (lvalue_kind (ref
) & clk_bitfield
);
379 /* C++-specific version of stabilize_reference. */
382 cp_stabilize_reference (tree ref
)
384 STRIP_ANY_LOCATION_WRAPPER (ref
);
385 switch (TREE_CODE (ref
))
387 case NON_DEPENDENT_EXPR
:
388 /* We aren't actually evaluating this. */
391 /* We need to treat specially anything stabilize_reference doesn't
392 handle specifically. */
403 case ARRAY_RANGE_REF
:
407 cp_lvalue_kind kind
= lvalue_kind (ref
);
408 if ((kind
& ~clk_class
) != clk_none
)
410 tree type
= unlowered_expr_type (ref
);
411 bool rval
= !!(kind
& clk_rvalueref
);
412 type
= cp_build_reference_type (type
, rval
);
413 /* This inhibits warnings in, eg, cxx_mark_addressable
415 warning_sentinel
s (extra_warnings
);
416 ref
= build_static_cast (type
, ref
, tf_error
);
420 return stabilize_reference (ref
);
423 /* Test whether DECL is a builtin that may appear in a
424 constant-expression. */
427 builtin_valid_in_constant_expr_p (const_tree decl
)
429 STRIP_ANY_LOCATION_WRAPPER (decl
);
430 if (TREE_CODE (decl
) != FUNCTION_DECL
)
431 /* Not a function. */
433 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
435 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
438 /* Not a built-in. */
441 switch (DECL_FUNCTION_CODE (decl
))
443 /* These always have constant results like the corresponding
446 case BUILT_IN_FUNCTION
:
449 /* The following built-ins are valid in constant expressions
450 when their arguments are. */
451 case BUILT_IN_ADD_OVERFLOW_P
:
452 case BUILT_IN_SUB_OVERFLOW_P
:
453 case BUILT_IN_MUL_OVERFLOW_P
:
455 /* These have constant results even if their operands are
457 case BUILT_IN_CONSTANT_P
:
458 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
465 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
468 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
471 tree type
= TREE_TYPE (decl
);
473 value
= mark_rvalue_use (value
);
475 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
476 || TREE_TYPE (decl
) == TREE_TYPE (value
)
477 /* On ARM ctors return 'this'. */
478 || (TYPE_PTR_P (TREE_TYPE (value
))
479 && TREE_CODE (value
) == CALL_EXPR
)
480 || useless_type_conversion_p (TREE_TYPE (decl
),
483 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
484 moving a constant aggregate into .rodata. */
485 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
486 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
487 && !VOID_TYPE_P (TREE_TYPE (value
))
488 && reduced_constant_expression_p (value
))
489 TREE_READONLY (decl
) = true;
491 if (complain
& tf_no_cleanup
)
492 /* The caller is building a new-expr and does not need a cleanup. */
496 t
= cxx_maybe_build_cleanup (decl
, complain
);
497 if (t
== error_mark_node
)
498 return error_mark_node
;
500 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
501 if (location_t eloc
= cp_expr_location (value
))
502 SET_EXPR_LOCATION (t
, eloc
);
503 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
504 ignore the TARGET_EXPR. If there really turn out to be no
505 side-effects, then the optimizer should be able to get rid of
506 whatever code is generated anyhow. */
507 TREE_SIDE_EFFECTS (t
) = 1;
512 /* Return an undeclared local temporary of type TYPE for use in building a
516 build_local_temp (tree type
)
518 tree slot
= build_decl (input_location
,
519 VAR_DECL
, NULL_TREE
, type
);
520 DECL_ARTIFICIAL (slot
) = 1;
521 DECL_IGNORED_P (slot
) = 1;
522 DECL_CONTEXT (slot
) = current_function_decl
;
523 layout_decl (slot
, 0);
527 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
530 process_aggr_init_operands (tree t
)
534 side_effects
= TREE_SIDE_EFFECTS (t
);
538 n
= TREE_OPERAND_LENGTH (t
);
539 for (i
= 1; i
< n
; i
++)
541 tree op
= TREE_OPERAND (t
, i
);
542 if (op
&& TREE_SIDE_EFFECTS (op
))
549 TREE_SIDE_EFFECTS (t
) = side_effects
;
552 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
553 FN, and SLOT. NARGS is the number of call arguments which are specified
554 as a tree array ARGS. */
557 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
563 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
564 TREE_TYPE (t
) = return_type
;
565 AGGR_INIT_EXPR_FN (t
) = fn
;
566 AGGR_INIT_EXPR_SLOT (t
) = slot
;
567 for (i
= 0; i
< nargs
; i
++)
568 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
569 process_aggr_init_operands (t
);
573 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
574 target. TYPE is the type to be initialized.
576 Build an AGGR_INIT_EXPR to represent the initialization. This function
577 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
578 to initialize another object, whereas a TARGET_EXPR can either
579 initialize another object or create its own temporary object, and as a
580 result building up a TARGET_EXPR requires that the type's destructor be
584 build_aggr_init_expr (tree type
, tree init
)
591 gcc_assert (!VOID_TYPE_P (type
));
593 /* Don't build AGGR_INIT_EXPR in a template. */
594 if (processing_template_decl
)
597 fn
= cp_get_callee (init
);
599 return convert (type
, init
);
601 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
602 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
603 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
605 /* We split the CALL_EXPR into its function and its arguments here.
606 Then, in expand_expr, we put them back together. The reason for
607 this is that this expression might be a default argument
608 expression. In that case, we need a new temporary every time the
609 expression is used. That's what break_out_target_exprs does; it
610 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
611 temporary slot. Then, expand_expr builds up a call-expression
612 using the new slot. */
614 /* If we don't need to use a constructor to create an object of this
615 type, don't mess with AGGR_INIT_EXPR. */
616 if (is_ctor
|| TREE_ADDRESSABLE (type
))
618 slot
= build_local_temp (type
);
620 if (TREE_CODE (init
) == CALL_EXPR
)
622 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
623 call_expr_nargs (init
),
624 CALL_EXPR_ARGP (init
));
625 AGGR_INIT_FROM_THUNK_P (rval
)
626 = CALL_FROM_THUNK_P (init
);
630 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
631 aggr_init_expr_nargs (init
),
632 AGGR_INIT_EXPR_ARGP (init
));
633 AGGR_INIT_FROM_THUNK_P (rval
)
634 = AGGR_INIT_FROM_THUNK_P (init
);
636 TREE_SIDE_EFFECTS (rval
) = 1;
637 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
638 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
639 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
640 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
641 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
649 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
650 target. TYPE is the type that this initialization should appear to
653 Build an encapsulation of the initialization to perform
654 and return it so that it can be processed by language-independent
655 and language-specific expression expanders. */
658 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
660 tree rval
= build_aggr_init_expr (type
, init
);
663 if (init
== error_mark_node
)
664 return error_mark_node
;
666 if (!complete_type_or_maybe_complain (type
, init
, complain
))
667 return error_mark_node
;
669 /* Make sure that we're not trying to create an instance of an
671 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
672 return error_mark_node
;
674 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
675 slot
= AGGR_INIT_EXPR_SLOT (rval
);
676 else if (TREE_CODE (rval
) == CALL_EXPR
677 || TREE_CODE (rval
) == CONSTRUCTOR
)
678 slot
= build_local_temp (type
);
682 rval
= build_target_expr (slot
, rval
, complain
);
684 if (rval
!= error_mark_node
)
685 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
690 /* Subroutine of build_vec_init_expr: Build up a single element
691 intialization as a proxy for the full array initialization to get things
692 marked as used and any appropriate diagnostics.
694 Since we're deferring building the actual constructor calls until
695 gimplification time, we need to build one now and throw it away so
696 that the relevant constructor gets mark_used before cgraph decides
697 what functions are needed. Here we assume that init is either
698 NULL_TREE, void_type_node (indicating value-initialization), or
699 another array to copy. */
702 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
704 tree inner_type
= strip_array_types (type
);
706 if (integer_zerop (array_type_nelts_total (type
))
707 || !CLASS_TYPE_P (inner_type
))
708 /* No interesting initialization to do. */
709 return integer_zero_node
;
710 else if (init
== void_type_node
)
711 return build_value_init (inner_type
, complain
);
713 gcc_assert (init
== NULL_TREE
714 || (same_type_ignoring_top_level_qualifiers_p
715 (type
, TREE_TYPE (init
))));
717 releasing_vec argvec
;
720 tree init_type
= strip_array_types (TREE_TYPE (init
));
721 tree dummy
= build_dummy_object (init_type
);
722 if (!lvalue_p (init
))
723 dummy
= move (dummy
);
724 argvec
->quick_push (dummy
);
726 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
727 &argvec
, inner_type
, LOOKUP_NORMAL
,
730 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
731 we don't want one here because we aren't creating a temporary. */
732 if (TREE_CODE (init
) == TARGET_EXPR
)
733 init
= TARGET_EXPR_INITIAL (init
);
738 /* Return a TARGET_EXPR which expresses the initialization of an array to
739 be named later, either default-initialization or copy-initialization
740 from another array of the same type. */
743 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
746 bool value_init
= false;
747 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
749 if (init
== void_type_node
)
755 slot
= build_local_temp (type
);
756 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
757 TREE_SIDE_EFFECTS (init
) = true;
758 SET_EXPR_LOCATION (init
, input_location
);
760 if (cxx_dialect
>= cxx11
761 && potential_constant_expression (elt_init
))
762 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
763 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
768 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
769 that requires a constant expression. */
772 diagnose_non_constexpr_vec_init (tree expr
)
774 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
776 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
777 init
= void_type_node
;
779 init
= VEC_INIT_EXPR_INIT (expr
);
781 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
782 require_potential_constant_expression (elt_init
);
786 build_array_copy (tree init
)
788 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
791 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
795 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
797 gcc_assert (!VOID_TYPE_P (type
));
799 if (TREE_CODE (init
) == TARGET_EXPR
800 || init
== error_mark_node
)
802 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
803 && !VOID_TYPE_P (TREE_TYPE (init
))
804 && TREE_CODE (init
) != COND_EXPR
805 && TREE_CODE (init
) != CONSTRUCTOR
806 && TREE_CODE (init
) != VA_ARG_EXPR
)
807 /* We need to build up a copy constructor call. A void initializer
808 means we're being called from bot_manip. COND_EXPR is a special
809 case because we already have copies on the arms and we don't want
810 another one here. A CONSTRUCTOR is aggregate initialization, which
811 is handled separately. A VA_ARG_EXPR is magic creation of an
812 aggregate; there's no additional work to be done. */
813 return force_rvalue (init
, complain
);
815 return force_target_expr (type
, init
, complain
);
818 /* Like the above function, but without the checking. This function should
819 only be used by code which is deliberately trying to subvert the type
820 system, such as call_builtin_trap. Or build_over_call, to avoid
821 infinite recursion. */
824 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
828 gcc_assert (!VOID_TYPE_P (type
));
830 slot
= build_local_temp (type
);
831 return build_target_expr (slot
, init
, complain
);
834 /* Like build_target_expr_with_type, but use the type of INIT. */
837 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
839 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
840 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
841 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
842 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
845 init
= convert_bitfield_to_declared_type (init
);
846 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
851 get_target_expr (tree init
)
853 return get_target_expr_sfinae (init
, tf_warning_or_error
);
856 /* If EXPR is a bitfield reference, convert it to the declared type of
857 the bitfield, and return the resulting expression. Otherwise,
858 return EXPR itself. */
861 convert_bitfield_to_declared_type (tree expr
)
865 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
867 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
872 /* EXPR is being used in an rvalue context. Return a version of EXPR
873 that is marked as an rvalue. */
880 if (error_operand_p (expr
))
883 expr
= mark_rvalue_use (expr
);
887 Non-class rvalues always have cv-unqualified types. */
888 type
= TREE_TYPE (expr
);
889 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
890 type
= cv_unqualified (type
);
892 /* We need to do this for rvalue refs as well to get the right answer
893 from decltype; see c++/36628. */
894 if (!processing_template_decl
&& glvalue_p (expr
))
895 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
896 else if (type
!= TREE_TYPE (expr
))
897 expr
= build_nop (type
, expr
);
903 struct cplus_array_info
909 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
911 typedef cplus_array_info
*compare_type
;
913 static hashval_t
hash (tree t
);
914 static bool equal (tree
, cplus_array_info
*);
917 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
920 cplus_array_hasher::hash (tree t
)
924 hash
= TYPE_UID (TREE_TYPE (t
));
926 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
930 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
931 of type `cplus_array_info*'. */
934 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
936 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
939 /* Hash table containing dependent array types, which are unsuitable for
940 the language-independent type hash table. */
941 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
943 /* Build an ARRAY_TYPE without laying it out. */
946 build_min_array_type (tree elt_type
, tree index_type
)
948 tree t
= cxx_make_type (ARRAY_TYPE
);
949 TREE_TYPE (t
) = elt_type
;
950 TYPE_DOMAIN (t
) = index_type
;
954 /* Set TYPE_CANONICAL like build_array_type_1, but using
955 build_cplus_array_type. */
958 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
960 /* Set the canonical type for this new node. */
961 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
962 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
963 SET_TYPE_STRUCTURAL_EQUALITY (t
);
964 else if (TYPE_CANONICAL (elt_type
) != elt_type
965 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
967 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
969 ? TYPE_CANONICAL (index_type
) : index_type
);
971 TYPE_CANONICAL (t
) = t
;
974 /* Like build_array_type, but handle special C++ semantics: an array of a
975 variant element type is a variant of the array of the main variant of
979 build_cplus_array_type (tree elt_type
, tree index_type
)
983 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
984 return error_mark_node
;
986 bool dependent
= (uses_template_parms (elt_type
)
987 || (index_type
&& uses_template_parms (index_type
)));
989 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
990 /* Start with an array of the TYPE_MAIN_VARIANT. */
991 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
995 /* Since type_hash_canon calls layout_type, we need to use our own
997 cplus_array_info cai
;
1000 if (cplus_array_htab
== NULL
)
1001 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1003 hash
= TYPE_UID (elt_type
);
1005 hash
^= TYPE_UID (index_type
);
1006 cai
.type
= elt_type
;
1007 cai
.domain
= index_type
;
1009 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1011 /* We have found the type: we're done. */
1015 /* Build a new array type. */
1016 t
= build_min_array_type (elt_type
, index_type
);
1018 /* Store it in the hash table. */
1021 /* Set the canonical type for this new node. */
1022 set_array_type_canon (t
, elt_type
, index_type
);
1027 bool typeless_storage
1028 = (elt_type
== unsigned_char_type_node
1029 || elt_type
== signed_char_type_node
1030 || elt_type
== char_type_node
1031 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1032 && TYPE_CONTEXT (elt_type
) == std_node
1033 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1034 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1037 /* Now check whether we already have this array variant. */
1038 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1041 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1042 if (TREE_TYPE (t
) == elt_type
1043 && TYPE_NAME (t
) == NULL_TREE
1044 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1048 t
= build_min_array_type (elt_type
, index_type
);
1049 set_array_type_canon (t
, elt_type
, index_type
);
1053 /* Make sure sizes are shared with the main variant.
1054 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1055 as it will overwrite alignment etc. of all variants. */
1056 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1057 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1058 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1061 TYPE_MAIN_VARIANT (t
) = m
;
1062 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1063 TYPE_NEXT_VARIANT (m
) = t
;
1067 /* Avoid spurious warnings with VLAs (c++/54583). */
1068 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1069 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1071 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1072 place more easily. */
1073 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1074 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1075 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1076 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1078 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1079 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1081 /* The element type has been completed since the last time we saw
1082 this array type; update the layout and 'tor flags for any variants
1085 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1087 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1088 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1095 /* Return an ARRAY_TYPE with element type ELT and length N. */
1098 build_array_of_n_type (tree elt
, int n
)
1100 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1103 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1104 for C++14 but then removed. This should only be used for N3639
1105 specifically; code wondering more generally if something is a VLA should use
1109 array_of_runtime_bound_p (tree t
)
1111 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1113 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1115 tree dom
= TYPE_DOMAIN (t
);
1118 tree max
= TYPE_MAX_VALUE (dom
);
1119 return (!potential_rvalue_constant_expression (max
)
1120 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1123 /* True iff T is a variable length array. */
1128 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1130 if (tree dom
= TYPE_DOMAIN (t
))
1132 tree max
= TYPE_MAX_VALUE (dom
);
1133 if (!potential_rvalue_constant_expression (max
)
1134 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1140 /* Return a reference type node referring to TO_TYPE. If RVAL is
1141 true, return an rvalue reference type, otherwise return an lvalue
1142 reference type. If a type node exists, reuse it, otherwise create
1145 cp_build_reference_type (tree to_type
, bool rval
)
1149 if (to_type
== error_mark_node
)
1150 return error_mark_node
;
1152 if (TYPE_REF_P (to_type
))
1154 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1155 to_type
= TREE_TYPE (to_type
);
1158 lvalue_ref
= build_reference_type (to_type
);
1162 /* This code to create rvalue reference types is based on and tied
1163 to the code creating lvalue reference types in the middle-end
1164 functions build_reference_type_for_mode and build_reference_type.
1166 It works by putting the rvalue reference type nodes after the
1167 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1168 they will effectively be ignored by the middle end. */
1170 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1171 if (TYPE_REF_IS_RVALUE (t
))
1174 t
= build_distinct_type_copy (lvalue_ref
);
1176 TYPE_REF_IS_RVALUE (t
) = true;
1177 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1178 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1180 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1181 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1182 else if (TYPE_CANONICAL (to_type
) != to_type
)
1184 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1186 TYPE_CANONICAL (t
) = t
;
1194 /* Returns EXPR cast to rvalue reference type, like std::move. */
1199 tree type
= TREE_TYPE (expr
);
1200 gcc_assert (!TYPE_REF_P (type
));
1201 type
= cp_build_reference_type (type
, /*rval*/true);
1202 return build_static_cast (type
, expr
, tf_warning_or_error
);
1205 /* Used by the C++ front end to build qualified array types. However,
1206 the C version of this function does not properly maintain canonical
1207 types (which are not used in C). */
1209 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1210 size_t /* orig_qual_indirect */)
1212 return cp_build_qualified_type (type
, type_quals
);
1216 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1217 arrays correctly. In particular, if TYPE is an array of T's, and
1218 TYPE_QUALS is non-empty, returns an array of qualified T's.
1220 FLAGS determines how to deal with ill-formed qualifications. If
1221 tf_ignore_bad_quals is set, then bad qualifications are dropped
1222 (this is permitted if TYPE was introduced via a typedef or template
1223 type parameter). If bad qualifications are dropped and tf_warning
1224 is set, then a warning is issued for non-const qualifications. If
1225 tf_ignore_bad_quals is not set and tf_error is not set, we
1226 return error_mark_node. Otherwise, we issue an error, and ignore
1229 Qualification of a reference type is valid when the reference came
1230 via a typedef or template type argument. [dcl.ref] No such
1231 dispensation is provided for qualifying a function type. [dcl.fct]
1232 DR 295 queries this and the proposed resolution brings it into line
1233 with qualifying a reference. We implement the DR. We also behave
1234 in a similar manner for restricting non-pointer types. */
1237 cp_build_qualified_type_real (tree type
,
1239 tsubst_flags_t complain
)
1242 int bad_quals
= TYPE_UNQUALIFIED
;
1244 if (type
== error_mark_node
)
1247 if (type_quals
== cp_type_quals (type
))
1250 if (TREE_CODE (type
) == ARRAY_TYPE
)
1252 /* In C++, the qualification really applies to the array element
1253 type. Obtain the appropriately qualified element type. */
1256 = cp_build_qualified_type_real (TREE_TYPE (type
),
1260 if (element_type
== error_mark_node
)
1261 return error_mark_node
;
1263 /* See if we already have an identically qualified type. Tests
1264 should be equivalent to those in check_qualified_type. */
1265 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1266 if (TREE_TYPE (t
) == element_type
1267 && TYPE_NAME (t
) == TYPE_NAME (type
)
1268 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1269 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1270 TYPE_ATTRIBUTES (type
)))
1275 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1277 /* Keep the typedef name. */
1278 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1280 t
= build_variant_type_copy (t
);
1281 TYPE_NAME (t
) = TYPE_NAME (type
);
1282 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1283 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1287 /* Even if we already had this variant, we update
1288 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1289 they changed since the variant was originally created.
1291 This seems hokey; if there is some way to use a previous
1292 variant *without* coming through here,
1293 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1294 TYPE_NEEDS_CONSTRUCTING (t
)
1295 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1296 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1297 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1300 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1302 tree t
= PACK_EXPANSION_PATTERN (type
);
1304 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1305 return make_pack_expansion (t
, complain
);
1308 /* A reference or method type shall not be cv-qualified.
1309 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1310 (in CD1) we always ignore extra cv-quals on functions. */
1311 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1312 && (TYPE_REF_P (type
)
1313 || FUNC_OR_METHOD_TYPE_P (type
)))
1315 if (TYPE_REF_P (type
))
1316 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1317 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1320 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1321 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1322 type_quals
|= type_memfn_quals (type
);
1324 /* A restrict-qualified type must be a pointer (or reference)
1325 to object or incomplete type. */
1326 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1327 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1328 && TREE_CODE (type
) != TYPENAME_TYPE
1329 && !INDIRECT_TYPE_P (type
))
1331 bad_quals
|= TYPE_QUAL_RESTRICT
;
1332 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1335 if (bad_quals
== TYPE_UNQUALIFIED
1336 || (complain
& tf_ignore_bad_quals
))
1338 else if (!(complain
& tf_error
))
1339 return error_mark_node
;
1342 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1343 error ("%qV qualifiers cannot be applied to %qT",
1347 /* Retrieve (or create) the appropriately qualified variant. */
1348 result
= build_qualified_type (type
, type_quals
);
1353 /* Return TYPE with const and volatile removed. */
1356 cv_unqualified (tree type
)
1360 if (type
== error_mark_node
)
1363 quals
= cp_type_quals (type
);
1364 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1365 return cp_build_qualified_type (type
, quals
);
1368 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1369 from ATTRIBS that affect type identity, and no others. If any are not
1370 applied, set *remove_attributes to true. */
1373 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1375 tree first_ident
= NULL_TREE
;
1376 tree new_attribs
= NULL_TREE
;
1377 tree
*p
= &new_attribs
;
1379 if (OVERLOAD_TYPE_P (result
))
1381 /* On classes and enums all attributes are ingrained. */
1382 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1386 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1388 const attribute_spec
*as
1389 = lookup_attribute_spec (get_attribute_name (a
));
1390 if (as
&& as
->affects_type_identity
)
1394 else if (first_ident
== error_mark_node
)
1396 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1397 p
= &TREE_CHAIN (*p
);
1400 else if (first_ident
)
1402 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1404 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1405 p
= &TREE_CHAIN (*p
);
1407 first_ident
= error_mark_node
;
1410 if (first_ident
!= error_mark_node
)
1411 new_attribs
= first_ident
;
1413 if (first_ident
== attribs
)
1414 /* All attributes affected type identity. */;
1416 *remove_attributes
= true;
1418 return cp_build_type_attribute_variant (result
, new_attribs
);
1421 /* Builds a qualified variant of T that is not a typedef variant.
1422 E.g. consider the following declarations:
1423 typedef const int ConstInt;
1424 typedef ConstInt* PtrConstInt;
1425 If T is PtrConstInt, this function returns a type representing
1427 In other words, if T is a typedef, the function returns the underlying type.
1428 The cv-qualification and attributes of the type returned match the
1430 They will always be compatible types.
1431 The returned type is built so that all of its subtypes
1432 recursively have their typedefs stripped as well.
1434 This is different from just returning TYPE_CANONICAL (T)
1435 Because of several reasons:
1436 * If T is a type that needs structural equality
1437 its TYPE_CANONICAL (T) will be NULL.
1438 * TYPE_CANONICAL (T) desn't carry type attributes
1439 and loses template parameter names.
1441 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1442 affect type identity, and set the referent to true if any were
1446 strip_typedefs (tree t
, bool *remove_attributes
)
1448 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1450 if (!t
|| t
== error_mark_node
)
1453 if (TREE_CODE (t
) == TREE_LIST
)
1455 bool changed
= false;
1458 for (; t
; t
= TREE_CHAIN (t
))
1460 gcc_assert (!TREE_PURPOSE (t
));
1461 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1462 if (elt
!= TREE_VALUE (t
))
1464 vec_safe_push (vec
, elt
);
1467 r
= build_tree_list_vec (vec
);
1471 gcc_assert (TYPE_P (t
));
1473 if (t
== TYPE_CANONICAL (t
))
1476 if (dependent_alias_template_spec_p (t
))
1477 /* DR 1558: However, if the template-id is dependent, subsequent
1478 template argument substitution still applies to the template-id. */
1481 switch (TREE_CODE (t
))
1484 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1485 result
= build_pointer_type (type
);
1487 case REFERENCE_TYPE
:
1488 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1489 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1492 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1493 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1494 result
= build_offset_type (t0
, type
);
1497 if (TYPE_PTRMEMFUNC_P (t
))
1499 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1500 result
= build_ptrmemfunc_type (t0
);
1504 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1505 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1506 result
= build_cplus_array_type (type
, t0
);
1511 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1514 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1515 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1516 can't expect that re-hashing a function type will find a previous
1517 equivalent type, so try to reuse the input type if nothing has
1518 changed. If the type is itself a variant, that will change. */
1519 bool is_variant
= typedef_variant_p (t
);
1520 if (remove_attributes
1521 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1524 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1525 tree canon_spec
= (flag_noexcept_type
1526 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1528 changed
= (type
!= TREE_TYPE (t
) || is_variant
1529 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1531 for (arg_node
= TYPE_ARG_TYPES (t
);
1533 arg_node
= TREE_CHAIN (arg_node
))
1535 if (arg_node
== void_list_node
)
1537 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1539 gcc_assert (arg_type
);
1540 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1546 for (arg_node2
= TYPE_ARG_TYPES (t
);
1547 arg_node2
!= arg_node
;
1548 arg_node2
= TREE_CHAIN (arg_node2
))
1550 = tree_cons (TREE_PURPOSE (arg_node2
),
1551 TREE_VALUE (arg_node2
), arg_types
);
1555 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1562 arg_types
= nreverse (arg_types
);
1564 /* A list of parameters not ending with an ellipsis
1565 must end with void_list_node. */
1567 arg_types
= chainon (arg_types
, void_list_node
);
1569 if (TREE_CODE (t
) == METHOD_TYPE
)
1571 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1572 gcc_assert (class_type
);
1574 build_method_type_directly (class_type
, type
,
1575 TREE_CHAIN (arg_types
));
1579 result
= build_function_type (type
, arg_types
);
1580 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1583 result
= build_cp_fntype_variant (result
,
1584 type_memfn_rqual (t
), canon_spec
,
1585 TYPE_HAS_LATE_RETURN_TYPE (t
));
1590 bool changed
= false;
1591 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1592 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1593 && TREE_OPERAND (fullname
, 1))
1595 tree args
= TREE_OPERAND (fullname
, 1);
1596 tree new_args
= copy_node (args
);
1597 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1599 tree arg
= TREE_VEC_ELT (args
, i
);
1602 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1604 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1605 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1606 if (strip_arg
!= arg
)
1611 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1612 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1614 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1618 ggc_free (new_args
);
1620 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1621 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1623 tree name
= fullname
;
1624 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1625 name
= TREE_OPERAND (fullname
, 0);
1626 /* Use build_typename_type rather than make_typename_type because we
1627 don't want to resolve it here, just strip typedefs. */
1628 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1632 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1634 if (result
== DECLTYPE_TYPE_EXPR (t
))
1637 result
= (finish_decltype_type
1639 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1642 case UNDERLYING_TYPE
:
1643 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1644 result
= finish_underlying_type (type
);
1652 if (typedef_variant_p (t
))
1654 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1655 strip typedefs with attributes. */
1656 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1657 result
= strip_typedefs (result
);
1660 result
= TYPE_MAIN_VARIANT (t
);
1662 gcc_assert (!typedef_variant_p (result
));
1664 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1665 /* If RESULT is complete and T isn't, it's likely the case that T
1666 is a variant of RESULT which hasn't been updated yet. Skip the
1667 attribute handling. */;
1670 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1671 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1673 gcc_assert (TYPE_USER_ALIGN (t
));
1674 if (remove_attributes
)
1675 *remove_attributes
= true;
1678 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1679 result
= build_variant_type_copy (result
);
1681 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1682 TYPE_USER_ALIGN (result
) = true;
1686 if (TYPE_ATTRIBUTES (t
))
1688 if (remove_attributes
)
1689 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1692 result
= cp_build_type_attribute_variant (result
,
1693 TYPE_ATTRIBUTES (t
));
1697 return cp_build_qualified_type (result
, cp_type_quals (t
));
1700 /* Like strip_typedefs above, but works on expressions, so that in
1702 template<class T> struct A
1708 sizeof(TT) is replaced by sizeof(T). */
1711 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1715 enum tree_code code
;
1717 if (t
== NULL_TREE
|| t
== error_mark_node
)
1720 STRIP_ANY_LOCATION_WRAPPER (t
);
1722 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1725 /* Some expressions have type operands, so let's handle types here rather
1726 than check TYPE_P in multiple places below. */
1728 return strip_typedefs (t
, remove_attributes
);
1730 code
= TREE_CODE (t
);
1733 case IDENTIFIER_NODE
:
1734 case TEMPLATE_PARM_INDEX
:
1737 case ARGUMENT_PACK_SELECT
:
1742 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1743 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1744 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1745 && type2
== TRAIT_EXPR_TYPE2 (t
))
1748 TRAIT_EXPR_TYPE1 (r
) = type1
;
1749 TRAIT_EXPR_TYPE2 (r
) = type2
;
1756 bool changed
= false;
1758 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1760 tree val
= strip_typedefs_expr (TREE_VALUE (it
), remove_attributes
);
1761 vec_safe_push (vec
, val
);
1762 if (val
!= TREE_VALUE (it
))
1764 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1769 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1770 r
= tree_cons (NULL_TREE
, it
, r
);
1779 bool changed
= false;
1781 n
= TREE_VEC_LENGTH (t
);
1782 vec_safe_reserve (vec
, n
);
1783 for (i
= 0; i
< n
; ++i
)
1785 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1787 vec
->quick_push (op
);
1788 if (op
!= TREE_VEC_ELT (t
, i
))
1794 for (i
= 0; i
< n
; ++i
)
1795 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1796 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1797 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1806 bool changed
= false;
1807 vec
<constructor_elt
, va_gc
> *vec
1808 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1809 n
= CONSTRUCTOR_NELTS (t
);
1810 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1811 for (i
= 0; i
< n
; ++i
)
1813 constructor_elt
*e
= &(*vec
)[i
];
1814 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1821 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1824 if (!changed
&& type
== TREE_TYPE (t
))
1832 TREE_TYPE (r
) = type
;
1833 CONSTRUCTOR_ELTS (r
) = vec
;
1841 case STATEMENT_LIST
:
1842 error ("statement-expression in a constant expression");
1843 return error_mark_node
;
1849 gcc_assert (EXPR_P (t
));
1851 n
= cp_tree_operand_length (t
);
1852 ops
= XALLOCAVEC (tree
, n
);
1853 type
= TREE_TYPE (t
);
1858 case IMPLICIT_CONV_EXPR
:
1859 case DYNAMIC_CAST_EXPR
:
1860 case STATIC_CAST_EXPR
:
1861 case CONST_CAST_EXPR
:
1862 case REINTERPRET_CAST_EXPR
:
1865 type
= strip_typedefs (type
, remove_attributes
);
1869 for (i
= 0; i
< n
; ++i
)
1870 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1874 /* If nothing changed, return t. */
1875 for (i
= 0; i
< n
; ++i
)
1876 if (ops
[i
] != TREE_OPERAND (t
, i
))
1878 if (i
== n
&& type
== TREE_TYPE (t
))
1882 TREE_TYPE (r
) = type
;
1883 for (i
= 0; i
< n
; ++i
)
1884 TREE_OPERAND (r
, i
) = ops
[i
];
1888 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1889 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1890 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1891 VIRT indicates whether TYPE is inherited virtually or not.
1892 IGO_PREV points at the previous binfo of the inheritance graph
1893 order chain. The newly copied binfo's TREE_CHAIN forms this
1896 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1897 correct order. That is in the order the bases themselves should be
1900 The BINFO_INHERITANCE of a virtual base class points to the binfo
1901 of the most derived type. ??? We could probably change this so that
1902 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1903 remove a field. They currently can only differ for primary virtual
1907 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1913 /* See if we've already made this virtual base. */
1914 new_binfo
= binfo_for_vbase (type
, t
);
1919 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1920 BINFO_TYPE (new_binfo
) = type
;
1922 /* Chain it into the inheritance graph. */
1923 TREE_CHAIN (*igo_prev
) = new_binfo
;
1924 *igo_prev
= new_binfo
;
1926 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1931 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1933 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1934 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1936 /* We do not need to copy the accesses, as they are read only. */
1937 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1939 /* Recursively copy base binfos of BINFO. */
1940 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1942 tree new_base_binfo
;
1943 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1945 BINFO_VIRTUAL_P (base_binfo
));
1947 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1948 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1949 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1953 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1957 /* Push it onto the list after any virtual bases it contains
1958 will have been pushed. */
1959 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1960 BINFO_VIRTUAL_P (new_binfo
) = 1;
1961 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1967 /* Hashing of lists so that we don't make duplicates.
1968 The entry point is `list_hash_canon'. */
1977 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1979 typedef list_proxy
*compare_type
;
1981 static hashval_t
hash (tree
);
1982 static bool equal (tree
, list_proxy
*);
1985 /* Now here is the hash table. When recording a list, it is added
1986 to the slot whose index is the hash code mod the table size.
1987 Note that the hash table is used for several kinds of lists.
1988 While all these live in the same table, they are completely independent,
1989 and the hash code is computed differently for each of these. */
1991 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1993 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1994 for a node we are thinking about adding). */
1997 list_hasher::equal (tree t
, list_proxy
*proxy
)
1999 return (TREE_VALUE (t
) == proxy
->value
2000 && TREE_PURPOSE (t
) == proxy
->purpose
2001 && TREE_CHAIN (t
) == proxy
->chain
);
2004 /* Compute a hash code for a list (chain of TREE_LIST nodes
2005 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2006 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2009 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2011 hashval_t hashcode
= 0;
2014 hashcode
+= TREE_HASH (chain
);
2017 hashcode
+= TREE_HASH (value
);
2021 hashcode
+= TREE_HASH (purpose
);
2027 /* Hash an already existing TREE_LIST. */
2030 list_hasher::hash (tree t
)
2032 return list_hash_pieces (TREE_PURPOSE (t
),
2037 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2038 object for an identical list if one already exists. Otherwise, build a
2039 new one, and record it as the canonical object. */
2042 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2046 struct list_proxy proxy
;
2048 /* Hash the list node. */
2049 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2050 /* Create a proxy for the TREE_LIST we would like to create. We
2051 don't actually create it so as to avoid creating garbage. */
2052 proxy
.purpose
= purpose
;
2053 proxy
.value
= value
;
2054 proxy
.chain
= chain
;
2055 /* See if it is already in the table. */
2056 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2057 /* If not, create a new node. */
2059 *slot
= tree_cons (purpose
, value
, chain
);
2060 return (tree
) *slot
;
2063 /* Constructor for hashed lists. */
2066 hash_tree_chain (tree value
, tree chain
)
2068 return hash_tree_cons (NULL_TREE
, value
, chain
);
2072 debug_binfo (tree elem
)
2077 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2079 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2080 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2081 debug_tree (BINFO_TYPE (elem
));
2082 if (BINFO_VTABLE (elem
))
2083 fprintf (stderr
, "vtable decl \"%s\"\n",
2084 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2086 fprintf (stderr
, "no vtable decl yet\n");
2087 fprintf (stderr
, "virtuals:\n");
2088 virtuals
= BINFO_VIRTUALS (elem
);
2093 tree fndecl
= TREE_VALUE (virtuals
);
2094 fprintf (stderr
, "%s [%ld =? %ld]\n",
2095 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2096 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2098 virtuals
= TREE_CHAIN (virtuals
);
2102 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2103 the type of the result expression, if known, or NULL_TREE if the
2104 resulting expression is type-dependent. If TEMPLATE_P is true,
2105 NAME is known to be a template because the user explicitly used the
2106 "template" keyword after the "::".
2108 All SCOPE_REFs should be built by use of this function. */
2111 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2114 if (type
== error_mark_node
2115 || scope
== error_mark_node
2116 || name
== error_mark_node
)
2117 return error_mark_node
;
2118 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2119 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2120 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2121 PTRMEM_OK_P (t
) = true;
2123 t
= convert_from_reference (t
);
2127 /* Like check_qualified_type, but also check ref-qualifier, exception
2128 specification, and whether the return type was specified after the
2132 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2133 cp_ref_qualifier rqual
, tree raises
, bool late
)
2135 return (TYPE_QUALS (cand
) == type_quals
2136 && check_base_type (cand
, base
)
2137 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2139 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2140 && type_memfn_rqual (cand
) == rqual
);
2143 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2146 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2148 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2149 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2150 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2153 /* Make a raw overload node containing FN. */
2156 ovl_make (tree fn
, tree next
)
2158 tree result
= make_node (OVERLOAD
);
2160 if (TREE_CODE (fn
) == OVERLOAD
)
2161 OVL_NESTED_P (result
) = true;
2163 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2164 ? unknown_type_node
: TREE_TYPE (fn
));
2165 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2166 OVL_DEDUP_P (result
) = true;
2167 OVL_FUNCTION (result
) = fn
;
2168 OVL_CHAIN (result
) = next
;
2172 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2173 true, if FN is via a using declaration. We also pay attention to
2174 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2178 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2180 tree result
= maybe_ovl
;
2181 tree insert_after
= NULL_TREE
;
2184 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2185 && OVL_HIDDEN_P (maybe_ovl
);
2186 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2188 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2189 insert_after
= maybe_ovl
;
2192 bool hidden_p
= DECL_HIDDEN_P (fn
);
2193 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2195 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2197 OVL_HIDDEN_P (maybe_ovl
) = true;
2199 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2206 OVL_CHAIN (insert_after
) = maybe_ovl
;
2207 TREE_TYPE (insert_after
) = unknown_type_node
;
2215 /* Skip any hidden names at the beginning of OVL. */
2218 ovl_skip_hidden (tree ovl
)
2221 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2222 ovl
= OVL_CHAIN (ovl
))
2223 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2225 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2227 /* Any hidden functions should have been wrapped in an
2228 overload, but injected friend classes will not. */
2229 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2236 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2239 ovl_iterator::reveal_node (tree overload
, tree node
)
2241 /* We cannot have returned NODE as part of a lookup overload, so we
2242 don't have to worry about preserving that. */
2244 OVL_HIDDEN_P (node
) = false;
2245 if (tree chain
= OVL_CHAIN (node
))
2246 if (TREE_CODE (chain
) == OVERLOAD
)
2248 if (OVL_HIDDEN_P (chain
))
2250 /* The node needs moving, and the simplest way is to remove it
2252 overload
= remove_node (overload
, node
);
2253 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2255 else if (OVL_DEDUP_P (chain
))
2256 OVL_DEDUP_P (node
) = true;
2261 /* NODE is on the overloads of OVL. Remove it.
2262 The removed node is unaltered and may continue to be iterated
2263 from (i.e. it is safe to remove a node from an overload one is
2264 currently iterating over). */
2267 ovl_iterator::remove_node (tree overload
, tree node
)
2269 tree
*slot
= &overload
;
2270 while (*slot
!= node
)
2273 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2275 slot
= &OVL_CHAIN (probe
);
2278 /* Stitch out NODE. We don't have to worry about now making a
2279 singleton overload (and consequently maybe setting its type),
2280 because all uses of this function will be followed by inserting a
2281 new node that must follow the place we've cut this out from. */
2282 if (TREE_CODE (node
) != OVERLOAD
)
2283 /* Cloned inherited ctors don't mark themselves as via_using. */
2286 *slot
= OVL_CHAIN (node
);
2291 /* Mark or unmark a lookup set. */
2294 lookup_mark (tree ovl
, bool val
)
2296 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2298 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2299 LOOKUP_SEEN_P (*iter
) = val
;
2303 /* Add a set of new FNS into a lookup. */
2306 lookup_add (tree fns
, tree lookup
)
2308 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2310 lookup
= ovl_make (fns
, lookup
);
2311 OVL_LOOKUP_P (lookup
) = true;
2319 /* FNS is a new overload set, add them to LOOKUP, if they are not
2320 already present there. */
2323 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2326 for (tree next
, probe
= fns
; probe
; probe
= next
)
2331 if (TREE_CODE (probe
) == OVERLOAD
)
2333 fn
= OVL_FUNCTION (probe
);
2334 next
= OVL_CHAIN (probe
);
2337 if (!LOOKUP_SEEN_P (fn
))
2338 LOOKUP_SEEN_P (fn
) = true;
2341 /* This function was already seen. Insert all the
2342 predecessors onto the lookup. */
2343 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2345 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2346 /* Propagate OVL_USING, but OVL_HIDDEN &
2347 OVL_DEDUP_P don't matter. */
2348 if (OVL_USING_P (fns
))
2349 OVL_USING_P (lookup
) = true;
2352 /* And now skip this function. */
2358 /* We ended in a set of new functions. Add them all in one go. */
2359 lookup
= lookup_add (fns
, lookup
);
2364 /* Returns nonzero if X is an expression for a (possibly overloaded)
2365 function. If "f" is a function or function template, "f", "c->f",
2366 "c.f", "C::f", and "f<int>" will all be considered possibly
2367 overloaded functions. Returns 2 if the function is actually
2368 overloaded, i.e., if it is impossible to know the type of the
2369 function without performing overload resolution. */
2372 is_overloaded_fn (tree x
)
2374 STRIP_ANY_LOCATION_WRAPPER (x
);
2376 /* A baselink is also considered an overloaded function. */
2377 if (TREE_CODE (x
) == OFFSET_REF
2378 || TREE_CODE (x
) == COMPONENT_REF
)
2379 x
= TREE_OPERAND (x
, 1);
2380 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2381 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2382 x
= TREE_OPERAND (x
, 0);
2384 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2385 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2391 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2392 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2396 dependent_name (tree x
)
2398 if (identifier_p (x
))
2400 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2401 x
= TREE_OPERAND (x
, 0);
2403 return OVL_NAME (x
);
2407 /* Returns true iff X is an expression for an overloaded function
2408 whose type cannot be known without performing overload
2412 really_overloaded_fn (tree x
)
2414 return is_overloaded_fn (x
) == 2;
2417 /* Get the overload set FROM refers to. Returns NULL if it's not an
2421 maybe_get_fns (tree from
)
2423 STRIP_ANY_LOCATION_WRAPPER (from
);
2425 /* A baselink is also considered an overloaded function. */
2426 if (TREE_CODE (from
) == OFFSET_REF
2427 || TREE_CODE (from
) == COMPONENT_REF
)
2428 from
= TREE_OPERAND (from
, 1);
2429 if (BASELINK_P (from
))
2430 from
= BASELINK_FUNCTIONS (from
);
2431 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2432 from
= TREE_OPERAND (from
, 0);
2440 /* FROM refers to an overload set. Return that set (or die). */
2445 tree res
= maybe_get_fns (from
);
2451 /* Return the first function of the overload set FROM refers to. */
2454 get_first_fn (tree from
)
2456 return OVL_FIRST (get_fns (from
));
2459 /* Return the scope where the overloaded functions OVL were found. */
2462 ovl_scope (tree ovl
)
2464 if (TREE_CODE (ovl
) == OFFSET_REF
2465 || TREE_CODE (ovl
) == COMPONENT_REF
)
2466 ovl
= TREE_OPERAND (ovl
, 1);
2467 if (TREE_CODE (ovl
) == BASELINK
)
2468 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2469 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2470 ovl
= TREE_OPERAND (ovl
, 0);
2471 /* Skip using-declarations. */
2472 lkp_iterator
iter (ovl
);
2475 while (iter
.using_p () && ++iter
);
2477 return CP_DECL_CONTEXT (ovl
);
2480 #define PRINT_RING_SIZE 4
2483 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2485 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2486 static char *print_ring
[PRINT_RING_SIZE
];
2487 static bool trans_ring
[PRINT_RING_SIZE
];
2488 static int ring_counter
;
2491 /* Only cache functions. */
2493 || TREE_CODE (decl
) != FUNCTION_DECL
2494 || DECL_LANG_SPECIFIC (decl
) == 0)
2495 return lang_decl_name (decl
, v
, translate
);
2497 /* See if this print name is lying around. */
2498 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2499 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2500 /* yes, so return it. */
2501 return print_ring
[i
];
2503 if (++ring_counter
== PRINT_RING_SIZE
)
2506 if (current_function_decl
!= NULL_TREE
)
2508 /* There may be both translated and untranslated versions of the
2510 for (i
= 0; i
< 2; i
++)
2512 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2514 if (ring_counter
== PRINT_RING_SIZE
)
2517 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2520 free (print_ring
[ring_counter
]);
2522 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2523 uid_ring
[ring_counter
] = DECL_UID (decl
);
2524 trans_ring
[ring_counter
] = translate
;
2525 return print_ring
[ring_counter
];
2529 cxx_printable_name (tree decl
, int v
)
2531 return cxx_printable_name_internal (decl
, v
, false);
2535 cxx_printable_name_translate (tree decl
, int v
)
2537 return cxx_printable_name_internal (decl
, v
, true);
2540 /* Return the canonical version of exception-specification RAISES for a C++17
2541 function type, for use in type comparison and building TYPE_CANONICAL. */
2544 canonical_eh_spec (tree raises
)
2546 if (raises
== NULL_TREE
)
2548 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2549 || uses_template_parms (raises
)
2550 || uses_template_parms (TREE_PURPOSE (raises
)))
2551 /* Keep a dependent or deferred exception specification. */
2553 else if (nothrow_spec_p (raises
))
2554 /* throw() -> noexcept. */
2555 return noexcept_true_spec
;
2557 /* For C++17 type matching, anything else -> nothing. */
2562 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2563 tree raises
, bool late
)
2565 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2567 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2570 tree v
= TYPE_MAIN_VARIANT (type
);
2571 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2572 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2575 /* Need to build a new variant. */
2576 v
= build_variant_type_copy (type
);
2577 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2578 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2581 case REF_QUAL_RVALUE
:
2582 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2583 FUNCTION_REF_QUALIFIED (v
) = 1;
2585 case REF_QUAL_LVALUE
:
2586 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2587 FUNCTION_REF_QUALIFIED (v
) = 1;
2590 FUNCTION_REF_QUALIFIED (v
) = 0;
2594 /* Canonicalize the exception specification. */
2595 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2597 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2598 /* Propagate structural equality. */
2599 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2600 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2601 /* Build the underlying canonical type, since it is different
2603 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2606 /* T is its own canonical type. */
2607 TYPE_CANONICAL (v
) = v
;
2612 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2613 listed in RAISES. */
2616 build_exception_variant (tree type
, tree raises
)
2618 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2619 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2620 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2623 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2624 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2628 bind_template_template_parm (tree t
, tree newargs
)
2630 tree decl
= TYPE_NAME (t
);
2633 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2634 decl
= build_decl (input_location
,
2635 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2637 /* These nodes have to be created to reflect new TYPE_DECL and template
2639 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2640 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2641 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2642 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2644 TREE_TYPE (decl
) = t2
;
2645 TYPE_NAME (t2
) = decl
;
2646 TYPE_STUB_DECL (t2
) = decl
;
2648 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2653 /* Called from count_trees via walk_tree. */
2656 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2666 /* Debugging function for measuring the rough complexity of a tree
2670 count_trees (tree t
)
2673 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2677 /* Called from verify_stmt_tree via walk_tree. */
2680 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2683 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2684 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2687 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2690 /* If this statement is already present in the hash table, then
2691 there is a circularity in the statement tree. */
2692 gcc_assert (!statements
->find (t
));
2694 slot
= statements
->find_slot (t
, INSERT
);
2700 /* Debugging function to check that the statement T has not been
2701 corrupted. For now, this function simply checks that T contains no
2705 verify_stmt_tree (tree t
)
2707 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2708 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2711 /* Check if the type T depends on a type with no linkage and if so, return
2712 it. If RELAXED_P then do not consider a class type declared within
2713 a vague-linkage function to have no linkage. */
2716 no_linkage_check (tree t
, bool relaxed_p
)
2720 /* Lambda types that don't have mangling scope have no linkage. We
2721 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2722 when we get here from pushtag none of the lambda information is
2723 set up yet, so we want to assume that the lambda has linkage and
2724 fix it up later if not. We need to check this even in templates so
2725 that we properly handle a lambda-expression in the signature. */
2726 if (LAMBDA_TYPE_P (t
)
2727 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2728 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2731 /* Otherwise there's no point in checking linkage on template functions; we
2732 can't know their complete types. */
2733 if (processing_template_decl
)
2736 switch (TREE_CODE (t
))
2739 if (TYPE_PTRMEMFUNC_P (t
))
2743 if (!CLASS_TYPE_P (t
))
2747 /* Only treat unnamed types as having no linkage if they're at
2748 namespace scope. This is core issue 966. */
2749 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2752 for (r
= CP_TYPE_CONTEXT (t
); ; )
2754 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2755 have linkage, or we might just be in an anonymous namespace.
2756 If we're in a TREE_PUBLIC class, we have linkage. */
2757 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2758 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2759 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2761 if (!relaxed_p
|| !vague_linkage_p (r
))
2764 r
= CP_DECL_CONTEXT (r
);
2774 case REFERENCE_TYPE
:
2776 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2780 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2784 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2789 tree parm
= TYPE_ARG_TYPES (t
);
2790 if (TREE_CODE (t
) == METHOD_TYPE
)
2791 /* The 'this' pointer isn't interesting; a method has the same
2792 linkage (or lack thereof) as its enclosing class. */
2793 parm
= TREE_CHAIN (parm
);
2795 parm
&& parm
!= void_list_node
;
2796 parm
= TREE_CHAIN (parm
))
2798 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2802 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2810 extern int depth_reached
;
2813 cxx_print_statistics (void)
2815 print_template_statistics ();
2816 if (GATHER_STATISTICS
)
2817 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2821 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2822 (which is an ARRAY_TYPE). This counts only elements of the top
2826 array_type_nelts_top (tree type
)
2828 return fold_build2_loc (input_location
,
2829 PLUS_EXPR
, sizetype
,
2830 array_type_nelts (type
),
2834 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2835 (which is an ARRAY_TYPE). This one is a recursive count of all
2836 ARRAY_TYPEs that are clumped together. */
2839 array_type_nelts_total (tree type
)
2841 tree sz
= array_type_nelts_top (type
);
2842 type
= TREE_TYPE (type
);
2843 while (TREE_CODE (type
) == ARRAY_TYPE
)
2845 tree n
= array_type_nelts_top (type
);
2846 sz
= fold_build2_loc (input_location
,
2847 MULT_EXPR
, sizetype
, sz
, n
);
2848 type
= TREE_TYPE (type
);
2855 splay_tree target_remap
;
2856 bool clear_location
;
2859 /* Called from break_out_target_exprs via mapcar. */
2862 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2864 bot_data
&data
= *(bot_data
*)data_
;
2865 splay_tree target_remap
= data
.target_remap
;
2868 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2870 /* There can't be any TARGET_EXPRs or their slot variables below this
2871 point. But we must make a copy, in case subsequent processing
2872 alters any part of it. For example, during gimplification a cast
2873 of the form (T) &X::f (where "f" is a member function) will lead
2874 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2876 *tp
= unshare_expr (t
);
2879 if (TREE_CODE (t
) == TARGET_EXPR
)
2883 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2885 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2886 tf_warning_or_error
);
2887 if (u
== error_mark_node
)
2889 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2890 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2893 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2894 tf_warning_or_error
);
2896 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2897 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2898 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2900 /* Map the old variable to the new one. */
2901 splay_tree_insert (target_remap
,
2902 (splay_tree_key
) TREE_OPERAND (t
, 0),
2903 (splay_tree_value
) TREE_OPERAND (u
, 0));
2905 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2906 data
.clear_location
);
2907 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2908 return error_mark_node
;
2910 /* Replace the old expression with the new version. */
2912 /* We don't have to go below this point; the recursive call to
2913 break_out_target_exprs will have handled anything below this
2918 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2921 splay_tree_node n
= splay_tree_lookup (target_remap
,
2922 (splay_tree_key
) t
);
2925 *tp
= (tree
)n
->value
;
2930 copy_tree_r (tp
, walk_subtrees
, NULL
);
2931 splay_tree_insert (target_remap
,
2933 (splay_tree_value
)*tp
);
2934 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2935 splay_tree_insert (target_remap
,
2936 (splay_tree_key
)*tp
,
2937 (splay_tree_value
)*tp
);
2942 /* Make a copy of this node. */
2943 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2944 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2945 if (!processing_template_decl
)
2946 set_flags_from_callee (*tp
);
2947 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2948 SET_EXPR_LOCATION (*tp
, input_location
);
2952 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2953 DATA is really a splay-tree mapping old variables to new
2957 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
2959 bot_data
&data
= *(bot_data
*)data_
;
2960 splay_tree target_remap
= data
.target_remap
;
2964 splay_tree_node n
= splay_tree_lookup (target_remap
,
2965 (splay_tree_key
) *t
);
2967 *t
= (tree
) n
->value
;
2969 else if (TREE_CODE (*t
) == PARM_DECL
2970 && DECL_NAME (*t
) == this_identifier
2971 && !DECL_CONTEXT (*t
))
2973 /* In an NSDMI we need to replace the 'this' parameter we used for
2974 parsing with the real one for this function. */
2975 *t
= current_class_ptr
;
2977 else if (TREE_CODE (*t
) == CONVERT_EXPR
2978 && CONVERT_EXPR_VBASE_PATH (*t
))
2980 /* In an NSDMI build_base_path defers building conversions to virtual
2981 bases, and we handle it here. */
2982 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2983 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2985 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2986 if (BINFO_TYPE (binfo
) == basetype
)
2988 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2989 tf_warning_or_error
);
2995 /* When we parse a default argument expression, we may create
2996 temporary variables via TARGET_EXPRs. When we actually use the
2997 default-argument expression, we make a copy of the expression
2998 and replace the temporaries with appropriate local versions.
3000 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3004 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3006 static int target_remap_count
;
3007 static splay_tree target_remap
;
3009 if (!target_remap_count
++)
3010 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3011 /*splay_tree_delete_key_fn=*/NULL
,
3012 /*splay_tree_delete_value_fn=*/NULL
);
3013 bot_data data
= { target_remap
, clear_location
};
3014 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3015 t
= error_mark_node
;
3016 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3018 if (!--target_remap_count
)
3020 splay_tree_delete (target_remap
);
3021 target_remap
= NULL
;
3027 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3028 which we expect to have type TYPE. */
3031 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3033 if (index
== NULL_TREE
)
3034 /* Can't refer to a particular member of a vector. */
3036 else if (TREE_CODE (index
) == INTEGER_CST
)
3037 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3039 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3040 /*reference*/false, tf_none
);
3043 tree objtype
= TREE_TYPE (obj
);
3044 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3046 /* When the destination object refers to a flexible array member
3047 verify that it matches the type of the source object except
3048 for its domain and qualifiers. */
3049 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3050 TYPE_MAIN_VARIANT (objtype
),
3051 COMPARE_REDECLARATION
));
3054 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3060 struct replace_placeholders_t
3062 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3063 tree exp
; /* The outermost exp. */
3064 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3065 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3068 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3069 build up subexpressions as we go deeper. */
3072 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3074 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3077 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3079 *walk_subtrees
= false;
3083 switch (TREE_CODE (*t
))
3085 case PLACEHOLDER_EXPR
:
3088 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3090 x
= TREE_OPERAND (x
, 0))
3091 gcc_assert (handled_component_p (x
));
3092 *t
= unshare_expr (x
);
3093 *walk_subtrees
= false;
3100 constructor_elt
*ce
;
3101 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3102 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3103 other than the d->exp one, those have PLACEHOLDER_EXPRs
3104 related to another object. */
3105 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3107 || d
->pset
->add (*t
))
3109 *walk_subtrees
= false;
3112 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3114 tree
*valp
= &ce
->value
;
3115 tree type
= TREE_TYPE (*valp
);
3118 if (TREE_CODE (*valp
) == CONSTRUCTOR
3119 && AGGREGATE_TYPE_P (type
))
3121 /* If we're looking at the initializer for OBJ, then build
3122 a sub-object reference. If we're looking at an
3123 initializer for another object, just pass OBJ down. */
3124 if (same_type_ignoring_top_level_qualifiers_p
3125 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3126 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3127 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3128 valp
= &TARGET_EXPR_INITIAL (*valp
);
3131 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3134 *walk_subtrees
= false;
3139 if (d
->pset
->add (*t
))
3140 *walk_subtrees
= false;
3147 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3148 a PLACEHOLDER_EXPR has been encountered. */
3151 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3153 /* This is only relevant for C++14. */
3154 if (cxx_dialect
< cxx14
)
3157 /* If the object isn't a (member of a) class, do nothing. */
3159 while (TREE_CODE (op0
) == COMPONENT_REF
)
3160 op0
= TREE_OPERAND (op0
, 0);
3161 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3165 if (TREE_CODE (exp
) == TARGET_EXPR
)
3166 tp
= &TARGET_EXPR_INITIAL (exp
);
3167 hash_set
<tree
> pset
;
3168 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3169 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3171 *seen_p
= data
.seen
;
3175 /* Callback function for find_placeholders. */
3178 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3180 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3182 *walk_subtrees
= false;
3186 switch (TREE_CODE (*t
))
3188 case PLACEHOLDER_EXPR
:
3192 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3193 *walk_subtrees
= false;
3203 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3204 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3207 find_placeholders (tree exp
)
3209 /* This is only relevant for C++14. */
3210 if (cxx_dialect
< cxx14
)
3213 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3216 /* Similar to `build_nt', but for template definitions of dependent
3220 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3227 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3231 t
= make_node (code
);
3232 SET_EXPR_LOCATION (t
, loc
);
3233 length
= TREE_CODE_LENGTH (code
);
3235 for (i
= 0; i
< length
; i
++)
3236 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3242 /* Similar to `build', but for template definitions. */
3245 build_min (enum tree_code code
, tree tt
, ...)
3252 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3256 t
= make_node (code
);
3257 length
= TREE_CODE_LENGTH (code
);
3260 for (i
= 0; i
< length
; i
++)
3262 tree x
= va_arg (p
, tree
);
3263 TREE_OPERAND (t
, i
) = x
;
3264 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3265 TREE_SIDE_EFFECTS (t
) = 1;
3273 /* Similar to `build', but for template definitions of non-dependent
3274 expressions. NON_DEP is the non-dependent expression that has been
3278 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3285 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3287 va_start (p
, non_dep
);
3289 if (REFERENCE_REF_P (non_dep
))
3290 non_dep
= TREE_OPERAND (non_dep
, 0);
3292 t
= make_node (code
);
3293 length
= TREE_CODE_LENGTH (code
);
3294 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3295 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3297 for (i
= 0; i
< length
; i
++)
3298 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3300 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3301 /* This should not be considered a COMPOUND_EXPR, because it
3302 resolves to an overload. */
3303 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3306 return convert_from_reference (t
);
3309 /* Similar to build_min_nt, but call expressions */
3312 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3317 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3318 CALL_EXPR_FN (ret
) = fn
;
3319 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3320 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3321 CALL_EXPR_ARG (ret
, ix
) = t
;
3326 /* Similar to `build_min_nt_call_vec', but for template definitions of
3327 non-dependent expressions. NON_DEP is the non-dependent expression
3328 that has been built. */
3331 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3333 tree t
= build_min_nt_call_vec (fn
, argvec
);
3334 if (REFERENCE_REF_P (non_dep
))
3335 non_dep
= TREE_OPERAND (non_dep
, 0);
3336 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3337 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3338 return convert_from_reference (t
);
3341 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3342 a call to an operator overload. OP is the operator that has been
3343 overloaded. NON_DEP is the non-dependent expression that's been built,
3344 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3345 the overload that NON_DEP is calling. */
3348 build_min_non_dep_op_overload (enum tree_code op
,
3353 int nargs
, expected_nargs
;
3356 non_dep
= extract_call_expr (non_dep
);
3358 nargs
= call_expr_nargs (non_dep
);
3360 expected_nargs
= cp_tree_code_length (op
);
3361 if ((op
== POSTINCREMENT_EXPR
3362 || op
== POSTDECREMENT_EXPR
)
3363 /* With -fpermissive non_dep could be operator++(). */
3364 && (!flag_permissive
|| nargs
!= expected_nargs
))
3365 expected_nargs
+= 1;
3366 gcc_assert (nargs
== expected_nargs
);
3369 va_start (p
, overload
);
3371 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3374 for (int i
= 0; i
< nargs
; i
++)
3376 tree arg
= va_arg (p
, tree
);
3377 vec_safe_push (args
, arg
);
3380 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3382 tree object
= va_arg (p
, tree
);
3383 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3384 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3385 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3386 object
, method
, NULL_TREE
);
3387 for (int i
= 1; i
< nargs
; i
++)
3389 tree arg
= va_arg (p
, tree
);
3390 vec_safe_push (args
, arg
);
3397 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3399 tree call_expr
= extract_call_expr (call
);
3400 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3401 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3402 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3403 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3408 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3411 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3413 unsigned len
= vec_safe_length (old_vec
);
3414 gcc_assert (idx
<= len
);
3416 vec
<tree
, va_gc
> *new_vec
= NULL
;
3417 vec_alloc (new_vec
, len
+ 1);
3420 for (i
= 0; i
< len
; ++i
)
3423 new_vec
->quick_push (elt
);
3424 new_vec
->quick_push ((*old_vec
)[i
]);
3427 new_vec
->quick_push (elt
);
3433 get_type_decl (tree t
)
3435 if (TREE_CODE (t
) == TYPE_DECL
)
3438 return TYPE_STUB_DECL (t
);
3439 gcc_assert (t
== error_mark_node
);
3443 /* Returns the namespace that contains DECL, whether directly or
3447 decl_namespace_context (tree decl
)
3451 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3453 else if (TYPE_P (decl
))
3454 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3456 decl
= CP_DECL_CONTEXT (decl
);
3460 /* Returns true if decl is within an anonymous namespace, however deeply
3461 nested, or false otherwise. */
3464 decl_anon_ns_mem_p (const_tree decl
)
3466 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3468 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3470 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3472 decl
= CP_DECL_CONTEXT (decl
);
3474 return !TREE_PUBLIC (decl
);
3477 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3478 CALL_EXPRS. Return whether they are equivalent. */
3481 called_fns_equal (tree t1
, tree t2
)
3483 /* Core 1321: dependent names are equivalent even if the overload sets
3484 are different. But do compare explicit template arguments. */
3485 tree name1
= dependent_name (t1
);
3486 tree name2
= dependent_name (t2
);
3489 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3494 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3495 targs1
= TREE_OPERAND (t1
, 1);
3496 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3497 targs2
= TREE_OPERAND (t2
, 1);
3498 return cp_tree_equal (targs1
, targs2
);
3501 return cp_tree_equal (t1
, t2
);
3504 /* Return truthvalue of whether T1 is the same tree structure as T2.
3505 Return 1 if they are the same. Return 0 if they are different. */
3508 cp_tree_equal (tree t1
, tree t2
)
3510 enum tree_code code1
, code2
;
3517 code1
= TREE_CODE (t1
);
3518 code2
= TREE_CODE (t2
);
3523 if (CONSTANT_CLASS_P (t1
)
3524 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3530 /* There's only a single VOID_CST node, so we should never reach
3535 return tree_int_cst_equal (t1
, t2
);
3538 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3541 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3542 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3543 TREE_STRING_LENGTH (t1
));
3546 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3547 TREE_FIXED_CST (t2
));
3550 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3551 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3554 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3557 /* We need to do this when determining whether or not two
3558 non-type pointer to member function template arguments
3560 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3561 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3566 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3568 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3569 if (!cp_tree_equal (field
, elt2
->index
)
3570 || !cp_tree_equal (value
, elt2
->value
))
3577 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3579 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3581 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3584 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3589 call_expr_arg_iterator iter1
, iter2
;
3590 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3592 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3593 arg2
= first_call_expr_arg (t2
, &iter2
);
3595 arg1
= next_call_expr_arg (&iter1
),
3596 arg2
= next_call_expr_arg (&iter2
))
3597 if (!cp_tree_equal (arg1
, arg2
))
3606 tree o1
= TREE_OPERAND (t1
, 0);
3607 tree o2
= TREE_OPERAND (t2
, 0);
3609 /* Special case: if either target is an unallocated VAR_DECL,
3610 it means that it's going to be unified with whatever the
3611 TARGET_EXPR is really supposed to initialize, so treat it
3612 as being equivalent to anything. */
3613 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3614 && !DECL_RTL_SET_P (o1
))
3616 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3617 && !DECL_RTL_SET_P (o2
))
3619 else if (!cp_tree_equal (o1
, o2
))
3622 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3626 /* For comparing uses of parameters in late-specified return types
3627 with an out-of-class definition of the function, but can also come
3628 up for expressions that involve 'this' in a member function
3631 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3632 /* When comparing hash table entries, only an exact match is
3633 good enough; we don't want to replace 'this' with the
3634 version from another function. But be more flexible
3635 with local parameters in a requires-expression. */
3638 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3640 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3642 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3644 if (DECL_ARTIFICIAL (t1
)
3645 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3646 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3656 case IDENTIFIER_NODE
:
3662 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3663 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3664 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3665 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3666 BASELINK_FUNCTIONS (t2
)));
3668 case TEMPLATE_PARM_INDEX
:
3669 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3670 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3671 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3672 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3673 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3674 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3676 case TEMPLATE_ID_EXPR
:
3677 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3678 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3680 case CONSTRAINT_INFO
:
3681 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3682 CI_ASSOCIATED_CONSTRAINTS (t2
));
3685 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3686 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3687 CHECK_CONSTR_ARGS (t2
)));
3692 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3694 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3695 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3696 TREE_VEC_ELT (t2
, ix
)))
3704 tree o1
= TREE_OPERAND (t1
, 0);
3705 tree o2
= TREE_OPERAND (t2
, 0);
3707 if (code1
== SIZEOF_EXPR
)
3709 if (SIZEOF_EXPR_TYPE_P (t1
))
3710 o1
= TREE_TYPE (o1
);
3711 if (SIZEOF_EXPR_TYPE_P (t2
))
3712 o2
= TREE_TYPE (o2
);
3714 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3717 return same_type_p (o1
, o2
);
3719 return cp_tree_equal (o1
, o2
);
3724 tree t1_op1
, t2_op1
;
3726 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3729 t1_op1
= TREE_OPERAND (t1
, 1);
3730 t2_op1
= TREE_OPERAND (t2
, 1);
3731 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3734 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3738 /* Two pointer-to-members are the same if they point to the same
3739 field or function in the same class. */
3740 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3743 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3747 /* Two overloads. Must be exactly the same set of decls. */
3748 lkp_iterator
first (t1
);
3749 lkp_iterator
second (t2
);
3751 for (; first
&& second
; ++first
, ++second
)
3752 if (*first
!= *second
)
3754 return !(first
|| second
);
3758 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3760 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3761 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3764 case STATIC_CAST_EXPR
:
3765 case REINTERPRET_CAST_EXPR
:
3766 case CONST_CAST_EXPR
:
3767 case DYNAMIC_CAST_EXPR
:
3768 case IMPLICIT_CONV_EXPR
:
3771 case NON_LVALUE_EXPR
:
3772 case VIEW_CONVERT_EXPR
:
3773 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3775 /* Now compare operands as usual. */
3778 case DEFERRED_NOEXCEPT
:
3779 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3780 DEFERRED_NOEXCEPT_PATTERN (t2
))
3781 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3782 DEFERRED_NOEXCEPT_ARGS (t2
)));
3786 /* Two lambda-expressions are never considered equivalent. */
3793 switch (TREE_CODE_CLASS (code1
))
3797 case tcc_comparison
:
3798 case tcc_expression
:
3805 n
= cp_tree_operand_length (t1
);
3806 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3807 && n
!= TREE_OPERAND_LENGTH (t2
))
3810 for (i
= 0; i
< n
; ++i
)
3811 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3818 return same_type_p (t1
, t2
);
3822 /* We can get here with --disable-checking. */
3826 /* The type of ARG when used as an lvalue. */
3829 lvalue_type (tree arg
)
3831 tree type
= TREE_TYPE (arg
);
3835 /* The type of ARG for printing error messages; denote lvalues with
3839 error_type (tree arg
)
3841 tree type
= TREE_TYPE (arg
);
3843 if (TREE_CODE (type
) == ARRAY_TYPE
)
3845 else if (TREE_CODE (type
) == ERROR_MARK
)
3847 else if (lvalue_p (arg
))
3848 type
= build_reference_type (lvalue_type (arg
));
3849 else if (MAYBE_CLASS_TYPE_P (type
))
3850 type
= lvalue_type (arg
);
3855 /* Does FUNCTION use a variable-length argument list? */
3858 varargs_function_p (const_tree function
)
3860 return stdarg_p (TREE_TYPE (function
));
3863 /* Returns 1 if decl is a member of a class. */
3866 member_p (const_tree decl
)
3868 const_tree
const ctx
= DECL_CONTEXT (decl
);
3869 return (ctx
&& TYPE_P (ctx
));
3872 /* Create a placeholder for member access where we don't actually have an
3873 object that the access is against. */
3876 build_dummy_object (tree type
)
3878 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3879 return cp_build_fold_indirect_ref (decl
);
3882 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3883 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3884 binfo path from current_class_type to TYPE, or 0. */
3887 maybe_dummy_object (tree type
, tree
* binfop
)
3891 tree current
= current_nonlambda_class_type ();
3894 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3895 tf_warning_or_error
)))
3899 /* Reference from a nested class member function. */
3901 binfo
= TYPE_BINFO (type
);
3907 if (current_class_ref
3908 /* current_class_ref might not correspond to current_class_type if
3909 we're in tsubst_default_argument or a lambda-declarator; in either
3910 case, we want to use current_class_ref if it matches CONTEXT. */
3911 && (same_type_ignoring_top_level_qualifiers_p
3912 (TREE_TYPE (current_class_ref
), context
)))
3913 decl
= current_class_ref
;
3915 decl
= build_dummy_object (context
);
3920 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3923 is_dummy_object (const_tree ob
)
3925 if (INDIRECT_REF_P (ob
))
3926 ob
= TREE_OPERAND (ob
, 0);
3927 return (TREE_CODE (ob
) == CONVERT_EXPR
3928 && TREE_OPERAND (ob
, 0) == void_node
);
3931 /* Returns 1 iff type T is something we want to treat as a scalar type for
3932 the purpose of deciding whether it is trivial/POD/standard-layout. */
3935 scalarish_type_p (const_tree t
)
3937 if (t
== error_mark_node
)
3940 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3943 /* Returns true iff T requires non-trivial default initialization. */
3946 type_has_nontrivial_default_init (const_tree t
)
3948 t
= strip_array_types (CONST_CAST_TREE (t
));
3950 if (CLASS_TYPE_P (t
))
3951 return TYPE_HAS_COMPLEX_DFLT (t
);
3956 /* Track classes with only deleted copy/move constructors so that we can warn
3957 if they are used in call/return by value. */
3959 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
3961 remember_deleted_copy (const_tree t
)
3963 if (!deleted_copy_types
)
3964 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
3965 deleted_copy_types
->add (CONST_CAST_TREE (t
));
3968 maybe_warn_parm_abi (tree t
, location_t loc
)
3970 if (!deleted_copy_types
3971 || !deleted_copy_types
->contains (t
))
3974 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
3975 && classtype_has_non_deleted_move_ctor (t
))
3978 auto_diagnostic_group d
;
3979 if (flag_abi_version
> 12)
3980 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
3981 "the calling convention for %qT, which was "
3982 "accidentally changed in 8.1", t
);
3984 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
3985 "ally changes the calling convention for %qT", t
);
3987 inform (location_of (t
), " declared here");
3991 auto_diagnostic_group d
;
3992 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
3993 "%<-fabi-version=13%> (GCC 8.2)", t
))
3994 inform (location_of (t
), " because all of its copy and move "
3995 "constructors are deleted");
3998 /* Returns true iff copying an object of type T (including via move
3999 constructor) is non-trivial. That is, T has no non-trivial copy
4000 constructors and no non-trivial move constructors, and not all copy/move
4001 constructors are deleted. This function implements the ABI notion of
4002 non-trivial copy, which has diverged from the one in the standard. */
4005 type_has_nontrivial_copy_init (const_tree type
)
4007 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4009 if (CLASS_TYPE_P (t
))
4011 gcc_assert (COMPLETE_TYPE_P (t
));
4013 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4014 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4018 if (cxx_dialect
< cxx11
)
4019 /* No deleted functions before C++11. */
4022 /* Before ABI v12 we did a bitwise copy of types with only deleted
4023 copy/move constructors. */
4024 if (!abi_version_at_least (12)
4025 && !(warn_abi
&& abi_version_crosses (12)))
4028 bool saw_copy
= false;
4029 bool saw_non_deleted
= false;
4030 bool saw_non_deleted_move
= false;
4032 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4033 saw_copy
= saw_non_deleted
= true;
4034 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4037 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4038 /* [class.copy]/8 If the class definition declares a move
4039 constructor or move assignment operator, the implicitly declared
4040 copy constructor is defined as deleted.... */;
4042 /* Any other reason the implicitly-declared function would be
4043 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4045 saw_non_deleted
= true;
4048 if (!saw_non_deleted
)
4049 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4055 if (!DECL_DELETED_FN (fn
))
4057 /* Not deleted, therefore trivial. */
4058 saw_non_deleted
= true;
4062 else if (move_fn_p (fn
))
4063 if (!DECL_DELETED_FN (fn
))
4064 saw_non_deleted_move
= true;
4067 gcc_assert (saw_copy
);
4069 /* ABI v12 buggily ignored move constructors. */
4070 bool v11nontriv
= false;
4071 bool v12nontriv
= !saw_non_deleted
;
4072 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4073 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4074 : flag_abi_version
== 12 ? v12nontriv
4076 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4077 : warn_abi_version
== 12 ? v12nontriv
4079 if (nontriv
!= warn_nontriv
)
4080 remember_deleted_copy (t
);
4088 /* Returns 1 iff type T is a trivially copyable type, as defined in
4089 [basic.types] and [class]. */
4092 trivially_copyable_p (const_tree t
)
4094 t
= strip_array_types (CONST_CAST_TREE (t
));
4096 if (CLASS_TYPE_P (t
))
4097 return ((!TYPE_HAS_COPY_CTOR (t
)
4098 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4099 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4100 && (!TYPE_HAS_COPY_ASSIGN (t
)
4101 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4102 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4103 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4105 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4106 return scalarish_type_p (t
);
4109 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4113 trivial_type_p (const_tree t
)
4115 t
= strip_array_types (CONST_CAST_TREE (t
));
4117 if (CLASS_TYPE_P (t
))
4118 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4119 && trivially_copyable_p (t
));
4121 return scalarish_type_p (t
);
4124 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4127 pod_type_p (const_tree t
)
4129 /* This CONST_CAST is okay because strip_array_types returns its
4130 argument unmodified and we assign it to a const_tree. */
4131 t
= strip_array_types (CONST_CAST_TREE(t
));
4133 if (!CLASS_TYPE_P (t
))
4134 return scalarish_type_p (t
);
4135 else if (cxx_dialect
> cxx98
)
4136 /* [class]/10: A POD struct is a class that is both a trivial class and a
4137 standard-layout class, and has no non-static data members of type
4138 non-POD struct, non-POD union (or array of such types).
4140 We don't need to check individual members because if a member is
4141 non-std-layout or non-trivial, the class will be too. */
4142 return (std_layout_type_p (t
) && trivial_type_p (t
));
4144 /* The C++98 definition of POD is different. */
4145 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4148 /* Returns true iff T is POD for the purpose of layout, as defined in the
4152 layout_pod_type_p (const_tree t
)
4154 t
= strip_array_types (CONST_CAST_TREE (t
));
4156 if (CLASS_TYPE_P (t
))
4157 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4159 return scalarish_type_p (t
);
4162 /* Returns true iff T is a standard-layout type, as defined in
4166 std_layout_type_p (const_tree t
)
4168 t
= strip_array_types (CONST_CAST_TREE (t
));
4170 if (CLASS_TYPE_P (t
))
4171 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4173 return scalarish_type_p (t
);
4176 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4178 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4179 as defined in [meta.unary.prop]. */
4182 type_has_unique_obj_representations (const_tree t
)
4186 t
= strip_array_types (CONST_CAST_TREE (t
));
4188 if (!trivially_copyable_p (t
))
4191 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4192 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4194 switch (TREE_CODE (t
))
4198 case REFERENCE_TYPE
:
4199 /* If some backend has any paddings in these types, we should add
4200 a target hook for this and handle it there. */
4204 /* For bool values other than 0 and 1 should only appear with
4205 undefined behavior. */
4209 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4212 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4213 when storing long double values, so for that we have to return false.
4214 Other kinds of floating point values are questionable due to +.0/-.0
4215 and NaNs, let's play safe for now. */
4218 case FIXED_POINT_TYPE
:
4226 return type_has_unique_obj_representations (TREE_TYPE (t
));
4229 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4230 if (CLASS_TYPE_P (t
))
4232 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4233 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4241 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4242 if (TREE_CODE (field
) == FIELD_DECL
)
4245 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4246 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4252 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4254 if (CLASS_TYPE_P (t
))
4256 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4257 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4272 /* Helper function for type_has_unique_obj_representations. */
4275 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4277 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4278 if (TREE_CODE (field
) != FIELD_DECL
)
4280 /* For bases, can't use type_has_unique_obj_representations here, as in
4281 struct S { int i : 24; S (); };
4282 struct T : public S { int j : 8; T (); };
4283 S doesn't have unique obj representations, but T does. */
4284 else if (DECL_FIELD_IS_BASE (field
))
4286 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4290 else if (DECL_C_BIT_FIELD (field
))
4292 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4293 if (!type_has_unique_obj_representations (btype
))
4296 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4300 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4301 if (TREE_CODE (field
) == FIELD_DECL
)
4303 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4304 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4305 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4308 if (DECL_SIZE (field
))
4310 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4314 if (cur
!= wi::to_offset (sz
))
4320 /* Nonzero iff type T is a class template implicit specialization. */
4323 class_tmpl_impl_spec_p (const_tree t
)
4325 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4328 /* Returns 1 iff zero initialization of type T means actually storing
4332 zero_init_p (const_tree t
)
4334 /* This CONST_CAST is okay because strip_array_types returns its
4335 argument unmodified and we assign it to a const_tree. */
4336 t
= strip_array_types (CONST_CAST_TREE(t
));
4338 if (t
== error_mark_node
)
4341 /* NULL pointers to data members are initialized with -1. */
4342 if (TYPE_PTRDATAMEM_P (t
))
4345 /* Classes that contain types that can't be zero-initialized, cannot
4346 be zero-initialized themselves. */
4347 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4353 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4354 warn_unused_result attribute. */
4357 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4358 int /*flags*/, bool *no_add_attrs
)
4360 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4362 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4363 warning_at (DECL_SOURCE_LOCATION (*node
),
4364 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4365 "return type", name
, *node
);
4367 else if (OVERLOAD_TYPE_P (*node
))
4371 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4372 "functions or to class or enumeration types", name
);
4373 *no_add_attrs
= true;
4378 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4379 struct attribute_spec.handler. */
4381 handle_no_unique_addr_attribute (tree
* node
,
4387 if (TREE_CODE (*node
) != FIELD_DECL
)
4389 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4390 "non-static data members", name
);
4391 *no_add_attrs
= true;
4393 else if (DECL_C_BIT_FIELD (*node
))
4395 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4396 "a bit-field", name
);
4397 *no_add_attrs
= true;
4403 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4404 hot/cold attributes. */
4407 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4408 int flags
, bool *no_add_attrs
)
4410 *no_add_attrs
= true;
4411 if (TREE_CODE (*node
) == LABEL_DECL
4412 || TREE_CODE (*node
) == FUNCTION_DECL
)
4415 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4416 tree bname
= (is_attribute_p ("likely", name
)
4417 ? get_identifier ("hot") : get_identifier ("cold"));
4418 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4419 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4420 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4421 tree battr
= build_tree_list (bname
, NULL_TREE
);
4422 decl_attributes (node
, battr
, flags
);
4426 return error_mark_node
;
4429 /* Table of valid C++ attributes. */
4430 const struct attribute_spec cxx_attribute_table
[] =
4432 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4433 affects_type_identity, handler, exclude } */
4434 { "init_priority", 1, 1, true, false, false, false,
4435 handle_init_priority_attribute
, NULL
},
4436 { "abi_tag", 1, -1, false, false, false, true,
4437 handle_abi_tag_attribute
, NULL
},
4438 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4441 /* Table of C++ standard attributes. */
4442 const struct attribute_spec std_attribute_table
[] =
4444 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4445 affects_type_identity, handler, exclude } */
4446 { "maybe_unused", 0, 0, false, false, false, false,
4447 handle_unused_attribute
, NULL
},
4448 { "nodiscard", 0, 0, false, false, false, false,
4449 handle_nodiscard_attribute
, NULL
},
4450 { "no_unique_address", 0, 0, true, false, false, false,
4451 handle_no_unique_addr_attribute
, NULL
},
4452 { "likely", 0, 0, false, false, false, false,
4453 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4454 { "unlikely", 0, 0, false, false, false, false,
4455 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4456 { "noreturn", 0, 0, true, false, false, false,
4457 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4458 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4461 /* Handle an "init_priority" attribute; arguments as in
4462 struct attribute_spec.handler. */
4464 handle_init_priority_attribute (tree
* node
,
4470 tree initp_expr
= TREE_VALUE (args
);
4472 tree type
= TREE_TYPE (decl
);
4475 STRIP_NOPS (initp_expr
);
4476 initp_expr
= default_conversion (initp_expr
);
4478 initp_expr
= maybe_constant_value (initp_expr
);
4480 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4482 error ("requested %<init_priority%> is not an integer constant");
4483 cxx_constant_value (initp_expr
);
4484 *no_add_attrs
= true;
4488 pri
= TREE_INT_CST_LOW (initp_expr
);
4490 type
= strip_array_types (type
);
4492 if (decl
== NULL_TREE
4494 || !TREE_STATIC (decl
)
4495 || DECL_EXTERNAL (decl
)
4496 || (TREE_CODE (type
) != RECORD_TYPE
4497 && TREE_CODE (type
) != UNION_TYPE
)
4498 /* Static objects in functions are initialized the
4499 first time control passes through that
4500 function. This is not precise enough to pin down an
4501 init_priority value, so don't allow it. */
4502 || current_function_decl
)
4504 error ("can only use %qE attribute on file-scope definitions "
4505 "of objects of class type", name
);
4506 *no_add_attrs
= true;
4510 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4512 error ("requested %<init_priority%> %i is out of range [0, %i]",
4513 pri
, MAX_INIT_PRIORITY
);
4514 *no_add_attrs
= true;
4518 /* Check for init_priorities that are reserved for
4519 language and runtime support implementations.*/
4520 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4523 (0, "requested %<init_priority%> %i is reserved for internal use",
4527 if (SUPPORTS_INIT_PRIORITY
)
4529 SET_DECL_INIT_PRIORITY (decl
, pri
);
4530 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4535 error ("%qE attribute is not supported on this platform", name
);
4536 *no_add_attrs
= true;
4541 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4542 and the new one has the tags in NEW_. Give an error if there are tags
4543 in NEW_ that weren't in OLD. */
4546 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4548 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4549 old
= TREE_VALUE (old
);
4550 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4551 new_
= TREE_VALUE (new_
);
4553 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4555 tree str
= TREE_VALUE (t
);
4556 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4558 tree ostr
= TREE_VALUE (in
);
4559 if (cp_tree_equal (str
, ostr
))
4562 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4568 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4574 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4575 ill-formed, give an error and return false; otherwise, return true. */
4578 check_abi_tag_args (tree args
, tree name
)
4582 error ("the %qE attribute requires arguments", name
);
4585 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4587 tree elt
= TREE_VALUE (arg
);
4588 if (TREE_CODE (elt
) != STRING_CST
4589 || (!same_type_ignoring_top_level_qualifiers_p
4590 (strip_array_types (TREE_TYPE (elt
)),
4593 error ("arguments to the %qE attribute must be narrow string "
4597 const char *begin
= TREE_STRING_POINTER (elt
);
4598 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4599 for (const char *p
= begin
; p
!= end
; ++p
)
4604 if (!ISALPHA (c
) && c
!= '_')
4606 error ("arguments to the %qE attribute must contain valid "
4607 "identifiers", name
);
4608 inform (input_location
, "%<%c%> is not a valid first "
4609 "character for an identifier", c
);
4613 else if (p
== end
- 1)
4614 gcc_assert (c
== 0);
4617 if (!ISALNUM (c
) && c
!= '_')
4619 error ("arguments to the %qE attribute must contain valid "
4620 "identifiers", name
);
4621 inform (input_location
, "%<%c%> is not a valid character "
4622 "in an identifier", c
);
4631 /* Handle an "abi_tag" attribute; arguments as in
4632 struct attribute_spec.handler. */
4635 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4636 int flags
, bool* no_add_attrs
)
4638 if (!check_abi_tag_args (args
, name
))
4643 if (!OVERLOAD_TYPE_P (*node
))
4645 error ("%qE attribute applied to non-class, non-enum type %qT",
4649 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4651 error ("%qE attribute applied to %qT after its definition",
4655 else if (CLASS_TYPE_P (*node
)
4656 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4658 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4659 "template instantiation %qT", name
, *node
);
4662 else if (CLASS_TYPE_P (*node
)
4663 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4665 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4666 "template specialization %qT", name
, *node
);
4670 tree attributes
= TYPE_ATTRIBUTES (*node
);
4671 tree decl
= TYPE_NAME (*node
);
4673 /* Make sure all declarations have the same abi tags. */
4674 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4676 if (!check_abi_tag_redeclaration (decl
,
4677 lookup_attribute ("abi_tag",
4685 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4687 error ("%qE attribute applied to non-function, non-variable %qD",
4691 else if (DECL_LANGUAGE (*node
) == lang_c
)
4693 error ("%qE attribute applied to extern \"C\" declaration %qD",
4702 *no_add_attrs
= true;
4706 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4707 thing pointed to by the constant. */
4710 make_ptrmem_cst (tree type
, tree member
)
4712 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4713 TREE_TYPE (ptrmem_cst
) = type
;
4714 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4718 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4719 return an existing type if an appropriate type already exists. */
4722 cp_build_type_attribute_variant (tree type
, tree attributes
)
4726 new_type
= build_type_attribute_variant (type
, attributes
);
4727 if (FUNC_OR_METHOD_TYPE_P (new_type
))
4728 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4730 /* Making a new main variant of a class type is broken. */
4731 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4736 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4737 Called only after doing all language independent checks. */
4740 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4742 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
4744 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4746 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4748 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4749 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4752 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4753 C++, these are the exception-specifier and ref-qualifier. */
4756 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4758 tree type
= CONST_CAST_TREE (typea
);
4759 if (FUNC_OR_METHOD_TYPE_P (type
))
4760 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4761 TYPE_RAISES_EXCEPTIONS (typeb
),
4762 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4766 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4767 traversal. Called from walk_tree. */
4770 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4771 void *data
, hash_set
<tree
> *pset
)
4773 enum tree_code code
= TREE_CODE (*tp
);
4776 #define WALK_SUBTREE(NODE) \
4779 result = cp_walk_tree (&(NODE), func, data, pset); \
4780 if (result) goto out; \
4784 /* Not one of the easy cases. We must explicitly go through the
4790 case TEMPLATE_TEMPLATE_PARM
:
4791 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4792 case UNBOUND_CLASS_TEMPLATE
:
4793 case TEMPLATE_PARM_INDEX
:
4794 case TEMPLATE_TYPE_PARM
:
4797 case UNDERLYING_TYPE
:
4798 /* None of these have subtrees other than those already walked
4800 *walk_subtrees_p
= 0;
4804 if (BASELINK_QUALIFIED_P (*tp
))
4805 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4806 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4807 *walk_subtrees_p
= 0;
4811 WALK_SUBTREE (TREE_TYPE (*tp
));
4812 *walk_subtrees_p
= 0;
4816 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4820 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4821 WALK_SUBTREE (OVL_CHAIN (*tp
));
4822 *walk_subtrees_p
= 0;
4826 WALK_SUBTREE (DECL_NAME (*tp
));
4827 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4828 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4829 *walk_subtrees_p
= 0;
4833 if (TYPE_PTRMEMFUNC_P (*tp
))
4834 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4837 case TYPE_ARGUMENT_PACK
:
4838 case NONTYPE_ARGUMENT_PACK
:
4840 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4841 int i
, len
= TREE_VEC_LENGTH (args
);
4842 for (i
= 0; i
< len
; i
++)
4843 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4847 case TYPE_PACK_EXPANSION
:
4848 WALK_SUBTREE (TREE_TYPE (*tp
));
4849 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4850 *walk_subtrees_p
= 0;
4853 case EXPR_PACK_EXPANSION
:
4854 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4855 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4856 *walk_subtrees_p
= 0;
4860 case REINTERPRET_CAST_EXPR
:
4861 case STATIC_CAST_EXPR
:
4862 case CONST_CAST_EXPR
:
4863 case DYNAMIC_CAST_EXPR
:
4864 case IMPLICIT_CONV_EXPR
:
4865 if (TREE_TYPE (*tp
))
4866 WALK_SUBTREE (TREE_TYPE (*tp
));
4870 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4871 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4873 *walk_subtrees_p
= 0;
4877 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4878 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4879 *walk_subtrees_p
= 0;
4883 ++cp_unevaluated_operand
;
4884 /* We can't use WALK_SUBTREE here because of the goto. */
4885 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4886 --cp_unevaluated_operand
;
4887 *walk_subtrees_p
= 0;
4893 ++cp_unevaluated_operand
;
4894 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4895 --cp_unevaluated_operand
;
4896 *walk_subtrees_p
= 0;
4900 // Only recurse through the nested expression. Do not
4901 // walk the parameter list. Doing so causes false
4902 // positives in the pack expansion checker since the
4903 // requires parameters are introduced as pack expansions.
4904 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4905 *walk_subtrees_p
= 0;
4909 /* User variables should be mentioned in BIND_EXPR_VARS
4910 and their initializers and sizes walked when walking
4911 the containing BIND_EXPR. Compiler temporaries are
4912 handled here. And also normal variables in templates,
4913 since do_poplevel doesn't build a BIND_EXPR then. */
4914 if (VAR_P (TREE_OPERAND (*tp
, 0))
4915 && (processing_template_decl
4916 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4917 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4919 tree decl
= TREE_OPERAND (*tp
, 0);
4920 WALK_SUBTREE (DECL_INITIAL (decl
));
4921 WALK_SUBTREE (DECL_SIZE (decl
));
4922 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4927 /* Don't walk into the body of the lambda, but the capture initializers
4928 are part of the enclosing context. */
4929 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
4930 cap
= TREE_CHAIN (cap
))
4931 WALK_SUBTREE (TREE_VALUE (cap
));
4938 /* We didn't find what we were looking for. */
4945 /* Like save_expr, but for C++. */
4948 cp_save_expr (tree expr
)
4950 /* There is no reason to create a SAVE_EXPR within a template; if
4951 needed, we can create the SAVE_EXPR when instantiating the
4952 template. Furthermore, the middle-end cannot handle C++-specific
4954 if (processing_template_decl
)
4957 /* TARGET_EXPRs are only expanded once. */
4958 if (TREE_CODE (expr
) == TARGET_EXPR
)
4961 return save_expr (expr
);
4964 /* Initialize tree.c. */
4969 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4970 register_scoped_attributes (std_attribute_table
, NULL
);
4973 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4974 is. Note that sfk_none is zero, so this function can be used as a
4975 predicate to test whether or not DECL is a special function. */
4977 special_function_kind
4978 special_function_p (const_tree decl
)
4980 /* Rather than doing all this stuff with magic names, we should
4981 probably have a field of type `special_function_kind' in
4982 DECL_LANG_SPECIFIC. */
4983 if (DECL_INHERITED_CTOR (decl
))
4984 return sfk_inheriting_constructor
;
4985 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4986 return sfk_copy_constructor
;
4987 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4988 return sfk_move_constructor
;
4989 if (DECL_CONSTRUCTOR_P (decl
))
4990 return sfk_constructor
;
4991 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
4992 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
4994 if (copy_fn_p (decl
))
4995 return sfk_copy_assignment
;
4996 if (move_fn_p (decl
))
4997 return sfk_move_assignment
;
4999 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5000 return sfk_destructor
;
5001 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5002 return sfk_complete_destructor
;
5003 if (DECL_BASE_DESTRUCTOR_P (decl
))
5004 return sfk_base_destructor
;
5005 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5006 return sfk_deleting_destructor
;
5007 if (DECL_CONV_FN_P (decl
))
5008 return sfk_conversion
;
5009 if (deduction_guide_p (decl
))
5010 return sfk_deduction_guide
;
5015 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5018 char_type_p (tree type
)
5020 return (same_type_p (type
, char_type_node
)
5021 || same_type_p (type
, unsigned_char_type_node
)
5022 || same_type_p (type
, signed_char_type_node
)
5023 || same_type_p (type
, char8_type_node
)
5024 || same_type_p (type
, char16_type_node
)
5025 || same_type_p (type
, char32_type_node
)
5026 || same_type_p (type
, wchar_type_node
));
5029 /* Returns the kind of linkage associated with the indicated DECL. Th
5030 value returned is as specified by the language standard; it is
5031 independent of implementation details regarding template
5032 instantiation, etc. For example, it is possible that a declaration
5033 to which this function assigns external linkage would not show up
5034 as a global symbol when you run `nm' on the resulting object file. */
5037 decl_linkage (tree decl
)
5039 /* This function doesn't attempt to calculate the linkage from first
5040 principles as given in [basic.link]. Instead, it makes use of
5041 the fact that we have already set TREE_PUBLIC appropriately, and
5042 then handles a few special cases. Ideally, we would calculate
5043 linkage first, and then transform that into a concrete
5046 /* Things that don't have names have no linkage. */
5047 if (!DECL_NAME (decl
))
5050 /* Fields have no linkage. */
5051 if (TREE_CODE (decl
) == FIELD_DECL
)
5054 /* Things that are TREE_PUBLIC have external linkage. */
5055 if (TREE_PUBLIC (decl
))
5058 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5059 check one of the "clones" for the real linkage. */
5060 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5061 && DECL_CHAIN (decl
)
5062 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5063 return decl_linkage (DECL_CHAIN (decl
));
5065 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5068 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5070 if (TREE_CODE (decl
) == CONST_DECL
)
5071 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5073 /* Things in local scope do not have linkage, if they don't have
5075 if (decl_function_context (decl
))
5078 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5079 are considered to have external linkage for language purposes, as do
5080 template instantiations on targets without weak symbols. DECLs really
5081 meant to have internal linkage have DECL_THIS_STATIC set. */
5082 if (TREE_CODE (decl
) == TYPE_DECL
)
5084 if (VAR_OR_FUNCTION_DECL_P (decl
))
5086 if (!DECL_THIS_STATIC (decl
))
5089 /* Static data members and static member functions from classes
5090 in anonymous namespace also don't have TREE_PUBLIC set. */
5091 if (DECL_CLASS_CONTEXT (decl
))
5095 /* Everything else has internal linkage. */
5099 /* Returns the storage duration of the object or reference associated with
5100 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5103 decl_storage_duration (tree decl
)
5105 if (TREE_CODE (decl
) == PARM_DECL
)
5107 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5109 gcc_assert (VAR_P (decl
));
5110 if (!TREE_STATIC (decl
)
5111 && !DECL_EXTERNAL (decl
))
5113 if (CP_DECL_THREAD_LOCAL_P (decl
))
5118 /* EXP is an expression that we want to pre-evaluate. Returns (in
5119 *INITP) an expression that will perform the pre-evaluation. The
5120 value returned by this function is a side-effect free expression
5121 equivalent to the pre-evaluated expression. Callers must ensure
5122 that *INITP is evaluated before EXP. */
5125 stabilize_expr (tree exp
, tree
* initp
)
5129 if (!TREE_SIDE_EFFECTS (exp
))
5130 init_expr
= NULL_TREE
;
5131 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5136 /* There are no expressions with REFERENCE_TYPE, but there can be call
5137 arguments with such a type; just treat it as a pointer. */
5138 else if (TYPE_REF_P (TREE_TYPE (exp
))
5139 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5140 || !glvalue_p (exp
))
5142 init_expr
= get_target_expr (exp
);
5143 exp
= TARGET_EXPR_SLOT (init_expr
);
5144 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5151 bool xval
= !lvalue_p (exp
);
5152 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5153 init_expr
= get_target_expr (exp
);
5154 exp
= TARGET_EXPR_SLOT (init_expr
);
5155 exp
= cp_build_fold_indirect_ref (exp
);
5161 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5165 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5166 similar expression ORIG. */
5169 add_stmt_to_compound (tree orig
, tree new_expr
)
5171 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5173 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5175 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5178 /* Like stabilize_expr, but for a call whose arguments we want to
5179 pre-evaluate. CALL is modified in place to use the pre-evaluated
5180 arguments, while, upon return, *INITP contains an expression to
5181 compute the arguments. */
5184 stabilize_call (tree call
, tree
*initp
)
5186 tree inits
= NULL_TREE
;
5188 int nargs
= call_expr_nargs (call
);
5190 if (call
== error_mark_node
|| processing_template_decl
)
5196 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5198 for (i
= 0; i
< nargs
; i
++)
5201 CALL_EXPR_ARG (call
, i
) =
5202 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5203 inits
= add_stmt_to_compound (inits
, init
);
5209 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5210 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5211 arguments, while, upon return, *INITP contains an expression to
5212 compute the arguments. */
5215 stabilize_aggr_init (tree call
, tree
*initp
)
5217 tree inits
= NULL_TREE
;
5219 int nargs
= aggr_init_expr_nargs (call
);
5221 if (call
== error_mark_node
)
5224 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5226 for (i
= 0; i
< nargs
; i
++)
5229 AGGR_INIT_EXPR_ARG (call
, i
) =
5230 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5231 inits
= add_stmt_to_compound (inits
, init
);
5237 /* Like stabilize_expr, but for an initialization.
5239 If the initialization is for an object of class type, this function
5240 takes care not to introduce additional temporaries.
5242 Returns TRUE iff the expression was successfully pre-evaluated,
5243 i.e., if INIT is now side-effect free, except for, possibly, a
5244 single call to a constructor. */
5247 stabilize_init (tree init
, tree
*initp
)
5253 if (t
== error_mark_node
|| processing_template_decl
)
5256 if (TREE_CODE (t
) == INIT_EXPR
)
5257 t
= TREE_OPERAND (t
, 1);
5258 if (TREE_CODE (t
) == TARGET_EXPR
)
5259 t
= TARGET_EXPR_INITIAL (t
);
5261 /* If the RHS can be stabilized without breaking copy elision, stabilize
5262 it. We specifically don't stabilize class prvalues here because that
5263 would mean an extra copy, but they might be stabilized below. */
5264 if (TREE_CODE (init
) == INIT_EXPR
5265 && TREE_CODE (t
) != CONSTRUCTOR
5266 && TREE_CODE (t
) != AGGR_INIT_EXPR
5267 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5270 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5274 if (TREE_CODE (t
) == COMPOUND_EXPR
5275 && TREE_CODE (init
) == INIT_EXPR
)
5277 tree last
= expr_last (t
);
5278 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5279 if (!TREE_SIDE_EFFECTS (last
))
5282 TREE_OPERAND (init
, 1) = last
;
5287 if (TREE_CODE (t
) == CONSTRUCTOR
)
5289 /* Aggregate initialization: stabilize each of the field
5292 constructor_elt
*ce
;
5294 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5295 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5297 tree type
= TREE_TYPE (ce
->value
);
5299 if (TYPE_REF_P (type
)
5300 || SCALAR_TYPE_P (type
))
5301 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5302 else if (!stabilize_init (ce
->value
, &subinit
))
5304 *initp
= add_stmt_to_compound (*initp
, subinit
);
5309 if (TREE_CODE (t
) == CALL_EXPR
)
5311 stabilize_call (t
, initp
);
5315 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5317 stabilize_aggr_init (t
, initp
);
5321 /* The initialization is being performed via a bitwise copy -- and
5322 the item copied may have side effects. */
5323 return !TREE_SIDE_EFFECTS (init
);
5326 /* Returns true if a cast to TYPE may appear in an integral constant
5330 cast_valid_in_integral_constant_expression_p (tree type
)
5332 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5333 || cxx_dialect
>= cxx11
5334 || dependent_type_p (type
)
5335 || type
== error_mark_node
);
5338 /* Return true if we need to fix linkage information of DECL. */
5341 cp_fix_function_decl_p (tree decl
)
5343 /* Skip if DECL is not externally visible. */
5344 if (!TREE_PUBLIC (decl
))
5347 /* We need to fix DECL if it a appears to be exported but with no
5348 function body. Thunks do not have CFGs and we may need to
5349 handle them specially later. */
5350 if (!gimple_has_body_p (decl
)
5351 && !DECL_THUNK_P (decl
)
5352 && !DECL_EXTERNAL (decl
))
5354 struct cgraph_node
*node
= cgraph_node::get (decl
);
5356 /* Don't fix same_body aliases. Although they don't have their own
5357 CFG, they share it with what they alias to. */
5358 if (!node
|| !node
->alias
5359 || !vec_safe_length (node
->ref_list
.references
))
5366 /* Clean the C++ specific parts of the tree T. */
5369 cp_free_lang_data (tree t
)
5371 if (FUNC_OR_METHOD_TYPE_P (t
))
5373 /* Default args are not interesting anymore. */
5374 tree argtypes
= TYPE_ARG_TYPES (t
);
5377 TREE_PURPOSE (argtypes
) = 0;
5378 argtypes
= TREE_CHAIN (argtypes
);
5381 else if (TREE_CODE (t
) == FUNCTION_DECL
5382 && cp_fix_function_decl_p (t
))
5384 /* If T is used in this translation unit at all, the definition
5385 must exist somewhere else since we have decided to not emit it
5386 in this TU. So make it an external reference. */
5387 DECL_EXTERNAL (t
) = 1;
5388 TREE_STATIC (t
) = 0;
5390 if (TREE_CODE (t
) == FUNCTION_DECL
)
5391 discard_operator_bindings (t
);
5392 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5393 /* We do not need the leftover chaining of namespaces from the
5395 DECL_CHAIN (t
) = NULL_TREE
;
5398 /* Stub for c-common. Please keep in sync with c-decl.c.
5399 FIXME: If address space support is target specific, then this
5400 should be a C target hook. But currently this is not possible,
5401 because this function is called via REGISTER_TARGET_PRAGMAS. */
5403 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5407 /* Return the number of operands in T that we care about for things like
5411 cp_tree_operand_length (const_tree t
)
5413 enum tree_code code
= TREE_CODE (t
);
5415 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5416 return VL_EXP_OPERAND_LENGTH (t
);
5418 return cp_tree_code_length (code
);
5421 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5424 cp_tree_code_length (enum tree_code code
)
5426 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5430 case PREINCREMENT_EXPR
:
5431 case PREDECREMENT_EXPR
:
5432 case POSTINCREMENT_EXPR
:
5433 case POSTDECREMENT_EXPR
:
5439 case EXPR_PACK_EXPANSION
:
5443 return TREE_CODE_LENGTH (code
);
5447 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5451 cp_expr_location (const_tree t_
)
5453 tree t
= CONST_CAST_TREE (t_
);
5455 return UNKNOWN_LOCATION
;
5456 switch (TREE_CODE (t
))
5459 return LAMBDA_EXPR_LOCATION (t
);
5461 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5463 return EXPR_LOCATION (t
);
5467 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5468 conditions for the warning hold, false otherwise. */
5470 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5472 if (c_inhibit_evaluation_warnings
== 0
5473 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5475 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5476 "zero as null pointer constant");
5482 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5483 /* Complain that some language-specific thing hanging off a tree
5484 node has been accessed improperly. */
5487 lang_check_failed (const char* file
, int line
, const char* function
)
5489 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5490 function
, trim_filename (file
), line
);
5492 #endif /* ENABLE_TREE_CHECKING */
5496 namespace selftest
{
5498 /* Verify that lvalue_kind () works, for various expressions,
5499 and that location wrappers don't affect the results. */
5504 location_t loc
= BUILTINS_LOCATION
;
5506 /* Verify constants and parameters, without and with
5507 location wrappers. */
5508 tree int_cst
= build_int_cst (integer_type_node
, 42);
5509 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5511 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5512 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5513 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5515 tree string_lit
= build_string (4, "foo");
5516 TREE_TYPE (string_lit
) = char_array_type_node
;
5517 string_lit
= fix_string_type (string_lit
);
5518 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5520 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5521 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5522 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5524 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5525 get_identifier ("some_parm"),
5527 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5529 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5530 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5531 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5533 /* Verify that lvalue_kind of std::move on a parm isn't
5534 affected by location wrappers. */
5535 tree rvalue_ref_of_parm
= move (parm
);
5536 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5537 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5538 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5540 /* Verify lvalue_p. */
5541 ASSERT_FALSE (lvalue_p (int_cst
));
5542 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5543 ASSERT_TRUE (lvalue_p (parm
));
5544 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5545 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5546 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5549 /* Run all of the selftests within this file. */
5554 test_lvalue_kind ();
5557 } // namespace selftest
5559 #endif /* #if CHECKING_P */
5562 #include "gt-cp-tree.h"