1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2017 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"
39 static tree
bot_manip (tree
*, int *, void *);
40 static tree
bot_replace (tree
*, int *, void *);
41 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
42 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
43 static tree
count_trees_r (tree
*, int *, void *);
44 static tree
verify_stmt_tree_r (tree
*, int *, void *);
45 static tree
build_local_temp (tree
);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 switch (TREE_CODE (ref
))
89 /* preincrements and predecrements are valid lvals, provided
90 what they refer to are valid lvals. */
91 case PREINCREMENT_EXPR
:
92 case PREDECREMENT_EXPR
:
96 return lvalue_kind (TREE_OPERAND (ref
, 0));
100 if (TREE_CODE (ref
) == MEMBER_REF
)
101 op1_lvalue_kind
= clk_ordinary
;
103 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
104 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
105 op1_lvalue_kind
= clk_none
;
106 return op1_lvalue_kind
;
109 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
111 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
113 /* For static member function recurse on the BASELINK, we can get
114 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
115 OVERLOAD, the overload is resolved first if possible through
116 resolve_address_of_overloaded_function. */
117 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
118 return lvalue_kind (TREE_OPERAND (ref
, 1));
120 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
121 /* Look at the member designator. */
122 if (!op1_lvalue_kind
)
124 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
125 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
126 situations. If we're seeing a COMPONENT_REF, it's a non-static
127 member, so it isn't an lvalue. */
128 op1_lvalue_kind
= clk_none
;
129 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
130 /* This can be IDENTIFIER_NODE in a template. */;
131 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
133 /* Clear the ordinary bit. If this object was a class
134 rvalue we want to preserve that information. */
135 op1_lvalue_kind
&= ~clk_ordinary
;
136 /* The lvalue is for a bitfield. */
137 op1_lvalue_kind
|= clk_bitfield
;
139 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
140 op1_lvalue_kind
|= clk_packed
;
142 return op1_lvalue_kind
;
145 case COMPOUND_LITERAL_EXPR
:
149 /* CONST_DECL without TREE_STATIC are enumeration values and
150 thus not lvalues. With TREE_STATIC they are used by ObjC++
151 in objc_build_string_object and need to be considered as
153 if (! TREE_STATIC (ref
))
157 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
158 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
160 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
161 && DECL_LANG_SPECIFIC (ref
)
162 && DECL_IN_AGGR_P (ref
))
170 case PLACEHOLDER_EXPR
:
173 /* A scope ref in a template, left as SCOPE_REF to support later
176 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
178 tree op
= TREE_OPERAND (ref
, 1);
179 if (TREE_CODE (op
) == FIELD_DECL
)
180 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
182 return lvalue_kind (op
);
187 /* Disallow <? and >? as lvalues if either argument side-effects. */
188 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
189 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
191 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
192 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
196 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
197 ? TREE_OPERAND (ref
, 1)
198 : TREE_OPERAND (ref
, 0));
199 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
203 /* We expect to see unlowered MODOP_EXPRs only during
204 template processing. */
205 gcc_assert (processing_template_decl
);
213 return lvalue_kind (TREE_OPERAND (ref
, 1));
219 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
222 /* We can see calls outside of TARGET_EXPR in templates. */
223 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
228 /* All functions (except non-static-member functions) are
230 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
231 ? clk_none
: clk_ordinary
);
234 /* We now represent a reference to a single static member function
236 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
237 its argument unmodified and we assign it to a const_tree. */
238 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
240 case NON_DEPENDENT_EXPR
:
241 return lvalue_kind (TREE_OPERAND (ref
, 0));
244 if (!TREE_TYPE (ref
))
246 if (CLASS_TYPE_P (TREE_TYPE (ref
))
247 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
252 /* If one operand is not an lvalue at all, then this expression is
254 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
257 /* Otherwise, it's an lvalue, and it has all the odd properties
258 contributed by either operand. */
259 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
260 /* It's not an ordinary lvalue if it involves any other kind. */
261 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
262 op1_lvalue_kind
&= ~clk_ordinary
;
263 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
264 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
265 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
266 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
267 op1_lvalue_kind
= clk_none
;
268 return op1_lvalue_kind
;
271 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
274 real_lvalue_p (const_tree ref
)
276 cp_lvalue_kind kind
= lvalue_kind (ref
);
277 if (kind
& (clk_rvalueref
|clk_class
))
283 /* c-common wants us to return bool. */
286 lvalue_p (const_tree t
)
288 return real_lvalue_p (t
);
291 /* This differs from lvalue_p in that xvalues are included. */
294 glvalue_p (const_tree ref
)
296 cp_lvalue_kind kind
= lvalue_kind (ref
);
297 if (kind
& clk_class
)
300 return (kind
!= clk_none
);
303 /* This differs from glvalue_p in that class prvalues are included. */
306 obvalue_p (const_tree ref
)
308 return (lvalue_kind (ref
) != clk_none
);
311 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
312 reference), false otherwise. */
315 xvalue_p (const_tree ref
)
317 return (lvalue_kind (ref
) == clk_rvalueref
);
320 /* True if REF is a bit-field. */
323 bitfield_p (const_tree ref
)
325 return (lvalue_kind (ref
) & clk_bitfield
);
328 /* C++-specific version of stabilize_reference. */
331 cp_stabilize_reference (tree ref
)
333 switch (TREE_CODE (ref
))
335 case NON_DEPENDENT_EXPR
:
336 /* We aren't actually evaluating this. */
339 /* We need to treat specially anything stabilize_reference doesn't
340 handle specifically. */
351 case ARRAY_RANGE_REF
:
355 cp_lvalue_kind kind
= lvalue_kind (ref
);
356 if ((kind
& ~clk_class
) != clk_none
)
358 tree type
= unlowered_expr_type (ref
);
359 bool rval
= !!(kind
& clk_rvalueref
);
360 type
= cp_build_reference_type (type
, rval
);
361 /* This inhibits warnings in, eg, cxx_mark_addressable
363 warning_sentinel
s (extra_warnings
);
364 ref
= build_static_cast (type
, ref
, tf_error
);
368 return stabilize_reference (ref
);
371 /* Test whether DECL is a builtin that may appear in a
372 constant-expression. */
375 builtin_valid_in_constant_expr_p (const_tree decl
)
377 if (!(TREE_CODE (decl
) == FUNCTION_DECL
378 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
))
379 /* Not a built-in. */
381 switch (DECL_FUNCTION_CODE (decl
))
383 /* These always have constant results like the corresponding
386 case BUILT_IN_FUNCTION
:
389 /* The following built-ins are valid in constant expressions
390 when their arguments are. */
391 case BUILT_IN_ADD_OVERFLOW_P
:
392 case BUILT_IN_SUB_OVERFLOW_P
:
393 case BUILT_IN_MUL_OVERFLOW_P
:
395 /* These have constant results even if their operands are
397 case BUILT_IN_CONSTANT_P
:
398 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
405 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
408 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
411 tree type
= TREE_TYPE (decl
);
413 value
= mark_rvalue_use (value
);
415 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
416 || TREE_TYPE (decl
) == TREE_TYPE (value
)
417 /* On ARM ctors return 'this'. */
418 || (TYPE_PTR_P (TREE_TYPE (value
))
419 && TREE_CODE (value
) == CALL_EXPR
)
420 || useless_type_conversion_p (TREE_TYPE (decl
),
423 if (complain
& tf_no_cleanup
)
424 /* The caller is building a new-expr and does not need a cleanup. */
428 t
= cxx_maybe_build_cleanup (decl
, complain
);
429 if (t
== error_mark_node
)
430 return error_mark_node
;
432 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
433 if (EXPR_HAS_LOCATION (value
))
434 SET_EXPR_LOCATION (t
, EXPR_LOCATION (value
));
435 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
436 ignore the TARGET_EXPR. If there really turn out to be no
437 side-effects, then the optimizer should be able to get rid of
438 whatever code is generated anyhow. */
439 TREE_SIDE_EFFECTS (t
) = 1;
444 /* Return an undeclared local temporary of type TYPE for use in building a
448 build_local_temp (tree type
)
450 tree slot
= build_decl (input_location
,
451 VAR_DECL
, NULL_TREE
, type
);
452 DECL_ARTIFICIAL (slot
) = 1;
453 DECL_IGNORED_P (slot
) = 1;
454 DECL_CONTEXT (slot
) = current_function_decl
;
455 layout_decl (slot
, 0);
459 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
462 process_aggr_init_operands (tree t
)
466 side_effects
= TREE_SIDE_EFFECTS (t
);
470 n
= TREE_OPERAND_LENGTH (t
);
471 for (i
= 1; i
< n
; i
++)
473 tree op
= TREE_OPERAND (t
, i
);
474 if (op
&& TREE_SIDE_EFFECTS (op
))
481 TREE_SIDE_EFFECTS (t
) = side_effects
;
484 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
485 FN, and SLOT. NARGS is the number of call arguments which are specified
486 as a tree array ARGS. */
489 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
495 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
496 TREE_TYPE (t
) = return_type
;
497 AGGR_INIT_EXPR_FN (t
) = fn
;
498 AGGR_INIT_EXPR_SLOT (t
) = slot
;
499 for (i
= 0; i
< nargs
; i
++)
500 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
501 process_aggr_init_operands (t
);
505 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
506 target. TYPE is the type to be initialized.
508 Build an AGGR_INIT_EXPR to represent the initialization. This function
509 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
510 to initialize another object, whereas a TARGET_EXPR can either
511 initialize another object or create its own temporary object, and as a
512 result building up a TARGET_EXPR requires that the type's destructor be
516 build_aggr_init_expr (tree type
, tree init
)
523 /* Don't build AGGR_INIT_EXPR in a template. */
524 if (processing_template_decl
)
527 fn
= cp_get_callee (init
);
529 return convert (type
, init
);
531 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
532 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
533 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
535 /* We split the CALL_EXPR into its function and its arguments here.
536 Then, in expand_expr, we put them back together. The reason for
537 this is that this expression might be a default argument
538 expression. In that case, we need a new temporary every time the
539 expression is used. That's what break_out_target_exprs does; it
540 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
541 temporary slot. Then, expand_expr builds up a call-expression
542 using the new slot. */
544 /* If we don't need to use a constructor to create an object of this
545 type, don't mess with AGGR_INIT_EXPR. */
546 if (is_ctor
|| TREE_ADDRESSABLE (type
))
548 slot
= build_local_temp (type
);
550 if (TREE_CODE (init
) == CALL_EXPR
)
552 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
553 call_expr_nargs (init
),
554 CALL_EXPR_ARGP (init
));
555 AGGR_INIT_FROM_THUNK_P (rval
)
556 = CALL_FROM_THUNK_P (init
);
560 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
561 aggr_init_expr_nargs (init
),
562 AGGR_INIT_EXPR_ARGP (init
));
563 AGGR_INIT_FROM_THUNK_P (rval
)
564 = AGGR_INIT_FROM_THUNK_P (init
);
566 TREE_SIDE_EFFECTS (rval
) = 1;
567 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
568 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
569 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
570 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
571 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
579 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
580 target. TYPE is the type that this initialization should appear to
583 Build an encapsulation of the initialization to perform
584 and return it so that it can be processed by language-independent
585 and language-specific expression expanders. */
588 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
590 tree rval
= build_aggr_init_expr (type
, init
);
593 if (!complete_type_or_maybe_complain (type
, init
, complain
))
594 return error_mark_node
;
596 /* Make sure that we're not trying to create an instance of an
598 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
599 return error_mark_node
;
601 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
602 slot
= AGGR_INIT_EXPR_SLOT (rval
);
603 else if (TREE_CODE (rval
) == CALL_EXPR
604 || TREE_CODE (rval
) == CONSTRUCTOR
)
605 slot
= build_local_temp (type
);
609 rval
= build_target_expr (slot
, rval
, complain
);
611 if (rval
!= error_mark_node
)
612 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
617 /* Subroutine of build_vec_init_expr: Build up a single element
618 intialization as a proxy for the full array initialization to get things
619 marked as used and any appropriate diagnostics.
621 Since we're deferring building the actual constructor calls until
622 gimplification time, we need to build one now and throw it away so
623 that the relevant constructor gets mark_used before cgraph decides
624 what functions are needed. Here we assume that init is either
625 NULL_TREE, void_type_node (indicating value-initialization), or
626 another array to copy. */
629 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
631 tree inner_type
= strip_array_types (type
);
632 vec
<tree
, va_gc
> *argvec
;
634 if (integer_zerop (array_type_nelts_total (type
))
635 || !CLASS_TYPE_P (inner_type
))
636 /* No interesting initialization to do. */
637 return integer_zero_node
;
638 else if (init
== void_type_node
)
639 return build_value_init (inner_type
, complain
);
641 gcc_assert (init
== NULL_TREE
642 || (same_type_ignoring_top_level_qualifiers_p
643 (type
, TREE_TYPE (init
))));
645 argvec
= make_tree_vector ();
648 tree init_type
= strip_array_types (TREE_TYPE (init
));
649 tree dummy
= build_dummy_object (init_type
);
650 if (!lvalue_p (init
))
651 dummy
= move (dummy
);
652 argvec
->quick_push (dummy
);
654 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
655 &argvec
, inner_type
, LOOKUP_NORMAL
,
657 release_tree_vector (argvec
);
659 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
660 we don't want one here because we aren't creating a temporary. */
661 if (TREE_CODE (init
) == TARGET_EXPR
)
662 init
= TARGET_EXPR_INITIAL (init
);
667 /* Return a TARGET_EXPR which expresses the initialization of an array to
668 be named later, either default-initialization or copy-initialization
669 from another array of the same type. */
672 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
675 bool value_init
= false;
676 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
678 if (init
== void_type_node
)
684 slot
= build_local_temp (type
);
685 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
686 TREE_SIDE_EFFECTS (init
) = true;
687 SET_EXPR_LOCATION (init
, input_location
);
689 if (cxx_dialect
>= cxx11
690 && potential_constant_expression (elt_init
))
691 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
692 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
697 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
698 that requires a constant expression. */
701 diagnose_non_constexpr_vec_init (tree expr
)
703 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
705 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
706 init
= void_type_node
;
708 init
= VEC_INIT_EXPR_INIT (expr
);
710 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
711 require_potential_constant_expression (elt_init
);
715 build_array_copy (tree init
)
717 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
720 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
724 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
726 gcc_assert (!VOID_TYPE_P (type
));
728 if (TREE_CODE (init
) == TARGET_EXPR
729 || init
== error_mark_node
)
731 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
732 && !VOID_TYPE_P (TREE_TYPE (init
))
733 && TREE_CODE (init
) != COND_EXPR
734 && TREE_CODE (init
) != CONSTRUCTOR
735 && TREE_CODE (init
) != VA_ARG_EXPR
)
736 /* We need to build up a copy constructor call. A void initializer
737 means we're being called from bot_manip. COND_EXPR is a special
738 case because we already have copies on the arms and we don't want
739 another one here. A CONSTRUCTOR is aggregate initialization, which
740 is handled separately. A VA_ARG_EXPR is magic creation of an
741 aggregate; there's no additional work to be done. */
742 return force_rvalue (init
, complain
);
744 return force_target_expr (type
, init
, complain
);
747 /* Like the above function, but without the checking. This function should
748 only be used by code which is deliberately trying to subvert the type
749 system, such as call_builtin_trap. Or build_over_call, to avoid
750 infinite recursion. */
753 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
757 gcc_assert (!VOID_TYPE_P (type
));
759 slot
= build_local_temp (type
);
760 return build_target_expr (slot
, init
, complain
);
763 /* Like build_target_expr_with_type, but use the type of INIT. */
766 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
768 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
769 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
770 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
771 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
774 init
= convert_bitfield_to_declared_type (init
);
775 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
780 get_target_expr (tree init
)
782 return get_target_expr_sfinae (init
, tf_warning_or_error
);
785 /* If EXPR is a bitfield reference, convert it to the declared type of
786 the bitfield, and return the resulting expression. Otherwise,
787 return EXPR itself. */
790 convert_bitfield_to_declared_type (tree expr
)
794 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
796 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
801 /* EXPR is being used in an rvalue context. Return a version of EXPR
802 that is marked as an rvalue. */
809 if (error_operand_p (expr
))
812 expr
= mark_rvalue_use (expr
);
816 Non-class rvalues always have cv-unqualified types. */
817 type
= TREE_TYPE (expr
);
818 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
819 type
= cv_unqualified (type
);
821 /* We need to do this for rvalue refs as well to get the right answer
822 from decltype; see c++/36628. */
823 if (!processing_template_decl
&& glvalue_p (expr
))
824 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
825 else if (type
!= TREE_TYPE (expr
))
826 expr
= build_nop (type
, expr
);
832 struct cplus_array_info
838 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
840 typedef cplus_array_info
*compare_type
;
842 static hashval_t
hash (tree t
);
843 static bool equal (tree
, cplus_array_info
*);
846 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
849 cplus_array_hasher::hash (tree t
)
853 hash
= TYPE_UID (TREE_TYPE (t
));
855 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
859 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
860 of type `cplus_array_info*'. */
863 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
865 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
868 /* Hash table containing dependent array types, which are unsuitable for
869 the language-independent type hash table. */
870 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
872 /* Build an ARRAY_TYPE without laying it out. */
875 build_min_array_type (tree elt_type
, tree index_type
)
877 tree t
= cxx_make_type (ARRAY_TYPE
);
878 TREE_TYPE (t
) = elt_type
;
879 TYPE_DOMAIN (t
) = index_type
;
883 /* Set TYPE_CANONICAL like build_array_type_1, but using
884 build_cplus_array_type. */
887 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
889 /* Set the canonical type for this new node. */
890 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
891 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
892 SET_TYPE_STRUCTURAL_EQUALITY (t
);
893 else if (TYPE_CANONICAL (elt_type
) != elt_type
894 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
896 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
898 ? TYPE_CANONICAL (index_type
) : index_type
);
900 TYPE_CANONICAL (t
) = t
;
903 /* Like build_array_type, but handle special C++ semantics: an array of a
904 variant element type is a variant of the array of the main variant of
908 build_cplus_array_type (tree elt_type
, tree index_type
)
912 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
913 return error_mark_node
;
915 bool dependent
= (uses_template_parms (elt_type
)
916 || (index_type
&& uses_template_parms (index_type
)));
918 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
919 /* Start with an array of the TYPE_MAIN_VARIANT. */
920 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
924 /* Since type_hash_canon calls layout_type, we need to use our own
926 cplus_array_info cai
;
929 if (cplus_array_htab
== NULL
)
930 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
932 hash
= TYPE_UID (elt_type
);
934 hash
^= TYPE_UID (index_type
);
936 cai
.domain
= index_type
;
938 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
940 /* We have found the type: we're done. */
944 /* Build a new array type. */
945 t
= build_min_array_type (elt_type
, index_type
);
947 /* Store it in the hash table. */
950 /* Set the canonical type for this new node. */
951 set_array_type_canon (t
, elt_type
, index_type
);
956 bool typeless_storage
957 = (elt_type
== unsigned_char_type_node
958 || elt_type
== signed_char_type_node
959 || elt_type
== char_type_node
960 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
961 && TYPE_CONTEXT (elt_type
) == std_node
962 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
963 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
966 /* Now check whether we already have this array variant. */
967 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
970 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
971 if (TREE_TYPE (t
) == elt_type
972 && TYPE_NAME (t
) == NULL_TREE
973 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
977 t
= build_min_array_type (elt_type
, index_type
);
978 set_array_type_canon (t
, elt_type
, index_type
);
982 /* Make sure sizes are shared with the main variant.
983 layout_type can't be called after setting TYPE_NEXT_VARIANT,
984 as it will overwrite alignment etc. of all variants. */
985 TYPE_SIZE (t
) = TYPE_SIZE (m
);
986 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
987 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
990 TYPE_MAIN_VARIANT (t
) = m
;
991 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
992 TYPE_NEXT_VARIANT (m
) = t
;
996 /* Avoid spurious warnings with VLAs (c++/54583). */
997 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
998 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1000 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1001 place more easily. */
1002 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1003 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1004 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1005 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1007 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1008 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1010 /* The element type has been completed since the last time we saw
1011 this array type; update the layout and 'tor flags for any variants
1014 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1016 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1017 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1024 /* Return an ARRAY_TYPE with element type ELT and length N. */
1027 build_array_of_n_type (tree elt
, int n
)
1029 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1032 /* True iff T is an N3639 array of runtime bound (VLA). These were
1033 approved for C++14 but then removed. */
1036 array_of_runtime_bound_p (tree t
)
1038 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1040 tree dom
= TYPE_DOMAIN (t
);
1043 tree max
= TYPE_MAX_VALUE (dom
);
1044 return (!potential_rvalue_constant_expression (max
)
1045 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1048 /* Return a reference type node referring to TO_TYPE. If RVAL is
1049 true, return an rvalue reference type, otherwise return an lvalue
1050 reference type. If a type node exists, reuse it, otherwise create
1053 cp_build_reference_type (tree to_type
, bool rval
)
1057 if (TREE_CODE (to_type
) == REFERENCE_TYPE
)
1059 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1060 to_type
= TREE_TYPE (to_type
);
1063 lvalue_ref
= build_reference_type (to_type
);
1067 /* This code to create rvalue reference types is based on and tied
1068 to the code creating lvalue reference types in the middle-end
1069 functions build_reference_type_for_mode and build_reference_type.
1071 It works by putting the rvalue reference type nodes after the
1072 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1073 they will effectively be ignored by the middle end. */
1075 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1076 if (TYPE_REF_IS_RVALUE (t
))
1079 t
= build_distinct_type_copy (lvalue_ref
);
1081 TYPE_REF_IS_RVALUE (t
) = true;
1082 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1083 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1085 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1086 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1087 else if (TYPE_CANONICAL (to_type
) != to_type
)
1089 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1091 TYPE_CANONICAL (t
) = t
;
1099 /* Returns EXPR cast to rvalue reference type, like std::move. */
1104 tree type
= TREE_TYPE (expr
);
1105 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
1106 type
= cp_build_reference_type (type
, /*rval*/true);
1107 return build_static_cast (type
, expr
, tf_warning_or_error
);
1110 /* Used by the C++ front end to build qualified array types. However,
1111 the C version of this function does not properly maintain canonical
1112 types (which are not used in C). */
1114 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1115 size_t /* orig_qual_indirect */)
1117 return cp_build_qualified_type (type
, type_quals
);
1121 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1122 arrays correctly. In particular, if TYPE is an array of T's, and
1123 TYPE_QUALS is non-empty, returns an array of qualified T's.
1125 FLAGS determines how to deal with ill-formed qualifications. If
1126 tf_ignore_bad_quals is set, then bad qualifications are dropped
1127 (this is permitted if TYPE was introduced via a typedef or template
1128 type parameter). If bad qualifications are dropped and tf_warning
1129 is set, then a warning is issued for non-const qualifications. If
1130 tf_ignore_bad_quals is not set and tf_error is not set, we
1131 return error_mark_node. Otherwise, we issue an error, and ignore
1134 Qualification of a reference type is valid when the reference came
1135 via a typedef or template type argument. [dcl.ref] No such
1136 dispensation is provided for qualifying a function type. [dcl.fct]
1137 DR 295 queries this and the proposed resolution brings it into line
1138 with qualifying a reference. We implement the DR. We also behave
1139 in a similar manner for restricting non-pointer types. */
1142 cp_build_qualified_type_real (tree type
,
1144 tsubst_flags_t complain
)
1147 int bad_quals
= TYPE_UNQUALIFIED
;
1149 if (type
== error_mark_node
)
1152 if (type_quals
== cp_type_quals (type
))
1155 if (TREE_CODE (type
) == ARRAY_TYPE
)
1157 /* In C++, the qualification really applies to the array element
1158 type. Obtain the appropriately qualified element type. */
1161 = cp_build_qualified_type_real (TREE_TYPE (type
),
1165 if (element_type
== error_mark_node
)
1166 return error_mark_node
;
1168 /* See if we already have an identically qualified type. Tests
1169 should be equivalent to those in check_qualified_type. */
1170 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1171 if (TREE_TYPE (t
) == element_type
1172 && TYPE_NAME (t
) == TYPE_NAME (type
)
1173 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1174 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1175 TYPE_ATTRIBUTES (type
)))
1180 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1182 /* Keep the typedef name. */
1183 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1185 t
= build_variant_type_copy (t
);
1186 TYPE_NAME (t
) = TYPE_NAME (type
);
1187 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1188 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1192 /* Even if we already had this variant, we update
1193 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1194 they changed since the variant was originally created.
1196 This seems hokey; if there is some way to use a previous
1197 variant *without* coming through here,
1198 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1199 TYPE_NEEDS_CONSTRUCTING (t
)
1200 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1201 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1202 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1205 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1207 tree t
= PACK_EXPANSION_PATTERN (type
);
1209 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1210 return make_pack_expansion (t
, complain
);
1213 /* A reference or method type shall not be cv-qualified.
1214 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1215 (in CD1) we always ignore extra cv-quals on functions. */
1216 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1217 && (TREE_CODE (type
) == REFERENCE_TYPE
1218 || TREE_CODE (type
) == FUNCTION_TYPE
1219 || TREE_CODE (type
) == METHOD_TYPE
))
1221 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1222 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1223 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1226 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1227 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1228 type_quals
|= type_memfn_quals (type
);
1230 /* A restrict-qualified type must be a pointer (or reference)
1231 to object or incomplete type. */
1232 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1233 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1234 && TREE_CODE (type
) != TYPENAME_TYPE
1235 && !POINTER_TYPE_P (type
))
1237 bad_quals
|= TYPE_QUAL_RESTRICT
;
1238 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1241 if (bad_quals
== TYPE_UNQUALIFIED
1242 || (complain
& tf_ignore_bad_quals
))
1244 else if (!(complain
& tf_error
))
1245 return error_mark_node
;
1248 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1249 error ("%qV qualifiers cannot be applied to %qT",
1253 /* Retrieve (or create) the appropriately qualified variant. */
1254 result
= build_qualified_type (type
, type_quals
);
1256 /* Preserve exception specs and ref-qualifier since build_qualified_type
1257 doesn't know about them. */
1258 if (TREE_CODE (result
) == FUNCTION_TYPE
1259 || TREE_CODE (result
) == METHOD_TYPE
)
1261 result
= build_exception_variant (result
, TYPE_RAISES_EXCEPTIONS (type
));
1262 result
= build_ref_qualified_type (result
, type_memfn_rqual (type
));
1268 /* Return TYPE with const and volatile removed. */
1271 cv_unqualified (tree type
)
1275 if (type
== error_mark_node
)
1278 quals
= cp_type_quals (type
);
1279 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1280 return cp_build_qualified_type (type
, quals
);
1283 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1284 from ATTRIBS that affect type identity, and no others. If any are not
1285 applied, set *remove_attributes to true. */
1288 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1290 tree first_ident
= NULL_TREE
;
1291 tree new_attribs
= NULL_TREE
;
1292 tree
*p
= &new_attribs
;
1294 if (OVERLOAD_TYPE_P (result
))
1296 /* On classes and enums all attributes are ingrained. */
1297 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1301 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1303 const attribute_spec
*as
1304 = lookup_attribute_spec (get_attribute_name (a
));
1305 if (as
&& as
->affects_type_identity
)
1309 else if (first_ident
== error_mark_node
)
1311 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1312 p
= &TREE_CHAIN (*p
);
1315 else if (first_ident
)
1317 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1319 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1320 p
= &TREE_CHAIN (*p
);
1322 first_ident
= error_mark_node
;
1325 if (first_ident
!= error_mark_node
)
1326 new_attribs
= first_ident
;
1328 if (first_ident
== attribs
)
1329 /* All attributes affected type identity. */;
1331 *remove_attributes
= true;
1333 return cp_build_type_attribute_variant (result
, new_attribs
);
1336 /* Builds a qualified variant of T that is not a typedef variant.
1337 E.g. consider the following declarations:
1338 typedef const int ConstInt;
1339 typedef ConstInt* PtrConstInt;
1340 If T is PtrConstInt, this function returns a type representing
1342 In other words, if T is a typedef, the function returns the underlying type.
1343 The cv-qualification and attributes of the type returned match the
1345 They will always be compatible types.
1346 The returned type is built so that all of its subtypes
1347 recursively have their typedefs stripped as well.
1349 This is different from just returning TYPE_CANONICAL (T)
1350 Because of several reasons:
1351 * If T is a type that needs structural equality
1352 its TYPE_CANONICAL (T) will be NULL.
1353 * TYPE_CANONICAL (T) desn't carry type attributes
1354 and loses template parameter names.
1356 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1357 affect type identity, and set the referent to true if any were
1361 strip_typedefs (tree t
, bool *remove_attributes
)
1363 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1365 if (!t
|| t
== error_mark_node
)
1368 if (TREE_CODE (t
) == TREE_LIST
)
1370 bool changed
= false;
1371 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1373 for (; t
; t
= TREE_CHAIN (t
))
1375 gcc_assert (!TREE_PURPOSE (t
));
1376 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1377 if (elt
!= TREE_VALUE (t
))
1379 vec_safe_push (vec
, elt
);
1382 r
= build_tree_list_vec (vec
);
1383 release_tree_vector (vec
);
1387 gcc_assert (TYPE_P (t
));
1389 if (t
== TYPE_CANONICAL (t
))
1392 if (dependent_alias_template_spec_p (t
))
1393 /* DR 1558: However, if the template-id is dependent, subsequent
1394 template argument substitution still applies to the template-id. */
1397 switch (TREE_CODE (t
))
1400 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1401 result
= build_pointer_type (type
);
1403 case REFERENCE_TYPE
:
1404 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1405 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1408 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1409 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1410 result
= build_offset_type (t0
, type
);
1413 if (TYPE_PTRMEMFUNC_P (t
))
1415 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1416 result
= build_ptrmemfunc_type (t0
);
1420 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1421 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1422 result
= build_cplus_array_type (type
, t0
);
1427 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1430 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1431 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1432 can't expect that re-hashing a function type will find a previous
1433 equivalent type, so try to reuse the input type if nothing has
1434 changed. If the type is itself a variant, that will change. */
1435 bool is_variant
= typedef_variant_p (t
);
1436 if (remove_attributes
1437 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1440 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1441 tree canon_spec
= (flag_noexcept_type
1442 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1444 changed
= (type
!= TREE_TYPE (t
) || is_variant
1445 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1447 for (arg_node
= TYPE_ARG_TYPES (t
);
1449 arg_node
= TREE_CHAIN (arg_node
))
1451 if (arg_node
== void_list_node
)
1453 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1455 gcc_assert (arg_type
);
1456 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1462 for (arg_node2
= TYPE_ARG_TYPES (t
);
1463 arg_node2
!= arg_node
;
1464 arg_node2
= TREE_CHAIN (arg_node2
))
1466 = tree_cons (TREE_PURPOSE (arg_node2
),
1467 TREE_VALUE (arg_node2
), arg_types
);
1471 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1478 arg_types
= nreverse (arg_types
);
1480 /* A list of parameters not ending with an ellipsis
1481 must end with void_list_node. */
1483 arg_types
= chainon (arg_types
, void_list_node
);
1485 if (TREE_CODE (t
) == METHOD_TYPE
)
1487 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1488 gcc_assert (class_type
);
1490 build_method_type_directly (class_type
, type
,
1491 TREE_CHAIN (arg_types
));
1493 = build_ref_qualified_type (result
, type_memfn_rqual (t
));
1497 result
= build_function_type (type
,
1499 result
= apply_memfn_quals (result
,
1500 type_memfn_quals (t
),
1501 type_memfn_rqual (t
));
1505 result
= build_exception_variant (result
, canon_spec
);
1506 if (TYPE_HAS_LATE_RETURN_TYPE (t
))
1507 TYPE_HAS_LATE_RETURN_TYPE (result
) = 1;
1512 bool changed
= false;
1513 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1514 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1515 && TREE_OPERAND (fullname
, 1))
1517 tree args
= TREE_OPERAND (fullname
, 1);
1518 tree new_args
= copy_node (args
);
1519 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1521 tree arg
= TREE_VEC_ELT (args
, i
);
1524 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1526 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1527 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1528 if (strip_arg
!= arg
)
1533 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1534 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1536 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1540 ggc_free (new_args
);
1542 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1543 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1545 tree name
= fullname
;
1546 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1547 name
= TREE_OPERAND (fullname
, 0);
1548 /* Use build_typename_type rather than make_typename_type because we
1549 don't want to resolve it here, just strip typedefs. */
1550 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1554 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1556 if (result
== DECLTYPE_TYPE_EXPR (t
))
1559 result
= (finish_decltype_type
1561 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1564 case UNDERLYING_TYPE
:
1565 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1566 result
= finish_underlying_type (type
);
1574 if (typedef_variant_p (t
))
1576 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1577 strip typedefs with attributes. */
1578 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1579 result
= strip_typedefs (result
);
1582 result
= TYPE_MAIN_VARIANT (t
);
1584 gcc_assert (!typedef_variant_p (result
));
1586 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1587 /* If RESULT is complete and T isn't, it's likely the case that T
1588 is a variant of RESULT which hasn't been updated yet. Skip the
1589 attribute handling. */;
1592 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1593 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1595 gcc_assert (TYPE_USER_ALIGN (t
));
1596 if (remove_attributes
)
1597 *remove_attributes
= true;
1600 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1601 result
= build_variant_type_copy (result
);
1603 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1604 TYPE_USER_ALIGN (result
) = true;
1608 if (TYPE_ATTRIBUTES (t
))
1610 if (remove_attributes
)
1611 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1614 result
= cp_build_type_attribute_variant (result
,
1615 TYPE_ATTRIBUTES (t
));
1619 return cp_build_qualified_type (result
, cp_type_quals (t
));
1622 /* Like strip_typedefs above, but works on expressions, so that in
1624 template<class T> struct A
1630 sizeof(TT) is replaced by sizeof(T). */
1633 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1637 enum tree_code code
;
1639 if (t
== NULL_TREE
|| t
== error_mark_node
)
1642 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1645 /* Some expressions have type operands, so let's handle types here rather
1646 than check TYPE_P in multiple places below. */
1648 return strip_typedefs (t
, remove_attributes
);
1650 code
= TREE_CODE (t
);
1653 case IDENTIFIER_NODE
:
1654 case TEMPLATE_PARM_INDEX
:
1657 case ARGUMENT_PACK_SELECT
:
1662 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1663 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1664 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1665 && type2
== TRAIT_EXPR_TYPE2 (t
))
1668 TRAIT_EXPR_TYPE1 (r
) = type1
;
1669 TRAIT_EXPR_TYPE2 (r
) = type2
;
1675 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1676 bool changed
= false;
1678 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1680 tree val
= strip_typedefs_expr (TREE_VALUE (t
), remove_attributes
);
1681 vec_safe_push (vec
, val
);
1682 if (val
!= TREE_VALUE (t
))
1684 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1689 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1690 r
= tree_cons (NULL_TREE
, it
, r
);
1694 release_tree_vector (vec
);
1700 bool changed
= false;
1701 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1702 n
= TREE_VEC_LENGTH (t
);
1703 vec_safe_reserve (vec
, n
);
1704 for (i
= 0; i
< n
; ++i
)
1706 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1708 vec
->quick_push (op
);
1709 if (op
!= TREE_VEC_ELT (t
, i
))
1715 for (i
= 0; i
< n
; ++i
)
1716 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1717 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1718 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1722 release_tree_vector (vec
);
1728 bool changed
= false;
1729 vec
<constructor_elt
, va_gc
> *vec
1730 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1731 n
= CONSTRUCTOR_NELTS (t
);
1732 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1733 for (i
= 0; i
< n
; ++i
)
1735 constructor_elt
*e
= &(*vec
)[i
];
1736 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1743 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1746 if (!changed
&& type
== TREE_TYPE (t
))
1754 TREE_TYPE (r
) = type
;
1755 CONSTRUCTOR_ELTS (r
) = vec
;
1761 error ("lambda-expression in a constant expression");
1762 return error_mark_node
;
1768 gcc_assert (EXPR_P (t
));
1770 n
= TREE_OPERAND_LENGTH (t
);
1771 ops
= XALLOCAVEC (tree
, n
);
1772 type
= TREE_TYPE (t
);
1777 case IMPLICIT_CONV_EXPR
:
1778 case DYNAMIC_CAST_EXPR
:
1779 case STATIC_CAST_EXPR
:
1780 case CONST_CAST_EXPR
:
1781 case REINTERPRET_CAST_EXPR
:
1784 type
= strip_typedefs (type
, remove_attributes
);
1788 for (i
= 0; i
< n
; ++i
)
1789 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1793 /* If nothing changed, return t. */
1794 for (i
= 0; i
< n
; ++i
)
1795 if (ops
[i
] != TREE_OPERAND (t
, i
))
1797 if (i
== n
&& type
== TREE_TYPE (t
))
1801 TREE_TYPE (r
) = type
;
1802 for (i
= 0; i
< n
; ++i
)
1803 TREE_OPERAND (r
, i
) = ops
[i
];
1807 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1808 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1809 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1810 VIRT indicates whether TYPE is inherited virtually or not.
1811 IGO_PREV points at the previous binfo of the inheritance graph
1812 order chain. The newly copied binfo's TREE_CHAIN forms this
1815 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1816 correct order. That is in the order the bases themselves should be
1819 The BINFO_INHERITANCE of a virtual base class points to the binfo
1820 of the most derived type. ??? We could probably change this so that
1821 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1822 remove a field. They currently can only differ for primary virtual
1826 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1832 /* See if we've already made this virtual base. */
1833 new_binfo
= binfo_for_vbase (type
, t
);
1838 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1839 BINFO_TYPE (new_binfo
) = type
;
1841 /* Chain it into the inheritance graph. */
1842 TREE_CHAIN (*igo_prev
) = new_binfo
;
1843 *igo_prev
= new_binfo
;
1845 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1850 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1852 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1853 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1855 /* We do not need to copy the accesses, as they are read only. */
1856 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1858 /* Recursively copy base binfos of BINFO. */
1859 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1861 tree new_base_binfo
;
1862 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1864 BINFO_VIRTUAL_P (base_binfo
));
1866 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1867 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1868 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1872 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1876 /* Push it onto the list after any virtual bases it contains
1877 will have been pushed. */
1878 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1879 BINFO_VIRTUAL_P (new_binfo
) = 1;
1880 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1886 /* Hashing of lists so that we don't make duplicates.
1887 The entry point is `list_hash_canon'. */
1896 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1898 typedef list_proxy
*compare_type
;
1900 static hashval_t
hash (tree
);
1901 static bool equal (tree
, list_proxy
*);
1904 /* Now here is the hash table. When recording a list, it is added
1905 to the slot whose index is the hash code mod the table size.
1906 Note that the hash table is used for several kinds of lists.
1907 While all these live in the same table, they are completely independent,
1908 and the hash code is computed differently for each of these. */
1910 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1912 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1913 for a node we are thinking about adding). */
1916 list_hasher::equal (tree t
, list_proxy
*proxy
)
1918 return (TREE_VALUE (t
) == proxy
->value
1919 && TREE_PURPOSE (t
) == proxy
->purpose
1920 && TREE_CHAIN (t
) == proxy
->chain
);
1923 /* Compute a hash code for a list (chain of TREE_LIST nodes
1924 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1925 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1928 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1930 hashval_t hashcode
= 0;
1933 hashcode
+= TREE_HASH (chain
);
1936 hashcode
+= TREE_HASH (value
);
1940 hashcode
+= TREE_HASH (purpose
);
1946 /* Hash an already existing TREE_LIST. */
1949 list_hasher::hash (tree t
)
1951 return list_hash_pieces (TREE_PURPOSE (t
),
1956 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1957 object for an identical list if one already exists. Otherwise, build a
1958 new one, and record it as the canonical object. */
1961 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1965 struct list_proxy proxy
;
1967 /* Hash the list node. */
1968 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1969 /* Create a proxy for the TREE_LIST we would like to create. We
1970 don't actually create it so as to avoid creating garbage. */
1971 proxy
.purpose
= purpose
;
1972 proxy
.value
= value
;
1973 proxy
.chain
= chain
;
1974 /* See if it is already in the table. */
1975 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
1976 /* If not, create a new node. */
1978 *slot
= tree_cons (purpose
, value
, chain
);
1979 return (tree
) *slot
;
1982 /* Constructor for hashed lists. */
1985 hash_tree_chain (tree value
, tree chain
)
1987 return hash_tree_cons (NULL_TREE
, value
, chain
);
1991 debug_binfo (tree elem
)
1996 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1998 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1999 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2000 debug_tree (BINFO_TYPE (elem
));
2001 if (BINFO_VTABLE (elem
))
2002 fprintf (stderr
, "vtable decl \"%s\"\n",
2003 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2005 fprintf (stderr
, "no vtable decl yet\n");
2006 fprintf (stderr
, "virtuals:\n");
2007 virtuals
= BINFO_VIRTUALS (elem
);
2012 tree fndecl
= TREE_VALUE (virtuals
);
2013 fprintf (stderr
, "%s [%ld =? %ld]\n",
2014 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2015 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2017 virtuals
= TREE_CHAIN (virtuals
);
2021 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2022 the type of the result expression, if known, or NULL_TREE if the
2023 resulting expression is type-dependent. If TEMPLATE_P is true,
2024 NAME is known to be a template because the user explicitly used the
2025 "template" keyword after the "::".
2027 All SCOPE_REFs should be built by use of this function. */
2030 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2033 if (type
== error_mark_node
2034 || scope
== error_mark_node
2035 || name
== error_mark_node
)
2036 return error_mark_node
;
2037 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2038 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2039 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2040 PTRMEM_OK_P (t
) = true;
2042 t
= convert_from_reference (t
);
2046 /* Like check_qualified_type, but also check ref-qualifier and exception
2050 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2051 cp_ref_qualifier rqual
, tree raises
)
2053 return (TYPE_QUALS (cand
) == type_quals
2054 && check_base_type (cand
, base
)
2055 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2057 && type_memfn_rqual (cand
) == rqual
);
2060 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2063 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2067 if (rqual
== type_memfn_rqual (type
))
2070 int type_quals
= TYPE_QUALS (type
);
2071 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2072 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
2073 if (cp_check_qualified_type (t
, type
, type_quals
, rqual
, raises
))
2076 t
= build_variant_type_copy (type
);
2079 case REF_QUAL_RVALUE
:
2080 FUNCTION_RVALUE_QUALIFIED (t
) = 1;
2081 FUNCTION_REF_QUALIFIED (t
) = 1;
2083 case REF_QUAL_LVALUE
:
2084 FUNCTION_RVALUE_QUALIFIED (t
) = 0;
2085 FUNCTION_REF_QUALIFIED (t
) = 1;
2088 FUNCTION_REF_QUALIFIED (t
) = 0;
2092 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2093 /* Propagate structural equality. */
2094 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2095 else if (TYPE_CANONICAL (type
) != type
)
2096 /* Build the underlying canonical type, since it is different
2098 TYPE_CANONICAL (t
) = build_ref_qualified_type (TYPE_CANONICAL (type
),
2101 /* T is its own canonical type. */
2102 TYPE_CANONICAL (t
) = t
;
2107 /* Cache of free ovl nodes. Uses OVL_FUNCTION for chaining. */
2108 static GTY((deletable
)) tree ovl_cache
;
2110 /* Make a raw overload node containing FN. */
2113 ovl_make (tree fn
, tree next
)
2115 tree result
= ovl_cache
;
2119 ovl_cache
= OVL_FUNCTION (result
);
2120 /* Zap the flags. */
2121 memset (result
, 0, sizeof (tree_base
));
2122 TREE_SET_CODE (result
, OVERLOAD
);
2125 result
= make_node (OVERLOAD
);
2127 if (TREE_CODE (fn
) == OVERLOAD
)
2128 OVL_NESTED_P (result
) = true;
2130 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2131 ? unknown_type_node
: TREE_TYPE (fn
));
2132 OVL_FUNCTION (result
) = fn
;
2133 OVL_CHAIN (result
) = next
;
2140 tree result
= ovl_cache
;
2144 ovl_cache
= OVL_FUNCTION (result
);
2145 /* Zap the flags. */
2146 memset (result
, 0, sizeof (tree_base
));
2147 TREE_SET_CODE (result
, OVERLOAD
);
2150 result
= make_node (OVERLOAD
);
2152 gcc_checking_assert (!OVL_NESTED_P (ovl
) && OVL_USED_P (ovl
));
2153 TREE_TYPE (result
) = TREE_TYPE (ovl
);
2154 OVL_FUNCTION (result
) = OVL_FUNCTION (ovl
);
2155 OVL_CHAIN (result
) = OVL_CHAIN (ovl
);
2156 OVL_HIDDEN_P (result
) = OVL_HIDDEN_P (ovl
);
2157 OVL_USING_P (result
) = OVL_USING_P (ovl
);
2158 OVL_LOOKUP_P (result
) = OVL_LOOKUP_P (ovl
);
2163 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2164 true, if FN is via a using declaration. We also pay attention to
2165 DECL_HIDDEN. Overloads are ordered as hidden, using, regular. */
2168 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2170 bool copying
= false; /* Checking use only. */
2171 bool hidden_p
= DECL_HIDDEN_P (fn
);
2172 int weight
= (hidden_p
<< 1) | (using_p
<< 0);
2174 tree result
= NULL_TREE
;
2175 tree insert_after
= NULL_TREE
;
2177 /* Find insertion point. */
2178 while (maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2179 && (weight
< ((OVL_HIDDEN_P (maybe_ovl
) << 1)
2180 | (OVL_USING_P (maybe_ovl
) << 0))))
2182 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
)
2183 && (!copying
|| OVL_USED_P (maybe_ovl
)));
2184 if (OVL_USED_P (maybe_ovl
))
2187 maybe_ovl
= ovl_copy (maybe_ovl
);
2189 OVL_CHAIN (insert_after
) = maybe_ovl
;
2193 insert_after
= maybe_ovl
;
2194 maybe_ovl
= OVL_CHAIN (maybe_ovl
);
2198 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2200 trail
= ovl_make (fn
, maybe_ovl
);
2202 OVL_HIDDEN_P (trail
) = true;
2204 OVL_USING_P (trail
) = true;
2209 OVL_CHAIN (insert_after
) = trail
;
2210 TREE_TYPE (insert_after
) = unknown_type_node
;
2218 /* Skip any hidden names at the beginning of OVL. */
2221 ovl_skip_hidden (tree ovl
)
2224 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2225 ovl
= OVL_CHAIN (ovl
))
2226 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2228 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2230 /* Any hidden functions should have been wrapped in an
2231 overload, but injected friend classes will not. */
2232 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2239 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2242 ovl_iterator::reveal_node (tree overload
, tree node
)
2244 /* We cannot have returned NODE as part of a lookup overload, so it
2246 gcc_checking_assert (!OVL_USED_P (node
));
2248 OVL_HIDDEN_P (node
) = false;
2249 if (tree chain
= OVL_CHAIN (node
))
2250 if (TREE_CODE (chain
) == OVERLOAD
2251 && (OVL_USING_P (chain
) || OVL_HIDDEN_P (chain
)))
2253 /* The node needs moving, and the simplest way is to remove it
2255 overload
= remove_node (overload
, node
);
2256 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2261 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2262 OVL_USED_P we must copy OVL nodes, because those are immutable.
2263 The removed node is unaltered and may continue to be iterated
2264 from (i.e. it is safe to remove a node from an overload one is
2265 currently iterating over). */
2268 ovl_iterator::remove_node (tree overload
, tree node
)
2270 bool copying
= false; /* Checking use only. */
2272 tree
*slot
= &overload
;
2273 while (*slot
!= node
)
2276 gcc_checking_assert (!OVL_LOOKUP_P (probe
)
2277 && (!copying
|| OVL_USED_P (probe
)));
2278 if (OVL_USED_P (probe
))
2281 probe
= ovl_copy (probe
);
2285 slot
= &OVL_CHAIN (probe
);
2288 /* Stitch out NODE. We don't have to worry about now making a
2289 singleton overload (and consequently maybe setting its type),
2290 because all uses of this function will be followed by inserting a
2291 new node that must follow the place we've cut this out from. */
2292 if (TREE_CODE (node
) != OVERLOAD
)
2293 /* Cloned inherited ctors don't mark themselves as via_using. */
2296 *slot
= OVL_CHAIN (node
);
2301 /* Mark or unmark a lookup set. */
2304 lookup_mark (tree ovl
, bool val
)
2306 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2308 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2309 LOOKUP_SEEN_P (*iter
) = val
;
2313 /* Add a set of new FNS into a lookup. */
2316 lookup_add (tree fns
, tree lookup
)
2318 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2320 lookup
= ovl_make (fns
, lookup
);
2321 OVL_LOOKUP_P (lookup
) = true;
2329 /* FNS is a new overload set, add them to LOOKUP, if they are not
2330 already present there. */
2333 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2336 for (tree next
, probe
= fns
; probe
; probe
= next
)
2341 if (TREE_CODE (probe
) == OVERLOAD
)
2343 fn
= OVL_FUNCTION (probe
);
2344 next
= OVL_CHAIN (probe
);
2347 if (!LOOKUP_SEEN_P (fn
))
2348 LOOKUP_SEEN_P (fn
) = true;
2351 /* This function was already seen. Insert all the
2352 predecessors onto the lookup. */
2353 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2355 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2356 /* Propagate OVL_USING, but OVL_HIDDEN doesn't matter. */
2357 if (OVL_USING_P (fns
))
2358 OVL_USING_P (lookup
) = true;
2361 /* And now skip this function. */
2367 /* We ended in a set of new functions. Add them all in one go. */
2368 lookup
= lookup_add (fns
, lookup
);
2373 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2380 ovl
&& TREE_CODE (ovl
) == OVERLOAD
2381 && !OVL_USED_P (ovl
);
2382 ovl
= OVL_CHAIN (ovl
))
2384 gcc_checking_assert (!OVL_LOOKUP_P (ovl
));
2385 OVL_USED_P (ovl
) = true;
2389 /* If KEEP is true, preserve the contents of a lookup so that it is
2390 available for a later instantiation. Otherwise release the LOOKUP
2394 lookup_keep (tree lookup
, bool keep
)
2397 lookup
&& TREE_CODE (lookup
) == OVERLOAD
2398 && OVL_LOOKUP_P (lookup
) && !OVL_USED_P (lookup
);
2399 lookup
= OVL_CHAIN (lookup
))
2402 OVL_USED_P (lookup
) = true;
2403 ovl_used (OVL_FUNCTION (lookup
));
2407 OVL_FUNCTION (lookup
) = ovl_cache
;
2415 /* Returns nonzero if X is an expression for a (possibly overloaded)
2416 function. If "f" is a function or function template, "f", "c->f",
2417 "c.f", "C::f", and "f<int>" will all be considered possibly
2418 overloaded functions. Returns 2 if the function is actually
2419 overloaded, i.e., if it is impossible to know the type of the
2420 function without performing overload resolution. */
2423 is_overloaded_fn (tree x
)
2425 /* A baselink is also considered an overloaded function. */
2426 if (TREE_CODE (x
) == OFFSET_REF
2427 || TREE_CODE (x
) == COMPONENT_REF
)
2428 x
= TREE_OPERAND (x
, 1);
2429 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2430 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2431 x
= TREE_OPERAND (x
, 0);
2433 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2434 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2437 return (TREE_CODE (x
) == FUNCTION_DECL
2438 || TREE_CODE (x
) == OVERLOAD
);
2441 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2442 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2446 dependent_name (tree x
)
2448 if (identifier_p (x
))
2450 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2451 x
= TREE_OPERAND (x
, 0);
2452 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2453 return OVL_NAME (x
);
2457 /* Returns true iff X is an expression for an overloaded function
2458 whose type cannot be known without performing overload
2462 really_overloaded_fn (tree x
)
2464 return is_overloaded_fn (x
) == 2;
2467 /* Get the overload set FROM refers to. */
2472 /* A baselink is also considered an overloaded function. */
2473 if (TREE_CODE (from
) == OFFSET_REF
2474 || TREE_CODE (from
) == COMPONENT_REF
)
2475 from
= TREE_OPERAND (from
, 1);
2476 if (BASELINK_P (from
))
2477 from
= BASELINK_FUNCTIONS (from
);
2478 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2479 from
= TREE_OPERAND (from
, 0);
2480 gcc_assert (TREE_CODE (from
) == OVERLOAD
2481 || TREE_CODE (from
) == FUNCTION_DECL
);
2485 /* Return the first function of the overload set FROM refers to. */
2488 get_first_fn (tree from
)
2490 return OVL_FIRST (get_fns (from
));
2493 /* Return the scope where the overloaded functions OVL were found. */
2496 ovl_scope (tree ovl
)
2498 if (TREE_CODE (ovl
) == OFFSET_REF
2499 || TREE_CODE (ovl
) == COMPONENT_REF
)
2500 ovl
= TREE_OPERAND (ovl
, 1);
2501 if (TREE_CODE (ovl
) == BASELINK
)
2502 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2503 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2504 ovl
= TREE_OPERAND (ovl
, 0);
2505 /* Skip using-declarations. */
2506 lkp_iterator
iter (ovl
);
2509 while (iter
.using_p () && ++iter
);
2511 return CP_DECL_CONTEXT (ovl
);
2514 #define PRINT_RING_SIZE 4
2517 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2519 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2520 static char *print_ring
[PRINT_RING_SIZE
];
2521 static bool trans_ring
[PRINT_RING_SIZE
];
2522 static int ring_counter
;
2525 /* Only cache functions. */
2527 || TREE_CODE (decl
) != FUNCTION_DECL
2528 || DECL_LANG_SPECIFIC (decl
) == 0)
2529 return lang_decl_name (decl
, v
, translate
);
2531 /* See if this print name is lying around. */
2532 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2533 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2534 /* yes, so return it. */
2535 return print_ring
[i
];
2537 if (++ring_counter
== PRINT_RING_SIZE
)
2540 if (current_function_decl
!= NULL_TREE
)
2542 /* There may be both translated and untranslated versions of the
2544 for (i
= 0; i
< 2; i
++)
2546 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2548 if (ring_counter
== PRINT_RING_SIZE
)
2551 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2554 free (print_ring
[ring_counter
]);
2556 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2557 uid_ring
[ring_counter
] = DECL_UID (decl
);
2558 trans_ring
[ring_counter
] = translate
;
2559 return print_ring
[ring_counter
];
2563 cxx_printable_name (tree decl
, int v
)
2565 return cxx_printable_name_internal (decl
, v
, false);
2569 cxx_printable_name_translate (tree decl
, int v
)
2571 return cxx_printable_name_internal (decl
, v
, true);
2574 /* Return the canonical version of exception-specification RAISES for a C++17
2575 function type, for use in type comparison and building TYPE_CANONICAL. */
2578 canonical_eh_spec (tree raises
)
2580 if (raises
== NULL_TREE
)
2582 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2583 || uses_template_parms (raises
)
2584 || uses_template_parms (TREE_PURPOSE (raises
)))
2585 /* Keep a dependent or deferred exception specification. */
2587 else if (nothrow_spec_p (raises
))
2588 /* throw() -> noexcept. */
2589 return noexcept_true_spec
;
2591 /* For C++17 type matching, anything else -> nothing. */
2595 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2596 listed in RAISES. */
2599 build_exception_variant (tree type
, tree raises
)
2604 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
2607 type_quals
= TYPE_QUALS (type
);
2608 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2609 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
2610 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
))
2613 /* Need to build a new variant. */
2614 v
= build_variant_type_copy (type
);
2615 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2617 if (!flag_noexcept_type
)
2618 /* The exception-specification is not part of the canonical type. */
2621 /* Canonicalize the exception specification. */
2622 tree cr
= canonical_eh_spec (raises
);
2624 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2625 /* Propagate structural equality. */
2626 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2627 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
)
2628 /* Build the underlying canonical type, since it is different
2630 TYPE_CANONICAL (v
) = build_exception_variant (TYPE_CANONICAL (type
), cr
);
2632 /* T is its own canonical type. */
2633 TYPE_CANONICAL (v
) = v
;
2638 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2639 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2643 bind_template_template_parm (tree t
, tree newargs
)
2645 tree decl
= TYPE_NAME (t
);
2648 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2649 decl
= build_decl (input_location
,
2650 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2652 /* These nodes have to be created to reflect new TYPE_DECL and template
2654 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2655 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2656 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2657 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2659 TREE_TYPE (decl
) = t2
;
2660 TYPE_NAME (t2
) = decl
;
2661 TYPE_STUB_DECL (t2
) = decl
;
2663 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2668 /* Called from count_trees via walk_tree. */
2671 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2681 /* Debugging function for measuring the rough complexity of a tree
2685 count_trees (tree t
)
2688 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2692 /* Called from verify_stmt_tree via walk_tree. */
2695 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2698 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2699 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2702 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2705 /* If this statement is already present in the hash table, then
2706 there is a circularity in the statement tree. */
2707 gcc_assert (!statements
->find (t
));
2709 slot
= statements
->find_slot (t
, INSERT
);
2715 /* Debugging function to check that the statement T has not been
2716 corrupted. For now, this function simply checks that T contains no
2720 verify_stmt_tree (tree t
)
2722 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2723 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2726 /* Check if the type T depends on a type with no linkage and if so, return
2727 it. If RELAXED_P then do not consider a class type declared within
2728 a vague-linkage function to have no linkage. */
2731 no_linkage_check (tree t
, bool relaxed_p
)
2735 /* There's no point in checking linkage on template functions; we
2736 can't know their complete types. */
2737 if (processing_template_decl
)
2740 switch (TREE_CODE (t
))
2743 if (TYPE_PTRMEMFUNC_P (t
))
2745 /* Lambda types that don't have mangling scope have no linkage. We
2746 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2747 when we get here from pushtag none of the lambda information is
2748 set up yet, so we want to assume that the lambda has linkage and
2749 fix it up later if not. */
2750 if (CLASSTYPE_LAMBDA_EXPR (t
)
2751 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2752 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2756 if (!CLASS_TYPE_P (t
))
2760 /* Only treat unnamed types as having no linkage if they're at
2761 namespace scope. This is core issue 966. */
2762 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2765 for (r
= CP_TYPE_CONTEXT (t
); ; )
2767 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2768 have linkage, or we might just be in an anonymous namespace.
2769 If we're in a TREE_PUBLIC class, we have linkage. */
2770 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2771 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2772 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2774 if (!relaxed_p
|| !vague_linkage_p (r
))
2777 r
= CP_DECL_CONTEXT (r
);
2787 case REFERENCE_TYPE
:
2789 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2793 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2797 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2802 tree parm
= TYPE_ARG_TYPES (t
);
2803 if (TREE_CODE (t
) == METHOD_TYPE
)
2804 /* The 'this' pointer isn't interesting; a method has the same
2805 linkage (or lack thereof) as its enclosing class. */
2806 parm
= TREE_CHAIN (parm
);
2808 parm
&& parm
!= void_list_node
;
2809 parm
= TREE_CHAIN (parm
))
2811 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2815 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2823 extern int depth_reached
;
2826 cxx_print_statistics (void)
2828 print_class_statistics ();
2829 print_template_statistics ();
2830 if (GATHER_STATISTICS
)
2831 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2835 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2836 (which is an ARRAY_TYPE). This counts only elements of the top
2840 array_type_nelts_top (tree type
)
2842 return fold_build2_loc (input_location
,
2843 PLUS_EXPR
, sizetype
,
2844 array_type_nelts (type
),
2848 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2849 (which is an ARRAY_TYPE). This one is a recursive count of all
2850 ARRAY_TYPEs that are clumped together. */
2853 array_type_nelts_total (tree type
)
2855 tree sz
= array_type_nelts_top (type
);
2856 type
= TREE_TYPE (type
);
2857 while (TREE_CODE (type
) == ARRAY_TYPE
)
2859 tree n
= array_type_nelts_top (type
);
2860 sz
= fold_build2_loc (input_location
,
2861 MULT_EXPR
, sizetype
, sz
, n
);
2862 type
= TREE_TYPE (type
);
2867 /* Called from break_out_target_exprs via mapcar. */
2870 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
2872 splay_tree target_remap
= ((splay_tree
) data
);
2875 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2877 /* There can't be any TARGET_EXPRs or their slot variables below this
2878 point. But we must make a copy, in case subsequent processing
2879 alters any part of it. For example, during gimplification a cast
2880 of the form (T) &X::f (where "f" is a member function) will lead
2881 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2883 *tp
= unshare_expr (t
);
2886 if (TREE_CODE (t
) == TARGET_EXPR
)
2890 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2892 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2893 tf_warning_or_error
);
2894 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2895 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2898 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2899 tf_warning_or_error
);
2901 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2902 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2903 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2905 /* Map the old variable to the new one. */
2906 splay_tree_insert (target_remap
,
2907 (splay_tree_key
) TREE_OPERAND (t
, 0),
2908 (splay_tree_value
) TREE_OPERAND (u
, 0));
2910 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
2912 /* Replace the old expression with the new version. */
2914 /* We don't have to go below this point; the recursive call to
2915 break_out_target_exprs will have handled anything below this
2920 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2923 splay_tree_node n
= splay_tree_lookup (target_remap
,
2924 (splay_tree_key
) t
);
2927 *tp
= (tree
)n
->value
;
2932 copy_tree_r (tp
, walk_subtrees
, NULL
);
2933 splay_tree_insert (target_remap
,
2935 (splay_tree_value
)*tp
);
2936 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2937 splay_tree_insert (target_remap
,
2938 (splay_tree_key
)*tp
,
2939 (splay_tree_value
)*tp
);
2944 /* Make a copy of this node. */
2945 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2946 if (TREE_CODE (*tp
) == CALL_EXPR
)
2948 set_flags_from_callee (*tp
);
2950 /* builtin_LINE and builtin_FILE get the location where the default
2951 argument is expanded, not where the call was written. */
2952 tree callee
= get_callee_fndecl (*tp
);
2953 if (callee
&& DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
2954 switch (DECL_FUNCTION_CODE (callee
))
2958 SET_EXPR_LOCATION (*tp
, input_location
);
2966 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2967 DATA is really a splay-tree mapping old variables to new
2971 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data
)
2973 splay_tree target_remap
= ((splay_tree
) data
);
2977 splay_tree_node n
= splay_tree_lookup (target_remap
,
2978 (splay_tree_key
) *t
);
2980 *t
= (tree
) n
->value
;
2982 else if (TREE_CODE (*t
) == PARM_DECL
2983 && DECL_NAME (*t
) == this_identifier
2984 && !DECL_CONTEXT (*t
))
2986 /* In an NSDMI we need to replace the 'this' parameter we used for
2987 parsing with the real one for this function. */
2988 *t
= current_class_ptr
;
2990 else if (TREE_CODE (*t
) == CONVERT_EXPR
2991 && CONVERT_EXPR_VBASE_PATH (*t
))
2993 /* In an NSDMI build_base_path defers building conversions to virtual
2994 bases, and we handle it here. */
2995 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2996 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2998 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2999 if (BINFO_TYPE (binfo
) == basetype
)
3001 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3002 tf_warning_or_error
);
3008 /* When we parse a default argument expression, we may create
3009 temporary variables via TARGET_EXPRs. When we actually use the
3010 default-argument expression, we make a copy of the expression
3011 and replace the temporaries with appropriate local versions. */
3014 break_out_target_exprs (tree t
)
3016 static int target_remap_count
;
3017 static splay_tree target_remap
;
3019 if (!target_remap_count
++)
3020 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3021 /*splay_tree_delete_key_fn=*/NULL
,
3022 /*splay_tree_delete_value_fn=*/NULL
);
3023 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
3024 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
3026 if (!--target_remap_count
)
3028 splay_tree_delete (target_remap
);
3029 target_remap
= NULL
;
3035 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3036 which we expect to have type TYPE. */
3039 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3041 if (index
== NULL_TREE
)
3042 /* Can't refer to a particular member of a vector. */
3044 else if (TREE_CODE (index
) == INTEGER_CST
)
3045 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3047 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3048 /*reference*/false, tf_none
);
3051 tree objtype
= TREE_TYPE (obj
);
3052 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3054 /* When the destination object refers to a flexible array member
3055 verify that it matches the type of the source object except
3056 for its domain and qualifiers. */
3057 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3058 TYPE_MAIN_VARIANT (objtype
),
3059 COMPARE_REDECLARATION
));
3062 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3068 struct replace_placeholders_t
3070 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3071 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3072 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3075 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3076 build up subexpressions as we go deeper. */
3079 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3081 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3084 if (TREE_CONSTANT (*t
))
3086 *walk_subtrees
= false;
3090 switch (TREE_CODE (*t
))
3092 case PLACEHOLDER_EXPR
:
3095 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3097 x
= TREE_OPERAND (x
, 0))
3098 gcc_assert (TREE_CODE (x
) == COMPONENT_REF
);
3100 *walk_subtrees
= false;
3107 constructor_elt
*ce
;
3108 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3109 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3111 tree
*valp
= &ce
->value
;
3112 tree type
= TREE_TYPE (*valp
);
3115 if (TREE_CODE (*valp
) == CONSTRUCTOR
3116 && AGGREGATE_TYPE_P (type
))
3118 /* If we're looking at the initializer for OBJ, then build
3119 a sub-object reference. If we're looking at an
3120 initializer for another object, just pass OBJ down. */
3121 if (same_type_ignoring_top_level_qualifiers_p
3122 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3123 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3124 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3125 valp
= &TARGET_EXPR_INITIAL (*valp
);
3128 cp_walk_tree (valp
, replace_placeholders_r
, data_
, d
->pset
);
3131 *walk_subtrees
= false;
3142 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3143 a PLACEHOLDER_EXPR has been encountered. */
3146 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3148 /* This is only relevant for C++14. */
3149 if (cxx_dialect
< cxx14
)
3152 /* If the object isn't a (member of a) class, do nothing. */
3154 while (TREE_CODE (op0
) == COMPONENT_REF
)
3155 op0
= TREE_OPERAND (op0
, 0);
3156 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3160 hash_set
<tree
> pset
;
3161 replace_placeholders_t data
= { obj
, false, &pset
};
3162 if (TREE_CODE (exp
) == TARGET_EXPR
)
3163 tp
= &TARGET_EXPR_INITIAL (exp
);
3164 cp_walk_tree (tp
, replace_placeholders_r
, &data
, &pset
);
3166 *seen_p
= data
.seen
;
3170 /* Similar to `build_nt', but for template definitions of dependent
3174 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3181 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3185 t
= make_node (code
);
3186 SET_EXPR_LOCATION (t
, loc
);
3187 length
= TREE_CODE_LENGTH (code
);
3189 for (i
= 0; i
< length
; i
++)
3191 tree x
= va_arg (p
, tree
);
3192 TREE_OPERAND (t
, i
) = x
;
3193 if (x
&& TREE_CODE (x
) == OVERLOAD
)
3194 lookup_keep (x
, true);
3201 /* Similar to `build', but for template definitions. */
3204 build_min (enum tree_code code
, tree tt
, ...)
3211 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3215 t
= make_node (code
);
3216 length
= TREE_CODE_LENGTH (code
);
3219 for (i
= 0; i
< length
; i
++)
3221 tree x
= va_arg (p
, tree
);
3222 TREE_OPERAND (t
, i
) = x
;
3225 if (!TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3226 TREE_SIDE_EFFECTS (t
) = 1;
3227 if (TREE_CODE (x
) == OVERLOAD
)
3228 lookup_keep (x
, true);
3234 if (code
== CAST_EXPR
)
3235 /* The single operand is a TREE_LIST, which we have to check. */
3236 for (tree v
= TREE_OPERAND (t
, 0); v
; v
= TREE_CHAIN (v
))
3237 if (TREE_CODE (TREE_VALUE (v
)) == OVERLOAD
)
3238 lookup_keep (TREE_VALUE (v
), true);
3243 /* Similar to `build', but for template definitions of non-dependent
3244 expressions. NON_DEP is the non-dependent expression that has been
3248 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3255 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3257 va_start (p
, non_dep
);
3259 if (REFERENCE_REF_P (non_dep
))
3260 non_dep
= TREE_OPERAND (non_dep
, 0);
3262 t
= make_node (code
);
3263 length
= TREE_CODE_LENGTH (code
);
3264 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3265 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3267 for (i
= 0; i
< length
; i
++)
3269 tree x
= va_arg (p
, tree
);
3270 TREE_OPERAND (t
, i
) = x
;
3271 if (x
&& TREE_CODE (x
) == OVERLOAD
)
3272 lookup_keep (x
, true);
3275 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3276 /* This should not be considered a COMPOUND_EXPR, because it
3277 resolves to an overload. */
3278 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3281 return convert_from_reference (t
);
3284 /* Similar to build_min_nt, but call expressions */
3287 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3292 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3293 CALL_EXPR_FN (ret
) = fn
;
3294 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3295 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3297 CALL_EXPR_ARG (ret
, ix
) = t
;
3298 if (TREE_CODE (t
) == OVERLOAD
)
3299 lookup_keep (t
, true);
3304 /* Similar to `build_min_nt_call_vec', but for template definitions of
3305 non-dependent expressions. NON_DEP is the non-dependent expression
3306 that has been built. */
3309 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3311 tree t
= build_min_nt_call_vec (fn
, argvec
);
3312 if (REFERENCE_REF_P (non_dep
))
3313 non_dep
= TREE_OPERAND (non_dep
, 0);
3314 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3315 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3316 return convert_from_reference (t
);
3319 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3320 a call to an operator overload. OP is the operator that has been
3321 overloaded. NON_DEP is the non-dependent expression that's been built,
3322 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3323 the overload that NON_DEP is calling. */
3326 build_min_non_dep_op_overload (enum tree_code op
,
3331 int nargs
, expected_nargs
;
3333 vec
<tree
, va_gc
> *args
;
3335 non_dep
= extract_call_expr (non_dep
);
3337 nargs
= call_expr_nargs (non_dep
);
3339 expected_nargs
= cp_tree_code_length (op
);
3340 if ((op
== POSTINCREMENT_EXPR
3341 || op
== POSTDECREMENT_EXPR
)
3342 /* With -fpermissive non_dep could be operator++(). */
3343 && (!flag_permissive
|| nargs
!= expected_nargs
))
3344 expected_nargs
+= 1;
3345 gcc_assert (nargs
== expected_nargs
);
3347 args
= make_tree_vector ();
3348 va_start (p
, overload
);
3350 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3353 for (int i
= 0; i
< nargs
; i
++)
3355 tree arg
= va_arg (p
, tree
);
3356 vec_safe_push (args
, arg
);
3359 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3361 tree object
= va_arg (p
, tree
);
3362 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3363 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3364 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3365 object
, method
, NULL_TREE
);
3366 for (int i
= 1; i
< nargs
; i
++)
3368 tree arg
= va_arg (p
, tree
);
3369 vec_safe_push (args
, arg
);
3376 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3377 release_tree_vector (args
);
3379 tree call_expr
= extract_call_expr (call
);
3380 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3381 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3382 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3383 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3388 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3391 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3393 unsigned len
= vec_safe_length (old_vec
);
3394 gcc_assert (idx
<= len
);
3396 vec
<tree
, va_gc
> *new_vec
= NULL
;
3397 vec_alloc (new_vec
, len
+ 1);
3400 for (i
= 0; i
< len
; ++i
)
3403 new_vec
->quick_push (elt
);
3404 new_vec
->quick_push ((*old_vec
)[i
]);
3407 new_vec
->quick_push (elt
);
3413 get_type_decl (tree t
)
3415 if (TREE_CODE (t
) == TYPE_DECL
)
3418 return TYPE_STUB_DECL (t
);
3419 gcc_assert (t
== error_mark_node
);
3423 /* Returns the namespace that contains DECL, whether directly or
3427 decl_namespace_context (tree decl
)
3431 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3433 else if (TYPE_P (decl
))
3434 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3436 decl
= CP_DECL_CONTEXT (decl
);
3440 /* Returns true if decl is within an anonymous namespace, however deeply
3441 nested, or false otherwise. */
3444 decl_anon_ns_mem_p (const_tree decl
)
3446 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3448 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3450 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3452 decl
= CP_DECL_CONTEXT (decl
);
3454 return !TREE_PUBLIC (decl
);
3457 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3458 CALL_EXPRS. Return whether they are equivalent. */
3461 called_fns_equal (tree t1
, tree t2
)
3463 /* Core 1321: dependent names are equivalent even if the overload sets
3464 are different. But do compare explicit template arguments. */
3465 tree name1
= dependent_name (t1
);
3466 tree name2
= dependent_name (t2
);
3469 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3474 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3475 targs1
= TREE_OPERAND (t1
, 1);
3476 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3477 targs2
= TREE_OPERAND (t2
, 1);
3478 return cp_tree_equal (targs1
, targs2
);
3481 return cp_tree_equal (t1
, t2
);
3484 /* Return truthvalue of whether T1 is the same tree structure as T2.
3485 Return 1 if they are the same. Return 0 if they are different. */
3488 cp_tree_equal (tree t1
, tree t2
)
3490 enum tree_code code1
, code2
;
3497 code1
= TREE_CODE (t1
);
3498 code2
= TREE_CODE (t2
);
3503 if (CONSTANT_CLASS_P (t1
)
3504 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3510 /* There's only a single VOID_CST node, so we should never reach
3515 return tree_int_cst_equal (t1
, t2
);
3518 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3521 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3522 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3523 TREE_STRING_LENGTH (t1
));
3526 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3527 TREE_FIXED_CST (t2
));
3530 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3531 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3534 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3537 /* We need to do this when determining whether or not two
3538 non-type pointer to member function template arguments
3540 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3541 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3546 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3548 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3549 if (!cp_tree_equal (field
, elt2
->index
)
3550 || !cp_tree_equal (value
, elt2
->value
))
3557 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3559 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3561 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3564 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3569 call_expr_arg_iterator iter1
, iter2
;
3570 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3572 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3573 arg2
= first_call_expr_arg (t2
, &iter2
);
3575 arg1
= next_call_expr_arg (&iter1
),
3576 arg2
= next_call_expr_arg (&iter2
))
3577 if (!cp_tree_equal (arg1
, arg2
))
3586 tree o1
= TREE_OPERAND (t1
, 0);
3587 tree o2
= TREE_OPERAND (t2
, 0);
3589 /* Special case: if either target is an unallocated VAR_DECL,
3590 it means that it's going to be unified with whatever the
3591 TARGET_EXPR is really supposed to initialize, so treat it
3592 as being equivalent to anything. */
3593 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3594 && !DECL_RTL_SET_P (o1
))
3596 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3597 && !DECL_RTL_SET_P (o2
))
3599 else if (!cp_tree_equal (o1
, o2
))
3602 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3606 /* For comparing uses of parameters in late-specified return types
3607 with an out-of-class definition of the function, but can also come
3608 up for expressions that involve 'this' in a member function
3611 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3612 /* When comparing hash table entries, only an exact match is
3613 good enough; we don't want to replace 'this' with the
3614 version from another function. But be more flexible
3615 with local parameters in a requires-expression. */
3618 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3620 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3622 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3624 if (DECL_ARTIFICIAL (t1
)
3625 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3626 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3636 case IDENTIFIER_NODE
:
3641 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3642 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3643 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3644 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3645 BASELINK_FUNCTIONS (t2
)));
3647 case TEMPLATE_PARM_INDEX
:
3648 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3649 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3650 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3651 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3652 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3653 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3655 case TEMPLATE_ID_EXPR
:
3656 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3657 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3659 case CONSTRAINT_INFO
:
3660 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3661 CI_ASSOCIATED_CONSTRAINTS (t2
));
3664 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3665 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3666 CHECK_CONSTR_ARGS (t2
)));
3671 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3673 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3674 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3675 TREE_VEC_ELT (t2
, ix
)))
3683 tree o1
= TREE_OPERAND (t1
, 0);
3684 tree o2
= TREE_OPERAND (t2
, 0);
3686 if (code1
== SIZEOF_EXPR
)
3688 if (SIZEOF_EXPR_TYPE_P (t1
))
3689 o1
= TREE_TYPE (o1
);
3690 if (SIZEOF_EXPR_TYPE_P (t2
))
3691 o2
= TREE_TYPE (o2
);
3693 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3696 return same_type_p (o1
, o2
);
3698 return cp_tree_equal (o1
, o2
);
3703 tree t1_op1
, t2_op1
;
3705 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3708 t1_op1
= TREE_OPERAND (t1
, 1);
3709 t2_op1
= TREE_OPERAND (t2
, 1);
3710 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3713 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3717 /* Two pointer-to-members are the same if they point to the same
3718 field or function in the same class. */
3719 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3722 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3726 /* Two overloads. Must be exactly the same set of decls. */
3727 lkp_iterator
first (t1
);
3728 lkp_iterator
second (t2
);
3730 for (; first
&& second
; ++first
, ++second
)
3731 if (*first
!= *second
)
3733 return !(first
|| second
);
3737 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3739 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3740 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3743 case STATIC_CAST_EXPR
:
3744 case REINTERPRET_CAST_EXPR
:
3745 case CONST_CAST_EXPR
:
3746 case DYNAMIC_CAST_EXPR
:
3747 case IMPLICIT_CONV_EXPR
:
3750 case NON_LVALUE_EXPR
:
3751 case VIEW_CONVERT_EXPR
:
3752 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3754 /* Now compare operands as usual. */
3757 case DEFERRED_NOEXCEPT
:
3758 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3759 DEFERRED_NOEXCEPT_PATTERN (t2
))
3760 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3761 DEFERRED_NOEXCEPT_ARGS (t2
)));
3768 switch (TREE_CODE_CLASS (code1
))
3772 case tcc_comparison
:
3773 case tcc_expression
:
3780 n
= cp_tree_operand_length (t1
);
3781 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3782 && n
!= TREE_OPERAND_LENGTH (t2
))
3785 for (i
= 0; i
< n
; ++i
)
3786 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3793 return same_type_p (t1
, t2
);
3797 /* We can get here with --disable-checking. */
3801 /* The type of ARG when used as an lvalue. */
3804 lvalue_type (tree arg
)
3806 tree type
= TREE_TYPE (arg
);
3810 /* The type of ARG for printing error messages; denote lvalues with
3814 error_type (tree arg
)
3816 tree type
= TREE_TYPE (arg
);
3818 if (TREE_CODE (type
) == ARRAY_TYPE
)
3820 else if (TREE_CODE (type
) == ERROR_MARK
)
3822 else if (lvalue_p (arg
))
3823 type
= build_reference_type (lvalue_type (arg
));
3824 else if (MAYBE_CLASS_TYPE_P (type
))
3825 type
= lvalue_type (arg
);
3830 /* Does FUNCTION use a variable-length argument list? */
3833 varargs_function_p (const_tree function
)
3835 return stdarg_p (TREE_TYPE (function
));
3838 /* Returns 1 if decl is a member of a class. */
3841 member_p (const_tree decl
)
3843 const_tree
const ctx
= DECL_CONTEXT (decl
);
3844 return (ctx
&& TYPE_P (ctx
));
3847 /* Create a placeholder for member access where we don't actually have an
3848 object that the access is against. */
3851 build_dummy_object (tree type
)
3853 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3854 return cp_build_fold_indirect_ref (decl
);
3857 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3858 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3859 binfo path from current_class_type to TYPE, or 0. */
3862 maybe_dummy_object (tree type
, tree
* binfop
)
3866 tree current
= current_nonlambda_class_type ();
3869 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3870 tf_warning_or_error
)))
3874 /* Reference from a nested class member function. */
3876 binfo
= TYPE_BINFO (type
);
3882 if (current_class_ref
3883 /* current_class_ref might not correspond to current_class_type if
3884 we're in tsubst_default_argument or a lambda-declarator; in either
3885 case, we want to use current_class_ref if it matches CONTEXT. */
3886 && (same_type_ignoring_top_level_qualifiers_p
3887 (TREE_TYPE (current_class_ref
), context
)))
3888 decl
= current_class_ref
;
3890 decl
= build_dummy_object (context
);
3895 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3898 is_dummy_object (const_tree ob
)
3900 if (INDIRECT_REF_P (ob
))
3901 ob
= TREE_OPERAND (ob
, 0);
3902 return (TREE_CODE (ob
) == CONVERT_EXPR
3903 && TREE_OPERAND (ob
, 0) == void_node
);
3906 /* Returns 1 iff type T is something we want to treat as a scalar type for
3907 the purpose of deciding whether it is trivial/POD/standard-layout. */
3910 scalarish_type_p (const_tree t
)
3912 if (t
== error_mark_node
)
3915 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3918 /* Returns true iff T requires non-trivial default initialization. */
3921 type_has_nontrivial_default_init (const_tree t
)
3923 t
= strip_array_types (CONST_CAST_TREE (t
));
3925 if (CLASS_TYPE_P (t
))
3926 return TYPE_HAS_COMPLEX_DFLT (t
);
3931 /* Track classes with only deleted copy/move constructors so that we can warn
3932 if they are used in call/return by value. */
3934 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
3936 remember_deleted_copy (const_tree t
)
3938 if (!deleted_copy_types
)
3939 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
3940 deleted_copy_types
->add (CONST_CAST_TREE (t
));
3943 maybe_warn_parm_abi (tree t
, location_t loc
)
3945 if (!deleted_copy_types
3946 || !deleted_copy_types
->contains (t
))
3949 warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
3950 "-fabi-version=12 (GCC 8)", t
);
3951 static bool explained
= false;
3954 inform (loc
, " because all of its copy and move constructors "
3960 /* Returns true iff copying an object of type T (including via move
3961 constructor) is non-trivial. That is, T has no non-trivial copy
3962 constructors and no non-trivial move constructors, and not all copy/move
3963 constructors are deleted. This function implements the ABI notion of
3964 non-trivial copy, which has diverged from the one in the standard. */
3967 type_has_nontrivial_copy_init (const_tree type
)
3969 tree t
= strip_array_types (CONST_CAST_TREE (type
));
3971 if (CLASS_TYPE_P (t
))
3973 gcc_assert (COMPLETE_TYPE_P (t
));
3975 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
3976 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
3980 if (cxx_dialect
< cxx11
)
3981 /* No deleted functions before C++11. */
3984 /* Before ABI v12 we did a bitwise copy of types with only deleted
3985 copy/move constructors. */
3986 if (!abi_version_at_least (12)
3987 && !(warn_abi
&& abi_version_crosses (12)))
3990 bool saw_copy
= false;
3991 bool saw_non_deleted
= false;
3993 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
3994 saw_copy
= saw_non_deleted
= true;
3995 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
3998 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
3999 /* [class.copy]/8 If the class definition declares a move
4000 constructor or move assignment operator, the implicitly declared
4001 copy constructor is defined as deleted.... */;
4003 /* Any other reason the implicitly-declared function would be
4004 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4006 saw_non_deleted
= true;
4009 if (!saw_non_deleted
)
4010 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4016 if (!DECL_DELETED_FN (fn
))
4018 /* Not deleted, therefore trivial. */
4019 saw_non_deleted
= true;
4025 gcc_assert (saw_copy
);
4027 if (saw_copy
&& !saw_non_deleted
)
4029 if (warn_abi
&& abi_version_crosses (12))
4030 remember_deleted_copy (t
);
4031 if (abi_version_at_least (12))
4041 /* Returns 1 iff type T is a trivially copyable type, as defined in
4042 [basic.types] and [class]. */
4045 trivially_copyable_p (const_tree t
)
4047 t
= strip_array_types (CONST_CAST_TREE (t
));
4049 if (CLASS_TYPE_P (t
))
4050 return ((!TYPE_HAS_COPY_CTOR (t
)
4051 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4052 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4053 && (!TYPE_HAS_COPY_ASSIGN (t
)
4054 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4055 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4056 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4058 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4061 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4065 trivial_type_p (const_tree t
)
4067 t
= strip_array_types (CONST_CAST_TREE (t
));
4069 if (CLASS_TYPE_P (t
))
4070 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4071 && trivially_copyable_p (t
));
4073 return scalarish_type_p (t
);
4076 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4079 pod_type_p (const_tree t
)
4081 /* This CONST_CAST is okay because strip_array_types returns its
4082 argument unmodified and we assign it to a const_tree. */
4083 t
= strip_array_types (CONST_CAST_TREE(t
));
4085 if (!CLASS_TYPE_P (t
))
4086 return scalarish_type_p (t
);
4087 else if (cxx_dialect
> cxx98
)
4088 /* [class]/10: A POD struct is a class that is both a trivial class and a
4089 standard-layout class, and has no non-static data members of type
4090 non-POD struct, non-POD union (or array of such types).
4092 We don't need to check individual members because if a member is
4093 non-std-layout or non-trivial, the class will be too. */
4094 return (std_layout_type_p (t
) && trivial_type_p (t
));
4096 /* The C++98 definition of POD is different. */
4097 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4100 /* Returns true iff T is POD for the purpose of layout, as defined in the
4104 layout_pod_type_p (const_tree t
)
4106 t
= strip_array_types (CONST_CAST_TREE (t
));
4108 if (CLASS_TYPE_P (t
))
4109 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4111 return scalarish_type_p (t
);
4114 /* Returns true iff T is a standard-layout type, as defined in
4118 std_layout_type_p (const_tree t
)
4120 t
= strip_array_types (CONST_CAST_TREE (t
));
4122 if (CLASS_TYPE_P (t
))
4123 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4125 return scalarish_type_p (t
);
4128 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4130 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4131 as defined in [meta.unary.prop]. */
4134 type_has_unique_obj_representations (const_tree t
)
4138 t
= strip_array_types (CONST_CAST_TREE (t
));
4140 if (!trivially_copyable_p (t
))
4143 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4144 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4146 switch (TREE_CODE (t
))
4150 case REFERENCE_TYPE
:
4151 /* If some backend has any paddings in these types, we should add
4152 a target hook for this and handle it there. */
4156 /* For bool values other than 0 and 1 should only appear with
4157 undefined behavior. */
4161 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4164 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4165 when storing long double values, so for that we have to return false.
4166 Other kinds of floating point values are questionable due to +.0/-.0
4167 and NaNs, let's play safe for now. */
4170 case FIXED_POINT_TYPE
:
4178 return type_has_unique_obj_representations (TREE_TYPE (t
));
4181 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4182 if (CLASS_TYPE_P (t
))
4184 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4185 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4193 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4194 if (TREE_CODE (field
) == FIELD_DECL
)
4197 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4198 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4204 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4206 if (CLASS_TYPE_P (t
))
4208 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4209 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4224 /* Helper function for type_has_unique_obj_representations. */
4227 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4229 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4230 if (TREE_CODE (field
) != FIELD_DECL
)
4232 /* For bases, can't use type_has_unique_obj_representations here, as in
4233 struct S { int i : 24; S (); };
4234 struct T : public S { int j : 8; T (); };
4235 S doesn't have unique obj representations, but T does. */
4236 else if (DECL_FIELD_IS_BASE (field
))
4238 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4242 else if (DECL_C_BIT_FIELD (field
))
4244 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4245 if (!type_has_unique_obj_representations (btype
))
4248 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4252 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4253 if (TREE_CODE (field
) == FIELD_DECL
)
4255 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4256 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4257 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4260 if (DECL_SIZE (field
))
4262 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4266 if (cur
!= wi::to_offset (sz
))
4272 /* Nonzero iff type T is a class template implicit specialization. */
4275 class_tmpl_impl_spec_p (const_tree t
)
4277 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4280 /* Returns 1 iff zero initialization of type T means actually storing
4284 zero_init_p (const_tree t
)
4286 /* This CONST_CAST is okay because strip_array_types returns its
4287 argument unmodified and we assign it to a const_tree. */
4288 t
= strip_array_types (CONST_CAST_TREE(t
));
4290 if (t
== error_mark_node
)
4293 /* NULL pointers to data members are initialized with -1. */
4294 if (TYPE_PTRDATAMEM_P (t
))
4297 /* Classes that contain types that can't be zero-initialized, cannot
4298 be zero-initialized themselves. */
4299 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4305 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4306 warn_unused_result attribute. */
4309 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4310 int /*flags*/, bool *no_add_attrs
)
4312 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4314 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4315 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4316 "return type", name
, *node
);
4318 else if (OVERLOAD_TYPE_P (*node
))
4322 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4323 "functions or to class or enumeration types", name
);
4324 *no_add_attrs
= true;
4329 /* Table of valid C++ attributes. */
4330 const struct attribute_spec cxx_attribute_table
[] =
4332 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4333 affects_type_identity, handler, exclude } */
4334 { "init_priority", 1, 1, true, false, false, false,
4335 handle_init_priority_attribute
, NULL
},
4336 { "abi_tag", 1, -1, false, false, false, true,
4337 handle_abi_tag_attribute
, NULL
},
4338 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4341 /* Table of C++ standard attributes. */
4342 const struct attribute_spec std_attribute_table
[] =
4344 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4345 affects_type_identity, handler, exclude } */
4346 { "maybe_unused", 0, 0, false, false, false, false,
4347 handle_unused_attribute
, NULL
},
4348 { "nodiscard", 0, 0, false, false, false, false,
4349 handle_nodiscard_attribute
, NULL
},
4350 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4353 /* Handle an "init_priority" attribute; arguments as in
4354 struct attribute_spec.handler. */
4356 handle_init_priority_attribute (tree
* node
,
4362 tree initp_expr
= TREE_VALUE (args
);
4364 tree type
= TREE_TYPE (decl
);
4367 STRIP_NOPS (initp_expr
);
4368 initp_expr
= default_conversion (initp_expr
);
4370 initp_expr
= maybe_constant_value (initp_expr
);
4372 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4374 error ("requested init_priority is not an integer constant");
4375 cxx_constant_value (initp_expr
);
4376 *no_add_attrs
= true;
4380 pri
= TREE_INT_CST_LOW (initp_expr
);
4382 type
= strip_array_types (type
);
4384 if (decl
== NULL_TREE
4386 || !TREE_STATIC (decl
)
4387 || DECL_EXTERNAL (decl
)
4388 || (TREE_CODE (type
) != RECORD_TYPE
4389 && TREE_CODE (type
) != UNION_TYPE
)
4390 /* Static objects in functions are initialized the
4391 first time control passes through that
4392 function. This is not precise enough to pin down an
4393 init_priority value, so don't allow it. */
4394 || current_function_decl
)
4396 error ("can only use %qE attribute on file-scope definitions "
4397 "of objects of class type", name
);
4398 *no_add_attrs
= true;
4402 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4404 error ("requested init_priority is out of range");
4405 *no_add_attrs
= true;
4409 /* Check for init_priorities that are reserved for
4410 language and runtime support implementations.*/
4411 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4414 (0, "requested init_priority is reserved for internal use");
4417 if (SUPPORTS_INIT_PRIORITY
)
4419 SET_DECL_INIT_PRIORITY (decl
, pri
);
4420 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4425 error ("%qE attribute is not supported on this platform", name
);
4426 *no_add_attrs
= true;
4431 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4432 and the new one has the tags in NEW_. Give an error if there are tags
4433 in NEW_ that weren't in OLD. */
4436 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4438 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4439 old
= TREE_VALUE (old
);
4440 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4441 new_
= TREE_VALUE (new_
);
4443 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4445 tree str
= TREE_VALUE (t
);
4446 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4448 tree ostr
= TREE_VALUE (in
);
4449 if (cp_tree_equal (str
, ostr
))
4452 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4458 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4464 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4465 ill-formed, give an error and return false; otherwise, return true. */
4468 check_abi_tag_args (tree args
, tree name
)
4472 error ("the %qE attribute requires arguments", name
);
4475 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4477 tree elt
= TREE_VALUE (arg
);
4478 if (TREE_CODE (elt
) != STRING_CST
4479 || (!same_type_ignoring_top_level_qualifiers_p
4480 (strip_array_types (TREE_TYPE (elt
)),
4483 error ("arguments to the %qE attribute must be narrow string "
4487 const char *begin
= TREE_STRING_POINTER (elt
);
4488 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4489 for (const char *p
= begin
; p
!= end
; ++p
)
4494 if (!ISALPHA (c
) && c
!= '_')
4496 error ("arguments to the %qE attribute must contain valid "
4497 "identifiers", name
);
4498 inform (input_location
, "%<%c%> is not a valid first "
4499 "character for an identifier", c
);
4503 else if (p
== end
- 1)
4504 gcc_assert (c
== 0);
4507 if (!ISALNUM (c
) && c
!= '_')
4509 error ("arguments to the %qE attribute must contain valid "
4510 "identifiers", name
);
4511 inform (input_location
, "%<%c%> is not a valid character "
4512 "in an identifier", c
);
4521 /* Handle an "abi_tag" attribute; arguments as in
4522 struct attribute_spec.handler. */
4525 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4526 int flags
, bool* no_add_attrs
)
4528 if (!check_abi_tag_args (args
, name
))
4533 if (!OVERLOAD_TYPE_P (*node
))
4535 error ("%qE attribute applied to non-class, non-enum type %qT",
4539 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4541 error ("%qE attribute applied to %qT after its definition",
4545 else if (CLASS_TYPE_P (*node
)
4546 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4548 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4549 "template instantiation %qT", name
, *node
);
4552 else if (CLASS_TYPE_P (*node
)
4553 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4555 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4556 "template specialization %qT", name
, *node
);
4560 tree attributes
= TYPE_ATTRIBUTES (*node
);
4561 tree decl
= TYPE_NAME (*node
);
4563 /* Make sure all declarations have the same abi tags. */
4564 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4566 if (!check_abi_tag_redeclaration (decl
,
4567 lookup_attribute ("abi_tag",
4575 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4577 error ("%qE attribute applied to non-function, non-variable %qD",
4581 else if (DECL_LANGUAGE (*node
) == lang_c
)
4583 error ("%qE attribute applied to extern \"C\" declaration %qD",
4592 *no_add_attrs
= true;
4596 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4597 thing pointed to by the constant. */
4600 make_ptrmem_cst (tree type
, tree member
)
4602 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4603 TREE_TYPE (ptrmem_cst
) = type
;
4604 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4608 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4609 return an existing type if an appropriate type already exists. */
4612 cp_build_type_attribute_variant (tree type
, tree attributes
)
4616 new_type
= build_type_attribute_variant (type
, attributes
);
4617 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4618 || TREE_CODE (new_type
) == METHOD_TYPE
)
4620 new_type
= build_exception_variant (new_type
,
4621 TYPE_RAISES_EXCEPTIONS (type
));
4622 new_type
= build_ref_qualified_type (new_type
,
4623 type_memfn_rqual (type
));
4626 /* Making a new main variant of a class type is broken. */
4627 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4632 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4633 Called only after doing all language independent checks. */
4636 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4638 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4639 || TREE_CODE (typea
) == METHOD_TYPE
);
4641 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4643 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4644 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4647 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4648 C++, these are the exception-specifier and ref-qualifier. */
4651 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4653 tree type
= CONST_CAST_TREE (typea
);
4654 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4656 type
= build_exception_variant (type
, TYPE_RAISES_EXCEPTIONS (typeb
));
4657 type
= build_ref_qualified_type (type
, type_memfn_rqual (typeb
));
4662 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4663 traversal. Called from walk_tree. */
4666 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4667 void *data
, hash_set
<tree
> *pset
)
4669 enum tree_code code
= TREE_CODE (*tp
);
4672 #define WALK_SUBTREE(NODE) \
4675 result = cp_walk_tree (&(NODE), func, data, pset); \
4676 if (result) goto out; \
4680 /* Not one of the easy cases. We must explicitly go through the
4686 case TEMPLATE_TEMPLATE_PARM
:
4687 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4688 case UNBOUND_CLASS_TEMPLATE
:
4689 case TEMPLATE_PARM_INDEX
:
4690 case TEMPLATE_TYPE_PARM
:
4693 case UNDERLYING_TYPE
:
4694 /* None of these have subtrees other than those already walked
4696 *walk_subtrees_p
= 0;
4700 if (BASELINK_QUALIFIED_P (*tp
))
4701 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4702 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4703 *walk_subtrees_p
= 0;
4707 WALK_SUBTREE (TREE_TYPE (*tp
));
4708 *walk_subtrees_p
= 0;
4712 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4716 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4717 WALK_SUBTREE (OVL_CHAIN (*tp
));
4718 *walk_subtrees_p
= 0;
4722 WALK_SUBTREE (DECL_NAME (*tp
));
4723 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4724 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4725 *walk_subtrees_p
= 0;
4729 if (TYPE_PTRMEMFUNC_P (*tp
))
4730 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4733 case TYPE_ARGUMENT_PACK
:
4734 case NONTYPE_ARGUMENT_PACK
:
4736 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4737 int i
, len
= TREE_VEC_LENGTH (args
);
4738 for (i
= 0; i
< len
; i
++)
4739 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4743 case TYPE_PACK_EXPANSION
:
4744 WALK_SUBTREE (TREE_TYPE (*tp
));
4745 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4746 *walk_subtrees_p
= 0;
4749 case EXPR_PACK_EXPANSION
:
4750 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4751 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4752 *walk_subtrees_p
= 0;
4756 case REINTERPRET_CAST_EXPR
:
4757 case STATIC_CAST_EXPR
:
4758 case CONST_CAST_EXPR
:
4759 case DYNAMIC_CAST_EXPR
:
4760 case IMPLICIT_CONV_EXPR
:
4761 if (TREE_TYPE (*tp
))
4762 WALK_SUBTREE (TREE_TYPE (*tp
));
4766 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4767 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4769 *walk_subtrees_p
= 0;
4773 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4774 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4775 *walk_subtrees_p
= 0;
4779 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
4780 *walk_subtrees_p
= 0;
4784 // Only recurse through the nested expression. Do not
4785 // walk the parameter list. Doing so causes false
4786 // positives in the pack expansion checker since the
4787 // requires parameters are introduced as pack expansions.
4788 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4789 *walk_subtrees_p
= 0;
4793 /* User variables should be mentioned in BIND_EXPR_VARS
4794 and their initializers and sizes walked when walking
4795 the containing BIND_EXPR. Compiler temporaries are
4797 if (VAR_P (TREE_OPERAND (*tp
, 0))
4798 && DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4799 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))
4801 tree decl
= TREE_OPERAND (*tp
, 0);
4802 WALK_SUBTREE (DECL_INITIAL (decl
));
4803 WALK_SUBTREE (DECL_SIZE (decl
));
4804 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4812 /* We didn't find what we were looking for. */
4819 /* Like save_expr, but for C++. */
4822 cp_save_expr (tree expr
)
4824 /* There is no reason to create a SAVE_EXPR within a template; if
4825 needed, we can create the SAVE_EXPR when instantiating the
4826 template. Furthermore, the middle-end cannot handle C++-specific
4828 if (processing_template_decl
)
4830 return save_expr (expr
);
4833 /* Initialize tree.c. */
4838 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4839 register_scoped_attributes (std_attribute_table
, NULL
);
4842 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4843 is. Note that sfk_none is zero, so this function can be used as a
4844 predicate to test whether or not DECL is a special function. */
4846 special_function_kind
4847 special_function_p (const_tree decl
)
4849 /* Rather than doing all this stuff with magic names, we should
4850 probably have a field of type `special_function_kind' in
4851 DECL_LANG_SPECIFIC. */
4852 if (DECL_INHERITED_CTOR (decl
))
4853 return sfk_inheriting_constructor
;
4854 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4855 return sfk_copy_constructor
;
4856 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4857 return sfk_move_constructor
;
4858 if (DECL_CONSTRUCTOR_P (decl
))
4859 return sfk_constructor
;
4860 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
4861 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
4863 if (copy_fn_p (decl
))
4864 return sfk_copy_assignment
;
4865 if (move_fn_p (decl
))
4866 return sfk_move_assignment
;
4868 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
4869 return sfk_destructor
;
4870 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
4871 return sfk_complete_destructor
;
4872 if (DECL_BASE_DESTRUCTOR_P (decl
))
4873 return sfk_base_destructor
;
4874 if (DECL_DELETING_DESTRUCTOR_P (decl
))
4875 return sfk_deleting_destructor
;
4876 if (DECL_CONV_FN_P (decl
))
4877 return sfk_conversion
;
4878 if (deduction_guide_p (decl
))
4879 return sfk_deduction_guide
;
4884 /* Returns nonzero if TYPE is a character type, including wchar_t. */
4887 char_type_p (tree type
)
4889 return (same_type_p (type
, char_type_node
)
4890 || same_type_p (type
, unsigned_char_type_node
)
4891 || same_type_p (type
, signed_char_type_node
)
4892 || same_type_p (type
, char16_type_node
)
4893 || same_type_p (type
, char32_type_node
)
4894 || same_type_p (type
, wchar_type_node
));
4897 /* Returns the kind of linkage associated with the indicated DECL. Th
4898 value returned is as specified by the language standard; it is
4899 independent of implementation details regarding template
4900 instantiation, etc. For example, it is possible that a declaration
4901 to which this function assigns external linkage would not show up
4902 as a global symbol when you run `nm' on the resulting object file. */
4905 decl_linkage (tree decl
)
4907 /* This function doesn't attempt to calculate the linkage from first
4908 principles as given in [basic.link]. Instead, it makes use of
4909 the fact that we have already set TREE_PUBLIC appropriately, and
4910 then handles a few special cases. Ideally, we would calculate
4911 linkage first, and then transform that into a concrete
4914 /* Things that don't have names have no linkage. */
4915 if (!DECL_NAME (decl
))
4918 /* Fields have no linkage. */
4919 if (TREE_CODE (decl
) == FIELD_DECL
)
4922 /* Things that are TREE_PUBLIC have external linkage. */
4923 if (TREE_PUBLIC (decl
))
4926 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
4927 check one of the "clones" for the real linkage. */
4928 if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
)
4929 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
))
4930 && DECL_CHAIN (decl
)
4931 && DECL_CLONED_FUNCTION (DECL_CHAIN (decl
)))
4932 return decl_linkage (DECL_CHAIN (decl
));
4934 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4937 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4939 if (TREE_CODE (decl
) == CONST_DECL
)
4940 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
4942 /* Things in local scope do not have linkage, if they don't have
4944 if (decl_function_context (decl
))
4947 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4948 are considered to have external linkage for language purposes, as do
4949 template instantiations on targets without weak symbols. DECLs really
4950 meant to have internal linkage have DECL_THIS_STATIC set. */
4951 if (TREE_CODE (decl
) == TYPE_DECL
)
4953 if (VAR_OR_FUNCTION_DECL_P (decl
))
4955 if (!DECL_THIS_STATIC (decl
))
4958 /* Static data members and static member functions from classes
4959 in anonymous namespace also don't have TREE_PUBLIC set. */
4960 if (DECL_CLASS_CONTEXT (decl
))
4964 /* Everything else has internal linkage. */
4968 /* Returns the storage duration of the object or reference associated with
4969 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
4972 decl_storage_duration (tree decl
)
4974 if (TREE_CODE (decl
) == PARM_DECL
)
4976 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4978 gcc_assert (VAR_P (decl
));
4979 if (!TREE_STATIC (decl
)
4980 && !DECL_EXTERNAL (decl
))
4982 if (CP_DECL_THREAD_LOCAL_P (decl
))
4987 /* EXP is an expression that we want to pre-evaluate. Returns (in
4988 *INITP) an expression that will perform the pre-evaluation. The
4989 value returned by this function is a side-effect free expression
4990 equivalent to the pre-evaluated expression. Callers must ensure
4991 that *INITP is evaluated before EXP. */
4994 stabilize_expr (tree exp
, tree
* initp
)
4998 if (!TREE_SIDE_EFFECTS (exp
))
4999 init_expr
= NULL_TREE
;
5000 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5005 /* There are no expressions with REFERENCE_TYPE, but there can be call
5006 arguments with such a type; just treat it as a pointer. */
5007 else if (TREE_CODE (TREE_TYPE (exp
)) == REFERENCE_TYPE
5008 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5009 || !glvalue_p (exp
))
5011 init_expr
= get_target_expr (exp
);
5012 exp
= TARGET_EXPR_SLOT (init_expr
);
5013 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5020 bool xval
= !lvalue_p (exp
);
5021 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5022 init_expr
= get_target_expr (exp
);
5023 exp
= TARGET_EXPR_SLOT (init_expr
);
5024 exp
= cp_build_fold_indirect_ref (exp
);
5030 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5034 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5035 similar expression ORIG. */
5038 add_stmt_to_compound (tree orig
, tree new_expr
)
5040 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5042 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5044 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5047 /* Like stabilize_expr, but for a call whose arguments we want to
5048 pre-evaluate. CALL is modified in place to use the pre-evaluated
5049 arguments, while, upon return, *INITP contains an expression to
5050 compute the arguments. */
5053 stabilize_call (tree call
, tree
*initp
)
5055 tree inits
= NULL_TREE
;
5057 int nargs
= call_expr_nargs (call
);
5059 if (call
== error_mark_node
|| processing_template_decl
)
5065 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5067 for (i
= 0; i
< nargs
; i
++)
5070 CALL_EXPR_ARG (call
, i
) =
5071 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5072 inits
= add_stmt_to_compound (inits
, init
);
5078 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5079 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5080 arguments, while, upon return, *INITP contains an expression to
5081 compute the arguments. */
5084 stabilize_aggr_init (tree call
, tree
*initp
)
5086 tree inits
= NULL_TREE
;
5088 int nargs
= aggr_init_expr_nargs (call
);
5090 if (call
== error_mark_node
)
5093 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5095 for (i
= 0; i
< nargs
; i
++)
5098 AGGR_INIT_EXPR_ARG (call
, i
) =
5099 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5100 inits
= add_stmt_to_compound (inits
, init
);
5106 /* Like stabilize_expr, but for an initialization.
5108 If the initialization is for an object of class type, this function
5109 takes care not to introduce additional temporaries.
5111 Returns TRUE iff the expression was successfully pre-evaluated,
5112 i.e., if INIT is now side-effect free, except for, possibly, a
5113 single call to a constructor. */
5116 stabilize_init (tree init
, tree
*initp
)
5122 if (t
== error_mark_node
|| processing_template_decl
)
5125 if (TREE_CODE (t
) == INIT_EXPR
)
5126 t
= TREE_OPERAND (t
, 1);
5127 if (TREE_CODE (t
) == TARGET_EXPR
)
5128 t
= TARGET_EXPR_INITIAL (t
);
5130 /* If the RHS can be stabilized without breaking copy elision, stabilize
5131 it. We specifically don't stabilize class prvalues here because that
5132 would mean an extra copy, but they might be stabilized below. */
5133 if (TREE_CODE (init
) == INIT_EXPR
5134 && TREE_CODE (t
) != CONSTRUCTOR
5135 && TREE_CODE (t
) != AGGR_INIT_EXPR
5136 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5139 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5143 if (TREE_CODE (t
) == COMPOUND_EXPR
5144 && TREE_CODE (init
) == INIT_EXPR
)
5146 tree last
= expr_last (t
);
5147 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5148 if (!TREE_SIDE_EFFECTS (last
))
5151 TREE_OPERAND (init
, 1) = last
;
5156 if (TREE_CODE (t
) == CONSTRUCTOR
)
5158 /* Aggregate initialization: stabilize each of the field
5161 constructor_elt
*ce
;
5163 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5164 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5166 tree type
= TREE_TYPE (ce
->value
);
5168 if (TREE_CODE (type
) == REFERENCE_TYPE
5169 || SCALAR_TYPE_P (type
))
5170 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5171 else if (!stabilize_init (ce
->value
, &subinit
))
5173 *initp
= add_stmt_to_compound (*initp
, subinit
);
5178 if (TREE_CODE (t
) == CALL_EXPR
)
5180 stabilize_call (t
, initp
);
5184 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5186 stabilize_aggr_init (t
, initp
);
5190 /* The initialization is being performed via a bitwise copy -- and
5191 the item copied may have side effects. */
5192 return !TREE_SIDE_EFFECTS (init
);
5195 /* Returns true if a cast to TYPE may appear in an integral constant
5199 cast_valid_in_integral_constant_expression_p (tree type
)
5201 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5202 || cxx_dialect
>= cxx11
5203 || dependent_type_p (type
)
5204 || type
== error_mark_node
);
5207 /* Return true if we need to fix linkage information of DECL. */
5210 cp_fix_function_decl_p (tree decl
)
5212 /* Skip if DECL is not externally visible. */
5213 if (!TREE_PUBLIC (decl
))
5216 /* We need to fix DECL if it a appears to be exported but with no
5217 function body. Thunks do not have CFGs and we may need to
5218 handle them specially later. */
5219 if (!gimple_has_body_p (decl
)
5220 && !DECL_THUNK_P (decl
)
5221 && !DECL_EXTERNAL (decl
))
5223 struct cgraph_node
*node
= cgraph_node::get (decl
);
5225 /* Don't fix same_body aliases. Although they don't have their own
5226 CFG, they share it with what they alias to. */
5227 if (!node
|| !node
->alias
5228 || !vec_safe_length (node
->ref_list
.references
))
5235 /* Clean the C++ specific parts of the tree T. */
5238 cp_free_lang_data (tree t
)
5240 if (TREE_CODE (t
) == METHOD_TYPE
5241 || TREE_CODE (t
) == FUNCTION_TYPE
)
5243 /* Default args are not interesting anymore. */
5244 tree argtypes
= TYPE_ARG_TYPES (t
);
5247 TREE_PURPOSE (argtypes
) = 0;
5248 argtypes
= TREE_CHAIN (argtypes
);
5251 else if (TREE_CODE (t
) == FUNCTION_DECL
5252 && cp_fix_function_decl_p (t
))
5254 /* If T is used in this translation unit at all, the definition
5255 must exist somewhere else since we have decided to not emit it
5256 in this TU. So make it an external reference. */
5257 DECL_EXTERNAL (t
) = 1;
5258 TREE_STATIC (t
) = 0;
5260 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5261 /* We do not need the leftover chaining of namespaces from the
5263 DECL_CHAIN (t
) = NULL_TREE
;
5266 /* Stub for c-common. Please keep in sync with c-decl.c.
5267 FIXME: If address space support is target specific, then this
5268 should be a C target hook. But currently this is not possible,
5269 because this function is called via REGISTER_TARGET_PRAGMAS. */
5271 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5275 /* Return the number of operands in T that we care about for things like
5279 cp_tree_operand_length (const_tree t
)
5281 enum tree_code code
= TREE_CODE (t
);
5283 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5284 return VL_EXP_OPERAND_LENGTH (t
);
5286 return cp_tree_code_length (code
);
5289 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5292 cp_tree_code_length (enum tree_code code
)
5294 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5298 case PREINCREMENT_EXPR
:
5299 case PREDECREMENT_EXPR
:
5300 case POSTINCREMENT_EXPR
:
5301 case POSTDECREMENT_EXPR
:
5307 case EXPR_PACK_EXPANSION
:
5311 return TREE_CODE_LENGTH (code
);
5315 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5316 conditions for the warning hold, false otherwise. */
5318 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5320 if (c_inhibit_evaluation_warnings
== 0
5321 && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5323 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5324 "zero as null pointer constant");
5330 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5331 /* Complain that some language-specific thing hanging off a tree
5332 node has been accessed improperly. */
5335 lang_check_failed (const char* file
, int line
, const char* function
)
5337 internal_error ("lang_* check: failed in %s, at %s:%d",
5338 function
, trim_filename (file
), line
);
5340 #endif /* ENABLE_TREE_CHECKING */
5342 #include "gt-cp-tree.h"