1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2018 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 switch (TREE_CODE (ref
))
91 /* preincrements and predecrements are valid lvals, provided
92 what they refer to are valid lvals. */
93 case PREINCREMENT_EXPR
:
94 case PREDECREMENT_EXPR
:
98 case VIEW_CONVERT_EXPR
:
99 return lvalue_kind (TREE_OPERAND (ref
, 0));
103 tree op1
= TREE_OPERAND (ref
, 0);
104 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
106 op1_lvalue_kind
= lvalue_kind (op1
);
107 if (op1_lvalue_kind
== clk_class
)
108 /* in the case of an array operand, the result is an lvalue if
109 that operand is an lvalue and an xvalue otherwise */
110 op1_lvalue_kind
= clk_rvalueref
;
111 return op1_lvalue_kind
;
119 if (TREE_CODE (ref
) == MEMBER_REF
)
120 op1_lvalue_kind
= clk_ordinary
;
122 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
123 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
124 op1_lvalue_kind
= clk_none
;
125 else if (op1_lvalue_kind
== clk_class
)
126 /* The result of a .* expression whose second operand is a pointer to a
127 data member is an lvalue if the first operand is an lvalue and an
129 op1_lvalue_kind
= clk_rvalueref
;
130 return op1_lvalue_kind
;
133 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
135 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
137 /* For static member function recurse on the BASELINK, we can get
138 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
139 OVERLOAD, the overload is resolved first if possible through
140 resolve_address_of_overloaded_function. */
141 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
142 return lvalue_kind (TREE_OPERAND (ref
, 1));
144 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
145 if (op1_lvalue_kind
== clk_class
)
146 /* If E1 is an lvalue, then E1.E2 is an lvalue;
147 otherwise E1.E2 is an xvalue. */
148 op1_lvalue_kind
= clk_rvalueref
;
150 /* Look at the member designator. */
151 if (!op1_lvalue_kind
)
153 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
154 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
155 situations. If we're seeing a COMPONENT_REF, it's a non-static
156 member, so it isn't an lvalue. */
157 op1_lvalue_kind
= clk_none
;
158 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
159 /* This can be IDENTIFIER_NODE in a template. */;
160 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
162 /* Clear the ordinary bit. If this object was a class
163 rvalue we want to preserve that information. */
164 op1_lvalue_kind
&= ~clk_ordinary
;
165 /* The lvalue is for a bitfield. */
166 op1_lvalue_kind
|= clk_bitfield
;
168 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
169 op1_lvalue_kind
|= clk_packed
;
171 return op1_lvalue_kind
;
174 case COMPOUND_LITERAL_EXPR
:
178 /* CONST_DECL without TREE_STATIC are enumeration values and
179 thus not lvalues. With TREE_STATIC they are used by ObjC++
180 in objc_build_string_object and need to be considered as
182 if (! TREE_STATIC (ref
))
186 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
187 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
189 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
190 && DECL_LANG_SPECIFIC (ref
)
191 && DECL_IN_AGGR_P (ref
))
198 case PLACEHOLDER_EXPR
:
201 /* A scope ref in a template, left as SCOPE_REF to support later
204 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
206 tree op
= TREE_OPERAND (ref
, 1);
207 if (TREE_CODE (op
) == FIELD_DECL
)
208 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
210 return lvalue_kind (op
);
215 /* Disallow <? and >? as lvalues if either argument side-effects. */
216 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
217 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
219 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
220 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
224 if (processing_template_decl
)
226 /* Within templates, a REFERENCE_TYPE will indicate whether
227 the COND_EXPR result is an ordinary lvalue or rvalueref.
228 Since REFERENCE_TYPEs are handled above, if we reach this
229 point, we know we got a plain rvalue. Unless we have a
230 type-dependent expr, that is, but we shouldn't be testing
231 lvalueness if we can't even tell the types yet! */
232 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
235 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
236 ? TREE_OPERAND (ref
, 1)
237 : TREE_OPERAND (ref
, 0));
238 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
242 /* We expect to see unlowered MODOP_EXPRs only during
243 template processing. */
244 gcc_assert (processing_template_decl
);
252 return lvalue_kind (TREE_OPERAND (ref
, 1));
258 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
261 /* We can see calls outside of TARGET_EXPR in templates. */
262 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
267 /* All functions (except non-static-member functions) are
269 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
270 ? clk_none
: clk_ordinary
);
273 /* We now represent a reference to a single static member function
275 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
276 its argument unmodified and we assign it to a const_tree. */
277 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
279 case NON_DEPENDENT_EXPR
:
281 return lvalue_kind (TREE_OPERAND (ref
, 0));
283 case TEMPLATE_PARM_INDEX
:
284 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
285 /* A template parameter object is an lvalue. */
291 if (!TREE_TYPE (ref
))
293 if (CLASS_TYPE_P (TREE_TYPE (ref
))
294 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
299 /* If one operand is not an lvalue at all, then this expression is
301 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
304 /* Otherwise, it's an lvalue, and it has all the odd properties
305 contributed by either operand. */
306 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
307 /* It's not an ordinary lvalue if it involves any other kind. */
308 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
309 op1_lvalue_kind
&= ~clk_ordinary
;
310 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
311 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
312 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
313 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
314 op1_lvalue_kind
= clk_none
;
315 return op1_lvalue_kind
;
318 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
321 real_lvalue_p (const_tree ref
)
323 cp_lvalue_kind kind
= lvalue_kind (ref
);
324 if (kind
& (clk_rvalueref
|clk_class
))
330 /* c-common wants us to return bool. */
333 lvalue_p (const_tree t
)
335 return real_lvalue_p (t
);
338 /* This differs from lvalue_p in that xvalues are included. */
341 glvalue_p (const_tree ref
)
343 cp_lvalue_kind kind
= lvalue_kind (ref
);
344 if (kind
& clk_class
)
347 return (kind
!= clk_none
);
350 /* This differs from glvalue_p in that class prvalues are included. */
353 obvalue_p (const_tree ref
)
355 return (lvalue_kind (ref
) != clk_none
);
358 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
359 reference), false otherwise. */
362 xvalue_p (const_tree ref
)
364 return (lvalue_kind (ref
) == clk_rvalueref
);
367 /* True if REF is a bit-field. */
370 bitfield_p (const_tree ref
)
372 return (lvalue_kind (ref
) & clk_bitfield
);
375 /* C++-specific version of stabilize_reference. */
378 cp_stabilize_reference (tree ref
)
380 switch (TREE_CODE (ref
))
382 case NON_DEPENDENT_EXPR
:
383 /* We aren't actually evaluating this. */
386 /* We need to treat specially anything stabilize_reference doesn't
387 handle specifically. */
398 case ARRAY_RANGE_REF
:
402 cp_lvalue_kind kind
= lvalue_kind (ref
);
403 if ((kind
& ~clk_class
) != clk_none
)
405 tree type
= unlowered_expr_type (ref
);
406 bool rval
= !!(kind
& clk_rvalueref
);
407 type
= cp_build_reference_type (type
, rval
);
408 /* This inhibits warnings in, eg, cxx_mark_addressable
410 warning_sentinel
s (extra_warnings
);
411 ref
= build_static_cast (type
, ref
, tf_error
);
415 return stabilize_reference (ref
);
418 /* Test whether DECL is a builtin that may appear in a
419 constant-expression. */
422 builtin_valid_in_constant_expr_p (const_tree decl
)
424 if (TREE_CODE (decl
) != FUNCTION_DECL
)
425 /* Not a function. */
427 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
429 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
432 /* Not a built-in. */
435 switch (DECL_FUNCTION_CODE (decl
))
437 /* These always have constant results like the corresponding
440 case BUILT_IN_FUNCTION
:
443 /* The following built-ins are valid in constant expressions
444 when their arguments are. */
445 case BUILT_IN_ADD_OVERFLOW_P
:
446 case BUILT_IN_SUB_OVERFLOW_P
:
447 case BUILT_IN_MUL_OVERFLOW_P
:
449 /* These have constant results even if their operands are
451 case BUILT_IN_CONSTANT_P
:
452 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
459 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
462 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
465 tree type
= TREE_TYPE (decl
);
467 value
= mark_rvalue_use (value
);
469 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
470 || TREE_TYPE (decl
) == TREE_TYPE (value
)
471 /* On ARM ctors return 'this'. */
472 || (TYPE_PTR_P (TREE_TYPE (value
))
473 && TREE_CODE (value
) == CALL_EXPR
)
474 || useless_type_conversion_p (TREE_TYPE (decl
),
477 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
478 moving a constant aggregate into .rodata. */
479 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
480 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
481 && !VOID_TYPE_P (TREE_TYPE (value
))
482 && reduced_constant_expression_p (value
))
483 TREE_READONLY (decl
) = true;
485 if (complain
& tf_no_cleanup
)
486 /* The caller is building a new-expr and does not need a cleanup. */
490 t
= cxx_maybe_build_cleanup (decl
, complain
);
491 if (t
== error_mark_node
)
492 return error_mark_node
;
494 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
495 if (location_t eloc
= cp_expr_location (value
))
496 SET_EXPR_LOCATION (t
, eloc
);
497 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
498 ignore the TARGET_EXPR. If there really turn out to be no
499 side-effects, then the optimizer should be able to get rid of
500 whatever code is generated anyhow. */
501 TREE_SIDE_EFFECTS (t
) = 1;
506 /* Return an undeclared local temporary of type TYPE for use in building a
510 build_local_temp (tree type
)
512 tree slot
= build_decl (input_location
,
513 VAR_DECL
, NULL_TREE
, type
);
514 DECL_ARTIFICIAL (slot
) = 1;
515 DECL_IGNORED_P (slot
) = 1;
516 DECL_CONTEXT (slot
) = current_function_decl
;
517 layout_decl (slot
, 0);
521 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
524 process_aggr_init_operands (tree t
)
528 side_effects
= TREE_SIDE_EFFECTS (t
);
532 n
= TREE_OPERAND_LENGTH (t
);
533 for (i
= 1; i
< n
; i
++)
535 tree op
= TREE_OPERAND (t
, i
);
536 if (op
&& TREE_SIDE_EFFECTS (op
))
543 TREE_SIDE_EFFECTS (t
) = side_effects
;
546 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
547 FN, and SLOT. NARGS is the number of call arguments which are specified
548 as a tree array ARGS. */
551 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
557 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
558 TREE_TYPE (t
) = return_type
;
559 AGGR_INIT_EXPR_FN (t
) = fn
;
560 AGGR_INIT_EXPR_SLOT (t
) = slot
;
561 for (i
= 0; i
< nargs
; i
++)
562 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
563 process_aggr_init_operands (t
);
567 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
568 target. TYPE is the type to be initialized.
570 Build an AGGR_INIT_EXPR to represent the initialization. This function
571 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
572 to initialize another object, whereas a TARGET_EXPR can either
573 initialize another object or create its own temporary object, and as a
574 result building up a TARGET_EXPR requires that the type's destructor be
578 build_aggr_init_expr (tree type
, tree init
)
585 gcc_assert (!VOID_TYPE_P (type
));
587 /* Don't build AGGR_INIT_EXPR in a template. */
588 if (processing_template_decl
)
591 fn
= cp_get_callee (init
);
593 return convert (type
, init
);
595 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
596 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
597 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
599 /* We split the CALL_EXPR into its function and its arguments here.
600 Then, in expand_expr, we put them back together. The reason for
601 this is that this expression might be a default argument
602 expression. In that case, we need a new temporary every time the
603 expression is used. That's what break_out_target_exprs does; it
604 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
605 temporary slot. Then, expand_expr builds up a call-expression
606 using the new slot. */
608 /* If we don't need to use a constructor to create an object of this
609 type, don't mess with AGGR_INIT_EXPR. */
610 if (is_ctor
|| TREE_ADDRESSABLE (type
))
612 slot
= build_local_temp (type
);
614 if (TREE_CODE (init
) == CALL_EXPR
)
616 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
617 call_expr_nargs (init
),
618 CALL_EXPR_ARGP (init
));
619 AGGR_INIT_FROM_THUNK_P (rval
)
620 = CALL_FROM_THUNK_P (init
);
624 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
625 aggr_init_expr_nargs (init
),
626 AGGR_INIT_EXPR_ARGP (init
));
627 AGGR_INIT_FROM_THUNK_P (rval
)
628 = AGGR_INIT_FROM_THUNK_P (init
);
630 TREE_SIDE_EFFECTS (rval
) = 1;
631 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
632 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
633 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
634 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
635 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
643 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
644 target. TYPE is the type that this initialization should appear to
647 Build an encapsulation of the initialization to perform
648 and return it so that it can be processed by language-independent
649 and language-specific expression expanders. */
652 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
654 tree rval
= build_aggr_init_expr (type
, init
);
657 if (init
== error_mark_node
)
658 return error_mark_node
;
660 if (!complete_type_or_maybe_complain (type
, init
, complain
))
661 return error_mark_node
;
663 /* Make sure that we're not trying to create an instance of an
665 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
666 return error_mark_node
;
668 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
669 slot
= AGGR_INIT_EXPR_SLOT (rval
);
670 else if (TREE_CODE (rval
) == CALL_EXPR
671 || TREE_CODE (rval
) == CONSTRUCTOR
)
672 slot
= build_local_temp (type
);
676 rval
= build_target_expr (slot
, rval
, complain
);
678 if (rval
!= error_mark_node
)
679 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
684 /* Subroutine of build_vec_init_expr: Build up a single element
685 intialization as a proxy for the full array initialization to get things
686 marked as used and any appropriate diagnostics.
688 Since we're deferring building the actual constructor calls until
689 gimplification time, we need to build one now and throw it away so
690 that the relevant constructor gets mark_used before cgraph decides
691 what functions are needed. Here we assume that init is either
692 NULL_TREE, void_type_node (indicating value-initialization), or
693 another array to copy. */
696 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
698 tree inner_type
= strip_array_types (type
);
699 vec
<tree
, va_gc
> *argvec
;
701 if (integer_zerop (array_type_nelts_total (type
))
702 || !CLASS_TYPE_P (inner_type
))
703 /* No interesting initialization to do. */
704 return integer_zero_node
;
705 else if (init
== void_type_node
)
706 return build_value_init (inner_type
, complain
);
708 gcc_assert (init
== NULL_TREE
709 || (same_type_ignoring_top_level_qualifiers_p
710 (type
, TREE_TYPE (init
))));
712 argvec
= make_tree_vector ();
715 tree init_type
= strip_array_types (TREE_TYPE (init
));
716 tree dummy
= build_dummy_object (init_type
);
717 if (!lvalue_p (init
))
718 dummy
= move (dummy
);
719 argvec
->quick_push (dummy
);
721 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
722 &argvec
, inner_type
, LOOKUP_NORMAL
,
724 release_tree_vector (argvec
);
726 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
727 we don't want one here because we aren't creating a temporary. */
728 if (TREE_CODE (init
) == TARGET_EXPR
)
729 init
= TARGET_EXPR_INITIAL (init
);
734 /* Return a TARGET_EXPR which expresses the initialization of an array to
735 be named later, either default-initialization or copy-initialization
736 from another array of the same type. */
739 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
742 bool value_init
= false;
743 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
745 if (init
== void_type_node
)
751 slot
= build_local_temp (type
);
752 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
753 TREE_SIDE_EFFECTS (init
) = true;
754 SET_EXPR_LOCATION (init
, input_location
);
756 if (cxx_dialect
>= cxx11
757 && potential_constant_expression (elt_init
))
758 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
759 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
764 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
765 that requires a constant expression. */
768 diagnose_non_constexpr_vec_init (tree expr
)
770 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
772 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
773 init
= void_type_node
;
775 init
= VEC_INIT_EXPR_INIT (expr
);
777 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
778 require_potential_constant_expression (elt_init
);
782 build_array_copy (tree init
)
784 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
787 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
791 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
793 gcc_assert (!VOID_TYPE_P (type
));
795 if (TREE_CODE (init
) == TARGET_EXPR
796 || init
== error_mark_node
)
798 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
799 && !VOID_TYPE_P (TREE_TYPE (init
))
800 && TREE_CODE (init
) != COND_EXPR
801 && TREE_CODE (init
) != CONSTRUCTOR
802 && TREE_CODE (init
) != VA_ARG_EXPR
)
803 /* We need to build up a copy constructor call. A void initializer
804 means we're being called from bot_manip. COND_EXPR is a special
805 case because we already have copies on the arms and we don't want
806 another one here. A CONSTRUCTOR is aggregate initialization, which
807 is handled separately. A VA_ARG_EXPR is magic creation of an
808 aggregate; there's no additional work to be done. */
809 return force_rvalue (init
, complain
);
811 return force_target_expr (type
, init
, complain
);
814 /* Like the above function, but without the checking. This function should
815 only be used by code which is deliberately trying to subvert the type
816 system, such as call_builtin_trap. Or build_over_call, to avoid
817 infinite recursion. */
820 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
824 gcc_assert (!VOID_TYPE_P (type
));
826 slot
= build_local_temp (type
);
827 return build_target_expr (slot
, init
, complain
);
830 /* Like build_target_expr_with_type, but use the type of INIT. */
833 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
835 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
836 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
837 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
838 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
841 init
= convert_bitfield_to_declared_type (init
);
842 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
847 get_target_expr (tree init
)
849 return get_target_expr_sfinae (init
, tf_warning_or_error
);
852 /* If EXPR is a bitfield reference, convert it to the declared type of
853 the bitfield, and return the resulting expression. Otherwise,
854 return EXPR itself. */
857 convert_bitfield_to_declared_type (tree expr
)
861 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
863 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
868 /* EXPR is being used in an rvalue context. Return a version of EXPR
869 that is marked as an rvalue. */
876 if (error_operand_p (expr
))
879 expr
= mark_rvalue_use (expr
);
883 Non-class rvalues always have cv-unqualified types. */
884 type
= TREE_TYPE (expr
);
885 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
886 type
= cv_unqualified (type
);
888 /* We need to do this for rvalue refs as well to get the right answer
889 from decltype; see c++/36628. */
890 if (!processing_template_decl
&& glvalue_p (expr
))
891 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
892 else if (type
!= TREE_TYPE (expr
))
893 expr
= build_nop (type
, expr
);
899 struct cplus_array_info
905 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
907 typedef cplus_array_info
*compare_type
;
909 static hashval_t
hash (tree t
);
910 static bool equal (tree
, cplus_array_info
*);
913 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
916 cplus_array_hasher::hash (tree t
)
920 hash
= TYPE_UID (TREE_TYPE (t
));
922 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
926 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
927 of type `cplus_array_info*'. */
930 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
932 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
935 /* Hash table containing dependent array types, which are unsuitable for
936 the language-independent type hash table. */
937 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
939 /* Build an ARRAY_TYPE without laying it out. */
942 build_min_array_type (tree elt_type
, tree index_type
)
944 tree t
= cxx_make_type (ARRAY_TYPE
);
945 TREE_TYPE (t
) = elt_type
;
946 TYPE_DOMAIN (t
) = index_type
;
950 /* Set TYPE_CANONICAL like build_array_type_1, but using
951 build_cplus_array_type. */
954 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
956 /* Set the canonical type for this new node. */
957 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
958 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
959 SET_TYPE_STRUCTURAL_EQUALITY (t
);
960 else if (TYPE_CANONICAL (elt_type
) != elt_type
961 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
963 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
965 ? TYPE_CANONICAL (index_type
) : index_type
);
967 TYPE_CANONICAL (t
) = t
;
970 /* Like build_array_type, but handle special C++ semantics: an array of a
971 variant element type is a variant of the array of the main variant of
975 build_cplus_array_type (tree elt_type
, tree index_type
)
979 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
980 return error_mark_node
;
982 bool dependent
= (uses_template_parms (elt_type
)
983 || (index_type
&& uses_template_parms (index_type
)));
985 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
986 /* Start with an array of the TYPE_MAIN_VARIANT. */
987 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
991 /* Since type_hash_canon calls layout_type, we need to use our own
993 cplus_array_info cai
;
996 if (cplus_array_htab
== NULL
)
997 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
999 hash
= TYPE_UID (elt_type
);
1001 hash
^= TYPE_UID (index_type
);
1002 cai
.type
= elt_type
;
1003 cai
.domain
= index_type
;
1005 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1007 /* We have found the type: we're done. */
1011 /* Build a new array type. */
1012 t
= build_min_array_type (elt_type
, index_type
);
1014 /* Store it in the hash table. */
1017 /* Set the canonical type for this new node. */
1018 set_array_type_canon (t
, elt_type
, index_type
);
1023 bool typeless_storage
1024 = (elt_type
== unsigned_char_type_node
1025 || elt_type
== signed_char_type_node
1026 || elt_type
== char_type_node
1027 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1028 && TYPE_CONTEXT (elt_type
) == std_node
1029 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1030 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1033 /* Now check whether we already have this array variant. */
1034 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1037 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1038 if (TREE_TYPE (t
) == elt_type
1039 && TYPE_NAME (t
) == NULL_TREE
1040 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1044 t
= build_min_array_type (elt_type
, index_type
);
1045 set_array_type_canon (t
, elt_type
, index_type
);
1049 /* Make sure sizes are shared with the main variant.
1050 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1051 as it will overwrite alignment etc. of all variants. */
1052 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1053 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1054 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1057 TYPE_MAIN_VARIANT (t
) = m
;
1058 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1059 TYPE_NEXT_VARIANT (m
) = t
;
1063 /* Avoid spurious warnings with VLAs (c++/54583). */
1064 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1065 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1067 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1068 place more easily. */
1069 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1070 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1071 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1072 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1074 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1075 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1077 /* The element type has been completed since the last time we saw
1078 this array type; update the layout and 'tor flags for any variants
1081 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1083 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1084 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1091 /* Return an ARRAY_TYPE with element type ELT and length N. */
1094 build_array_of_n_type (tree elt
, int n
)
1096 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1099 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1100 for C++14 but then removed. This should only be used for N3639
1101 specifically; code wondering more generally if something is a VLA should use
1105 array_of_runtime_bound_p (tree t
)
1107 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1109 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1111 tree dom
= TYPE_DOMAIN (t
);
1114 tree max
= TYPE_MAX_VALUE (dom
);
1115 return (!potential_rvalue_constant_expression (max
)
1116 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1119 /* True iff T is a variable length array. */
1124 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1126 if (tree dom
= TYPE_DOMAIN (t
))
1128 tree max
= TYPE_MAX_VALUE (dom
);
1129 if (!potential_rvalue_constant_expression (max
)
1130 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1136 /* Return a reference type node referring to TO_TYPE. If RVAL is
1137 true, return an rvalue reference type, otherwise return an lvalue
1138 reference type. If a type node exists, reuse it, otherwise create
1141 cp_build_reference_type (tree to_type
, bool rval
)
1145 if (to_type
== error_mark_node
)
1146 return error_mark_node
;
1148 if (TYPE_REF_P (to_type
))
1150 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1151 to_type
= TREE_TYPE (to_type
);
1154 lvalue_ref
= build_reference_type (to_type
);
1158 /* This code to create rvalue reference types is based on and tied
1159 to the code creating lvalue reference types in the middle-end
1160 functions build_reference_type_for_mode and build_reference_type.
1162 It works by putting the rvalue reference type nodes after the
1163 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1164 they will effectively be ignored by the middle end. */
1166 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1167 if (TYPE_REF_IS_RVALUE (t
))
1170 t
= build_distinct_type_copy (lvalue_ref
);
1172 TYPE_REF_IS_RVALUE (t
) = true;
1173 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1174 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1176 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1177 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1178 else if (TYPE_CANONICAL (to_type
) != to_type
)
1180 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1182 TYPE_CANONICAL (t
) = t
;
1190 /* Returns EXPR cast to rvalue reference type, like std::move. */
1195 tree type
= TREE_TYPE (expr
);
1196 gcc_assert (!TYPE_REF_P (type
));
1197 type
= cp_build_reference_type (type
, /*rval*/true);
1198 return build_static_cast (type
, expr
, tf_warning_or_error
);
1201 /* Used by the C++ front end to build qualified array types. However,
1202 the C version of this function does not properly maintain canonical
1203 types (which are not used in C). */
1205 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1206 size_t /* orig_qual_indirect */)
1208 return cp_build_qualified_type (type
, type_quals
);
1212 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1213 arrays correctly. In particular, if TYPE is an array of T's, and
1214 TYPE_QUALS is non-empty, returns an array of qualified T's.
1216 FLAGS determines how to deal with ill-formed qualifications. If
1217 tf_ignore_bad_quals is set, then bad qualifications are dropped
1218 (this is permitted if TYPE was introduced via a typedef or template
1219 type parameter). If bad qualifications are dropped and tf_warning
1220 is set, then a warning is issued for non-const qualifications. If
1221 tf_ignore_bad_quals is not set and tf_error is not set, we
1222 return error_mark_node. Otherwise, we issue an error, and ignore
1225 Qualification of a reference type is valid when the reference came
1226 via a typedef or template type argument. [dcl.ref] No such
1227 dispensation is provided for qualifying a function type. [dcl.fct]
1228 DR 295 queries this and the proposed resolution brings it into line
1229 with qualifying a reference. We implement the DR. We also behave
1230 in a similar manner for restricting non-pointer types. */
1233 cp_build_qualified_type_real (tree type
,
1235 tsubst_flags_t complain
)
1238 int bad_quals
= TYPE_UNQUALIFIED
;
1240 if (type
== error_mark_node
)
1243 if (type_quals
== cp_type_quals (type
))
1246 if (TREE_CODE (type
) == ARRAY_TYPE
)
1248 /* In C++, the qualification really applies to the array element
1249 type. Obtain the appropriately qualified element type. */
1252 = cp_build_qualified_type_real (TREE_TYPE (type
),
1256 if (element_type
== error_mark_node
)
1257 return error_mark_node
;
1259 /* See if we already have an identically qualified type. Tests
1260 should be equivalent to those in check_qualified_type. */
1261 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1262 if (TREE_TYPE (t
) == element_type
1263 && TYPE_NAME (t
) == TYPE_NAME (type
)
1264 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1265 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1266 TYPE_ATTRIBUTES (type
)))
1271 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1273 /* Keep the typedef name. */
1274 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1276 t
= build_variant_type_copy (t
);
1277 TYPE_NAME (t
) = TYPE_NAME (type
);
1278 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1279 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1283 /* Even if we already had this variant, we update
1284 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1285 they changed since the variant was originally created.
1287 This seems hokey; if there is some way to use a previous
1288 variant *without* coming through here,
1289 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1290 TYPE_NEEDS_CONSTRUCTING (t
)
1291 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1292 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1293 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1296 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1298 tree t
= PACK_EXPANSION_PATTERN (type
);
1300 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1301 return make_pack_expansion (t
, complain
);
1304 /* A reference or method type shall not be cv-qualified.
1305 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1306 (in CD1) we always ignore extra cv-quals on functions. */
1307 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1308 && (TYPE_REF_P (type
)
1309 || TREE_CODE (type
) == FUNCTION_TYPE
1310 || TREE_CODE (type
) == METHOD_TYPE
))
1312 if (TYPE_REF_P (type
))
1313 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1314 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1317 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1318 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1319 type_quals
|= type_memfn_quals (type
);
1321 /* A restrict-qualified type must be a pointer (or reference)
1322 to object or incomplete type. */
1323 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1324 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1325 && TREE_CODE (type
) != TYPENAME_TYPE
1326 && !INDIRECT_TYPE_P (type
))
1328 bad_quals
|= TYPE_QUAL_RESTRICT
;
1329 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1332 if (bad_quals
== TYPE_UNQUALIFIED
1333 || (complain
& tf_ignore_bad_quals
))
1335 else if (!(complain
& tf_error
))
1336 return error_mark_node
;
1339 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1340 error ("%qV qualifiers cannot be applied to %qT",
1344 /* Retrieve (or create) the appropriately qualified variant. */
1345 result
= build_qualified_type (type
, type_quals
);
1350 /* Return TYPE with const and volatile removed. */
1353 cv_unqualified (tree type
)
1357 if (type
== error_mark_node
)
1360 quals
= cp_type_quals (type
);
1361 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1362 return cp_build_qualified_type (type
, quals
);
1365 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1366 from ATTRIBS that affect type identity, and no others. If any are not
1367 applied, set *remove_attributes to true. */
1370 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1372 tree first_ident
= NULL_TREE
;
1373 tree new_attribs
= NULL_TREE
;
1374 tree
*p
= &new_attribs
;
1376 if (OVERLOAD_TYPE_P (result
))
1378 /* On classes and enums all attributes are ingrained. */
1379 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1383 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1385 const attribute_spec
*as
1386 = lookup_attribute_spec (get_attribute_name (a
));
1387 if (as
&& as
->affects_type_identity
)
1391 else if (first_ident
== error_mark_node
)
1393 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1394 p
= &TREE_CHAIN (*p
);
1397 else if (first_ident
)
1399 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1401 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1402 p
= &TREE_CHAIN (*p
);
1404 first_ident
= error_mark_node
;
1407 if (first_ident
!= error_mark_node
)
1408 new_attribs
= first_ident
;
1410 if (first_ident
== attribs
)
1411 /* All attributes affected type identity. */;
1413 *remove_attributes
= true;
1415 return cp_build_type_attribute_variant (result
, new_attribs
);
1418 /* Builds a qualified variant of T that is not a typedef variant.
1419 E.g. consider the following declarations:
1420 typedef const int ConstInt;
1421 typedef ConstInt* PtrConstInt;
1422 If T is PtrConstInt, this function returns a type representing
1424 In other words, if T is a typedef, the function returns the underlying type.
1425 The cv-qualification and attributes of the type returned match the
1427 They will always be compatible types.
1428 The returned type is built so that all of its subtypes
1429 recursively have their typedefs stripped as well.
1431 This is different from just returning TYPE_CANONICAL (T)
1432 Because of several reasons:
1433 * If T is a type that needs structural equality
1434 its TYPE_CANONICAL (T) will be NULL.
1435 * TYPE_CANONICAL (T) desn't carry type attributes
1436 and loses template parameter names.
1438 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1439 affect type identity, and set the referent to true if any were
1443 strip_typedefs (tree t
, bool *remove_attributes
)
1445 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1447 if (!t
|| t
== error_mark_node
)
1450 if (TREE_CODE (t
) == TREE_LIST
)
1452 bool changed
= false;
1453 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1455 for (; t
; t
= TREE_CHAIN (t
))
1457 gcc_assert (!TREE_PURPOSE (t
));
1458 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1459 if (elt
!= TREE_VALUE (t
))
1461 vec_safe_push (vec
, elt
);
1464 r
= build_tree_list_vec (vec
);
1465 release_tree_vector (vec
);
1469 gcc_assert (TYPE_P (t
));
1471 if (t
== TYPE_CANONICAL (t
))
1474 if (dependent_alias_template_spec_p (t
))
1475 /* DR 1558: However, if the template-id is dependent, subsequent
1476 template argument substitution still applies to the template-id. */
1479 switch (TREE_CODE (t
))
1482 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1483 result
= build_pointer_type (type
);
1485 case REFERENCE_TYPE
:
1486 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1487 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1490 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1491 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1492 result
= build_offset_type (t0
, type
);
1495 if (TYPE_PTRMEMFUNC_P (t
))
1497 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1498 result
= build_ptrmemfunc_type (t0
);
1502 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1503 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1504 result
= build_cplus_array_type (type
, t0
);
1509 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1512 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1513 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1514 can't expect that re-hashing a function type will find a previous
1515 equivalent type, so try to reuse the input type if nothing has
1516 changed. If the type is itself a variant, that will change. */
1517 bool is_variant
= typedef_variant_p (t
);
1518 if (remove_attributes
1519 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1522 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1523 tree canon_spec
= (flag_noexcept_type
1524 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1526 changed
= (type
!= TREE_TYPE (t
) || is_variant
1527 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1529 for (arg_node
= TYPE_ARG_TYPES (t
);
1531 arg_node
= TREE_CHAIN (arg_node
))
1533 if (arg_node
== void_list_node
)
1535 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1537 gcc_assert (arg_type
);
1538 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1544 for (arg_node2
= TYPE_ARG_TYPES (t
);
1545 arg_node2
!= arg_node
;
1546 arg_node2
= TREE_CHAIN (arg_node2
))
1548 = tree_cons (TREE_PURPOSE (arg_node2
),
1549 TREE_VALUE (arg_node2
), arg_types
);
1553 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1560 arg_types
= nreverse (arg_types
);
1562 /* A list of parameters not ending with an ellipsis
1563 must end with void_list_node. */
1565 arg_types
= chainon (arg_types
, void_list_node
);
1567 if (TREE_CODE (t
) == METHOD_TYPE
)
1569 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1570 gcc_assert (class_type
);
1572 build_method_type_directly (class_type
, type
,
1573 TREE_CHAIN (arg_types
));
1577 result
= build_function_type (type
, arg_types
);
1578 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1581 result
= build_cp_fntype_variant (result
,
1582 type_memfn_rqual (t
), canon_spec
,
1583 TYPE_HAS_LATE_RETURN_TYPE (t
));
1588 bool changed
= false;
1589 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1590 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1591 && TREE_OPERAND (fullname
, 1))
1593 tree args
= TREE_OPERAND (fullname
, 1);
1594 tree new_args
= copy_node (args
);
1595 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1597 tree arg
= TREE_VEC_ELT (args
, i
);
1600 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1602 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1603 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1604 if (strip_arg
!= arg
)
1609 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1610 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1612 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1616 ggc_free (new_args
);
1618 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1619 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1621 tree name
= fullname
;
1622 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1623 name
= TREE_OPERAND (fullname
, 0);
1624 /* Use build_typename_type rather than make_typename_type because we
1625 don't want to resolve it here, just strip typedefs. */
1626 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1630 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1632 if (result
== DECLTYPE_TYPE_EXPR (t
))
1635 result
= (finish_decltype_type
1637 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1640 case UNDERLYING_TYPE
:
1641 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1642 result
= finish_underlying_type (type
);
1650 if (typedef_variant_p (t
))
1652 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1653 strip typedefs with attributes. */
1654 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1655 result
= strip_typedefs (result
);
1658 result
= TYPE_MAIN_VARIANT (t
);
1660 gcc_assert (!typedef_variant_p (result
));
1662 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1663 /* If RESULT is complete and T isn't, it's likely the case that T
1664 is a variant of RESULT which hasn't been updated yet. Skip the
1665 attribute handling. */;
1668 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1669 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1671 gcc_assert (TYPE_USER_ALIGN (t
));
1672 if (remove_attributes
)
1673 *remove_attributes
= true;
1676 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1677 result
= build_variant_type_copy (result
);
1679 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1680 TYPE_USER_ALIGN (result
) = true;
1684 if (TYPE_ATTRIBUTES (t
))
1686 if (remove_attributes
)
1687 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1690 result
= cp_build_type_attribute_variant (result
,
1691 TYPE_ATTRIBUTES (t
));
1695 return cp_build_qualified_type (result
, cp_type_quals (t
));
1698 /* Like strip_typedefs above, but works on expressions, so that in
1700 template<class T> struct A
1706 sizeof(TT) is replaced by sizeof(T). */
1709 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1713 enum tree_code code
;
1715 if (t
== NULL_TREE
|| t
== error_mark_node
)
1718 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1721 /* Some expressions have type operands, so let's handle types here rather
1722 than check TYPE_P in multiple places below. */
1724 return strip_typedefs (t
, remove_attributes
);
1726 code
= TREE_CODE (t
);
1729 case IDENTIFIER_NODE
:
1730 case TEMPLATE_PARM_INDEX
:
1733 case ARGUMENT_PACK_SELECT
:
1738 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1739 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1740 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1741 && type2
== TRAIT_EXPR_TYPE2 (t
))
1744 TRAIT_EXPR_TYPE1 (r
) = type1
;
1745 TRAIT_EXPR_TYPE2 (r
) = type2
;
1751 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1752 bool changed
= false;
1754 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1756 tree val
= strip_typedefs_expr (TREE_VALUE (it
), remove_attributes
);
1757 vec_safe_push (vec
, val
);
1758 if (val
!= TREE_VALUE (it
))
1760 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1765 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1766 r
= tree_cons (NULL_TREE
, it
, r
);
1770 release_tree_vector (vec
);
1776 bool changed
= false;
1777 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1778 n
= TREE_VEC_LENGTH (t
);
1779 vec_safe_reserve (vec
, n
);
1780 for (i
= 0; i
< n
; ++i
)
1782 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1784 vec
->quick_push (op
);
1785 if (op
!= TREE_VEC_ELT (t
, i
))
1791 for (i
= 0; i
< n
; ++i
)
1792 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1793 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1794 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1798 release_tree_vector (vec
);
1804 bool changed
= false;
1805 vec
<constructor_elt
, va_gc
> *vec
1806 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1807 n
= CONSTRUCTOR_NELTS (t
);
1808 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1809 for (i
= 0; i
< n
; ++i
)
1811 constructor_elt
*e
= &(*vec
)[i
];
1812 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1819 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1822 if (!changed
&& type
== TREE_TYPE (t
))
1830 TREE_TYPE (r
) = type
;
1831 CONSTRUCTOR_ELTS (r
) = vec
;
1837 error ("lambda-expression in a constant expression");
1838 return error_mark_node
;
1840 case STATEMENT_LIST
:
1841 error ("statement-expression in a constant expression");
1842 return error_mark_node
;
1848 gcc_assert (EXPR_P (t
));
1850 n
= cp_tree_operand_length (t
);
1851 ops
= XALLOCAVEC (tree
, n
);
1852 type
= TREE_TYPE (t
);
1857 case IMPLICIT_CONV_EXPR
:
1858 case DYNAMIC_CAST_EXPR
:
1859 case STATIC_CAST_EXPR
:
1860 case CONST_CAST_EXPR
:
1861 case REINTERPRET_CAST_EXPR
:
1864 type
= strip_typedefs (type
, remove_attributes
);
1868 for (i
= 0; i
< n
; ++i
)
1869 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1873 /* If nothing changed, return t. */
1874 for (i
= 0; i
< n
; ++i
)
1875 if (ops
[i
] != TREE_OPERAND (t
, i
))
1877 if (i
== n
&& type
== TREE_TYPE (t
))
1881 TREE_TYPE (r
) = type
;
1882 for (i
= 0; i
< n
; ++i
)
1883 TREE_OPERAND (r
, i
) = ops
[i
];
1887 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1888 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1889 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1890 VIRT indicates whether TYPE is inherited virtually or not.
1891 IGO_PREV points at the previous binfo of the inheritance graph
1892 order chain. The newly copied binfo's TREE_CHAIN forms this
1895 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1896 correct order. That is in the order the bases themselves should be
1899 The BINFO_INHERITANCE of a virtual base class points to the binfo
1900 of the most derived type. ??? We could probably change this so that
1901 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1902 remove a field. They currently can only differ for primary virtual
1906 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1912 /* See if we've already made this virtual base. */
1913 new_binfo
= binfo_for_vbase (type
, t
);
1918 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1919 BINFO_TYPE (new_binfo
) = type
;
1921 /* Chain it into the inheritance graph. */
1922 TREE_CHAIN (*igo_prev
) = new_binfo
;
1923 *igo_prev
= new_binfo
;
1925 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1930 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1932 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1933 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1935 /* We do not need to copy the accesses, as they are read only. */
1936 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1938 /* Recursively copy base binfos of BINFO. */
1939 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1941 tree new_base_binfo
;
1942 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1944 BINFO_VIRTUAL_P (base_binfo
));
1946 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1947 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1948 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1952 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1956 /* Push it onto the list after any virtual bases it contains
1957 will have been pushed. */
1958 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1959 BINFO_VIRTUAL_P (new_binfo
) = 1;
1960 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1966 /* Hashing of lists so that we don't make duplicates.
1967 The entry point is `list_hash_canon'. */
1976 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1978 typedef list_proxy
*compare_type
;
1980 static hashval_t
hash (tree
);
1981 static bool equal (tree
, list_proxy
*);
1984 /* Now here is the hash table. When recording a list, it is added
1985 to the slot whose index is the hash code mod the table size.
1986 Note that the hash table is used for several kinds of lists.
1987 While all these live in the same table, they are completely independent,
1988 and the hash code is computed differently for each of these. */
1990 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1992 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1993 for a node we are thinking about adding). */
1996 list_hasher::equal (tree t
, list_proxy
*proxy
)
1998 return (TREE_VALUE (t
) == proxy
->value
1999 && TREE_PURPOSE (t
) == proxy
->purpose
2000 && TREE_CHAIN (t
) == proxy
->chain
);
2003 /* Compute a hash code for a list (chain of TREE_LIST nodes
2004 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2005 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2008 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2010 hashval_t hashcode
= 0;
2013 hashcode
+= TREE_HASH (chain
);
2016 hashcode
+= TREE_HASH (value
);
2020 hashcode
+= TREE_HASH (purpose
);
2026 /* Hash an already existing TREE_LIST. */
2029 list_hasher::hash (tree t
)
2031 return list_hash_pieces (TREE_PURPOSE (t
),
2036 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2037 object for an identical list if one already exists. Otherwise, build a
2038 new one, and record it as the canonical object. */
2041 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2045 struct list_proxy proxy
;
2047 /* Hash the list node. */
2048 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2049 /* Create a proxy for the TREE_LIST we would like to create. We
2050 don't actually create it so as to avoid creating garbage. */
2051 proxy
.purpose
= purpose
;
2052 proxy
.value
= value
;
2053 proxy
.chain
= chain
;
2054 /* See if it is already in the table. */
2055 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2056 /* If not, create a new node. */
2058 *slot
= tree_cons (purpose
, value
, chain
);
2059 return (tree
) *slot
;
2062 /* Constructor for hashed lists. */
2065 hash_tree_chain (tree value
, tree chain
)
2067 return hash_tree_cons (NULL_TREE
, value
, chain
);
2071 debug_binfo (tree elem
)
2076 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2078 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2079 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2080 debug_tree (BINFO_TYPE (elem
));
2081 if (BINFO_VTABLE (elem
))
2082 fprintf (stderr
, "vtable decl \"%s\"\n",
2083 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2085 fprintf (stderr
, "no vtable decl yet\n");
2086 fprintf (stderr
, "virtuals:\n");
2087 virtuals
= BINFO_VIRTUALS (elem
);
2092 tree fndecl
= TREE_VALUE (virtuals
);
2093 fprintf (stderr
, "%s [%ld =? %ld]\n",
2094 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2095 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2097 virtuals
= TREE_CHAIN (virtuals
);
2101 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2102 the type of the result expression, if known, or NULL_TREE if the
2103 resulting expression is type-dependent. If TEMPLATE_P is true,
2104 NAME is known to be a template because the user explicitly used the
2105 "template" keyword after the "::".
2107 All SCOPE_REFs should be built by use of this function. */
2110 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2113 if (type
== error_mark_node
2114 || scope
== error_mark_node
2115 || name
== error_mark_node
)
2116 return error_mark_node
;
2117 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2118 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2119 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2120 PTRMEM_OK_P (t
) = true;
2122 t
= convert_from_reference (t
);
2126 /* Like check_qualified_type, but also check ref-qualifier, exception
2127 specification, and whether the return type was specified after the
2131 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2132 cp_ref_qualifier rqual
, tree raises
, bool late
)
2134 return (TYPE_QUALS (cand
) == type_quals
2135 && check_base_type (cand
, base
)
2136 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2138 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2139 && type_memfn_rqual (cand
) == rqual
);
2142 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2145 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2147 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2148 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2149 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2152 /* Make a raw overload node containing FN. */
2155 ovl_make (tree fn
, tree next
)
2157 tree result
= make_node (OVERLOAD
);
2159 if (TREE_CODE (fn
) == OVERLOAD
)
2160 OVL_NESTED_P (result
) = true;
2162 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2163 ? unknown_type_node
: TREE_TYPE (fn
));
2164 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2165 OVL_DEDUP_P (result
) = true;
2166 OVL_FUNCTION (result
) = fn
;
2167 OVL_CHAIN (result
) = next
;
2174 tree result
= make_node (OVERLOAD
);
2176 gcc_checking_assert (!OVL_NESTED_P (ovl
) && OVL_USED_P (ovl
));
2177 TREE_TYPE (result
) = TREE_TYPE (ovl
);
2178 OVL_FUNCTION (result
) = OVL_FUNCTION (ovl
);
2179 OVL_CHAIN (result
) = OVL_CHAIN (ovl
);
2180 OVL_DEDUP_P (result
) = OVL_DEDUP_P (ovl
);
2181 OVL_LOOKUP_P (result
) = OVL_LOOKUP_P (ovl
);
2182 OVL_HIDDEN_P (result
) = OVL_HIDDEN_P (ovl
);
2183 OVL_USING_P (result
) = OVL_USING_P (ovl
);
2188 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2189 true, if FN is via a using declaration. We also pay attention to
2190 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2194 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2196 tree result
= maybe_ovl
;
2197 tree insert_after
= NULL_TREE
;
2200 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2201 && OVL_HIDDEN_P (maybe_ovl
);
2202 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2204 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
)
2205 && !OVL_USED_P (maybe_ovl
));
2206 insert_after
= maybe_ovl
;
2209 bool hidden_p
= DECL_HIDDEN_P (fn
);
2210 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2212 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2214 OVL_HIDDEN_P (maybe_ovl
) = true;
2216 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2223 OVL_CHAIN (insert_after
) = maybe_ovl
;
2224 TREE_TYPE (insert_after
) = unknown_type_node
;
2232 /* Skip any hidden names at the beginning of OVL. */
2235 ovl_skip_hidden (tree ovl
)
2238 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2239 ovl
= OVL_CHAIN (ovl
))
2240 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2242 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2244 /* Any hidden functions should have been wrapped in an
2245 overload, but injected friend classes will not. */
2246 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2253 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2256 ovl_iterator::reveal_node (tree overload
, tree node
)
2258 /* We cannot have returned NODE as part of a lookup overload, so it
2260 gcc_checking_assert (!OVL_USED_P (node
));
2262 OVL_HIDDEN_P (node
) = false;
2263 if (tree chain
= OVL_CHAIN (node
))
2264 if (TREE_CODE (chain
) == OVERLOAD
2265 && (OVL_USING_P (chain
) || OVL_HIDDEN_P (chain
)))
2267 /* The node needs moving, and the simplest way is to remove it
2269 overload
= remove_node (overload
, node
);
2270 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2275 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2276 OVL_USED_P we must copy OVL nodes, because those are immutable.
2277 The removed node is unaltered and may continue to be iterated
2278 from (i.e. it is safe to remove a node from an overload one is
2279 currently iterating over). */
2282 ovl_iterator::remove_node (tree overload
, tree node
)
2284 bool copying
= false; /* Checking use only. */
2286 tree
*slot
= &overload
;
2287 while (*slot
!= node
)
2290 gcc_checking_assert (!OVL_LOOKUP_P (probe
)
2291 && (!copying
|| OVL_USED_P (probe
)));
2292 if (OVL_USED_P (probe
))
2295 probe
= ovl_copy (probe
);
2299 slot
= &OVL_CHAIN (probe
);
2302 /* Stitch out NODE. We don't have to worry about now making a
2303 singleton overload (and consequently maybe setting its type),
2304 because all uses of this function will be followed by inserting a
2305 new node that must follow the place we've cut this out from. */
2306 if (TREE_CODE (node
) != OVERLOAD
)
2307 /* Cloned inherited ctors don't mark themselves as via_using. */
2310 *slot
= OVL_CHAIN (node
);
2315 /* Mark or unmark a lookup set. */
2318 lookup_mark (tree ovl
, bool val
)
2320 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2322 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2323 LOOKUP_SEEN_P (*iter
) = val
;
2327 /* Add a set of new FNS into a lookup. */
2330 lookup_add (tree fns
, tree lookup
)
2332 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2334 lookup
= ovl_make (fns
, lookup
);
2335 OVL_LOOKUP_P (lookup
) = true;
2343 /* FNS is a new overload set, add them to LOOKUP, if they are not
2344 already present there. */
2347 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2350 for (tree next
, probe
= fns
; probe
; probe
= next
)
2355 if (TREE_CODE (probe
) == OVERLOAD
)
2357 fn
= OVL_FUNCTION (probe
);
2358 next
= OVL_CHAIN (probe
);
2361 if (!LOOKUP_SEEN_P (fn
))
2362 LOOKUP_SEEN_P (fn
) = true;
2365 /* This function was already seen. Insert all the
2366 predecessors onto the lookup. */
2367 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2369 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2370 /* Propagate OVL_USING, but OVL_HIDDEN &
2371 OVL_DEDUP_P don't matter. */
2372 if (OVL_USING_P (fns
))
2373 OVL_USING_P (lookup
) = true;
2376 /* And now skip this function. */
2382 /* We ended in a set of new functions. Add them all in one go. */
2383 lookup
= lookup_add (fns
, lookup
);
2388 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2395 ovl
&& TREE_CODE (ovl
) == OVERLOAD
2396 && !OVL_USED_P (ovl
);
2397 ovl
= OVL_CHAIN (ovl
))
2399 gcc_checking_assert (!OVL_LOOKUP_P (ovl
));
2400 OVL_USED_P (ovl
) = true;
2404 /* Preserve the contents of a lookup so that it is available for a
2405 later instantiation. */
2408 lookup_keep (tree lookup
)
2411 lookup
&& TREE_CODE (lookup
) == OVERLOAD
2412 && OVL_LOOKUP_P (lookup
) && !OVL_USED_P (lookup
);
2413 lookup
= OVL_CHAIN (lookup
))
2415 OVL_USED_P (lookup
) = true;
2416 ovl_used (OVL_FUNCTION (lookup
));
2422 /* Returns nonzero if X is an expression for a (possibly overloaded)
2423 function. If "f" is a function or function template, "f", "c->f",
2424 "c.f", "C::f", and "f<int>" will all be considered possibly
2425 overloaded functions. Returns 2 if the function is actually
2426 overloaded, i.e., if it is impossible to know the type of the
2427 function without performing overload resolution. */
2430 is_overloaded_fn (tree x
)
2432 /* A baselink is also considered an overloaded function. */
2433 if (TREE_CODE (x
) == OFFSET_REF
2434 || TREE_CODE (x
) == COMPONENT_REF
)
2435 x
= TREE_OPERAND (x
, 1);
2436 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2437 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2438 x
= TREE_OPERAND (x
, 0);
2440 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2441 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2444 return (TREE_CODE (x
) == FUNCTION_DECL
2445 || TREE_CODE (x
) == OVERLOAD
);
2448 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2449 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2453 dependent_name (tree x
)
2455 if (identifier_p (x
))
2457 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2458 x
= TREE_OPERAND (x
, 0);
2459 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2460 return OVL_NAME (x
);
2464 /* Returns true iff X is an expression for an overloaded function
2465 whose type cannot be known without performing overload
2469 really_overloaded_fn (tree x
)
2471 return is_overloaded_fn (x
) == 2;
2474 /* Get the overload set FROM refers to. Returns NULL if it's not an
2478 maybe_get_fns (tree from
)
2480 /* A baselink is also considered an overloaded function. */
2481 if (TREE_CODE (from
) == OFFSET_REF
2482 || TREE_CODE (from
) == COMPONENT_REF
)
2483 from
= TREE_OPERAND (from
, 1);
2484 if (BASELINK_P (from
))
2485 from
= BASELINK_FUNCTIONS (from
);
2486 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2487 from
= TREE_OPERAND (from
, 0);
2489 if (TREE_CODE (from
) == OVERLOAD
2490 || TREE_CODE (from
) == FUNCTION_DECL
)
2496 /* FROM refers to an overload set. Return that set (or die). */
2501 tree res
= maybe_get_fns (from
);
2507 /* Return the first function of the overload set FROM refers to. */
2510 get_first_fn (tree from
)
2512 return OVL_FIRST (get_fns (from
));
2515 /* Return the scope where the overloaded functions OVL were found. */
2518 ovl_scope (tree ovl
)
2520 if (TREE_CODE (ovl
) == OFFSET_REF
2521 || TREE_CODE (ovl
) == COMPONENT_REF
)
2522 ovl
= TREE_OPERAND (ovl
, 1);
2523 if (TREE_CODE (ovl
) == BASELINK
)
2524 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2525 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2526 ovl
= TREE_OPERAND (ovl
, 0);
2527 /* Skip using-declarations. */
2528 lkp_iterator
iter (ovl
);
2531 while (iter
.using_p () && ++iter
);
2533 return CP_DECL_CONTEXT (ovl
);
2536 #define PRINT_RING_SIZE 4
2539 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2541 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2542 static char *print_ring
[PRINT_RING_SIZE
];
2543 static bool trans_ring
[PRINT_RING_SIZE
];
2544 static int ring_counter
;
2547 /* Only cache functions. */
2549 || TREE_CODE (decl
) != FUNCTION_DECL
2550 || DECL_LANG_SPECIFIC (decl
) == 0)
2551 return lang_decl_name (decl
, v
, translate
);
2553 /* See if this print name is lying around. */
2554 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2555 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2556 /* yes, so return it. */
2557 return print_ring
[i
];
2559 if (++ring_counter
== PRINT_RING_SIZE
)
2562 if (current_function_decl
!= NULL_TREE
)
2564 /* There may be both translated and untranslated versions of the
2566 for (i
= 0; i
< 2; i
++)
2568 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2570 if (ring_counter
== PRINT_RING_SIZE
)
2573 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2576 free (print_ring
[ring_counter
]);
2578 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2579 uid_ring
[ring_counter
] = DECL_UID (decl
);
2580 trans_ring
[ring_counter
] = translate
;
2581 return print_ring
[ring_counter
];
2585 cxx_printable_name (tree decl
, int v
)
2587 return cxx_printable_name_internal (decl
, v
, false);
2591 cxx_printable_name_translate (tree decl
, int v
)
2593 return cxx_printable_name_internal (decl
, v
, true);
2596 /* Return the canonical version of exception-specification RAISES for a C++17
2597 function type, for use in type comparison and building TYPE_CANONICAL. */
2600 canonical_eh_spec (tree raises
)
2602 if (raises
== NULL_TREE
)
2604 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2605 || uses_template_parms (raises
)
2606 || uses_template_parms (TREE_PURPOSE (raises
)))
2607 /* Keep a dependent or deferred exception specification. */
2609 else if (nothrow_spec_p (raises
))
2610 /* throw() -> noexcept. */
2611 return noexcept_true_spec
;
2613 /* For C++17 type matching, anything else -> nothing. */
2618 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2619 tree raises
, bool late
)
2621 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2623 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2626 tree v
= TYPE_MAIN_VARIANT (type
);
2627 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2628 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2631 /* Need to build a new variant. */
2632 v
= build_variant_type_copy (type
);
2633 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2634 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2637 case REF_QUAL_RVALUE
:
2638 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2639 FUNCTION_REF_QUALIFIED (v
) = 1;
2641 case REF_QUAL_LVALUE
:
2642 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2643 FUNCTION_REF_QUALIFIED (v
) = 1;
2646 FUNCTION_REF_QUALIFIED (v
) = 0;
2650 /* Canonicalize the exception specification. */
2651 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2653 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2654 /* Propagate structural equality. */
2655 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2656 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2657 /* Build the underlying canonical type, since it is different
2659 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2662 /* T is its own canonical type. */
2663 TYPE_CANONICAL (v
) = v
;
2668 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2669 listed in RAISES. */
2672 build_exception_variant (tree type
, tree raises
)
2674 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2675 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2676 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2679 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2680 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2684 bind_template_template_parm (tree t
, tree newargs
)
2686 tree decl
= TYPE_NAME (t
);
2689 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2690 decl
= build_decl (input_location
,
2691 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2693 /* These nodes have to be created to reflect new TYPE_DECL and template
2695 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2696 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2697 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2698 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2700 TREE_TYPE (decl
) = t2
;
2701 TYPE_NAME (t2
) = decl
;
2702 TYPE_STUB_DECL (t2
) = decl
;
2704 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2709 /* Called from count_trees via walk_tree. */
2712 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2722 /* Debugging function for measuring the rough complexity of a tree
2726 count_trees (tree t
)
2729 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2733 /* Called from verify_stmt_tree via walk_tree. */
2736 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2739 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2740 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2743 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2746 /* If this statement is already present in the hash table, then
2747 there is a circularity in the statement tree. */
2748 gcc_assert (!statements
->find (t
));
2750 slot
= statements
->find_slot (t
, INSERT
);
2756 /* Debugging function to check that the statement T has not been
2757 corrupted. For now, this function simply checks that T contains no
2761 verify_stmt_tree (tree t
)
2763 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2764 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2767 /* Check if the type T depends on a type with no linkage and if so, return
2768 it. If RELAXED_P then do not consider a class type declared within
2769 a vague-linkage function to have no linkage. */
2772 no_linkage_check (tree t
, bool relaxed_p
)
2776 /* There's no point in checking linkage on template functions; we
2777 can't know their complete types. */
2778 if (processing_template_decl
)
2781 switch (TREE_CODE (t
))
2784 if (TYPE_PTRMEMFUNC_P (t
))
2786 /* Lambda types that don't have mangling scope have no linkage. We
2787 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2788 when we get here from pushtag none of the lambda information is
2789 set up yet, so we want to assume that the lambda has linkage and
2790 fix it up later if not. */
2791 if (CLASSTYPE_LAMBDA_EXPR (t
)
2792 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2793 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2797 if (!CLASS_TYPE_P (t
))
2801 /* Only treat unnamed types as having no linkage if they're at
2802 namespace scope. This is core issue 966. */
2803 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2806 for (r
= CP_TYPE_CONTEXT (t
); ; )
2808 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2809 have linkage, or we might just be in an anonymous namespace.
2810 If we're in a TREE_PUBLIC class, we have linkage. */
2811 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2812 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2813 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2815 if (!relaxed_p
|| !vague_linkage_p (r
))
2818 r
= CP_DECL_CONTEXT (r
);
2828 case REFERENCE_TYPE
:
2830 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2834 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2838 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2843 tree parm
= TYPE_ARG_TYPES (t
);
2844 if (TREE_CODE (t
) == METHOD_TYPE
)
2845 /* The 'this' pointer isn't interesting; a method has the same
2846 linkage (or lack thereof) as its enclosing class. */
2847 parm
= TREE_CHAIN (parm
);
2849 parm
&& parm
!= void_list_node
;
2850 parm
= TREE_CHAIN (parm
))
2852 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2856 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2864 extern int depth_reached
;
2867 cxx_print_statistics (void)
2869 print_template_statistics ();
2870 if (GATHER_STATISTICS
)
2871 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2875 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2876 (which is an ARRAY_TYPE). This counts only elements of the top
2880 array_type_nelts_top (tree type
)
2882 return fold_build2_loc (input_location
,
2883 PLUS_EXPR
, sizetype
,
2884 array_type_nelts (type
),
2888 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2889 (which is an ARRAY_TYPE). This one is a recursive count of all
2890 ARRAY_TYPEs that are clumped together. */
2893 array_type_nelts_total (tree type
)
2895 tree sz
= array_type_nelts_top (type
);
2896 type
= TREE_TYPE (type
);
2897 while (TREE_CODE (type
) == ARRAY_TYPE
)
2899 tree n
= array_type_nelts_top (type
);
2900 sz
= fold_build2_loc (input_location
,
2901 MULT_EXPR
, sizetype
, sz
, n
);
2902 type
= TREE_TYPE (type
);
2909 splay_tree target_remap
;
2910 bool clear_location
;
2913 /* Called from break_out_target_exprs via mapcar. */
2916 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2918 bot_data
&data
= *(bot_data
*)data_
;
2919 splay_tree target_remap
= data
.target_remap
;
2922 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2924 /* There can't be any TARGET_EXPRs or their slot variables below this
2925 point. But we must make a copy, in case subsequent processing
2926 alters any part of it. For example, during gimplification a cast
2927 of the form (T) &X::f (where "f" is a member function) will lead
2928 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2930 *tp
= unshare_expr (t
);
2933 if (TREE_CODE (t
) == TARGET_EXPR
)
2937 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2939 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2940 tf_warning_or_error
);
2941 if (u
== error_mark_node
)
2943 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2944 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2947 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2948 tf_warning_or_error
);
2950 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2951 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2952 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2954 /* Map the old variable to the new one. */
2955 splay_tree_insert (target_remap
,
2956 (splay_tree_key
) TREE_OPERAND (t
, 0),
2957 (splay_tree_value
) TREE_OPERAND (u
, 0));
2959 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2960 data
.clear_location
);
2961 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2962 return error_mark_node
;
2964 /* Replace the old expression with the new version. */
2966 /* We don't have to go below this point; the recursive call to
2967 break_out_target_exprs will have handled anything below this
2972 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2975 splay_tree_node n
= splay_tree_lookup (target_remap
,
2976 (splay_tree_key
) t
);
2979 *tp
= (tree
)n
->value
;
2984 copy_tree_r (tp
, walk_subtrees
, NULL
);
2985 splay_tree_insert (target_remap
,
2987 (splay_tree_value
)*tp
);
2988 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2989 splay_tree_insert (target_remap
,
2990 (splay_tree_key
)*tp
,
2991 (splay_tree_value
)*tp
);
2996 /* Make a copy of this node. */
2997 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2998 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2999 if (!processing_template_decl
)
3000 set_flags_from_callee (*tp
);
3001 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3002 SET_EXPR_LOCATION (*tp
, input_location
);
3006 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3007 DATA is really a splay-tree mapping old variables to new
3011 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3013 bot_data
&data
= *(bot_data
*)data_
;
3014 splay_tree target_remap
= data
.target_remap
;
3018 splay_tree_node n
= splay_tree_lookup (target_remap
,
3019 (splay_tree_key
) *t
);
3021 *t
= (tree
) n
->value
;
3023 else if (TREE_CODE (*t
) == PARM_DECL
3024 && DECL_NAME (*t
) == this_identifier
3025 && !DECL_CONTEXT (*t
))
3027 /* In an NSDMI we need to replace the 'this' parameter we used for
3028 parsing with the real one for this function. */
3029 *t
= current_class_ptr
;
3031 else if (TREE_CODE (*t
) == CONVERT_EXPR
3032 && CONVERT_EXPR_VBASE_PATH (*t
))
3034 /* In an NSDMI build_base_path defers building conversions to virtual
3035 bases, and we handle it here. */
3036 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3037 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3039 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3040 if (BINFO_TYPE (binfo
) == basetype
)
3042 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3043 tf_warning_or_error
);
3049 /* When we parse a default argument expression, we may create
3050 temporary variables via TARGET_EXPRs. When we actually use the
3051 default-argument expression, we make a copy of the expression
3052 and replace the temporaries with appropriate local versions.
3054 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3058 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3060 static int target_remap_count
;
3061 static splay_tree target_remap
;
3063 if (!target_remap_count
++)
3064 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3065 /*splay_tree_delete_key_fn=*/NULL
,
3066 /*splay_tree_delete_value_fn=*/NULL
);
3067 bot_data data
= { target_remap
, clear_location
};
3068 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3069 t
= error_mark_node
;
3070 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3072 if (!--target_remap_count
)
3074 splay_tree_delete (target_remap
);
3075 target_remap
= NULL
;
3081 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3082 which we expect to have type TYPE. */
3085 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3087 if (index
== NULL_TREE
)
3088 /* Can't refer to a particular member of a vector. */
3090 else if (TREE_CODE (index
) == INTEGER_CST
)
3091 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3093 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3094 /*reference*/false, tf_none
);
3097 tree objtype
= TREE_TYPE (obj
);
3098 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3100 /* When the destination object refers to a flexible array member
3101 verify that it matches the type of the source object except
3102 for its domain and qualifiers. */
3103 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3104 TYPE_MAIN_VARIANT (objtype
),
3105 COMPARE_REDECLARATION
));
3108 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3114 struct replace_placeholders_t
3116 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3117 tree exp
; /* The outermost exp. */
3118 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3119 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3122 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3123 build up subexpressions as we go deeper. */
3126 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3128 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3131 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3133 *walk_subtrees
= false;
3137 switch (TREE_CODE (*t
))
3139 case PLACEHOLDER_EXPR
:
3142 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3144 x
= TREE_OPERAND (x
, 0))
3145 gcc_assert (handled_component_p (x
));
3146 *t
= unshare_expr (x
);
3147 *walk_subtrees
= false;
3154 constructor_elt
*ce
;
3155 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3156 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3157 other than the d->exp one, those have PLACEHOLDER_EXPRs
3158 related to another object. */
3159 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3161 || d
->pset
->add (*t
))
3163 *walk_subtrees
= false;
3166 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3168 tree
*valp
= &ce
->value
;
3169 tree type
= TREE_TYPE (*valp
);
3172 if (TREE_CODE (*valp
) == CONSTRUCTOR
3173 && AGGREGATE_TYPE_P (type
))
3175 /* If we're looking at the initializer for OBJ, then build
3176 a sub-object reference. If we're looking at an
3177 initializer for another object, just pass OBJ down. */
3178 if (same_type_ignoring_top_level_qualifiers_p
3179 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3180 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3181 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3182 valp
= &TARGET_EXPR_INITIAL (*valp
);
3185 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3188 *walk_subtrees
= false;
3193 if (d
->pset
->add (*t
))
3194 *walk_subtrees
= false;
3201 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3202 a PLACEHOLDER_EXPR has been encountered. */
3205 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3207 /* This is only relevant for C++14. */
3208 if (cxx_dialect
< cxx14
)
3211 /* If the object isn't a (member of a) class, do nothing. */
3213 while (TREE_CODE (op0
) == COMPONENT_REF
)
3214 op0
= TREE_OPERAND (op0
, 0);
3215 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3219 if (TREE_CODE (exp
) == TARGET_EXPR
)
3220 tp
= &TARGET_EXPR_INITIAL (exp
);
3221 hash_set
<tree
> pset
;
3222 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3223 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3225 *seen_p
= data
.seen
;
3229 /* Callback function for find_placeholders. */
3232 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3234 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3236 *walk_subtrees
= false;
3240 switch (TREE_CODE (*t
))
3242 case PLACEHOLDER_EXPR
:
3246 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3247 *walk_subtrees
= false;
3257 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3258 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3261 find_placeholders (tree exp
)
3263 /* This is only relevant for C++14. */
3264 if (cxx_dialect
< cxx14
)
3267 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3270 /* Similar to `build_nt', but for template definitions of dependent
3274 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3281 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3285 t
= make_node (code
);
3286 SET_EXPR_LOCATION (t
, loc
);
3287 length
= TREE_CODE_LENGTH (code
);
3289 for (i
= 0; i
< length
; i
++)
3290 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3296 /* Similar to `build', but for template definitions. */
3299 build_min (enum tree_code code
, tree tt
, ...)
3306 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3310 t
= make_node (code
);
3311 length
= TREE_CODE_LENGTH (code
);
3314 for (i
= 0; i
< length
; i
++)
3316 tree x
= va_arg (p
, tree
);
3317 TREE_OPERAND (t
, i
) = x
;
3318 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3319 TREE_SIDE_EFFECTS (t
) = 1;
3327 /* Similar to `build', but for template definitions of non-dependent
3328 expressions. NON_DEP is the non-dependent expression that has been
3332 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3339 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3341 va_start (p
, non_dep
);
3343 if (REFERENCE_REF_P (non_dep
))
3344 non_dep
= TREE_OPERAND (non_dep
, 0);
3346 t
= make_node (code
);
3347 length
= TREE_CODE_LENGTH (code
);
3348 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3349 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3351 for (i
= 0; i
< length
; i
++)
3352 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3354 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3355 /* This should not be considered a COMPOUND_EXPR, because it
3356 resolves to an overload. */
3357 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3360 return convert_from_reference (t
);
3363 /* Similar to build_min_nt, but call expressions */
3366 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3371 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3372 CALL_EXPR_FN (ret
) = fn
;
3373 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3374 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3375 CALL_EXPR_ARG (ret
, ix
) = t
;
3380 /* Similar to `build_min_nt_call_vec', but for template definitions of
3381 non-dependent expressions. NON_DEP is the non-dependent expression
3382 that has been built. */
3385 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3387 tree t
= build_min_nt_call_vec (fn
, argvec
);
3388 if (REFERENCE_REF_P (non_dep
))
3389 non_dep
= TREE_OPERAND (non_dep
, 0);
3390 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3391 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3392 return convert_from_reference (t
);
3395 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3396 a call to an operator overload. OP is the operator that has been
3397 overloaded. NON_DEP is the non-dependent expression that's been built,
3398 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3399 the overload that NON_DEP is calling. */
3402 build_min_non_dep_op_overload (enum tree_code op
,
3407 int nargs
, expected_nargs
;
3409 vec
<tree
, va_gc
> *args
;
3411 non_dep
= extract_call_expr (non_dep
);
3413 nargs
= call_expr_nargs (non_dep
);
3415 expected_nargs
= cp_tree_code_length (op
);
3416 if ((op
== POSTINCREMENT_EXPR
3417 || op
== POSTDECREMENT_EXPR
)
3418 /* With -fpermissive non_dep could be operator++(). */
3419 && (!flag_permissive
|| nargs
!= expected_nargs
))
3420 expected_nargs
+= 1;
3421 gcc_assert (nargs
== expected_nargs
);
3423 args
= make_tree_vector ();
3424 va_start (p
, overload
);
3426 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3429 for (int i
= 0; i
< nargs
; i
++)
3431 tree arg
= va_arg (p
, tree
);
3432 vec_safe_push (args
, arg
);
3435 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3437 tree object
= va_arg (p
, tree
);
3438 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3439 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3440 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3441 object
, method
, NULL_TREE
);
3442 for (int i
= 1; i
< nargs
; i
++)
3444 tree arg
= va_arg (p
, tree
);
3445 vec_safe_push (args
, arg
);
3452 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3453 release_tree_vector (args
);
3455 tree call_expr
= extract_call_expr (call
);
3456 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3457 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3458 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3459 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3464 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3467 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3469 unsigned len
= vec_safe_length (old_vec
);
3470 gcc_assert (idx
<= len
);
3472 vec
<tree
, va_gc
> *new_vec
= NULL
;
3473 vec_alloc (new_vec
, len
+ 1);
3476 for (i
= 0; i
< len
; ++i
)
3479 new_vec
->quick_push (elt
);
3480 new_vec
->quick_push ((*old_vec
)[i
]);
3483 new_vec
->quick_push (elt
);
3489 get_type_decl (tree t
)
3491 if (TREE_CODE (t
) == TYPE_DECL
)
3494 return TYPE_STUB_DECL (t
);
3495 gcc_assert (t
== error_mark_node
);
3499 /* Returns the namespace that contains DECL, whether directly or
3503 decl_namespace_context (tree decl
)
3507 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3509 else if (TYPE_P (decl
))
3510 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3512 decl
= CP_DECL_CONTEXT (decl
);
3516 /* Returns true if decl is within an anonymous namespace, however deeply
3517 nested, or false otherwise. */
3520 decl_anon_ns_mem_p (const_tree decl
)
3522 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3524 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3526 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3528 decl
= CP_DECL_CONTEXT (decl
);
3530 return !TREE_PUBLIC (decl
);
3533 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3534 CALL_EXPRS. Return whether they are equivalent. */
3537 called_fns_equal (tree t1
, tree t2
)
3539 /* Core 1321: dependent names are equivalent even if the overload sets
3540 are different. But do compare explicit template arguments. */
3541 tree name1
= dependent_name (t1
);
3542 tree name2
= dependent_name (t2
);
3545 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3550 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3551 targs1
= TREE_OPERAND (t1
, 1);
3552 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3553 targs2
= TREE_OPERAND (t2
, 1);
3554 return cp_tree_equal (targs1
, targs2
);
3557 return cp_tree_equal (t1
, t2
);
3560 /* Return truthvalue of whether T1 is the same tree structure as T2.
3561 Return 1 if they are the same. Return 0 if they are different. */
3564 cp_tree_equal (tree t1
, tree t2
)
3566 enum tree_code code1
, code2
;
3573 code1
= TREE_CODE (t1
);
3574 code2
= TREE_CODE (t2
);
3579 if (CONSTANT_CLASS_P (t1
)
3580 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3586 /* There's only a single VOID_CST node, so we should never reach
3591 return tree_int_cst_equal (t1
, t2
);
3594 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3597 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3598 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3599 TREE_STRING_LENGTH (t1
));
3602 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3603 TREE_FIXED_CST (t2
));
3606 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3607 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3610 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3613 /* We need to do this when determining whether or not two
3614 non-type pointer to member function template arguments
3616 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3617 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3622 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3624 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3625 if (!cp_tree_equal (field
, elt2
->index
)
3626 || !cp_tree_equal (value
, elt2
->value
))
3633 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3635 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3637 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3640 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3645 call_expr_arg_iterator iter1
, iter2
;
3646 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3648 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3649 arg2
= first_call_expr_arg (t2
, &iter2
);
3651 arg1
= next_call_expr_arg (&iter1
),
3652 arg2
= next_call_expr_arg (&iter2
))
3653 if (!cp_tree_equal (arg1
, arg2
))
3662 tree o1
= TREE_OPERAND (t1
, 0);
3663 tree o2
= TREE_OPERAND (t2
, 0);
3665 /* Special case: if either target is an unallocated VAR_DECL,
3666 it means that it's going to be unified with whatever the
3667 TARGET_EXPR is really supposed to initialize, so treat it
3668 as being equivalent to anything. */
3669 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3670 && !DECL_RTL_SET_P (o1
))
3672 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3673 && !DECL_RTL_SET_P (o2
))
3675 else if (!cp_tree_equal (o1
, o2
))
3678 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3682 /* For comparing uses of parameters in late-specified return types
3683 with an out-of-class definition of the function, but can also come
3684 up for expressions that involve 'this' in a member function
3687 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3688 /* When comparing hash table entries, only an exact match is
3689 good enough; we don't want to replace 'this' with the
3690 version from another function. But be more flexible
3691 with local parameters in a requires-expression. */
3694 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3696 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3698 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3700 if (DECL_ARTIFICIAL (t1
)
3701 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3702 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3712 case IDENTIFIER_NODE
:
3717 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3718 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3719 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3720 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3721 BASELINK_FUNCTIONS (t2
)));
3723 case TEMPLATE_PARM_INDEX
:
3724 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3725 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3726 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3727 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3728 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3729 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3731 case TEMPLATE_ID_EXPR
:
3732 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3733 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3735 case CONSTRAINT_INFO
:
3736 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3737 CI_ASSOCIATED_CONSTRAINTS (t2
));
3740 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3741 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3742 CHECK_CONSTR_ARGS (t2
)));
3747 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3749 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3750 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3751 TREE_VEC_ELT (t2
, ix
)))
3759 tree o1
= TREE_OPERAND (t1
, 0);
3760 tree o2
= TREE_OPERAND (t2
, 0);
3762 if (code1
== SIZEOF_EXPR
)
3764 if (SIZEOF_EXPR_TYPE_P (t1
))
3765 o1
= TREE_TYPE (o1
);
3766 if (SIZEOF_EXPR_TYPE_P (t2
))
3767 o2
= TREE_TYPE (o2
);
3769 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3772 return same_type_p (o1
, o2
);
3774 return cp_tree_equal (o1
, o2
);
3779 tree t1_op1
, t2_op1
;
3781 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3784 t1_op1
= TREE_OPERAND (t1
, 1);
3785 t2_op1
= TREE_OPERAND (t2
, 1);
3786 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3789 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3793 /* Two pointer-to-members are the same if they point to the same
3794 field or function in the same class. */
3795 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3798 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3802 /* Two overloads. Must be exactly the same set of decls. */
3803 lkp_iterator
first (t1
);
3804 lkp_iterator
second (t2
);
3806 for (; first
&& second
; ++first
, ++second
)
3807 if (*first
!= *second
)
3809 return !(first
|| second
);
3813 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3815 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3816 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3819 case STATIC_CAST_EXPR
:
3820 case REINTERPRET_CAST_EXPR
:
3821 case CONST_CAST_EXPR
:
3822 case DYNAMIC_CAST_EXPR
:
3823 case IMPLICIT_CONV_EXPR
:
3826 case NON_LVALUE_EXPR
:
3827 case VIEW_CONVERT_EXPR
:
3828 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3830 /* Now compare operands as usual. */
3833 case DEFERRED_NOEXCEPT
:
3834 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3835 DEFERRED_NOEXCEPT_PATTERN (t2
))
3836 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3837 DEFERRED_NOEXCEPT_ARGS (t2
)));
3841 if (DECL_DEPENDENT_P (t1
) && DECL_DEPENDENT_P (t2
))
3842 return (cp_tree_equal (USING_DECL_SCOPE (t1
),
3843 USING_DECL_SCOPE (t2
))
3844 && cp_tree_equal (DECL_NAME (t1
),
3852 switch (TREE_CODE_CLASS (code1
))
3856 case tcc_comparison
:
3857 case tcc_expression
:
3864 n
= cp_tree_operand_length (t1
);
3865 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3866 && n
!= TREE_OPERAND_LENGTH (t2
))
3869 for (i
= 0; i
< n
; ++i
)
3870 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3877 return same_type_p (t1
, t2
);
3881 /* We can get here with --disable-checking. */
3885 /* The type of ARG when used as an lvalue. */
3888 lvalue_type (tree arg
)
3890 tree type
= TREE_TYPE (arg
);
3894 /* The type of ARG for printing error messages; denote lvalues with
3898 error_type (tree arg
)
3900 tree type
= TREE_TYPE (arg
);
3902 if (TREE_CODE (type
) == ARRAY_TYPE
)
3904 else if (TREE_CODE (type
) == ERROR_MARK
)
3906 else if (lvalue_p (arg
))
3907 type
= build_reference_type (lvalue_type (arg
));
3908 else if (MAYBE_CLASS_TYPE_P (type
))
3909 type
= lvalue_type (arg
);
3914 /* Does FUNCTION use a variable-length argument list? */
3917 varargs_function_p (const_tree function
)
3919 return stdarg_p (TREE_TYPE (function
));
3922 /* Returns 1 if decl is a member of a class. */
3925 member_p (const_tree decl
)
3927 const_tree
const ctx
= DECL_CONTEXT (decl
);
3928 return (ctx
&& TYPE_P (ctx
));
3931 /* Create a placeholder for member access where we don't actually have an
3932 object that the access is against. */
3935 build_dummy_object (tree type
)
3937 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3938 return cp_build_fold_indirect_ref (decl
);
3941 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3942 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3943 binfo path from current_class_type to TYPE, or 0. */
3946 maybe_dummy_object (tree type
, tree
* binfop
)
3950 tree current
= current_nonlambda_class_type ();
3953 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3954 tf_warning_or_error
)))
3958 /* Reference from a nested class member function. */
3960 binfo
= TYPE_BINFO (type
);
3966 if (current_class_ref
3967 /* current_class_ref might not correspond to current_class_type if
3968 we're in tsubst_default_argument or a lambda-declarator; in either
3969 case, we want to use current_class_ref if it matches CONTEXT. */
3970 && (same_type_ignoring_top_level_qualifiers_p
3971 (TREE_TYPE (current_class_ref
), context
)))
3972 decl
= current_class_ref
;
3974 decl
= build_dummy_object (context
);
3979 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3982 is_dummy_object (const_tree ob
)
3984 if (INDIRECT_REF_P (ob
))
3985 ob
= TREE_OPERAND (ob
, 0);
3986 return (TREE_CODE (ob
) == CONVERT_EXPR
3987 && TREE_OPERAND (ob
, 0) == void_node
);
3990 /* Returns 1 iff type T is something we want to treat as a scalar type for
3991 the purpose of deciding whether it is trivial/POD/standard-layout. */
3994 scalarish_type_p (const_tree t
)
3996 if (t
== error_mark_node
)
3999 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4002 /* Returns true iff T requires non-trivial default initialization. */
4005 type_has_nontrivial_default_init (const_tree t
)
4007 t
= strip_array_types (CONST_CAST_TREE (t
));
4009 if (CLASS_TYPE_P (t
))
4010 return TYPE_HAS_COMPLEX_DFLT (t
);
4015 /* Track classes with only deleted copy/move constructors so that we can warn
4016 if they are used in call/return by value. */
4018 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4020 remember_deleted_copy (const_tree t
)
4022 if (!deleted_copy_types
)
4023 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4024 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4027 maybe_warn_parm_abi (tree t
, location_t loc
)
4029 if (!deleted_copy_types
4030 || !deleted_copy_types
->contains (t
))
4033 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4034 && classtype_has_non_deleted_move_ctor (t
))
4037 auto_diagnostic_group d
;
4038 if (flag_abi_version
> 12)
4039 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=13 (GCC 8.2) fixes the "
4040 "calling convention for %qT, which was accidentally "
4041 "changed in 8.1", t
);
4043 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=12 (GCC 8.1) accident"
4044 "ally changes the calling convention for %qT", t
);
4046 inform (location_of (t
), " declared here");
4050 auto_diagnostic_group d
;
4051 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4052 "-fabi-version=13 (GCC 8.2)", t
))
4053 inform (location_of (t
), " because all of its copy and move "
4054 "constructors are deleted");
4057 /* Returns true iff copying an object of type T (including via move
4058 constructor) is non-trivial. That is, T has no non-trivial copy
4059 constructors and no non-trivial move constructors, and not all copy/move
4060 constructors are deleted. This function implements the ABI notion of
4061 non-trivial copy, which has diverged from the one in the standard. */
4064 type_has_nontrivial_copy_init (const_tree type
)
4066 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4068 if (CLASS_TYPE_P (t
))
4070 gcc_assert (COMPLETE_TYPE_P (t
));
4072 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4073 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4077 if (cxx_dialect
< cxx11
)
4078 /* No deleted functions before C++11. */
4081 /* Before ABI v12 we did a bitwise copy of types with only deleted
4082 copy/move constructors. */
4083 if (!abi_version_at_least (12)
4084 && !(warn_abi
&& abi_version_crosses (12)))
4087 bool saw_copy
= false;
4088 bool saw_non_deleted
= false;
4089 bool saw_non_deleted_move
= false;
4091 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4092 saw_copy
= saw_non_deleted
= true;
4093 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4096 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4097 /* [class.copy]/8 If the class definition declares a move
4098 constructor or move assignment operator, the implicitly declared
4099 copy constructor is defined as deleted.... */;
4101 /* Any other reason the implicitly-declared function would be
4102 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4104 saw_non_deleted
= true;
4107 if (!saw_non_deleted
)
4108 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4114 if (!DECL_DELETED_FN (fn
))
4116 /* Not deleted, therefore trivial. */
4117 saw_non_deleted
= true;
4121 else if (move_fn_p (fn
))
4122 if (!DECL_DELETED_FN (fn
))
4123 saw_non_deleted_move
= true;
4126 gcc_assert (saw_copy
);
4128 /* ABI v12 buggily ignored move constructors. */
4129 bool v11nontriv
= false;
4130 bool v12nontriv
= !saw_non_deleted
;
4131 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4132 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4133 : flag_abi_version
== 12 ? v12nontriv
4135 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4136 : warn_abi_version
== 12 ? v12nontriv
4138 if (nontriv
!= warn_nontriv
)
4139 remember_deleted_copy (t
);
4147 /* Returns 1 iff type T is a trivially copyable type, as defined in
4148 [basic.types] and [class]. */
4151 trivially_copyable_p (const_tree t
)
4153 t
= strip_array_types (CONST_CAST_TREE (t
));
4155 if (CLASS_TYPE_P (t
))
4156 return ((!TYPE_HAS_COPY_CTOR (t
)
4157 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4158 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4159 && (!TYPE_HAS_COPY_ASSIGN (t
)
4160 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4161 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4162 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4164 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4167 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4171 trivial_type_p (const_tree t
)
4173 t
= strip_array_types (CONST_CAST_TREE (t
));
4175 if (CLASS_TYPE_P (t
))
4176 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4177 && trivially_copyable_p (t
));
4179 return scalarish_type_p (t
);
4182 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4185 pod_type_p (const_tree t
)
4187 /* This CONST_CAST is okay because strip_array_types returns its
4188 argument unmodified and we assign it to a const_tree. */
4189 t
= strip_array_types (CONST_CAST_TREE(t
));
4191 if (!CLASS_TYPE_P (t
))
4192 return scalarish_type_p (t
);
4193 else if (cxx_dialect
> cxx98
)
4194 /* [class]/10: A POD struct is a class that is both a trivial class and a
4195 standard-layout class, and has no non-static data members of type
4196 non-POD struct, non-POD union (or array of such types).
4198 We don't need to check individual members because if a member is
4199 non-std-layout or non-trivial, the class will be too. */
4200 return (std_layout_type_p (t
) && trivial_type_p (t
));
4202 /* The C++98 definition of POD is different. */
4203 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4206 /* Returns true iff T is POD for the purpose of layout, as defined in the
4210 layout_pod_type_p (const_tree t
)
4212 t
= strip_array_types (CONST_CAST_TREE (t
));
4214 if (CLASS_TYPE_P (t
))
4215 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4217 return scalarish_type_p (t
);
4220 /* Returns true iff T is a standard-layout type, as defined in
4224 std_layout_type_p (const_tree t
)
4226 t
= strip_array_types (CONST_CAST_TREE (t
));
4228 if (CLASS_TYPE_P (t
))
4229 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4231 return scalarish_type_p (t
);
4234 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4236 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4237 as defined in [meta.unary.prop]. */
4240 type_has_unique_obj_representations (const_tree t
)
4244 t
= strip_array_types (CONST_CAST_TREE (t
));
4246 if (!trivially_copyable_p (t
))
4249 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4250 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4252 switch (TREE_CODE (t
))
4256 case REFERENCE_TYPE
:
4257 /* If some backend has any paddings in these types, we should add
4258 a target hook for this and handle it there. */
4262 /* For bool values other than 0 and 1 should only appear with
4263 undefined behavior. */
4267 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4270 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4271 when storing long double values, so for that we have to return false.
4272 Other kinds of floating point values are questionable due to +.0/-.0
4273 and NaNs, let's play safe for now. */
4276 case FIXED_POINT_TYPE
:
4284 return type_has_unique_obj_representations (TREE_TYPE (t
));
4287 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4288 if (CLASS_TYPE_P (t
))
4290 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4291 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4299 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4300 if (TREE_CODE (field
) == FIELD_DECL
)
4303 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4304 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4310 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4312 if (CLASS_TYPE_P (t
))
4314 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4315 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4330 /* Helper function for type_has_unique_obj_representations. */
4333 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4335 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4336 if (TREE_CODE (field
) != FIELD_DECL
)
4338 /* For bases, can't use type_has_unique_obj_representations here, as in
4339 struct S { int i : 24; S (); };
4340 struct T : public S { int j : 8; T (); };
4341 S doesn't have unique obj representations, but T does. */
4342 else if (DECL_FIELD_IS_BASE (field
))
4344 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4348 else if (DECL_C_BIT_FIELD (field
))
4350 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4351 if (!type_has_unique_obj_representations (btype
))
4354 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4358 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4359 if (TREE_CODE (field
) == FIELD_DECL
)
4361 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4362 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4363 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4366 if (DECL_SIZE (field
))
4368 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4372 if (cur
!= wi::to_offset (sz
))
4378 /* Nonzero iff type T is a class template implicit specialization. */
4381 class_tmpl_impl_spec_p (const_tree t
)
4383 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4386 /* Returns 1 iff zero initialization of type T means actually storing
4390 zero_init_p (const_tree t
)
4392 /* This CONST_CAST is okay because strip_array_types returns its
4393 argument unmodified and we assign it to a const_tree. */
4394 t
= strip_array_types (CONST_CAST_TREE(t
));
4396 if (t
== error_mark_node
)
4399 /* NULL pointers to data members are initialized with -1. */
4400 if (TYPE_PTRDATAMEM_P (t
))
4403 /* Classes that contain types that can't be zero-initialized, cannot
4404 be zero-initialized themselves. */
4405 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4411 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4412 warn_unused_result attribute. */
4415 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4416 int /*flags*/, bool *no_add_attrs
)
4418 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4420 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4421 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4422 "return type", name
, *node
);
4424 else if (OVERLOAD_TYPE_P (*node
))
4428 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4429 "functions or to class or enumeration types", name
);
4430 *no_add_attrs
= true;
4435 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4436 struct attribute_spec.handler. */
4438 handle_no_unique_addr_attribute (tree
* node
,
4444 if (TREE_CODE (*node
) != FIELD_DECL
)
4446 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4447 "non-static data members", name
);
4448 *no_add_attrs
= true;
4450 else if (DECL_C_BIT_FIELD (*node
))
4452 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4453 "a bit-field", name
);
4454 *no_add_attrs
= true;
4460 /* Table of valid C++ attributes. */
4461 const struct attribute_spec cxx_attribute_table
[] =
4463 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4464 affects_type_identity, handler, exclude } */
4465 { "init_priority", 1, 1, true, false, false, false,
4466 handle_init_priority_attribute
, NULL
},
4467 { "abi_tag", 1, -1, false, false, false, true,
4468 handle_abi_tag_attribute
, NULL
},
4469 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4472 /* Table of C++ standard attributes. */
4473 const struct attribute_spec std_attribute_table
[] =
4475 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4476 affects_type_identity, handler, exclude } */
4477 { "maybe_unused", 0, 0, false, false, false, false,
4478 handle_unused_attribute
, NULL
},
4479 { "nodiscard", 0, 0, false, false, false, false,
4480 handle_nodiscard_attribute
, NULL
},
4481 { "no_unique_address", 0, 0, true, false, false, false,
4482 handle_no_unique_addr_attribute
, NULL
},
4483 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4486 /* Handle an "init_priority" attribute; arguments as in
4487 struct attribute_spec.handler. */
4489 handle_init_priority_attribute (tree
* node
,
4495 tree initp_expr
= TREE_VALUE (args
);
4497 tree type
= TREE_TYPE (decl
);
4500 STRIP_NOPS (initp_expr
);
4501 initp_expr
= default_conversion (initp_expr
);
4503 initp_expr
= maybe_constant_value (initp_expr
);
4505 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4507 error ("requested init_priority is not an integer constant");
4508 cxx_constant_value (initp_expr
);
4509 *no_add_attrs
= true;
4513 pri
= TREE_INT_CST_LOW (initp_expr
);
4515 type
= strip_array_types (type
);
4517 if (decl
== NULL_TREE
4519 || !TREE_STATIC (decl
)
4520 || DECL_EXTERNAL (decl
)
4521 || (TREE_CODE (type
) != RECORD_TYPE
4522 && TREE_CODE (type
) != UNION_TYPE
)
4523 /* Static objects in functions are initialized the
4524 first time control passes through that
4525 function. This is not precise enough to pin down an
4526 init_priority value, so don't allow it. */
4527 || current_function_decl
)
4529 error ("can only use %qE attribute on file-scope definitions "
4530 "of objects of class type", name
);
4531 *no_add_attrs
= true;
4535 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4537 error ("requested init_priority is out of range");
4538 *no_add_attrs
= true;
4542 /* Check for init_priorities that are reserved for
4543 language and runtime support implementations.*/
4544 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4547 (0, "requested init_priority is reserved for internal use");
4550 if (SUPPORTS_INIT_PRIORITY
)
4552 SET_DECL_INIT_PRIORITY (decl
, pri
);
4553 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4558 error ("%qE attribute is not supported on this platform", name
);
4559 *no_add_attrs
= true;
4564 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4565 and the new one has the tags in NEW_. Give an error if there are tags
4566 in NEW_ that weren't in OLD. */
4569 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4571 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4572 old
= TREE_VALUE (old
);
4573 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4574 new_
= TREE_VALUE (new_
);
4576 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4578 tree str
= TREE_VALUE (t
);
4579 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4581 tree ostr
= TREE_VALUE (in
);
4582 if (cp_tree_equal (str
, ostr
))
4585 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4591 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4597 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4598 ill-formed, give an error and return false; otherwise, return true. */
4601 check_abi_tag_args (tree args
, tree name
)
4605 error ("the %qE attribute requires arguments", name
);
4608 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4610 tree elt
= TREE_VALUE (arg
);
4611 if (TREE_CODE (elt
) != STRING_CST
4612 || (!same_type_ignoring_top_level_qualifiers_p
4613 (strip_array_types (TREE_TYPE (elt
)),
4616 error ("arguments to the %qE attribute must be narrow string "
4620 const char *begin
= TREE_STRING_POINTER (elt
);
4621 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4622 for (const char *p
= begin
; p
!= end
; ++p
)
4627 if (!ISALPHA (c
) && c
!= '_')
4629 error ("arguments to the %qE attribute must contain valid "
4630 "identifiers", name
);
4631 inform (input_location
, "%<%c%> is not a valid first "
4632 "character for an identifier", c
);
4636 else if (p
== end
- 1)
4637 gcc_assert (c
== 0);
4640 if (!ISALNUM (c
) && c
!= '_')
4642 error ("arguments to the %qE attribute must contain valid "
4643 "identifiers", name
);
4644 inform (input_location
, "%<%c%> is not a valid character "
4645 "in an identifier", c
);
4654 /* Handle an "abi_tag" attribute; arguments as in
4655 struct attribute_spec.handler. */
4658 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4659 int flags
, bool* no_add_attrs
)
4661 if (!check_abi_tag_args (args
, name
))
4666 if (!OVERLOAD_TYPE_P (*node
))
4668 error ("%qE attribute applied to non-class, non-enum type %qT",
4672 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4674 error ("%qE attribute applied to %qT after its definition",
4678 else if (CLASS_TYPE_P (*node
)
4679 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4681 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4682 "template instantiation %qT", name
, *node
);
4685 else if (CLASS_TYPE_P (*node
)
4686 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4688 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4689 "template specialization %qT", name
, *node
);
4693 tree attributes
= TYPE_ATTRIBUTES (*node
);
4694 tree decl
= TYPE_NAME (*node
);
4696 /* Make sure all declarations have the same abi tags. */
4697 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4699 if (!check_abi_tag_redeclaration (decl
,
4700 lookup_attribute ("abi_tag",
4708 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4710 error ("%qE attribute applied to non-function, non-variable %qD",
4714 else if (DECL_LANGUAGE (*node
) == lang_c
)
4716 error ("%qE attribute applied to extern \"C\" declaration %qD",
4725 *no_add_attrs
= true;
4729 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4730 thing pointed to by the constant. */
4733 make_ptrmem_cst (tree type
, tree member
)
4735 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4736 TREE_TYPE (ptrmem_cst
) = type
;
4737 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4741 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4742 return an existing type if an appropriate type already exists. */
4745 cp_build_type_attribute_variant (tree type
, tree attributes
)
4749 new_type
= build_type_attribute_variant (type
, attributes
);
4750 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4751 || TREE_CODE (new_type
) == METHOD_TYPE
)
4752 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4754 /* Making a new main variant of a class type is broken. */
4755 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4760 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4761 Called only after doing all language independent checks. */
4764 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4766 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4767 || TREE_CODE (typea
) == METHOD_TYPE
);
4769 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4771 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4773 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4774 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4777 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4778 C++, these are the exception-specifier and ref-qualifier. */
4781 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4783 tree type
= CONST_CAST_TREE (typea
);
4784 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4785 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4786 TYPE_RAISES_EXCEPTIONS (typeb
),
4787 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4791 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4792 traversal. Called from walk_tree. */
4795 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4796 void *data
, hash_set
<tree
> *pset
)
4798 enum tree_code code
= TREE_CODE (*tp
);
4801 #define WALK_SUBTREE(NODE) \
4804 result = cp_walk_tree (&(NODE), func, data, pset); \
4805 if (result) goto out; \
4809 /* Not one of the easy cases. We must explicitly go through the
4815 case TEMPLATE_TEMPLATE_PARM
:
4816 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4817 case UNBOUND_CLASS_TEMPLATE
:
4818 case TEMPLATE_PARM_INDEX
:
4819 case TEMPLATE_TYPE_PARM
:
4822 case UNDERLYING_TYPE
:
4823 /* None of these have subtrees other than those already walked
4825 *walk_subtrees_p
= 0;
4829 if (BASELINK_QUALIFIED_P (*tp
))
4830 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4831 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4832 *walk_subtrees_p
= 0;
4836 WALK_SUBTREE (TREE_TYPE (*tp
));
4837 *walk_subtrees_p
= 0;
4841 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4845 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4846 WALK_SUBTREE (OVL_CHAIN (*tp
));
4847 *walk_subtrees_p
= 0;
4851 WALK_SUBTREE (DECL_NAME (*tp
));
4852 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4853 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4854 *walk_subtrees_p
= 0;
4858 if (TYPE_PTRMEMFUNC_P (*tp
))
4859 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4862 case TYPE_ARGUMENT_PACK
:
4863 case NONTYPE_ARGUMENT_PACK
:
4865 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4866 int i
, len
= TREE_VEC_LENGTH (args
);
4867 for (i
= 0; i
< len
; i
++)
4868 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4872 case TYPE_PACK_EXPANSION
:
4873 WALK_SUBTREE (TREE_TYPE (*tp
));
4874 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4875 *walk_subtrees_p
= 0;
4878 case EXPR_PACK_EXPANSION
:
4879 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4880 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4881 *walk_subtrees_p
= 0;
4885 case REINTERPRET_CAST_EXPR
:
4886 case STATIC_CAST_EXPR
:
4887 case CONST_CAST_EXPR
:
4888 case DYNAMIC_CAST_EXPR
:
4889 case IMPLICIT_CONV_EXPR
:
4890 if (TREE_TYPE (*tp
))
4891 WALK_SUBTREE (TREE_TYPE (*tp
));
4895 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4896 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4898 *walk_subtrees_p
= 0;
4902 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4903 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4904 *walk_subtrees_p
= 0;
4908 ++cp_unevaluated_operand
;
4909 /* We can't use WALK_SUBTREE here because of the goto. */
4910 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4911 --cp_unevaluated_operand
;
4912 *walk_subtrees_p
= 0;
4918 ++cp_unevaluated_operand
;
4919 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4920 --cp_unevaluated_operand
;
4921 *walk_subtrees_p
= 0;
4925 // Only recurse through the nested expression. Do not
4926 // walk the parameter list. Doing so causes false
4927 // positives in the pack expansion checker since the
4928 // requires parameters are introduced as pack expansions.
4929 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4930 *walk_subtrees_p
= 0;
4934 /* User variables should be mentioned in BIND_EXPR_VARS
4935 and their initializers and sizes walked when walking
4936 the containing BIND_EXPR. Compiler temporaries are
4937 handled here. And also normal variables in templates,
4938 since do_poplevel doesn't build a BIND_EXPR then. */
4939 if (VAR_P (TREE_OPERAND (*tp
, 0))
4940 && (processing_template_decl
4941 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4942 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4944 tree decl
= TREE_OPERAND (*tp
, 0);
4945 WALK_SUBTREE (DECL_INITIAL (decl
));
4946 WALK_SUBTREE (DECL_SIZE (decl
));
4947 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4955 /* We didn't find what we were looking for. */
4962 /* Like save_expr, but for C++. */
4965 cp_save_expr (tree expr
)
4967 /* There is no reason to create a SAVE_EXPR within a template; if
4968 needed, we can create the SAVE_EXPR when instantiating the
4969 template. Furthermore, the middle-end cannot handle C++-specific
4971 if (processing_template_decl
)
4974 /* TARGET_EXPRs are only expanded once. */
4975 if (TREE_CODE (expr
) == TARGET_EXPR
)
4978 return save_expr (expr
);
4981 /* Initialize tree.c. */
4986 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4987 register_scoped_attributes (std_attribute_table
, NULL
);
4990 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4991 is. Note that sfk_none is zero, so this function can be used as a
4992 predicate to test whether or not DECL is a special function. */
4994 special_function_kind
4995 special_function_p (const_tree decl
)
4997 /* Rather than doing all this stuff with magic names, we should
4998 probably have a field of type `special_function_kind' in
4999 DECL_LANG_SPECIFIC. */
5000 if (DECL_INHERITED_CTOR (decl
))
5001 return sfk_inheriting_constructor
;
5002 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5003 return sfk_copy_constructor
;
5004 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5005 return sfk_move_constructor
;
5006 if (DECL_CONSTRUCTOR_P (decl
))
5007 return sfk_constructor
;
5008 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5009 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5011 if (copy_fn_p (decl
))
5012 return sfk_copy_assignment
;
5013 if (move_fn_p (decl
))
5014 return sfk_move_assignment
;
5016 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5017 return sfk_destructor
;
5018 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5019 return sfk_complete_destructor
;
5020 if (DECL_BASE_DESTRUCTOR_P (decl
))
5021 return sfk_base_destructor
;
5022 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5023 return sfk_deleting_destructor
;
5024 if (DECL_CONV_FN_P (decl
))
5025 return sfk_conversion
;
5026 if (deduction_guide_p (decl
))
5027 return sfk_deduction_guide
;
5032 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5035 char_type_p (tree type
)
5037 return (same_type_p (type
, char_type_node
)
5038 || same_type_p (type
, unsigned_char_type_node
)
5039 || same_type_p (type
, signed_char_type_node
)
5040 || same_type_p (type
, char16_type_node
)
5041 || same_type_p (type
, char32_type_node
)
5042 || same_type_p (type
, wchar_type_node
));
5045 /* Returns the kind of linkage associated with the indicated DECL. Th
5046 value returned is as specified by the language standard; it is
5047 independent of implementation details regarding template
5048 instantiation, etc. For example, it is possible that a declaration
5049 to which this function assigns external linkage would not show up
5050 as a global symbol when you run `nm' on the resulting object file. */
5053 decl_linkage (tree decl
)
5055 /* This function doesn't attempt to calculate the linkage from first
5056 principles as given in [basic.link]. Instead, it makes use of
5057 the fact that we have already set TREE_PUBLIC appropriately, and
5058 then handles a few special cases. Ideally, we would calculate
5059 linkage first, and then transform that into a concrete
5062 /* Things that don't have names have no linkage. */
5063 if (!DECL_NAME (decl
))
5066 /* Fields have no linkage. */
5067 if (TREE_CODE (decl
) == FIELD_DECL
)
5070 /* Things that are TREE_PUBLIC have external linkage. */
5071 if (TREE_PUBLIC (decl
))
5074 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5075 check one of the "clones" for the real linkage. */
5076 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5077 && DECL_CHAIN (decl
)
5078 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5079 return decl_linkage (DECL_CHAIN (decl
));
5081 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5084 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5086 if (TREE_CODE (decl
) == CONST_DECL
)
5087 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5089 /* Things in local scope do not have linkage, if they don't have
5091 if (decl_function_context (decl
))
5094 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5095 are considered to have external linkage for language purposes, as do
5096 template instantiations on targets without weak symbols. DECLs really
5097 meant to have internal linkage have DECL_THIS_STATIC set. */
5098 if (TREE_CODE (decl
) == TYPE_DECL
)
5100 if (VAR_OR_FUNCTION_DECL_P (decl
))
5102 if (!DECL_THIS_STATIC (decl
))
5105 /* Static data members and static member functions from classes
5106 in anonymous namespace also don't have TREE_PUBLIC set. */
5107 if (DECL_CLASS_CONTEXT (decl
))
5111 /* Everything else has internal linkage. */
5115 /* Returns the storage duration of the object or reference associated with
5116 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5119 decl_storage_duration (tree decl
)
5121 if (TREE_CODE (decl
) == PARM_DECL
)
5123 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5125 gcc_assert (VAR_P (decl
));
5126 if (!TREE_STATIC (decl
)
5127 && !DECL_EXTERNAL (decl
))
5129 if (CP_DECL_THREAD_LOCAL_P (decl
))
5134 /* EXP is an expression that we want to pre-evaluate. Returns (in
5135 *INITP) an expression that will perform the pre-evaluation. The
5136 value returned by this function is a side-effect free expression
5137 equivalent to the pre-evaluated expression. Callers must ensure
5138 that *INITP is evaluated before EXP. */
5141 stabilize_expr (tree exp
, tree
* initp
)
5145 if (!TREE_SIDE_EFFECTS (exp
))
5146 init_expr
= NULL_TREE
;
5147 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5152 /* There are no expressions with REFERENCE_TYPE, but there can be call
5153 arguments with such a type; just treat it as a pointer. */
5154 else if (TYPE_REF_P (TREE_TYPE (exp
))
5155 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5156 || !glvalue_p (exp
))
5158 init_expr
= get_target_expr (exp
);
5159 exp
= TARGET_EXPR_SLOT (init_expr
);
5160 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5167 bool xval
= !lvalue_p (exp
);
5168 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5169 init_expr
= get_target_expr (exp
);
5170 exp
= TARGET_EXPR_SLOT (init_expr
);
5171 exp
= cp_build_fold_indirect_ref (exp
);
5177 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5181 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5182 similar expression ORIG. */
5185 add_stmt_to_compound (tree orig
, tree new_expr
)
5187 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5189 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5191 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5194 /* Like stabilize_expr, but for a call whose arguments we want to
5195 pre-evaluate. CALL is modified in place to use the pre-evaluated
5196 arguments, while, upon return, *INITP contains an expression to
5197 compute the arguments. */
5200 stabilize_call (tree call
, tree
*initp
)
5202 tree inits
= NULL_TREE
;
5204 int nargs
= call_expr_nargs (call
);
5206 if (call
== error_mark_node
|| processing_template_decl
)
5212 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5214 for (i
= 0; i
< nargs
; i
++)
5217 CALL_EXPR_ARG (call
, i
) =
5218 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5219 inits
= add_stmt_to_compound (inits
, init
);
5225 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5226 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5227 arguments, while, upon return, *INITP contains an expression to
5228 compute the arguments. */
5231 stabilize_aggr_init (tree call
, tree
*initp
)
5233 tree inits
= NULL_TREE
;
5235 int nargs
= aggr_init_expr_nargs (call
);
5237 if (call
== error_mark_node
)
5240 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5242 for (i
= 0; i
< nargs
; i
++)
5245 AGGR_INIT_EXPR_ARG (call
, i
) =
5246 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5247 inits
= add_stmt_to_compound (inits
, init
);
5253 /* Like stabilize_expr, but for an initialization.
5255 If the initialization is for an object of class type, this function
5256 takes care not to introduce additional temporaries.
5258 Returns TRUE iff the expression was successfully pre-evaluated,
5259 i.e., if INIT is now side-effect free, except for, possibly, a
5260 single call to a constructor. */
5263 stabilize_init (tree init
, tree
*initp
)
5269 if (t
== error_mark_node
|| processing_template_decl
)
5272 if (TREE_CODE (t
) == INIT_EXPR
)
5273 t
= TREE_OPERAND (t
, 1);
5274 if (TREE_CODE (t
) == TARGET_EXPR
)
5275 t
= TARGET_EXPR_INITIAL (t
);
5277 /* If the RHS can be stabilized without breaking copy elision, stabilize
5278 it. We specifically don't stabilize class prvalues here because that
5279 would mean an extra copy, but they might be stabilized below. */
5280 if (TREE_CODE (init
) == INIT_EXPR
5281 && TREE_CODE (t
) != CONSTRUCTOR
5282 && TREE_CODE (t
) != AGGR_INIT_EXPR
5283 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5286 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5290 if (TREE_CODE (t
) == COMPOUND_EXPR
5291 && TREE_CODE (init
) == INIT_EXPR
)
5293 tree last
= expr_last (t
);
5294 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5295 if (!TREE_SIDE_EFFECTS (last
))
5298 TREE_OPERAND (init
, 1) = last
;
5303 if (TREE_CODE (t
) == CONSTRUCTOR
)
5305 /* Aggregate initialization: stabilize each of the field
5308 constructor_elt
*ce
;
5310 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5311 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5313 tree type
= TREE_TYPE (ce
->value
);
5315 if (TYPE_REF_P (type
)
5316 || SCALAR_TYPE_P (type
))
5317 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5318 else if (!stabilize_init (ce
->value
, &subinit
))
5320 *initp
= add_stmt_to_compound (*initp
, subinit
);
5325 if (TREE_CODE (t
) == CALL_EXPR
)
5327 stabilize_call (t
, initp
);
5331 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5333 stabilize_aggr_init (t
, initp
);
5337 /* The initialization is being performed via a bitwise copy -- and
5338 the item copied may have side effects. */
5339 return !TREE_SIDE_EFFECTS (init
);
5342 /* Returns true if a cast to TYPE may appear in an integral constant
5346 cast_valid_in_integral_constant_expression_p (tree type
)
5348 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5349 || cxx_dialect
>= cxx11
5350 || dependent_type_p (type
)
5351 || type
== error_mark_node
);
5354 /* Return true if we need to fix linkage information of DECL. */
5357 cp_fix_function_decl_p (tree decl
)
5359 /* Skip if DECL is not externally visible. */
5360 if (!TREE_PUBLIC (decl
))
5363 /* We need to fix DECL if it a appears to be exported but with no
5364 function body. Thunks do not have CFGs and we may need to
5365 handle them specially later. */
5366 if (!gimple_has_body_p (decl
)
5367 && !DECL_THUNK_P (decl
)
5368 && !DECL_EXTERNAL (decl
))
5370 struct cgraph_node
*node
= cgraph_node::get (decl
);
5372 /* Don't fix same_body aliases. Although they don't have their own
5373 CFG, they share it with what they alias to. */
5374 if (!node
|| !node
->alias
5375 || !vec_safe_length (node
->ref_list
.references
))
5382 /* Clean the C++ specific parts of the tree T. */
5385 cp_free_lang_data (tree t
)
5387 if (TREE_CODE (t
) == METHOD_TYPE
5388 || TREE_CODE (t
) == FUNCTION_TYPE
)
5390 /* Default args are not interesting anymore. */
5391 tree argtypes
= TYPE_ARG_TYPES (t
);
5394 TREE_PURPOSE (argtypes
) = 0;
5395 argtypes
= TREE_CHAIN (argtypes
);
5398 else if (TREE_CODE (t
) == FUNCTION_DECL
5399 && cp_fix_function_decl_p (t
))
5401 /* If T is used in this translation unit at all, the definition
5402 must exist somewhere else since we have decided to not emit it
5403 in this TU. So make it an external reference. */
5404 DECL_EXTERNAL (t
) = 1;
5405 TREE_STATIC (t
) = 0;
5407 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5408 /* We do not need the leftover chaining of namespaces from the
5410 DECL_CHAIN (t
) = NULL_TREE
;
5413 /* Stub for c-common. Please keep in sync with c-decl.c.
5414 FIXME: If address space support is target specific, then this
5415 should be a C target hook. But currently this is not possible,
5416 because this function is called via REGISTER_TARGET_PRAGMAS. */
5418 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5422 /* Return the number of operands in T that we care about for things like
5426 cp_tree_operand_length (const_tree t
)
5428 enum tree_code code
= TREE_CODE (t
);
5430 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5431 return VL_EXP_OPERAND_LENGTH (t
);
5433 return cp_tree_code_length (code
);
5436 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5439 cp_tree_code_length (enum tree_code code
)
5441 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5445 case PREINCREMENT_EXPR
:
5446 case PREDECREMENT_EXPR
:
5447 case POSTINCREMENT_EXPR
:
5448 case POSTDECREMENT_EXPR
:
5454 case EXPR_PACK_EXPANSION
:
5458 return TREE_CODE_LENGTH (code
);
5462 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5466 cp_expr_location (const_tree t_
)
5468 tree t
= CONST_CAST_TREE (t_
);
5470 return UNKNOWN_LOCATION
;
5471 switch (TREE_CODE (t
))
5474 return LAMBDA_EXPR_LOCATION (t
);
5476 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5478 return EXPR_LOCATION (t
);
5482 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5483 conditions for the warning hold, false otherwise. */
5485 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5487 if (c_inhibit_evaluation_warnings
== 0
5488 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5490 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5491 "zero as null pointer constant");
5497 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5498 /* Complain that some language-specific thing hanging off a tree
5499 node has been accessed improperly. */
5502 lang_check_failed (const char* file
, int line
, const char* function
)
5504 internal_error ("lang_* check: failed in %s, at %s:%d",
5505 function
, trim_filename (file
), line
);
5507 #endif /* ENABLE_TREE_CHECKING */
5511 namespace selftest
{
5513 /* Verify that lvalue_kind () works, for various expressions,
5514 and that location wrappers don't affect the results. */
5519 location_t loc
= BUILTINS_LOCATION
;
5521 /* Verify constants and parameters, without and with
5522 location wrappers. */
5523 tree int_cst
= build_int_cst (integer_type_node
, 42);
5524 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5526 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5527 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5528 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5530 tree string_lit
= build_string (4, "foo");
5531 TREE_TYPE (string_lit
) = char_array_type_node
;
5532 string_lit
= fix_string_type (string_lit
);
5533 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5535 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5536 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5537 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5539 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5540 get_identifier ("some_parm"),
5542 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5544 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5545 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5546 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5548 /* Verify that lvalue_kind of std::move on a parm isn't
5549 affected by location wrappers. */
5550 tree rvalue_ref_of_parm
= move (parm
);
5551 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5552 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5553 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5556 /* Run all of the selftests within this file. */
5561 test_lvalue_kind ();
5564 } // namespace selftest
5566 #endif /* #if CHECKING_P */
5569 #include "gt-cp-tree.h"