1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
46 static tree
build_local_temp (tree
);
48 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
55 lvalue_kind (const_tree ref
)
57 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
58 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
64 if (REFERENCE_REF_P (ref
))
65 return lvalue_kind (TREE_OPERAND (ref
, 0));
68 && TYPE_REF_P (TREE_TYPE (ref
)))
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
72 && TREE_CODE (ref
) != PARM_DECL
74 && TREE_CODE (ref
) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
79 /* lvalue references and named rvalue references are lvalues. */
83 if (ref
== current_class_ptr
)
86 switch (TREE_CODE (ref
))
91 /* preincrements and predecrements are valid lvals, provided
92 what they refer to are valid lvals. */
93 case PREINCREMENT_EXPR
:
94 case PREDECREMENT_EXPR
:
98 case VIEW_CONVERT_EXPR
:
99 return lvalue_kind (TREE_OPERAND (ref
, 0));
103 tree op1
= TREE_OPERAND (ref
, 0);
104 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
106 op1_lvalue_kind
= lvalue_kind (op1
);
107 if (op1_lvalue_kind
== clk_class
)
108 /* in the case of an array operand, the result is an lvalue if
109 that operand is an lvalue and an xvalue otherwise */
110 op1_lvalue_kind
= clk_rvalueref
;
111 return op1_lvalue_kind
;
119 if (TREE_CODE (ref
) == MEMBER_REF
)
120 op1_lvalue_kind
= clk_ordinary
;
122 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
123 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
124 op1_lvalue_kind
= clk_none
;
125 else if (op1_lvalue_kind
== clk_class
)
126 /* The result of a .* expression whose second operand is a pointer to a
127 data member is an lvalue if the first operand is an lvalue and an
129 op1_lvalue_kind
= clk_rvalueref
;
130 return op1_lvalue_kind
;
133 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
135 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
137 /* For static member function recurse on the BASELINK, we can get
138 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
139 OVERLOAD, the overload is resolved first if possible through
140 resolve_address_of_overloaded_function. */
141 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
142 return lvalue_kind (TREE_OPERAND (ref
, 1));
144 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
145 if (op1_lvalue_kind
== clk_class
)
146 /* If E1 is an lvalue, then E1.E2 is an lvalue;
147 otherwise E1.E2 is an xvalue. */
148 op1_lvalue_kind
= clk_rvalueref
;
150 /* Look at the member designator. */
151 if (!op1_lvalue_kind
)
153 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
154 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
155 situations. If we're seeing a COMPONENT_REF, it's a non-static
156 member, so it isn't an lvalue. */
157 op1_lvalue_kind
= clk_none
;
158 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
159 /* This can be IDENTIFIER_NODE in a template. */;
160 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
162 /* Clear the ordinary bit. If this object was a class
163 rvalue we want to preserve that information. */
164 op1_lvalue_kind
&= ~clk_ordinary
;
165 /* The lvalue is for a bitfield. */
166 op1_lvalue_kind
|= clk_bitfield
;
168 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
169 op1_lvalue_kind
|= clk_packed
;
171 return op1_lvalue_kind
;
174 case COMPOUND_LITERAL_EXPR
:
178 /* CONST_DECL without TREE_STATIC are enumeration values and
179 thus not lvalues. With TREE_STATIC they are used by ObjC++
180 in objc_build_string_object and need to be considered as
182 if (! TREE_STATIC (ref
))
186 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
187 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
189 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
190 && DECL_LANG_SPECIFIC (ref
)
191 && DECL_IN_AGGR_P (ref
))
198 case PLACEHOLDER_EXPR
:
201 /* A scope ref in a template, left as SCOPE_REF to support later
204 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
206 tree op
= TREE_OPERAND (ref
, 1);
207 if (TREE_CODE (op
) == FIELD_DECL
)
208 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
210 return lvalue_kind (op
);
215 /* Disallow <? and >? as lvalues if either argument side-effects. */
216 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
217 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
219 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
220 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
224 if (processing_template_decl
)
226 /* Within templates, a REFERENCE_TYPE will indicate whether
227 the COND_EXPR result is an ordinary lvalue or rvalueref.
228 Since REFERENCE_TYPEs are handled above, if we reach this
229 point, we know we got a plain rvalue. Unless we have a
230 type-dependent expr, that is, but we shouldn't be testing
231 lvalueness if we can't even tell the types yet! */
232 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
235 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
236 ? TREE_OPERAND (ref
, 1)
237 : TREE_OPERAND (ref
, 0));
238 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
242 /* We expect to see unlowered MODOP_EXPRs only during
243 template processing. */
244 gcc_assert (processing_template_decl
);
252 return lvalue_kind (TREE_OPERAND (ref
, 1));
258 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
261 /* We can see calls outside of TARGET_EXPR in templates. */
262 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
267 /* All functions (except non-static-member functions) are
269 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
270 ? clk_none
: clk_ordinary
);
273 /* We now represent a reference to a single static member function
275 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
276 its argument unmodified and we assign it to a const_tree. */
277 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
279 case NON_DEPENDENT_EXPR
:
281 return lvalue_kind (TREE_OPERAND (ref
, 0));
285 if (!TREE_TYPE (ref
))
287 if (CLASS_TYPE_P (TREE_TYPE (ref
))
288 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
293 /* If one operand is not an lvalue at all, then this expression is
295 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
298 /* Otherwise, it's an lvalue, and it has all the odd properties
299 contributed by either operand. */
300 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
301 /* It's not an ordinary lvalue if it involves any other kind. */
302 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
303 op1_lvalue_kind
&= ~clk_ordinary
;
304 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
305 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
306 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
307 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
308 op1_lvalue_kind
= clk_none
;
309 return op1_lvalue_kind
;
312 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
315 real_lvalue_p (const_tree ref
)
317 cp_lvalue_kind kind
= lvalue_kind (ref
);
318 if (kind
& (clk_rvalueref
|clk_class
))
324 /* c-common wants us to return bool. */
327 lvalue_p (const_tree t
)
329 return real_lvalue_p (t
);
332 /* This differs from lvalue_p in that xvalues are included. */
335 glvalue_p (const_tree ref
)
337 cp_lvalue_kind kind
= lvalue_kind (ref
);
338 if (kind
& clk_class
)
341 return (kind
!= clk_none
);
344 /* This differs from glvalue_p in that class prvalues are included. */
347 obvalue_p (const_tree ref
)
349 return (lvalue_kind (ref
) != clk_none
);
352 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
353 reference), false otherwise. */
356 xvalue_p (const_tree ref
)
358 return (lvalue_kind (ref
) == clk_rvalueref
);
361 /* True if REF is a bit-field. */
364 bitfield_p (const_tree ref
)
366 return (lvalue_kind (ref
) & clk_bitfield
);
369 /* C++-specific version of stabilize_reference. */
372 cp_stabilize_reference (tree ref
)
374 switch (TREE_CODE (ref
))
376 case NON_DEPENDENT_EXPR
:
377 /* We aren't actually evaluating this. */
380 /* We need to treat specially anything stabilize_reference doesn't
381 handle specifically. */
392 case ARRAY_RANGE_REF
:
396 cp_lvalue_kind kind
= lvalue_kind (ref
);
397 if ((kind
& ~clk_class
) != clk_none
)
399 tree type
= unlowered_expr_type (ref
);
400 bool rval
= !!(kind
& clk_rvalueref
);
401 type
= cp_build_reference_type (type
, rval
);
402 /* This inhibits warnings in, eg, cxx_mark_addressable
404 warning_sentinel
s (extra_warnings
);
405 ref
= build_static_cast (type
, ref
, tf_error
);
409 return stabilize_reference (ref
);
412 /* Test whether DECL is a builtin that may appear in a
413 constant-expression. */
416 builtin_valid_in_constant_expr_p (const_tree decl
)
418 if (TREE_CODE (decl
) != FUNCTION_DECL
)
419 /* Not a function. */
421 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
423 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
426 /* Not a built-in. */
429 switch (DECL_FUNCTION_CODE (decl
))
431 /* These always have constant results like the corresponding
434 case BUILT_IN_FUNCTION
:
437 /* The following built-ins are valid in constant expressions
438 when their arguments are. */
439 case BUILT_IN_ADD_OVERFLOW_P
:
440 case BUILT_IN_SUB_OVERFLOW_P
:
441 case BUILT_IN_MUL_OVERFLOW_P
:
443 /* These have constant results even if their operands are
445 case BUILT_IN_CONSTANT_P
:
446 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
453 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
456 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
459 tree type
= TREE_TYPE (decl
);
461 value
= mark_rvalue_use (value
);
463 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
464 || TREE_TYPE (decl
) == TREE_TYPE (value
)
465 /* On ARM ctors return 'this'. */
466 || (TYPE_PTR_P (TREE_TYPE (value
))
467 && TREE_CODE (value
) == CALL_EXPR
)
468 || useless_type_conversion_p (TREE_TYPE (decl
),
471 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
472 moving a constant aggregate into .rodata. */
473 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
474 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
475 && !VOID_TYPE_P (TREE_TYPE (value
))
476 && reduced_constant_expression_p (value
))
477 TREE_READONLY (decl
) = true;
479 if (complain
& tf_no_cleanup
)
480 /* The caller is building a new-expr and does not need a cleanup. */
484 t
= cxx_maybe_build_cleanup (decl
, complain
);
485 if (t
== error_mark_node
)
486 return error_mark_node
;
488 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
489 if (location_t eloc
= cp_expr_location (value
))
490 SET_EXPR_LOCATION (t
, eloc
);
491 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
492 ignore the TARGET_EXPR. If there really turn out to be no
493 side-effects, then the optimizer should be able to get rid of
494 whatever code is generated anyhow. */
495 TREE_SIDE_EFFECTS (t
) = 1;
500 /* Return an undeclared local temporary of type TYPE for use in building a
504 build_local_temp (tree type
)
506 tree slot
= build_decl (input_location
,
507 VAR_DECL
, NULL_TREE
, type
);
508 DECL_ARTIFICIAL (slot
) = 1;
509 DECL_IGNORED_P (slot
) = 1;
510 DECL_CONTEXT (slot
) = current_function_decl
;
511 layout_decl (slot
, 0);
515 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
518 process_aggr_init_operands (tree t
)
522 side_effects
= TREE_SIDE_EFFECTS (t
);
526 n
= TREE_OPERAND_LENGTH (t
);
527 for (i
= 1; i
< n
; i
++)
529 tree op
= TREE_OPERAND (t
, i
);
530 if (op
&& TREE_SIDE_EFFECTS (op
))
537 TREE_SIDE_EFFECTS (t
) = side_effects
;
540 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
541 FN, and SLOT. NARGS is the number of call arguments which are specified
542 as a tree array ARGS. */
545 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
551 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
552 TREE_TYPE (t
) = return_type
;
553 AGGR_INIT_EXPR_FN (t
) = fn
;
554 AGGR_INIT_EXPR_SLOT (t
) = slot
;
555 for (i
= 0; i
< nargs
; i
++)
556 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
557 process_aggr_init_operands (t
);
561 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
562 target. TYPE is the type to be initialized.
564 Build an AGGR_INIT_EXPR to represent the initialization. This function
565 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
566 to initialize another object, whereas a TARGET_EXPR can either
567 initialize another object or create its own temporary object, and as a
568 result building up a TARGET_EXPR requires that the type's destructor be
572 build_aggr_init_expr (tree type
, tree init
)
579 gcc_assert (!VOID_TYPE_P (type
));
581 /* Don't build AGGR_INIT_EXPR in a template. */
582 if (processing_template_decl
)
585 fn
= cp_get_callee (init
);
587 return convert (type
, init
);
589 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
590 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
591 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
593 /* We split the CALL_EXPR into its function and its arguments here.
594 Then, in expand_expr, we put them back together. The reason for
595 this is that this expression might be a default argument
596 expression. In that case, we need a new temporary every time the
597 expression is used. That's what break_out_target_exprs does; it
598 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
599 temporary slot. Then, expand_expr builds up a call-expression
600 using the new slot. */
602 /* If we don't need to use a constructor to create an object of this
603 type, don't mess with AGGR_INIT_EXPR. */
604 if (is_ctor
|| TREE_ADDRESSABLE (type
))
606 slot
= build_local_temp (type
);
608 if (TREE_CODE (init
) == CALL_EXPR
)
610 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
611 call_expr_nargs (init
),
612 CALL_EXPR_ARGP (init
));
613 AGGR_INIT_FROM_THUNK_P (rval
)
614 = CALL_FROM_THUNK_P (init
);
618 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
619 aggr_init_expr_nargs (init
),
620 AGGR_INIT_EXPR_ARGP (init
));
621 AGGR_INIT_FROM_THUNK_P (rval
)
622 = AGGR_INIT_FROM_THUNK_P (init
);
624 TREE_SIDE_EFFECTS (rval
) = 1;
625 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
626 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
627 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
628 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
629 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
637 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
638 target. TYPE is the type that this initialization should appear to
641 Build an encapsulation of the initialization to perform
642 and return it so that it can be processed by language-independent
643 and language-specific expression expanders. */
646 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
648 tree rval
= build_aggr_init_expr (type
, init
);
651 if (init
== error_mark_node
)
652 return error_mark_node
;
654 if (!complete_type_or_maybe_complain (type
, init
, complain
))
655 return error_mark_node
;
657 /* Make sure that we're not trying to create an instance of an
659 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
660 return error_mark_node
;
662 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
663 slot
= AGGR_INIT_EXPR_SLOT (rval
);
664 else if (TREE_CODE (rval
) == CALL_EXPR
665 || TREE_CODE (rval
) == CONSTRUCTOR
)
666 slot
= build_local_temp (type
);
670 rval
= build_target_expr (slot
, rval
, complain
);
672 if (rval
!= error_mark_node
)
673 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
678 /* Subroutine of build_vec_init_expr: Build up a single element
679 intialization as a proxy for the full array initialization to get things
680 marked as used and any appropriate diagnostics.
682 Since we're deferring building the actual constructor calls until
683 gimplification time, we need to build one now and throw it away so
684 that the relevant constructor gets mark_used before cgraph decides
685 what functions are needed. Here we assume that init is either
686 NULL_TREE, void_type_node (indicating value-initialization), or
687 another array to copy. */
690 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
692 tree inner_type
= strip_array_types (type
);
693 vec
<tree
, va_gc
> *argvec
;
695 if (integer_zerop (array_type_nelts_total (type
))
696 || !CLASS_TYPE_P (inner_type
))
697 /* No interesting initialization to do. */
698 return integer_zero_node
;
699 else if (init
== void_type_node
)
700 return build_value_init (inner_type
, complain
);
702 gcc_assert (init
== NULL_TREE
703 || (same_type_ignoring_top_level_qualifiers_p
704 (type
, TREE_TYPE (init
))));
706 argvec
= make_tree_vector ();
709 tree init_type
= strip_array_types (TREE_TYPE (init
));
710 tree dummy
= build_dummy_object (init_type
);
711 if (!lvalue_p (init
))
712 dummy
= move (dummy
);
713 argvec
->quick_push (dummy
);
715 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
716 &argvec
, inner_type
, LOOKUP_NORMAL
,
718 release_tree_vector (argvec
);
720 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
721 we don't want one here because we aren't creating a temporary. */
722 if (TREE_CODE (init
) == TARGET_EXPR
)
723 init
= TARGET_EXPR_INITIAL (init
);
728 /* Return a TARGET_EXPR which expresses the initialization of an array to
729 be named later, either default-initialization or copy-initialization
730 from another array of the same type. */
733 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
736 bool value_init
= false;
737 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
739 if (init
== void_type_node
)
745 slot
= build_local_temp (type
);
746 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
747 TREE_SIDE_EFFECTS (init
) = true;
748 SET_EXPR_LOCATION (init
, input_location
);
750 if (cxx_dialect
>= cxx11
751 && potential_constant_expression (elt_init
))
752 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
753 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
758 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
759 that requires a constant expression. */
762 diagnose_non_constexpr_vec_init (tree expr
)
764 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
766 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
767 init
= void_type_node
;
769 init
= VEC_INIT_EXPR_INIT (expr
);
771 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
772 require_potential_constant_expression (elt_init
);
776 build_array_copy (tree init
)
778 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
781 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
785 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
787 gcc_assert (!VOID_TYPE_P (type
));
789 if (TREE_CODE (init
) == TARGET_EXPR
790 || init
== error_mark_node
)
792 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
793 && !VOID_TYPE_P (TREE_TYPE (init
))
794 && TREE_CODE (init
) != COND_EXPR
795 && TREE_CODE (init
) != CONSTRUCTOR
796 && TREE_CODE (init
) != VA_ARG_EXPR
)
797 /* We need to build up a copy constructor call. A void initializer
798 means we're being called from bot_manip. COND_EXPR is a special
799 case because we already have copies on the arms and we don't want
800 another one here. A CONSTRUCTOR is aggregate initialization, which
801 is handled separately. A VA_ARG_EXPR is magic creation of an
802 aggregate; there's no additional work to be done. */
803 return force_rvalue (init
, complain
);
805 return force_target_expr (type
, init
, complain
);
808 /* Like the above function, but without the checking. This function should
809 only be used by code which is deliberately trying to subvert the type
810 system, such as call_builtin_trap. Or build_over_call, to avoid
811 infinite recursion. */
814 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
818 gcc_assert (!VOID_TYPE_P (type
));
820 slot
= build_local_temp (type
);
821 return build_target_expr (slot
, init
, complain
);
824 /* Like build_target_expr_with_type, but use the type of INIT. */
827 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
829 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
830 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
831 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
832 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
835 init
= convert_bitfield_to_declared_type (init
);
836 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
841 get_target_expr (tree init
)
843 return get_target_expr_sfinae (init
, tf_warning_or_error
);
846 /* If EXPR is a bitfield reference, convert it to the declared type of
847 the bitfield, and return the resulting expression. Otherwise,
848 return EXPR itself. */
851 convert_bitfield_to_declared_type (tree expr
)
855 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
857 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
862 /* EXPR is being used in an rvalue context. Return a version of EXPR
863 that is marked as an rvalue. */
870 if (error_operand_p (expr
))
873 expr
= mark_rvalue_use (expr
);
877 Non-class rvalues always have cv-unqualified types. */
878 type
= TREE_TYPE (expr
);
879 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
880 type
= cv_unqualified (type
);
882 /* We need to do this for rvalue refs as well to get the right answer
883 from decltype; see c++/36628. */
884 if (!processing_template_decl
&& glvalue_p (expr
))
885 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
886 else if (type
!= TREE_TYPE (expr
))
887 expr
= build_nop (type
, expr
);
893 struct cplus_array_info
899 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
901 typedef cplus_array_info
*compare_type
;
903 static hashval_t
hash (tree t
);
904 static bool equal (tree
, cplus_array_info
*);
907 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
910 cplus_array_hasher::hash (tree t
)
914 hash
= TYPE_UID (TREE_TYPE (t
));
916 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
920 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
921 of type `cplus_array_info*'. */
924 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
926 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
929 /* Hash table containing dependent array types, which are unsuitable for
930 the language-independent type hash table. */
931 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
933 /* Build an ARRAY_TYPE without laying it out. */
936 build_min_array_type (tree elt_type
, tree index_type
)
938 tree t
= cxx_make_type (ARRAY_TYPE
);
939 TREE_TYPE (t
) = elt_type
;
940 TYPE_DOMAIN (t
) = index_type
;
944 /* Set TYPE_CANONICAL like build_array_type_1, but using
945 build_cplus_array_type. */
948 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
950 /* Set the canonical type for this new node. */
951 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
952 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
953 SET_TYPE_STRUCTURAL_EQUALITY (t
);
954 else if (TYPE_CANONICAL (elt_type
) != elt_type
955 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
957 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
959 ? TYPE_CANONICAL (index_type
) : index_type
);
961 TYPE_CANONICAL (t
) = t
;
964 /* Like build_array_type, but handle special C++ semantics: an array of a
965 variant element type is a variant of the array of the main variant of
969 build_cplus_array_type (tree elt_type
, tree index_type
)
973 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
974 return error_mark_node
;
976 bool dependent
= (uses_template_parms (elt_type
)
977 || (index_type
&& uses_template_parms (index_type
)));
979 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
980 /* Start with an array of the TYPE_MAIN_VARIANT. */
981 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
985 /* Since type_hash_canon calls layout_type, we need to use our own
987 cplus_array_info cai
;
990 if (cplus_array_htab
== NULL
)
991 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
993 hash
= TYPE_UID (elt_type
);
995 hash
^= TYPE_UID (index_type
);
997 cai
.domain
= index_type
;
999 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1001 /* We have found the type: we're done. */
1005 /* Build a new array type. */
1006 t
= build_min_array_type (elt_type
, index_type
);
1008 /* Store it in the hash table. */
1011 /* Set the canonical type for this new node. */
1012 set_array_type_canon (t
, elt_type
, index_type
);
1017 bool typeless_storage
1018 = (elt_type
== unsigned_char_type_node
1019 || elt_type
== signed_char_type_node
1020 || elt_type
== char_type_node
1021 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1022 && TYPE_CONTEXT (elt_type
) == std_node
1023 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1024 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1027 /* Now check whether we already have this array variant. */
1028 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1031 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1032 if (TREE_TYPE (t
) == elt_type
1033 && TYPE_NAME (t
) == NULL_TREE
1034 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1038 t
= build_min_array_type (elt_type
, index_type
);
1039 set_array_type_canon (t
, elt_type
, index_type
);
1043 /* Make sure sizes are shared with the main variant.
1044 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1045 as it will overwrite alignment etc. of all variants. */
1046 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1047 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1048 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1051 TYPE_MAIN_VARIANT (t
) = m
;
1052 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1053 TYPE_NEXT_VARIANT (m
) = t
;
1057 /* Avoid spurious warnings with VLAs (c++/54583). */
1058 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1059 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1061 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1062 place more easily. */
1063 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1064 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1065 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1066 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1068 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1069 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1071 /* The element type has been completed since the last time we saw
1072 this array type; update the layout and 'tor flags for any variants
1075 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1077 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1078 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1085 /* Return an ARRAY_TYPE with element type ELT and length N. */
1088 build_array_of_n_type (tree elt
, int n
)
1090 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1093 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1094 for C++14 but then removed. This should only be used for N3639
1095 specifically; code wondering more generally if something is a VLA should use
1099 array_of_runtime_bound_p (tree t
)
1101 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1103 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1105 tree dom
= TYPE_DOMAIN (t
);
1108 tree max
= TYPE_MAX_VALUE (dom
);
1109 return (!potential_rvalue_constant_expression (max
)
1110 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1113 /* True iff T is a variable length array. */
1118 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1120 if (tree dom
= TYPE_DOMAIN (t
))
1122 tree max
= TYPE_MAX_VALUE (dom
);
1123 if (!potential_rvalue_constant_expression (max
)
1124 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1130 /* Return a reference type node referring to TO_TYPE. If RVAL is
1131 true, return an rvalue reference type, otherwise return an lvalue
1132 reference type. If a type node exists, reuse it, otherwise create
1135 cp_build_reference_type (tree to_type
, bool rval
)
1139 if (to_type
== error_mark_node
)
1140 return error_mark_node
;
1142 if (TYPE_REF_P (to_type
))
1144 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1145 to_type
= TREE_TYPE (to_type
);
1148 lvalue_ref
= build_reference_type (to_type
);
1152 /* This code to create rvalue reference types is based on and tied
1153 to the code creating lvalue reference types in the middle-end
1154 functions build_reference_type_for_mode and build_reference_type.
1156 It works by putting the rvalue reference type nodes after the
1157 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1158 they will effectively be ignored by the middle end. */
1160 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1161 if (TYPE_REF_IS_RVALUE (t
))
1164 t
= build_distinct_type_copy (lvalue_ref
);
1166 TYPE_REF_IS_RVALUE (t
) = true;
1167 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1168 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1170 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1171 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1172 else if (TYPE_CANONICAL (to_type
) != to_type
)
1174 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1176 TYPE_CANONICAL (t
) = t
;
1184 /* Returns EXPR cast to rvalue reference type, like std::move. */
1189 tree type
= TREE_TYPE (expr
);
1190 gcc_assert (!TYPE_REF_P (type
));
1191 type
= cp_build_reference_type (type
, /*rval*/true);
1192 return build_static_cast (type
, expr
, tf_warning_or_error
);
1195 /* Used by the C++ front end to build qualified array types. However,
1196 the C version of this function does not properly maintain canonical
1197 types (which are not used in C). */
1199 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1200 size_t /* orig_qual_indirect */)
1202 return cp_build_qualified_type (type
, type_quals
);
1206 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1207 arrays correctly. In particular, if TYPE is an array of T's, and
1208 TYPE_QUALS is non-empty, returns an array of qualified T's.
1210 FLAGS determines how to deal with ill-formed qualifications. If
1211 tf_ignore_bad_quals is set, then bad qualifications are dropped
1212 (this is permitted if TYPE was introduced via a typedef or template
1213 type parameter). If bad qualifications are dropped and tf_warning
1214 is set, then a warning is issued for non-const qualifications. If
1215 tf_ignore_bad_quals is not set and tf_error is not set, we
1216 return error_mark_node. Otherwise, we issue an error, and ignore
1219 Qualification of a reference type is valid when the reference came
1220 via a typedef or template type argument. [dcl.ref] No such
1221 dispensation is provided for qualifying a function type. [dcl.fct]
1222 DR 295 queries this and the proposed resolution brings it into line
1223 with qualifying a reference. We implement the DR. We also behave
1224 in a similar manner for restricting non-pointer types. */
1227 cp_build_qualified_type_real (tree type
,
1229 tsubst_flags_t complain
)
1232 int bad_quals
= TYPE_UNQUALIFIED
;
1234 if (type
== error_mark_node
)
1237 if (type_quals
== cp_type_quals (type
))
1240 if (TREE_CODE (type
) == ARRAY_TYPE
)
1242 /* In C++, the qualification really applies to the array element
1243 type. Obtain the appropriately qualified element type. */
1246 = cp_build_qualified_type_real (TREE_TYPE (type
),
1250 if (element_type
== error_mark_node
)
1251 return error_mark_node
;
1253 /* See if we already have an identically qualified type. Tests
1254 should be equivalent to those in check_qualified_type. */
1255 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1256 if (TREE_TYPE (t
) == element_type
1257 && TYPE_NAME (t
) == TYPE_NAME (type
)
1258 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1259 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1260 TYPE_ATTRIBUTES (type
)))
1265 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1267 /* Keep the typedef name. */
1268 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1270 t
= build_variant_type_copy (t
);
1271 TYPE_NAME (t
) = TYPE_NAME (type
);
1272 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1273 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1277 /* Even if we already had this variant, we update
1278 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1279 they changed since the variant was originally created.
1281 This seems hokey; if there is some way to use a previous
1282 variant *without* coming through here,
1283 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1284 TYPE_NEEDS_CONSTRUCTING (t
)
1285 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1286 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1287 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1290 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1292 tree t
= PACK_EXPANSION_PATTERN (type
);
1294 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1295 return make_pack_expansion (t
, complain
);
1298 /* A reference or method type shall not be cv-qualified.
1299 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1300 (in CD1) we always ignore extra cv-quals on functions. */
1301 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1302 && (TYPE_REF_P (type
)
1303 || TREE_CODE (type
) == FUNCTION_TYPE
1304 || TREE_CODE (type
) == METHOD_TYPE
))
1306 if (TYPE_REF_P (type
))
1307 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1308 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1311 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1312 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1313 type_quals
|= type_memfn_quals (type
);
1315 /* A restrict-qualified type must be a pointer (or reference)
1316 to object or incomplete type. */
1317 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1318 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1319 && TREE_CODE (type
) != TYPENAME_TYPE
1320 && !INDIRECT_TYPE_P (type
))
1322 bad_quals
|= TYPE_QUAL_RESTRICT
;
1323 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1326 if (bad_quals
== TYPE_UNQUALIFIED
1327 || (complain
& tf_ignore_bad_quals
))
1329 else if (!(complain
& tf_error
))
1330 return error_mark_node
;
1333 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1334 error ("%qV qualifiers cannot be applied to %qT",
1338 /* Retrieve (or create) the appropriately qualified variant. */
1339 result
= build_qualified_type (type
, type_quals
);
1344 /* Return TYPE with const and volatile removed. */
1347 cv_unqualified (tree type
)
1351 if (type
== error_mark_node
)
1354 quals
= cp_type_quals (type
);
1355 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1356 return cp_build_qualified_type (type
, quals
);
1359 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1360 from ATTRIBS that affect type identity, and no others. If any are not
1361 applied, set *remove_attributes to true. */
1364 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1366 tree first_ident
= NULL_TREE
;
1367 tree new_attribs
= NULL_TREE
;
1368 tree
*p
= &new_attribs
;
1370 if (OVERLOAD_TYPE_P (result
))
1372 /* On classes and enums all attributes are ingrained. */
1373 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1377 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1379 const attribute_spec
*as
1380 = lookup_attribute_spec (get_attribute_name (a
));
1381 if (as
&& as
->affects_type_identity
)
1385 else if (first_ident
== error_mark_node
)
1387 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1388 p
= &TREE_CHAIN (*p
);
1391 else if (first_ident
)
1393 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1395 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1396 p
= &TREE_CHAIN (*p
);
1398 first_ident
= error_mark_node
;
1401 if (first_ident
!= error_mark_node
)
1402 new_attribs
= first_ident
;
1404 if (first_ident
== attribs
)
1405 /* All attributes affected type identity. */;
1407 *remove_attributes
= true;
1409 return cp_build_type_attribute_variant (result
, new_attribs
);
1412 /* Builds a qualified variant of T that is not a typedef variant.
1413 E.g. consider the following declarations:
1414 typedef const int ConstInt;
1415 typedef ConstInt* PtrConstInt;
1416 If T is PtrConstInt, this function returns a type representing
1418 In other words, if T is a typedef, the function returns the underlying type.
1419 The cv-qualification and attributes of the type returned match the
1421 They will always be compatible types.
1422 The returned type is built so that all of its subtypes
1423 recursively have their typedefs stripped as well.
1425 This is different from just returning TYPE_CANONICAL (T)
1426 Because of several reasons:
1427 * If T is a type that needs structural equality
1428 its TYPE_CANONICAL (T) will be NULL.
1429 * TYPE_CANONICAL (T) desn't carry type attributes
1430 and loses template parameter names.
1432 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1433 affect type identity, and set the referent to true if any were
1437 strip_typedefs (tree t
, bool *remove_attributes
)
1439 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1441 if (!t
|| t
== error_mark_node
)
1444 if (TREE_CODE (t
) == TREE_LIST
)
1446 bool changed
= false;
1447 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1449 for (; t
; t
= TREE_CHAIN (t
))
1451 gcc_assert (!TREE_PURPOSE (t
));
1452 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1453 if (elt
!= TREE_VALUE (t
))
1455 vec_safe_push (vec
, elt
);
1458 r
= build_tree_list_vec (vec
);
1459 release_tree_vector (vec
);
1463 gcc_assert (TYPE_P (t
));
1465 if (t
== TYPE_CANONICAL (t
))
1468 if (dependent_alias_template_spec_p (t
))
1469 /* DR 1558: However, if the template-id is dependent, subsequent
1470 template argument substitution still applies to the template-id. */
1473 switch (TREE_CODE (t
))
1476 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1477 result
= build_pointer_type (type
);
1479 case REFERENCE_TYPE
:
1480 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1481 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1484 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1485 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1486 result
= build_offset_type (t0
, type
);
1489 if (TYPE_PTRMEMFUNC_P (t
))
1491 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1492 result
= build_ptrmemfunc_type (t0
);
1496 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1497 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1498 result
= build_cplus_array_type (type
, t0
);
1503 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1506 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1507 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1508 can't expect that re-hashing a function type will find a previous
1509 equivalent type, so try to reuse the input type if nothing has
1510 changed. If the type is itself a variant, that will change. */
1511 bool is_variant
= typedef_variant_p (t
);
1512 if (remove_attributes
1513 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1516 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1517 tree canon_spec
= (flag_noexcept_type
1518 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1520 changed
= (type
!= TREE_TYPE (t
) || is_variant
1521 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1523 for (arg_node
= TYPE_ARG_TYPES (t
);
1525 arg_node
= TREE_CHAIN (arg_node
))
1527 if (arg_node
== void_list_node
)
1529 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1531 gcc_assert (arg_type
);
1532 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1538 for (arg_node2
= TYPE_ARG_TYPES (t
);
1539 arg_node2
!= arg_node
;
1540 arg_node2
= TREE_CHAIN (arg_node2
))
1542 = tree_cons (TREE_PURPOSE (arg_node2
),
1543 TREE_VALUE (arg_node2
), arg_types
);
1547 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1554 arg_types
= nreverse (arg_types
);
1556 /* A list of parameters not ending with an ellipsis
1557 must end with void_list_node. */
1559 arg_types
= chainon (arg_types
, void_list_node
);
1561 if (TREE_CODE (t
) == METHOD_TYPE
)
1563 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1564 gcc_assert (class_type
);
1566 build_method_type_directly (class_type
, type
,
1567 TREE_CHAIN (arg_types
));
1571 result
= build_function_type (type
, arg_types
);
1572 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1575 result
= build_cp_fntype_variant (result
,
1576 type_memfn_rqual (t
), canon_spec
,
1577 TYPE_HAS_LATE_RETURN_TYPE (t
));
1582 bool changed
= false;
1583 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1584 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1585 && TREE_OPERAND (fullname
, 1))
1587 tree args
= TREE_OPERAND (fullname
, 1);
1588 tree new_args
= copy_node (args
);
1589 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1591 tree arg
= TREE_VEC_ELT (args
, i
);
1594 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1596 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1597 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1598 if (strip_arg
!= arg
)
1603 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1604 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1606 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1610 ggc_free (new_args
);
1612 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1613 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1615 tree name
= fullname
;
1616 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1617 name
= TREE_OPERAND (fullname
, 0);
1618 /* Use build_typename_type rather than make_typename_type because we
1619 don't want to resolve it here, just strip typedefs. */
1620 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1624 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1626 if (result
== DECLTYPE_TYPE_EXPR (t
))
1629 result
= (finish_decltype_type
1631 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1634 case UNDERLYING_TYPE
:
1635 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1636 result
= finish_underlying_type (type
);
1644 if (typedef_variant_p (t
))
1646 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1647 strip typedefs with attributes. */
1648 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1649 result
= strip_typedefs (result
);
1652 result
= TYPE_MAIN_VARIANT (t
);
1654 gcc_assert (!typedef_variant_p (result
));
1656 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1657 /* If RESULT is complete and T isn't, it's likely the case that T
1658 is a variant of RESULT which hasn't been updated yet. Skip the
1659 attribute handling. */;
1662 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1663 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1665 gcc_assert (TYPE_USER_ALIGN (t
));
1666 if (remove_attributes
)
1667 *remove_attributes
= true;
1670 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1671 result
= build_variant_type_copy (result
);
1673 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1674 TYPE_USER_ALIGN (result
) = true;
1678 if (TYPE_ATTRIBUTES (t
))
1680 if (remove_attributes
)
1681 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1684 result
= cp_build_type_attribute_variant (result
,
1685 TYPE_ATTRIBUTES (t
));
1689 return cp_build_qualified_type (result
, cp_type_quals (t
));
1692 /* Like strip_typedefs above, but works on expressions, so that in
1694 template<class T> struct A
1700 sizeof(TT) is replaced by sizeof(T). */
1703 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1707 enum tree_code code
;
1709 if (t
== NULL_TREE
|| t
== error_mark_node
)
1712 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1715 /* Some expressions have type operands, so let's handle types here rather
1716 than check TYPE_P in multiple places below. */
1718 return strip_typedefs (t
, remove_attributes
);
1720 code
= TREE_CODE (t
);
1723 case IDENTIFIER_NODE
:
1724 case TEMPLATE_PARM_INDEX
:
1727 case ARGUMENT_PACK_SELECT
:
1732 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1733 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1734 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1735 && type2
== TRAIT_EXPR_TYPE2 (t
))
1738 TRAIT_EXPR_TYPE1 (r
) = type1
;
1739 TRAIT_EXPR_TYPE2 (r
) = type2
;
1745 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1746 bool changed
= false;
1748 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1750 tree val
= strip_typedefs_expr (TREE_VALUE (it
), remove_attributes
);
1751 vec_safe_push (vec
, val
);
1752 if (val
!= TREE_VALUE (it
))
1754 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1759 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1760 r
= tree_cons (NULL_TREE
, it
, r
);
1764 release_tree_vector (vec
);
1770 bool changed
= false;
1771 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1772 n
= TREE_VEC_LENGTH (t
);
1773 vec_safe_reserve (vec
, n
);
1774 for (i
= 0; i
< n
; ++i
)
1776 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1778 vec
->quick_push (op
);
1779 if (op
!= TREE_VEC_ELT (t
, i
))
1785 for (i
= 0; i
< n
; ++i
)
1786 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1787 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1788 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1792 release_tree_vector (vec
);
1798 bool changed
= false;
1799 vec
<constructor_elt
, va_gc
> *vec
1800 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1801 n
= CONSTRUCTOR_NELTS (t
);
1802 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1803 for (i
= 0; i
< n
; ++i
)
1805 constructor_elt
*e
= &(*vec
)[i
];
1806 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1813 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1816 if (!changed
&& type
== TREE_TYPE (t
))
1824 TREE_TYPE (r
) = type
;
1825 CONSTRUCTOR_ELTS (r
) = vec
;
1831 error ("lambda-expression in a constant expression");
1832 return error_mark_node
;
1834 case STATEMENT_LIST
:
1835 error ("statement-expression in a constant expression");
1836 return error_mark_node
;
1842 gcc_assert (EXPR_P (t
));
1844 n
= cp_tree_operand_length (t
);
1845 ops
= XALLOCAVEC (tree
, n
);
1846 type
= TREE_TYPE (t
);
1851 case IMPLICIT_CONV_EXPR
:
1852 case DYNAMIC_CAST_EXPR
:
1853 case STATIC_CAST_EXPR
:
1854 case CONST_CAST_EXPR
:
1855 case REINTERPRET_CAST_EXPR
:
1858 type
= strip_typedefs (type
, remove_attributes
);
1862 for (i
= 0; i
< n
; ++i
)
1863 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1867 /* If nothing changed, return t. */
1868 for (i
= 0; i
< n
; ++i
)
1869 if (ops
[i
] != TREE_OPERAND (t
, i
))
1871 if (i
== n
&& type
== TREE_TYPE (t
))
1875 TREE_TYPE (r
) = type
;
1876 for (i
= 0; i
< n
; ++i
)
1877 TREE_OPERAND (r
, i
) = ops
[i
];
1881 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1882 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1883 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1884 VIRT indicates whether TYPE is inherited virtually or not.
1885 IGO_PREV points at the previous binfo of the inheritance graph
1886 order chain. The newly copied binfo's TREE_CHAIN forms this
1889 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1890 correct order. That is in the order the bases themselves should be
1893 The BINFO_INHERITANCE of a virtual base class points to the binfo
1894 of the most derived type. ??? We could probably change this so that
1895 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1896 remove a field. They currently can only differ for primary virtual
1900 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1906 /* See if we've already made this virtual base. */
1907 new_binfo
= binfo_for_vbase (type
, t
);
1912 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1913 BINFO_TYPE (new_binfo
) = type
;
1915 /* Chain it into the inheritance graph. */
1916 TREE_CHAIN (*igo_prev
) = new_binfo
;
1917 *igo_prev
= new_binfo
;
1919 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1924 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1926 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1927 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1929 /* We do not need to copy the accesses, as they are read only. */
1930 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1932 /* Recursively copy base binfos of BINFO. */
1933 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1935 tree new_base_binfo
;
1936 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1938 BINFO_VIRTUAL_P (base_binfo
));
1940 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1941 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1942 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1946 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1950 /* Push it onto the list after any virtual bases it contains
1951 will have been pushed. */
1952 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1953 BINFO_VIRTUAL_P (new_binfo
) = 1;
1954 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1960 /* Hashing of lists so that we don't make duplicates.
1961 The entry point is `list_hash_canon'. */
1970 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1972 typedef list_proxy
*compare_type
;
1974 static hashval_t
hash (tree
);
1975 static bool equal (tree
, list_proxy
*);
1978 /* Now here is the hash table. When recording a list, it is added
1979 to the slot whose index is the hash code mod the table size.
1980 Note that the hash table is used for several kinds of lists.
1981 While all these live in the same table, they are completely independent,
1982 and the hash code is computed differently for each of these. */
1984 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1986 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1987 for a node we are thinking about adding). */
1990 list_hasher::equal (tree t
, list_proxy
*proxy
)
1992 return (TREE_VALUE (t
) == proxy
->value
1993 && TREE_PURPOSE (t
) == proxy
->purpose
1994 && TREE_CHAIN (t
) == proxy
->chain
);
1997 /* Compute a hash code for a list (chain of TREE_LIST nodes
1998 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1999 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2002 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2004 hashval_t hashcode
= 0;
2007 hashcode
+= TREE_HASH (chain
);
2010 hashcode
+= TREE_HASH (value
);
2014 hashcode
+= TREE_HASH (purpose
);
2020 /* Hash an already existing TREE_LIST. */
2023 list_hasher::hash (tree t
)
2025 return list_hash_pieces (TREE_PURPOSE (t
),
2030 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2031 object for an identical list if one already exists. Otherwise, build a
2032 new one, and record it as the canonical object. */
2035 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2039 struct list_proxy proxy
;
2041 /* Hash the list node. */
2042 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2043 /* Create a proxy for the TREE_LIST we would like to create. We
2044 don't actually create it so as to avoid creating garbage. */
2045 proxy
.purpose
= purpose
;
2046 proxy
.value
= value
;
2047 proxy
.chain
= chain
;
2048 /* See if it is already in the table. */
2049 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2050 /* If not, create a new node. */
2052 *slot
= tree_cons (purpose
, value
, chain
);
2053 return (tree
) *slot
;
2056 /* Constructor for hashed lists. */
2059 hash_tree_chain (tree value
, tree chain
)
2061 return hash_tree_cons (NULL_TREE
, value
, chain
);
2065 debug_binfo (tree elem
)
2070 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2072 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2073 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2074 debug_tree (BINFO_TYPE (elem
));
2075 if (BINFO_VTABLE (elem
))
2076 fprintf (stderr
, "vtable decl \"%s\"\n",
2077 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2079 fprintf (stderr
, "no vtable decl yet\n");
2080 fprintf (stderr
, "virtuals:\n");
2081 virtuals
= BINFO_VIRTUALS (elem
);
2086 tree fndecl
= TREE_VALUE (virtuals
);
2087 fprintf (stderr
, "%s [%ld =? %ld]\n",
2088 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2089 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2091 virtuals
= TREE_CHAIN (virtuals
);
2095 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2096 the type of the result expression, if known, or NULL_TREE if the
2097 resulting expression is type-dependent. If TEMPLATE_P is true,
2098 NAME is known to be a template because the user explicitly used the
2099 "template" keyword after the "::".
2101 All SCOPE_REFs should be built by use of this function. */
2104 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2107 if (type
== error_mark_node
2108 || scope
== error_mark_node
2109 || name
== error_mark_node
)
2110 return error_mark_node
;
2111 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2112 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2113 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2114 PTRMEM_OK_P (t
) = true;
2116 t
= convert_from_reference (t
);
2120 /* Like check_qualified_type, but also check ref-qualifier, exception
2121 specification, and whether the return type was specified after the
2125 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2126 cp_ref_qualifier rqual
, tree raises
, bool late
)
2128 return (TYPE_QUALS (cand
) == type_quals
2129 && check_base_type (cand
, base
)
2130 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2132 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2133 && type_memfn_rqual (cand
) == rqual
);
2136 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2139 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2141 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2142 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2143 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2146 /* Make a raw overload node containing FN. */
2149 ovl_make (tree fn
, tree next
)
2151 tree result
= make_node (OVERLOAD
);
2153 if (TREE_CODE (fn
) == OVERLOAD
)
2154 OVL_NESTED_P (result
) = true;
2156 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2157 ? unknown_type_node
: TREE_TYPE (fn
));
2158 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2159 OVL_DEDUP_P (result
) = true;
2160 OVL_FUNCTION (result
) = fn
;
2161 OVL_CHAIN (result
) = next
;
2168 tree result
= make_node (OVERLOAD
);
2170 gcc_checking_assert (!OVL_NESTED_P (ovl
) && OVL_USED_P (ovl
));
2171 TREE_TYPE (result
) = TREE_TYPE (ovl
);
2172 OVL_FUNCTION (result
) = OVL_FUNCTION (ovl
);
2173 OVL_CHAIN (result
) = OVL_CHAIN (ovl
);
2174 OVL_DEDUP_P (result
) = OVL_DEDUP_P (ovl
);
2175 OVL_LOOKUP_P (result
) = OVL_LOOKUP_P (ovl
);
2176 OVL_HIDDEN_P (result
) = OVL_HIDDEN_P (ovl
);
2177 OVL_USING_P (result
) = OVL_USING_P (ovl
);
2182 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2183 true, if FN is via a using declaration. We also pay attention to
2184 DECL_HIDDEN. We keep the hidden decls first, but remaining ones
2188 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2190 tree result
= maybe_ovl
;
2191 tree insert_after
= NULL_TREE
;
2194 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2195 && OVL_HIDDEN_P (maybe_ovl
);
2196 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2198 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
)
2199 && !OVL_USED_P (maybe_ovl
));
2200 insert_after
= maybe_ovl
;
2203 bool hidden_p
= DECL_HIDDEN_P (fn
);
2204 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2206 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2208 OVL_HIDDEN_P (maybe_ovl
) = true;
2210 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2217 OVL_CHAIN (insert_after
) = maybe_ovl
;
2218 TREE_TYPE (insert_after
) = unknown_type_node
;
2226 /* Skip any hidden names at the beginning of OVL. */
2229 ovl_skip_hidden (tree ovl
)
2232 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2233 ovl
= OVL_CHAIN (ovl
))
2234 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2236 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2238 /* Any hidden functions should have been wrapped in an
2239 overload, but injected friend classes will not. */
2240 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2247 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2250 ovl_iterator::reveal_node (tree overload
, tree node
)
2252 /* We cannot have returned NODE as part of a lookup overload, so it
2254 gcc_checking_assert (!OVL_USED_P (node
));
2256 OVL_HIDDEN_P (node
) = false;
2257 if (tree chain
= OVL_CHAIN (node
))
2258 if (TREE_CODE (chain
) == OVERLOAD
2259 && (OVL_USING_P (chain
) || OVL_HIDDEN_P (chain
)))
2261 /* The node needs moving, and the simplest way is to remove it
2263 overload
= remove_node (overload
, node
);
2264 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2269 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2270 OVL_USED_P we must copy OVL nodes, because those are immutable.
2271 The removed node is unaltered and may continue to be iterated
2272 from (i.e. it is safe to remove a node from an overload one is
2273 currently iterating over). */
2276 ovl_iterator::remove_node (tree overload
, tree node
)
2278 bool copying
= false; /* Checking use only. */
2280 tree
*slot
= &overload
;
2281 while (*slot
!= node
)
2284 gcc_checking_assert (!OVL_LOOKUP_P (probe
)
2285 && (!copying
|| OVL_USED_P (probe
)));
2286 if (OVL_USED_P (probe
))
2289 probe
= ovl_copy (probe
);
2293 slot
= &OVL_CHAIN (probe
);
2296 /* Stitch out NODE. We don't have to worry about now making a
2297 singleton overload (and consequently maybe setting its type),
2298 because all uses of this function will be followed by inserting a
2299 new node that must follow the place we've cut this out from. */
2300 if (TREE_CODE (node
) != OVERLOAD
)
2301 /* Cloned inherited ctors don't mark themselves as via_using. */
2304 *slot
= OVL_CHAIN (node
);
2309 /* Mark or unmark a lookup set. */
2312 lookup_mark (tree ovl
, bool val
)
2314 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2316 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2317 LOOKUP_SEEN_P (*iter
) = val
;
2321 /* Add a set of new FNS into a lookup. */
2324 lookup_add (tree fns
, tree lookup
)
2326 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2328 lookup
= ovl_make (fns
, lookup
);
2329 OVL_LOOKUP_P (lookup
) = true;
2337 /* FNS is a new overload set, add them to LOOKUP, if they are not
2338 already present there. */
2341 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2344 for (tree next
, probe
= fns
; probe
; probe
= next
)
2349 if (TREE_CODE (probe
) == OVERLOAD
)
2351 fn
= OVL_FUNCTION (probe
);
2352 next
= OVL_CHAIN (probe
);
2355 if (!LOOKUP_SEEN_P (fn
))
2356 LOOKUP_SEEN_P (fn
) = true;
2359 /* This function was already seen. Insert all the
2360 predecessors onto the lookup. */
2361 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2363 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2364 /* Propagate OVL_USING, but OVL_HIDDEN &
2365 OVL_DEDUP_P don't matter. */
2366 if (OVL_USING_P (fns
))
2367 OVL_USING_P (lookup
) = true;
2370 /* And now skip this function. */
2376 /* We ended in a set of new functions. Add them all in one go. */
2377 lookup
= lookup_add (fns
, lookup
);
2382 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2389 ovl
&& TREE_CODE (ovl
) == OVERLOAD
2390 && !OVL_USED_P (ovl
);
2391 ovl
= OVL_CHAIN (ovl
))
2393 gcc_checking_assert (!OVL_LOOKUP_P (ovl
));
2394 OVL_USED_P (ovl
) = true;
2398 /* Preserve the contents of a lookup so that it is available for a
2399 later instantiation. */
2402 lookup_keep (tree lookup
)
2405 lookup
&& TREE_CODE (lookup
) == OVERLOAD
2406 && OVL_LOOKUP_P (lookup
) && !OVL_USED_P (lookup
);
2407 lookup
= OVL_CHAIN (lookup
))
2409 OVL_USED_P (lookup
) = true;
2410 ovl_used (OVL_FUNCTION (lookup
));
2416 /* Returns nonzero if X is an expression for a (possibly overloaded)
2417 function. If "f" is a function or function template, "f", "c->f",
2418 "c.f", "C::f", and "f<int>" will all be considered possibly
2419 overloaded functions. Returns 2 if the function is actually
2420 overloaded, i.e., if it is impossible to know the type of the
2421 function without performing overload resolution. */
2424 is_overloaded_fn (tree x
)
2426 /* A baselink is also considered an overloaded function. */
2427 if (TREE_CODE (x
) == OFFSET_REF
2428 || TREE_CODE (x
) == COMPONENT_REF
)
2429 x
= TREE_OPERAND (x
, 1);
2430 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2431 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2432 x
= TREE_OPERAND (x
, 0);
2434 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2435 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2438 return (TREE_CODE (x
) == FUNCTION_DECL
2439 || TREE_CODE (x
) == OVERLOAD
);
2442 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2443 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2447 dependent_name (tree x
)
2449 if (identifier_p (x
))
2451 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2452 x
= TREE_OPERAND (x
, 0);
2453 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2454 return OVL_NAME (x
);
2458 /* Returns true iff X is an expression for an overloaded function
2459 whose type cannot be known without performing overload
2463 really_overloaded_fn (tree x
)
2465 return is_overloaded_fn (x
) == 2;
2468 /* Get the overload set FROM refers to. Returns NULL if it's not an
2472 maybe_get_fns (tree from
)
2474 /* A baselink is also considered an overloaded function. */
2475 if (TREE_CODE (from
) == OFFSET_REF
2476 || TREE_CODE (from
) == COMPONENT_REF
)
2477 from
= TREE_OPERAND (from
, 1);
2478 if (BASELINK_P (from
))
2479 from
= BASELINK_FUNCTIONS (from
);
2480 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2481 from
= TREE_OPERAND (from
, 0);
2483 if (TREE_CODE (from
) == OVERLOAD
2484 || TREE_CODE (from
) == FUNCTION_DECL
)
2490 /* FROM refers to an overload set. Return that set (or die). */
2495 tree res
= maybe_get_fns (from
);
2501 /* Return the first function of the overload set FROM refers to. */
2504 get_first_fn (tree from
)
2506 return OVL_FIRST (get_fns (from
));
2509 /* Return the scope where the overloaded functions OVL were found. */
2512 ovl_scope (tree ovl
)
2514 if (TREE_CODE (ovl
) == OFFSET_REF
2515 || TREE_CODE (ovl
) == COMPONENT_REF
)
2516 ovl
= TREE_OPERAND (ovl
, 1);
2517 if (TREE_CODE (ovl
) == BASELINK
)
2518 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2519 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2520 ovl
= TREE_OPERAND (ovl
, 0);
2521 /* Skip using-declarations. */
2522 lkp_iterator
iter (ovl
);
2525 while (iter
.using_p () && ++iter
);
2527 return CP_DECL_CONTEXT (ovl
);
2530 #define PRINT_RING_SIZE 4
2533 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2535 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2536 static char *print_ring
[PRINT_RING_SIZE
];
2537 static bool trans_ring
[PRINT_RING_SIZE
];
2538 static int ring_counter
;
2541 /* Only cache functions. */
2543 || TREE_CODE (decl
) != FUNCTION_DECL
2544 || DECL_LANG_SPECIFIC (decl
) == 0)
2545 return lang_decl_name (decl
, v
, translate
);
2547 /* See if this print name is lying around. */
2548 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2549 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2550 /* yes, so return it. */
2551 return print_ring
[i
];
2553 if (++ring_counter
== PRINT_RING_SIZE
)
2556 if (current_function_decl
!= NULL_TREE
)
2558 /* There may be both translated and untranslated versions of the
2560 for (i
= 0; i
< 2; i
++)
2562 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2564 if (ring_counter
== PRINT_RING_SIZE
)
2567 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2570 free (print_ring
[ring_counter
]);
2572 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2573 uid_ring
[ring_counter
] = DECL_UID (decl
);
2574 trans_ring
[ring_counter
] = translate
;
2575 return print_ring
[ring_counter
];
2579 cxx_printable_name (tree decl
, int v
)
2581 return cxx_printable_name_internal (decl
, v
, false);
2585 cxx_printable_name_translate (tree decl
, int v
)
2587 return cxx_printable_name_internal (decl
, v
, true);
2590 /* Return the canonical version of exception-specification RAISES for a C++17
2591 function type, for use in type comparison and building TYPE_CANONICAL. */
2594 canonical_eh_spec (tree raises
)
2596 if (raises
== NULL_TREE
)
2598 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2599 || uses_template_parms (raises
)
2600 || uses_template_parms (TREE_PURPOSE (raises
)))
2601 /* Keep a dependent or deferred exception specification. */
2603 else if (nothrow_spec_p (raises
))
2604 /* throw() -> noexcept. */
2605 return noexcept_true_spec
;
2607 /* For C++17 type matching, anything else -> nothing. */
2612 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2613 tree raises
, bool late
)
2615 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2617 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2620 tree v
= TYPE_MAIN_VARIANT (type
);
2621 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2622 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2625 /* Need to build a new variant. */
2626 v
= build_variant_type_copy (type
);
2627 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2628 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2631 case REF_QUAL_RVALUE
:
2632 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2633 FUNCTION_REF_QUALIFIED (v
) = 1;
2635 case REF_QUAL_LVALUE
:
2636 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2637 FUNCTION_REF_QUALIFIED (v
) = 1;
2640 FUNCTION_REF_QUALIFIED (v
) = 0;
2644 /* Canonicalize the exception specification. */
2645 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2647 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2648 /* Propagate structural equality. */
2649 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2650 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2651 /* Build the underlying canonical type, since it is different
2653 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2656 /* T is its own canonical type. */
2657 TYPE_CANONICAL (v
) = v
;
2662 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2663 listed in RAISES. */
2666 build_exception_variant (tree type
, tree raises
)
2668 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2669 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2670 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2673 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2674 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2678 bind_template_template_parm (tree t
, tree newargs
)
2680 tree decl
= TYPE_NAME (t
);
2683 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2684 decl
= build_decl (input_location
,
2685 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2687 /* These nodes have to be created to reflect new TYPE_DECL and template
2689 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2690 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2691 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2692 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2694 TREE_TYPE (decl
) = t2
;
2695 TYPE_NAME (t2
) = decl
;
2696 TYPE_STUB_DECL (t2
) = decl
;
2698 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2703 /* Called from count_trees via walk_tree. */
2706 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2716 /* Debugging function for measuring the rough complexity of a tree
2720 count_trees (tree t
)
2723 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2727 /* Called from verify_stmt_tree via walk_tree. */
2730 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2733 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2734 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2737 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2740 /* If this statement is already present in the hash table, then
2741 there is a circularity in the statement tree. */
2742 gcc_assert (!statements
->find (t
));
2744 slot
= statements
->find_slot (t
, INSERT
);
2750 /* Debugging function to check that the statement T has not been
2751 corrupted. For now, this function simply checks that T contains no
2755 verify_stmt_tree (tree t
)
2757 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2758 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2761 /* Check if the type T depends on a type with no linkage and if so, return
2762 it. If RELAXED_P then do not consider a class type declared within
2763 a vague-linkage function to have no linkage. */
2766 no_linkage_check (tree t
, bool relaxed_p
)
2770 /* There's no point in checking linkage on template functions; we
2771 can't know their complete types. */
2772 if (processing_template_decl
)
2775 switch (TREE_CODE (t
))
2778 if (TYPE_PTRMEMFUNC_P (t
))
2780 /* Lambda types that don't have mangling scope have no linkage. We
2781 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2782 when we get here from pushtag none of the lambda information is
2783 set up yet, so we want to assume that the lambda has linkage and
2784 fix it up later if not. */
2785 if (CLASSTYPE_LAMBDA_EXPR (t
)
2786 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2787 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2791 if (!CLASS_TYPE_P (t
))
2795 /* Only treat unnamed types as having no linkage if they're at
2796 namespace scope. This is core issue 966. */
2797 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2800 for (r
= CP_TYPE_CONTEXT (t
); ; )
2802 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2803 have linkage, or we might just be in an anonymous namespace.
2804 If we're in a TREE_PUBLIC class, we have linkage. */
2805 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2806 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2807 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2809 if (!relaxed_p
|| !vague_linkage_p (r
))
2812 r
= CP_DECL_CONTEXT (r
);
2822 case REFERENCE_TYPE
:
2824 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2828 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2832 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2837 tree parm
= TYPE_ARG_TYPES (t
);
2838 if (TREE_CODE (t
) == METHOD_TYPE
)
2839 /* The 'this' pointer isn't interesting; a method has the same
2840 linkage (or lack thereof) as its enclosing class. */
2841 parm
= TREE_CHAIN (parm
);
2843 parm
&& parm
!= void_list_node
;
2844 parm
= TREE_CHAIN (parm
))
2846 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2850 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2858 extern int depth_reached
;
2861 cxx_print_statistics (void)
2863 print_template_statistics ();
2864 if (GATHER_STATISTICS
)
2865 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2869 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2870 (which is an ARRAY_TYPE). This counts only elements of the top
2874 array_type_nelts_top (tree type
)
2876 return fold_build2_loc (input_location
,
2877 PLUS_EXPR
, sizetype
,
2878 array_type_nelts (type
),
2882 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2883 (which is an ARRAY_TYPE). This one is a recursive count of all
2884 ARRAY_TYPEs that are clumped together. */
2887 array_type_nelts_total (tree type
)
2889 tree sz
= array_type_nelts_top (type
);
2890 type
= TREE_TYPE (type
);
2891 while (TREE_CODE (type
) == ARRAY_TYPE
)
2893 tree n
= array_type_nelts_top (type
);
2894 sz
= fold_build2_loc (input_location
,
2895 MULT_EXPR
, sizetype
, sz
, n
);
2896 type
= TREE_TYPE (type
);
2903 splay_tree target_remap
;
2904 bool clear_location
;
2907 /* Called from break_out_target_exprs via mapcar. */
2910 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2912 bot_data
&data
= *(bot_data
*)data_
;
2913 splay_tree target_remap
= data
.target_remap
;
2916 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2918 /* There can't be any TARGET_EXPRs or their slot variables below this
2919 point. But we must make a copy, in case subsequent processing
2920 alters any part of it. For example, during gimplification a cast
2921 of the form (T) &X::f (where "f" is a member function) will lead
2922 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2924 *tp
= unshare_expr (t
);
2927 if (TREE_CODE (t
) == TARGET_EXPR
)
2931 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2933 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2934 tf_warning_or_error
);
2935 if (u
== error_mark_node
)
2937 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2938 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2941 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2942 tf_warning_or_error
);
2944 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2945 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2946 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2948 /* Map the old variable to the new one. */
2949 splay_tree_insert (target_remap
,
2950 (splay_tree_key
) TREE_OPERAND (t
, 0),
2951 (splay_tree_value
) TREE_OPERAND (u
, 0));
2953 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2954 data
.clear_location
);
2955 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2956 return error_mark_node
;
2958 /* Replace the old expression with the new version. */
2960 /* We don't have to go below this point; the recursive call to
2961 break_out_target_exprs will have handled anything below this
2966 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2969 splay_tree_node n
= splay_tree_lookup (target_remap
,
2970 (splay_tree_key
) t
);
2973 *tp
= (tree
)n
->value
;
2978 copy_tree_r (tp
, walk_subtrees
, NULL
);
2979 splay_tree_insert (target_remap
,
2981 (splay_tree_value
)*tp
);
2982 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2983 splay_tree_insert (target_remap
,
2984 (splay_tree_key
)*tp
,
2985 (splay_tree_value
)*tp
);
2990 /* Make a copy of this node. */
2991 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2992 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2993 if (!processing_template_decl
)
2994 set_flags_from_callee (*tp
);
2995 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2996 SET_EXPR_LOCATION (*tp
, input_location
);
3000 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3001 DATA is really a splay-tree mapping old variables to new
3005 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3007 bot_data
&data
= *(bot_data
*)data_
;
3008 splay_tree target_remap
= data
.target_remap
;
3012 splay_tree_node n
= splay_tree_lookup (target_remap
,
3013 (splay_tree_key
) *t
);
3015 *t
= (tree
) n
->value
;
3017 else if (TREE_CODE (*t
) == PARM_DECL
3018 && DECL_NAME (*t
) == this_identifier
3019 && !DECL_CONTEXT (*t
))
3021 /* In an NSDMI we need to replace the 'this' parameter we used for
3022 parsing with the real one for this function. */
3023 *t
= current_class_ptr
;
3025 else if (TREE_CODE (*t
) == CONVERT_EXPR
3026 && CONVERT_EXPR_VBASE_PATH (*t
))
3028 /* In an NSDMI build_base_path defers building conversions to virtual
3029 bases, and we handle it here. */
3030 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3031 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3033 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3034 if (BINFO_TYPE (binfo
) == basetype
)
3036 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3037 tf_warning_or_error
);
3043 /* When we parse a default argument expression, we may create
3044 temporary variables via TARGET_EXPRs. When we actually use the
3045 default-argument expression, we make a copy of the expression
3046 and replace the temporaries with appropriate local versions.
3048 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3052 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3054 static int target_remap_count
;
3055 static splay_tree target_remap
;
3057 if (!target_remap_count
++)
3058 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3059 /*splay_tree_delete_key_fn=*/NULL
,
3060 /*splay_tree_delete_value_fn=*/NULL
);
3061 bot_data data
= { target_remap
, clear_location
};
3062 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3063 t
= error_mark_node
;
3064 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3066 if (!--target_remap_count
)
3068 splay_tree_delete (target_remap
);
3069 target_remap
= NULL
;
3075 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3076 which we expect to have type TYPE. */
3079 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3081 if (index
== NULL_TREE
)
3082 /* Can't refer to a particular member of a vector. */
3084 else if (TREE_CODE (index
) == INTEGER_CST
)
3085 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3087 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3088 /*reference*/false, tf_none
);
3091 tree objtype
= TREE_TYPE (obj
);
3092 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3094 /* When the destination object refers to a flexible array member
3095 verify that it matches the type of the source object except
3096 for its domain and qualifiers. */
3097 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3098 TYPE_MAIN_VARIANT (objtype
),
3099 COMPARE_REDECLARATION
));
3102 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3108 struct replace_placeholders_t
3110 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3111 tree exp
; /* The outermost exp. */
3112 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3113 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3116 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3117 build up subexpressions as we go deeper. */
3120 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3122 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3125 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3127 *walk_subtrees
= false;
3131 switch (TREE_CODE (*t
))
3133 case PLACEHOLDER_EXPR
:
3136 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3138 x
= TREE_OPERAND (x
, 0))
3139 gcc_assert (handled_component_p (x
));
3140 *t
= unshare_expr (x
);
3141 *walk_subtrees
= false;
3148 constructor_elt
*ce
;
3149 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3150 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3151 other than the d->exp one, those have PLACEHOLDER_EXPRs
3152 related to another object. */
3153 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3155 || d
->pset
->add (*t
))
3157 *walk_subtrees
= false;
3160 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3162 tree
*valp
= &ce
->value
;
3163 tree type
= TREE_TYPE (*valp
);
3166 if (TREE_CODE (*valp
) == CONSTRUCTOR
3167 && AGGREGATE_TYPE_P (type
))
3169 /* If we're looking at the initializer for OBJ, then build
3170 a sub-object reference. If we're looking at an
3171 initializer for another object, just pass OBJ down. */
3172 if (same_type_ignoring_top_level_qualifiers_p
3173 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3174 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3175 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3176 valp
= &TARGET_EXPR_INITIAL (*valp
);
3179 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3182 *walk_subtrees
= false;
3187 if (d
->pset
->add (*t
))
3188 *walk_subtrees
= false;
3195 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3196 a PLACEHOLDER_EXPR has been encountered. */
3199 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3201 /* This is only relevant for C++14. */
3202 if (cxx_dialect
< cxx14
)
3205 /* If the object isn't a (member of a) class, do nothing. */
3207 while (TREE_CODE (op0
) == COMPONENT_REF
)
3208 op0
= TREE_OPERAND (op0
, 0);
3209 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3213 if (TREE_CODE (exp
) == TARGET_EXPR
)
3214 tp
= &TARGET_EXPR_INITIAL (exp
);
3215 hash_set
<tree
> pset
;
3216 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3217 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3219 *seen_p
= data
.seen
;
3223 /* Callback function for find_placeholders. */
3226 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3228 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3230 *walk_subtrees
= false;
3234 switch (TREE_CODE (*t
))
3236 case PLACEHOLDER_EXPR
:
3240 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3241 *walk_subtrees
= false;
3251 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3252 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3255 find_placeholders (tree exp
)
3257 /* This is only relevant for C++14. */
3258 if (cxx_dialect
< cxx14
)
3261 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3264 /* Similar to `build_nt', but for template definitions of dependent
3268 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3275 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3279 t
= make_node (code
);
3280 SET_EXPR_LOCATION (t
, loc
);
3281 length
= TREE_CODE_LENGTH (code
);
3283 for (i
= 0; i
< length
; i
++)
3284 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3290 /* Similar to `build', but for template definitions. */
3293 build_min (enum tree_code code
, tree tt
, ...)
3300 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3304 t
= make_node (code
);
3305 length
= TREE_CODE_LENGTH (code
);
3308 for (i
= 0; i
< length
; i
++)
3310 tree x
= va_arg (p
, tree
);
3311 TREE_OPERAND (t
, i
) = x
;
3312 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3313 TREE_SIDE_EFFECTS (t
) = 1;
3321 /* Similar to `build', but for template definitions of non-dependent
3322 expressions. NON_DEP is the non-dependent expression that has been
3326 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3333 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3335 va_start (p
, non_dep
);
3337 if (REFERENCE_REF_P (non_dep
))
3338 non_dep
= TREE_OPERAND (non_dep
, 0);
3340 t
= make_node (code
);
3341 length
= TREE_CODE_LENGTH (code
);
3342 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3343 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3345 for (i
= 0; i
< length
; i
++)
3346 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3348 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3349 /* This should not be considered a COMPOUND_EXPR, because it
3350 resolves to an overload. */
3351 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3354 return convert_from_reference (t
);
3357 /* Similar to build_min_nt, but call expressions */
3360 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3365 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3366 CALL_EXPR_FN (ret
) = fn
;
3367 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3368 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3369 CALL_EXPR_ARG (ret
, ix
) = t
;
3374 /* Similar to `build_min_nt_call_vec', but for template definitions of
3375 non-dependent expressions. NON_DEP is the non-dependent expression
3376 that has been built. */
3379 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3381 tree t
= build_min_nt_call_vec (fn
, argvec
);
3382 if (REFERENCE_REF_P (non_dep
))
3383 non_dep
= TREE_OPERAND (non_dep
, 0);
3384 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3385 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3386 return convert_from_reference (t
);
3389 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3390 a call to an operator overload. OP is the operator that has been
3391 overloaded. NON_DEP is the non-dependent expression that's been built,
3392 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3393 the overload that NON_DEP is calling. */
3396 build_min_non_dep_op_overload (enum tree_code op
,
3401 int nargs
, expected_nargs
;
3403 vec
<tree
, va_gc
> *args
;
3405 non_dep
= extract_call_expr (non_dep
);
3407 nargs
= call_expr_nargs (non_dep
);
3409 expected_nargs
= cp_tree_code_length (op
);
3410 if ((op
== POSTINCREMENT_EXPR
3411 || op
== POSTDECREMENT_EXPR
)
3412 /* With -fpermissive non_dep could be operator++(). */
3413 && (!flag_permissive
|| nargs
!= expected_nargs
))
3414 expected_nargs
+= 1;
3415 gcc_assert (nargs
== expected_nargs
);
3417 args
= make_tree_vector ();
3418 va_start (p
, overload
);
3420 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3423 for (int i
= 0; i
< nargs
; i
++)
3425 tree arg
= va_arg (p
, tree
);
3426 vec_safe_push (args
, arg
);
3429 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3431 tree object
= va_arg (p
, tree
);
3432 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3433 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3434 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3435 object
, method
, NULL_TREE
);
3436 for (int i
= 1; i
< nargs
; i
++)
3438 tree arg
= va_arg (p
, tree
);
3439 vec_safe_push (args
, arg
);
3446 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3447 release_tree_vector (args
);
3449 tree call_expr
= extract_call_expr (call
);
3450 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3451 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3452 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3453 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3458 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3461 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3463 unsigned len
= vec_safe_length (old_vec
);
3464 gcc_assert (idx
<= len
);
3466 vec
<tree
, va_gc
> *new_vec
= NULL
;
3467 vec_alloc (new_vec
, len
+ 1);
3470 for (i
= 0; i
< len
; ++i
)
3473 new_vec
->quick_push (elt
);
3474 new_vec
->quick_push ((*old_vec
)[i
]);
3477 new_vec
->quick_push (elt
);
3483 get_type_decl (tree t
)
3485 if (TREE_CODE (t
) == TYPE_DECL
)
3488 return TYPE_STUB_DECL (t
);
3489 gcc_assert (t
== error_mark_node
);
3493 /* Returns the namespace that contains DECL, whether directly or
3497 decl_namespace_context (tree decl
)
3501 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3503 else if (TYPE_P (decl
))
3504 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3506 decl
= CP_DECL_CONTEXT (decl
);
3510 /* Returns true if decl is within an anonymous namespace, however deeply
3511 nested, or false otherwise. */
3514 decl_anon_ns_mem_p (const_tree decl
)
3516 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3518 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3520 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3522 decl
= CP_DECL_CONTEXT (decl
);
3524 return !TREE_PUBLIC (decl
);
3527 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3528 CALL_EXPRS. Return whether they are equivalent. */
3531 called_fns_equal (tree t1
, tree t2
)
3533 /* Core 1321: dependent names are equivalent even if the overload sets
3534 are different. But do compare explicit template arguments. */
3535 tree name1
= dependent_name (t1
);
3536 tree name2
= dependent_name (t2
);
3539 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3544 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3545 targs1
= TREE_OPERAND (t1
, 1);
3546 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3547 targs2
= TREE_OPERAND (t2
, 1);
3548 return cp_tree_equal (targs1
, targs2
);
3551 return cp_tree_equal (t1
, t2
);
3554 /* Return truthvalue of whether T1 is the same tree structure as T2.
3555 Return 1 if they are the same. Return 0 if they are different. */
3558 cp_tree_equal (tree t1
, tree t2
)
3560 enum tree_code code1
, code2
;
3567 code1
= TREE_CODE (t1
);
3568 code2
= TREE_CODE (t2
);
3573 if (CONSTANT_CLASS_P (t1
)
3574 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3580 /* There's only a single VOID_CST node, so we should never reach
3585 return tree_int_cst_equal (t1
, t2
);
3588 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3591 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3592 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3593 TREE_STRING_LENGTH (t1
));
3596 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3597 TREE_FIXED_CST (t2
));
3600 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3601 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3604 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3607 /* We need to do this when determining whether or not two
3608 non-type pointer to member function template arguments
3610 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3611 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3616 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3618 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3619 if (!cp_tree_equal (field
, elt2
->index
)
3620 || !cp_tree_equal (value
, elt2
->value
))
3627 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3629 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3631 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3634 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3639 call_expr_arg_iterator iter1
, iter2
;
3640 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3642 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3643 arg2
= first_call_expr_arg (t2
, &iter2
);
3645 arg1
= next_call_expr_arg (&iter1
),
3646 arg2
= next_call_expr_arg (&iter2
))
3647 if (!cp_tree_equal (arg1
, arg2
))
3656 tree o1
= TREE_OPERAND (t1
, 0);
3657 tree o2
= TREE_OPERAND (t2
, 0);
3659 /* Special case: if either target is an unallocated VAR_DECL,
3660 it means that it's going to be unified with whatever the
3661 TARGET_EXPR is really supposed to initialize, so treat it
3662 as being equivalent to anything. */
3663 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3664 && !DECL_RTL_SET_P (o1
))
3666 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3667 && !DECL_RTL_SET_P (o2
))
3669 else if (!cp_tree_equal (o1
, o2
))
3672 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3676 /* For comparing uses of parameters in late-specified return types
3677 with an out-of-class definition of the function, but can also come
3678 up for expressions that involve 'this' in a member function
3681 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3682 /* When comparing hash table entries, only an exact match is
3683 good enough; we don't want to replace 'this' with the
3684 version from another function. But be more flexible
3685 with local parameters in a requires-expression. */
3688 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3690 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3692 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3694 if (DECL_ARTIFICIAL (t1
)
3695 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3696 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3706 case IDENTIFIER_NODE
:
3711 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3712 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3713 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3714 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3715 BASELINK_FUNCTIONS (t2
)));
3717 case TEMPLATE_PARM_INDEX
:
3718 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3719 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3720 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3721 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3722 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3723 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3725 case TEMPLATE_ID_EXPR
:
3726 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3727 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3729 case CONSTRAINT_INFO
:
3730 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3731 CI_ASSOCIATED_CONSTRAINTS (t2
));
3734 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3735 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3736 CHECK_CONSTR_ARGS (t2
)));
3741 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3743 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3744 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3745 TREE_VEC_ELT (t2
, ix
)))
3753 tree o1
= TREE_OPERAND (t1
, 0);
3754 tree o2
= TREE_OPERAND (t2
, 0);
3756 if (code1
== SIZEOF_EXPR
)
3758 if (SIZEOF_EXPR_TYPE_P (t1
))
3759 o1
= TREE_TYPE (o1
);
3760 if (SIZEOF_EXPR_TYPE_P (t2
))
3761 o2
= TREE_TYPE (o2
);
3763 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3766 return same_type_p (o1
, o2
);
3768 return cp_tree_equal (o1
, o2
);
3773 tree t1_op1
, t2_op1
;
3775 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3778 t1_op1
= TREE_OPERAND (t1
, 1);
3779 t2_op1
= TREE_OPERAND (t2
, 1);
3780 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3783 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3787 /* Two pointer-to-members are the same if they point to the same
3788 field or function in the same class. */
3789 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3792 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3796 /* Two overloads. Must be exactly the same set of decls. */
3797 lkp_iterator
first (t1
);
3798 lkp_iterator
second (t2
);
3800 for (; first
&& second
; ++first
, ++second
)
3801 if (*first
!= *second
)
3803 return !(first
|| second
);
3807 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3809 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3810 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3813 case STATIC_CAST_EXPR
:
3814 case REINTERPRET_CAST_EXPR
:
3815 case CONST_CAST_EXPR
:
3816 case DYNAMIC_CAST_EXPR
:
3817 case IMPLICIT_CONV_EXPR
:
3820 case NON_LVALUE_EXPR
:
3821 case VIEW_CONVERT_EXPR
:
3822 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3824 /* Now compare operands as usual. */
3827 case DEFERRED_NOEXCEPT
:
3828 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3829 DEFERRED_NOEXCEPT_PATTERN (t2
))
3830 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3831 DEFERRED_NOEXCEPT_ARGS (t2
)));
3835 if (DECL_DEPENDENT_P (t1
) && DECL_DEPENDENT_P (t2
))
3836 return (cp_tree_equal (USING_DECL_SCOPE (t1
),
3837 USING_DECL_SCOPE (t2
))
3838 && cp_tree_equal (DECL_NAME (t1
),
3846 switch (TREE_CODE_CLASS (code1
))
3850 case tcc_comparison
:
3851 case tcc_expression
:
3858 n
= cp_tree_operand_length (t1
);
3859 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3860 && n
!= TREE_OPERAND_LENGTH (t2
))
3863 for (i
= 0; i
< n
; ++i
)
3864 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3871 return same_type_p (t1
, t2
);
3875 /* We can get here with --disable-checking. */
3879 /* The type of ARG when used as an lvalue. */
3882 lvalue_type (tree arg
)
3884 tree type
= TREE_TYPE (arg
);
3888 /* The type of ARG for printing error messages; denote lvalues with
3892 error_type (tree arg
)
3894 tree type
= TREE_TYPE (arg
);
3896 if (TREE_CODE (type
) == ARRAY_TYPE
)
3898 else if (TREE_CODE (type
) == ERROR_MARK
)
3900 else if (lvalue_p (arg
))
3901 type
= build_reference_type (lvalue_type (arg
));
3902 else if (MAYBE_CLASS_TYPE_P (type
))
3903 type
= lvalue_type (arg
);
3908 /* Does FUNCTION use a variable-length argument list? */
3911 varargs_function_p (const_tree function
)
3913 return stdarg_p (TREE_TYPE (function
));
3916 /* Returns 1 if decl is a member of a class. */
3919 member_p (const_tree decl
)
3921 const_tree
const ctx
= DECL_CONTEXT (decl
);
3922 return (ctx
&& TYPE_P (ctx
));
3925 /* Create a placeholder for member access where we don't actually have an
3926 object that the access is against. */
3929 build_dummy_object (tree type
)
3931 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3932 return cp_build_fold_indirect_ref (decl
);
3935 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3936 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3937 binfo path from current_class_type to TYPE, or 0. */
3940 maybe_dummy_object (tree type
, tree
* binfop
)
3944 tree current
= current_nonlambda_class_type ();
3947 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3948 tf_warning_or_error
)))
3952 /* Reference from a nested class member function. */
3954 binfo
= TYPE_BINFO (type
);
3960 if (current_class_ref
3961 /* current_class_ref might not correspond to current_class_type if
3962 we're in tsubst_default_argument or a lambda-declarator; in either
3963 case, we want to use current_class_ref if it matches CONTEXT. */
3964 && (same_type_ignoring_top_level_qualifiers_p
3965 (TREE_TYPE (current_class_ref
), context
)))
3966 decl
= current_class_ref
;
3968 decl
= build_dummy_object (context
);
3973 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3976 is_dummy_object (const_tree ob
)
3978 if (INDIRECT_REF_P (ob
))
3979 ob
= TREE_OPERAND (ob
, 0);
3980 return (TREE_CODE (ob
) == CONVERT_EXPR
3981 && TREE_OPERAND (ob
, 0) == void_node
);
3984 /* Returns 1 iff type T is something we want to treat as a scalar type for
3985 the purpose of deciding whether it is trivial/POD/standard-layout. */
3988 scalarish_type_p (const_tree t
)
3990 if (t
== error_mark_node
)
3993 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3996 /* Returns true iff T requires non-trivial default initialization. */
3999 type_has_nontrivial_default_init (const_tree t
)
4001 t
= strip_array_types (CONST_CAST_TREE (t
));
4003 if (CLASS_TYPE_P (t
))
4004 return TYPE_HAS_COMPLEX_DFLT (t
);
4009 /* Track classes with only deleted copy/move constructors so that we can warn
4010 if they are used in call/return by value. */
4012 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4014 remember_deleted_copy (const_tree t
)
4016 if (!deleted_copy_types
)
4017 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4018 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4021 maybe_warn_parm_abi (tree t
, location_t loc
)
4023 if (!deleted_copy_types
4024 || !deleted_copy_types
->contains (t
))
4027 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4028 && classtype_has_non_deleted_move_ctor (t
))
4031 auto_diagnostic_group d
;
4032 if (flag_abi_version
> 12)
4033 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=13 (GCC 8.2) fixes the "
4034 "calling convention for %qT, which was accidentally "
4035 "changed in 8.1", t
);
4037 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=12 (GCC 8.1) accident"
4038 "ally changes the calling convention for %qT", t
);
4040 inform (location_of (t
), " declared here");
4044 auto_diagnostic_group d
;
4045 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4046 "-fabi-version=13 (GCC 8.2)", t
))
4047 inform (location_of (t
), " because all of its copy and move "
4048 "constructors are deleted");
4051 /* Returns true iff copying an object of type T (including via move
4052 constructor) is non-trivial. That is, T has no non-trivial copy
4053 constructors and no non-trivial move constructors, and not all copy/move
4054 constructors are deleted. This function implements the ABI notion of
4055 non-trivial copy, which has diverged from the one in the standard. */
4058 type_has_nontrivial_copy_init (const_tree type
)
4060 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4062 if (CLASS_TYPE_P (t
))
4064 gcc_assert (COMPLETE_TYPE_P (t
));
4066 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4067 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4071 if (cxx_dialect
< cxx11
)
4072 /* No deleted functions before C++11. */
4075 /* Before ABI v12 we did a bitwise copy of types with only deleted
4076 copy/move constructors. */
4077 if (!abi_version_at_least (12)
4078 && !(warn_abi
&& abi_version_crosses (12)))
4081 bool saw_copy
= false;
4082 bool saw_non_deleted
= false;
4083 bool saw_non_deleted_move
= false;
4085 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4086 saw_copy
= saw_non_deleted
= true;
4087 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4090 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4091 /* [class.copy]/8 If the class definition declares a move
4092 constructor or move assignment operator, the implicitly declared
4093 copy constructor is defined as deleted.... */;
4095 /* Any other reason the implicitly-declared function would be
4096 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4098 saw_non_deleted
= true;
4101 if (!saw_non_deleted
)
4102 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4108 if (!DECL_DELETED_FN (fn
))
4110 /* Not deleted, therefore trivial. */
4111 saw_non_deleted
= true;
4115 else if (move_fn_p (fn
))
4116 if (!DECL_DELETED_FN (fn
))
4117 saw_non_deleted_move
= true;
4120 gcc_assert (saw_copy
);
4122 /* ABI v12 buggily ignored move constructors. */
4123 bool v11nontriv
= false;
4124 bool v12nontriv
= !saw_non_deleted
;
4125 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4126 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4127 : flag_abi_version
== 12 ? v12nontriv
4129 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4130 : warn_abi_version
== 12 ? v12nontriv
4132 if (nontriv
!= warn_nontriv
)
4133 remember_deleted_copy (t
);
4141 /* Returns 1 iff type T is a trivially copyable type, as defined in
4142 [basic.types] and [class]. */
4145 trivially_copyable_p (const_tree t
)
4147 t
= strip_array_types (CONST_CAST_TREE (t
));
4149 if (CLASS_TYPE_P (t
))
4150 return ((!TYPE_HAS_COPY_CTOR (t
)
4151 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4152 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4153 && (!TYPE_HAS_COPY_ASSIGN (t
)
4154 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4155 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4156 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4158 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4161 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4165 trivial_type_p (const_tree t
)
4167 t
= strip_array_types (CONST_CAST_TREE (t
));
4169 if (CLASS_TYPE_P (t
))
4170 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4171 && trivially_copyable_p (t
));
4173 return scalarish_type_p (t
);
4176 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4179 pod_type_p (const_tree t
)
4181 /* This CONST_CAST is okay because strip_array_types returns its
4182 argument unmodified and we assign it to a const_tree. */
4183 t
= strip_array_types (CONST_CAST_TREE(t
));
4185 if (!CLASS_TYPE_P (t
))
4186 return scalarish_type_p (t
);
4187 else if (cxx_dialect
> cxx98
)
4188 /* [class]/10: A POD struct is a class that is both a trivial class and a
4189 standard-layout class, and has no non-static data members of type
4190 non-POD struct, non-POD union (or array of such types).
4192 We don't need to check individual members because if a member is
4193 non-std-layout or non-trivial, the class will be too. */
4194 return (std_layout_type_p (t
) && trivial_type_p (t
));
4196 /* The C++98 definition of POD is different. */
4197 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4200 /* Returns true iff T is POD for the purpose of layout, as defined in the
4204 layout_pod_type_p (const_tree t
)
4206 t
= strip_array_types (CONST_CAST_TREE (t
));
4208 if (CLASS_TYPE_P (t
))
4209 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4211 return scalarish_type_p (t
);
4214 /* Returns true iff T is a standard-layout type, as defined in
4218 std_layout_type_p (const_tree t
)
4220 t
= strip_array_types (CONST_CAST_TREE (t
));
4222 if (CLASS_TYPE_P (t
))
4223 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4225 return scalarish_type_p (t
);
4228 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4230 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4231 as defined in [meta.unary.prop]. */
4234 type_has_unique_obj_representations (const_tree t
)
4238 t
= strip_array_types (CONST_CAST_TREE (t
));
4240 if (!trivially_copyable_p (t
))
4243 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4244 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4246 switch (TREE_CODE (t
))
4250 case REFERENCE_TYPE
:
4251 /* If some backend has any paddings in these types, we should add
4252 a target hook for this and handle it there. */
4256 /* For bool values other than 0 and 1 should only appear with
4257 undefined behavior. */
4261 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4264 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4265 when storing long double values, so for that we have to return false.
4266 Other kinds of floating point values are questionable due to +.0/-.0
4267 and NaNs, let's play safe for now. */
4270 case FIXED_POINT_TYPE
:
4278 return type_has_unique_obj_representations (TREE_TYPE (t
));
4281 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4282 if (CLASS_TYPE_P (t
))
4284 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4285 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4293 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4294 if (TREE_CODE (field
) == FIELD_DECL
)
4297 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4298 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4304 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4306 if (CLASS_TYPE_P (t
))
4308 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4309 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4324 /* Helper function for type_has_unique_obj_representations. */
4327 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4329 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4330 if (TREE_CODE (field
) != FIELD_DECL
)
4332 /* For bases, can't use type_has_unique_obj_representations here, as in
4333 struct S { int i : 24; S (); };
4334 struct T : public S { int j : 8; T (); };
4335 S doesn't have unique obj representations, but T does. */
4336 else if (DECL_FIELD_IS_BASE (field
))
4338 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4342 else if (DECL_C_BIT_FIELD (field
))
4344 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4345 if (!type_has_unique_obj_representations (btype
))
4348 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4352 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4353 if (TREE_CODE (field
) == FIELD_DECL
)
4355 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4356 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4357 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4360 if (DECL_SIZE (field
))
4362 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4366 if (cur
!= wi::to_offset (sz
))
4372 /* Nonzero iff type T is a class template implicit specialization. */
4375 class_tmpl_impl_spec_p (const_tree t
)
4377 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4380 /* Returns 1 iff zero initialization of type T means actually storing
4384 zero_init_p (const_tree t
)
4386 /* This CONST_CAST is okay because strip_array_types returns its
4387 argument unmodified and we assign it to a const_tree. */
4388 t
= strip_array_types (CONST_CAST_TREE(t
));
4390 if (t
== error_mark_node
)
4393 /* NULL pointers to data members are initialized with -1. */
4394 if (TYPE_PTRDATAMEM_P (t
))
4397 /* Classes that contain types that can't be zero-initialized, cannot
4398 be zero-initialized themselves. */
4399 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4405 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4406 warn_unused_result attribute. */
4409 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4410 int /*flags*/, bool *no_add_attrs
)
4412 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4414 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4415 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4416 "return type", name
, *node
);
4418 else if (OVERLOAD_TYPE_P (*node
))
4422 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4423 "functions or to class or enumeration types", name
);
4424 *no_add_attrs
= true;
4429 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4430 struct attribute_spec.handler. */
4432 handle_no_unique_addr_attribute (tree
* node
,
4438 if (TREE_CODE (*node
) != FIELD_DECL
)
4440 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4441 "non-static data members", name
);
4442 *no_add_attrs
= true;
4444 else if (DECL_C_BIT_FIELD (*node
))
4446 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4447 "a bit-field", name
);
4448 *no_add_attrs
= true;
4454 /* Table of valid C++ attributes. */
4455 const struct attribute_spec cxx_attribute_table
[] =
4457 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4458 affects_type_identity, handler, exclude } */
4459 { "init_priority", 1, 1, true, false, false, false,
4460 handle_init_priority_attribute
, NULL
},
4461 { "abi_tag", 1, -1, false, false, false, true,
4462 handle_abi_tag_attribute
, NULL
},
4463 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4466 /* Table of C++ standard attributes. */
4467 const struct attribute_spec std_attribute_table
[] =
4469 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4470 affects_type_identity, handler, exclude } */
4471 { "maybe_unused", 0, 0, false, false, false, false,
4472 handle_unused_attribute
, NULL
},
4473 { "nodiscard", 0, 0, false, false, false, false,
4474 handle_nodiscard_attribute
, NULL
},
4475 { "no_unique_address", 0, 0, true, false, false, false,
4476 handle_no_unique_addr_attribute
, NULL
},
4477 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4480 /* Handle an "init_priority" attribute; arguments as in
4481 struct attribute_spec.handler. */
4483 handle_init_priority_attribute (tree
* node
,
4489 tree initp_expr
= TREE_VALUE (args
);
4491 tree type
= TREE_TYPE (decl
);
4494 STRIP_NOPS (initp_expr
);
4495 initp_expr
= default_conversion (initp_expr
);
4497 initp_expr
= maybe_constant_value (initp_expr
);
4499 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4501 error ("requested init_priority is not an integer constant");
4502 cxx_constant_value (initp_expr
);
4503 *no_add_attrs
= true;
4507 pri
= TREE_INT_CST_LOW (initp_expr
);
4509 type
= strip_array_types (type
);
4511 if (decl
== NULL_TREE
4513 || !TREE_STATIC (decl
)
4514 || DECL_EXTERNAL (decl
)
4515 || (TREE_CODE (type
) != RECORD_TYPE
4516 && TREE_CODE (type
) != UNION_TYPE
)
4517 /* Static objects in functions are initialized the
4518 first time control passes through that
4519 function. This is not precise enough to pin down an
4520 init_priority value, so don't allow it. */
4521 || current_function_decl
)
4523 error ("can only use %qE attribute on file-scope definitions "
4524 "of objects of class type", name
);
4525 *no_add_attrs
= true;
4529 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4531 error ("requested init_priority is out of range");
4532 *no_add_attrs
= true;
4536 /* Check for init_priorities that are reserved for
4537 language and runtime support implementations.*/
4538 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4541 (0, "requested init_priority is reserved for internal use");
4544 if (SUPPORTS_INIT_PRIORITY
)
4546 SET_DECL_INIT_PRIORITY (decl
, pri
);
4547 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4552 error ("%qE attribute is not supported on this platform", name
);
4553 *no_add_attrs
= true;
4558 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4559 and the new one has the tags in NEW_. Give an error if there are tags
4560 in NEW_ that weren't in OLD. */
4563 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4565 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4566 old
= TREE_VALUE (old
);
4567 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4568 new_
= TREE_VALUE (new_
);
4570 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4572 tree str
= TREE_VALUE (t
);
4573 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4575 tree ostr
= TREE_VALUE (in
);
4576 if (cp_tree_equal (str
, ostr
))
4579 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4585 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4591 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4592 ill-formed, give an error and return false; otherwise, return true. */
4595 check_abi_tag_args (tree args
, tree name
)
4599 error ("the %qE attribute requires arguments", name
);
4602 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4604 tree elt
= TREE_VALUE (arg
);
4605 if (TREE_CODE (elt
) != STRING_CST
4606 || (!same_type_ignoring_top_level_qualifiers_p
4607 (strip_array_types (TREE_TYPE (elt
)),
4610 error ("arguments to the %qE attribute must be narrow string "
4614 const char *begin
= TREE_STRING_POINTER (elt
);
4615 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4616 for (const char *p
= begin
; p
!= end
; ++p
)
4621 if (!ISALPHA (c
) && c
!= '_')
4623 error ("arguments to the %qE attribute must contain valid "
4624 "identifiers", name
);
4625 inform (input_location
, "%<%c%> is not a valid first "
4626 "character for an identifier", c
);
4630 else if (p
== end
- 1)
4631 gcc_assert (c
== 0);
4634 if (!ISALNUM (c
) && c
!= '_')
4636 error ("arguments to the %qE attribute must contain valid "
4637 "identifiers", name
);
4638 inform (input_location
, "%<%c%> is not a valid character "
4639 "in an identifier", c
);
4648 /* Handle an "abi_tag" attribute; arguments as in
4649 struct attribute_spec.handler. */
4652 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4653 int flags
, bool* no_add_attrs
)
4655 if (!check_abi_tag_args (args
, name
))
4660 if (!OVERLOAD_TYPE_P (*node
))
4662 error ("%qE attribute applied to non-class, non-enum type %qT",
4666 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4668 error ("%qE attribute applied to %qT after its definition",
4672 else if (CLASS_TYPE_P (*node
)
4673 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4675 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4676 "template instantiation %qT", name
, *node
);
4679 else if (CLASS_TYPE_P (*node
)
4680 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4682 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4683 "template specialization %qT", name
, *node
);
4687 tree attributes
= TYPE_ATTRIBUTES (*node
);
4688 tree decl
= TYPE_NAME (*node
);
4690 /* Make sure all declarations have the same abi tags. */
4691 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4693 if (!check_abi_tag_redeclaration (decl
,
4694 lookup_attribute ("abi_tag",
4702 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4704 error ("%qE attribute applied to non-function, non-variable %qD",
4708 else if (DECL_LANGUAGE (*node
) == lang_c
)
4710 error ("%qE attribute applied to extern \"C\" declaration %qD",
4719 *no_add_attrs
= true;
4723 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4724 thing pointed to by the constant. */
4727 make_ptrmem_cst (tree type
, tree member
)
4729 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4730 TREE_TYPE (ptrmem_cst
) = type
;
4731 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4735 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4736 return an existing type if an appropriate type already exists. */
4739 cp_build_type_attribute_variant (tree type
, tree attributes
)
4743 new_type
= build_type_attribute_variant (type
, attributes
);
4744 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4745 || TREE_CODE (new_type
) == METHOD_TYPE
)
4746 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4748 /* Making a new main variant of a class type is broken. */
4749 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4754 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4755 Called only after doing all language independent checks. */
4758 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4760 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4761 || TREE_CODE (typea
) == METHOD_TYPE
);
4763 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4765 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4767 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4768 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4771 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4772 C++, these are the exception-specifier and ref-qualifier. */
4775 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4777 tree type
= CONST_CAST_TREE (typea
);
4778 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4779 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4780 TYPE_RAISES_EXCEPTIONS (typeb
),
4781 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4785 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4786 traversal. Called from walk_tree. */
4789 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4790 void *data
, hash_set
<tree
> *pset
)
4792 enum tree_code code
= TREE_CODE (*tp
);
4795 #define WALK_SUBTREE(NODE) \
4798 result = cp_walk_tree (&(NODE), func, data, pset); \
4799 if (result) goto out; \
4803 /* Not one of the easy cases. We must explicitly go through the
4809 case TEMPLATE_TEMPLATE_PARM
:
4810 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4811 case UNBOUND_CLASS_TEMPLATE
:
4812 case TEMPLATE_PARM_INDEX
:
4813 case TEMPLATE_TYPE_PARM
:
4816 case UNDERLYING_TYPE
:
4817 /* None of these have subtrees other than those already walked
4819 *walk_subtrees_p
= 0;
4823 if (BASELINK_QUALIFIED_P (*tp
))
4824 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4825 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4826 *walk_subtrees_p
= 0;
4830 WALK_SUBTREE (TREE_TYPE (*tp
));
4831 *walk_subtrees_p
= 0;
4835 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4839 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4840 WALK_SUBTREE (OVL_CHAIN (*tp
));
4841 *walk_subtrees_p
= 0;
4845 WALK_SUBTREE (DECL_NAME (*tp
));
4846 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4847 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4848 *walk_subtrees_p
= 0;
4852 if (TYPE_PTRMEMFUNC_P (*tp
))
4853 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4856 case TYPE_ARGUMENT_PACK
:
4857 case NONTYPE_ARGUMENT_PACK
:
4859 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4860 int i
, len
= TREE_VEC_LENGTH (args
);
4861 for (i
= 0; i
< len
; i
++)
4862 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4866 case TYPE_PACK_EXPANSION
:
4867 WALK_SUBTREE (TREE_TYPE (*tp
));
4868 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4869 *walk_subtrees_p
= 0;
4872 case EXPR_PACK_EXPANSION
:
4873 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4874 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4875 *walk_subtrees_p
= 0;
4879 case REINTERPRET_CAST_EXPR
:
4880 case STATIC_CAST_EXPR
:
4881 case CONST_CAST_EXPR
:
4882 case DYNAMIC_CAST_EXPR
:
4883 case IMPLICIT_CONV_EXPR
:
4884 if (TREE_TYPE (*tp
))
4885 WALK_SUBTREE (TREE_TYPE (*tp
));
4889 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4890 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4892 *walk_subtrees_p
= 0;
4896 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4897 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4898 *walk_subtrees_p
= 0;
4902 ++cp_unevaluated_operand
;
4903 /* We can't use WALK_SUBTREE here because of the goto. */
4904 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4905 --cp_unevaluated_operand
;
4906 *walk_subtrees_p
= 0;
4912 ++cp_unevaluated_operand
;
4913 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4914 --cp_unevaluated_operand
;
4915 *walk_subtrees_p
= 0;
4919 // Only recurse through the nested expression. Do not
4920 // walk the parameter list. Doing so causes false
4921 // positives in the pack expansion checker since the
4922 // requires parameters are introduced as pack expansions.
4923 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4924 *walk_subtrees_p
= 0;
4928 /* User variables should be mentioned in BIND_EXPR_VARS
4929 and their initializers and sizes walked when walking
4930 the containing BIND_EXPR. Compiler temporaries are
4931 handled here. And also normal variables in templates,
4932 since do_poplevel doesn't build a BIND_EXPR then. */
4933 if (VAR_P (TREE_OPERAND (*tp
, 0))
4934 && (processing_template_decl
4935 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4936 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4938 tree decl
= TREE_OPERAND (*tp
, 0);
4939 WALK_SUBTREE (DECL_INITIAL (decl
));
4940 WALK_SUBTREE (DECL_SIZE (decl
));
4941 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4949 /* We didn't find what we were looking for. */
4956 /* Like save_expr, but for C++. */
4959 cp_save_expr (tree expr
)
4961 /* There is no reason to create a SAVE_EXPR within a template; if
4962 needed, we can create the SAVE_EXPR when instantiating the
4963 template. Furthermore, the middle-end cannot handle C++-specific
4965 if (processing_template_decl
)
4968 /* TARGET_EXPRs are only expanded once. */
4969 if (TREE_CODE (expr
) == TARGET_EXPR
)
4972 return save_expr (expr
);
4975 /* Initialize tree.c. */
4980 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4981 register_scoped_attributes (std_attribute_table
, NULL
);
4984 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4985 is. Note that sfk_none is zero, so this function can be used as a
4986 predicate to test whether or not DECL is a special function. */
4988 special_function_kind
4989 special_function_p (const_tree decl
)
4991 /* Rather than doing all this stuff with magic names, we should
4992 probably have a field of type `special_function_kind' in
4993 DECL_LANG_SPECIFIC. */
4994 if (DECL_INHERITED_CTOR (decl
))
4995 return sfk_inheriting_constructor
;
4996 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4997 return sfk_copy_constructor
;
4998 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4999 return sfk_move_constructor
;
5000 if (DECL_CONSTRUCTOR_P (decl
))
5001 return sfk_constructor
;
5002 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5003 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5005 if (copy_fn_p (decl
))
5006 return sfk_copy_assignment
;
5007 if (move_fn_p (decl
))
5008 return sfk_move_assignment
;
5010 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5011 return sfk_destructor
;
5012 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5013 return sfk_complete_destructor
;
5014 if (DECL_BASE_DESTRUCTOR_P (decl
))
5015 return sfk_base_destructor
;
5016 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5017 return sfk_deleting_destructor
;
5018 if (DECL_CONV_FN_P (decl
))
5019 return sfk_conversion
;
5020 if (deduction_guide_p (decl
))
5021 return sfk_deduction_guide
;
5026 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5029 char_type_p (tree type
)
5031 return (same_type_p (type
, char_type_node
)
5032 || same_type_p (type
, unsigned_char_type_node
)
5033 || same_type_p (type
, signed_char_type_node
)
5034 || same_type_p (type
, char16_type_node
)
5035 || same_type_p (type
, char32_type_node
)
5036 || same_type_p (type
, wchar_type_node
));
5039 /* Returns the kind of linkage associated with the indicated DECL. Th
5040 value returned is as specified by the language standard; it is
5041 independent of implementation details regarding template
5042 instantiation, etc. For example, it is possible that a declaration
5043 to which this function assigns external linkage would not show up
5044 as a global symbol when you run `nm' on the resulting object file. */
5047 decl_linkage (tree decl
)
5049 /* This function doesn't attempt to calculate the linkage from first
5050 principles as given in [basic.link]. Instead, it makes use of
5051 the fact that we have already set TREE_PUBLIC appropriately, and
5052 then handles a few special cases. Ideally, we would calculate
5053 linkage first, and then transform that into a concrete
5056 /* Things that don't have names have no linkage. */
5057 if (!DECL_NAME (decl
))
5060 /* Fields have no linkage. */
5061 if (TREE_CODE (decl
) == FIELD_DECL
)
5064 /* Things that are TREE_PUBLIC have external linkage. */
5065 if (TREE_PUBLIC (decl
))
5068 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5069 check one of the "clones" for the real linkage. */
5070 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5071 && DECL_CHAIN (decl
)
5072 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5073 return decl_linkage (DECL_CHAIN (decl
));
5075 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5078 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5080 if (TREE_CODE (decl
) == CONST_DECL
)
5081 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5083 /* Things in local scope do not have linkage, if they don't have
5085 if (decl_function_context (decl
))
5088 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5089 are considered to have external linkage for language purposes, as do
5090 template instantiations on targets without weak symbols. DECLs really
5091 meant to have internal linkage have DECL_THIS_STATIC set. */
5092 if (TREE_CODE (decl
) == TYPE_DECL
)
5094 if (VAR_OR_FUNCTION_DECL_P (decl
))
5096 if (!DECL_THIS_STATIC (decl
))
5099 /* Static data members and static member functions from classes
5100 in anonymous namespace also don't have TREE_PUBLIC set. */
5101 if (DECL_CLASS_CONTEXT (decl
))
5105 /* Everything else has internal linkage. */
5109 /* Returns the storage duration of the object or reference associated with
5110 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5113 decl_storage_duration (tree decl
)
5115 if (TREE_CODE (decl
) == PARM_DECL
)
5117 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5119 gcc_assert (VAR_P (decl
));
5120 if (!TREE_STATIC (decl
)
5121 && !DECL_EXTERNAL (decl
))
5123 if (CP_DECL_THREAD_LOCAL_P (decl
))
5128 /* EXP is an expression that we want to pre-evaluate. Returns (in
5129 *INITP) an expression that will perform the pre-evaluation. The
5130 value returned by this function is a side-effect free expression
5131 equivalent to the pre-evaluated expression. Callers must ensure
5132 that *INITP is evaluated before EXP. */
5135 stabilize_expr (tree exp
, tree
* initp
)
5139 if (!TREE_SIDE_EFFECTS (exp
))
5140 init_expr
= NULL_TREE
;
5141 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5146 /* There are no expressions with REFERENCE_TYPE, but there can be call
5147 arguments with such a type; just treat it as a pointer. */
5148 else if (TYPE_REF_P (TREE_TYPE (exp
))
5149 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5150 || !glvalue_p (exp
))
5152 init_expr
= get_target_expr (exp
);
5153 exp
= TARGET_EXPR_SLOT (init_expr
);
5154 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5161 bool xval
= !lvalue_p (exp
);
5162 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5163 init_expr
= get_target_expr (exp
);
5164 exp
= TARGET_EXPR_SLOT (init_expr
);
5165 exp
= cp_build_fold_indirect_ref (exp
);
5171 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5175 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5176 similar expression ORIG. */
5179 add_stmt_to_compound (tree orig
, tree new_expr
)
5181 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5183 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5185 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5188 /* Like stabilize_expr, but for a call whose arguments we want to
5189 pre-evaluate. CALL is modified in place to use the pre-evaluated
5190 arguments, while, upon return, *INITP contains an expression to
5191 compute the arguments. */
5194 stabilize_call (tree call
, tree
*initp
)
5196 tree inits
= NULL_TREE
;
5198 int nargs
= call_expr_nargs (call
);
5200 if (call
== error_mark_node
|| processing_template_decl
)
5206 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5208 for (i
= 0; i
< nargs
; i
++)
5211 CALL_EXPR_ARG (call
, i
) =
5212 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5213 inits
= add_stmt_to_compound (inits
, init
);
5219 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5220 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5221 arguments, while, upon return, *INITP contains an expression to
5222 compute the arguments. */
5225 stabilize_aggr_init (tree call
, tree
*initp
)
5227 tree inits
= NULL_TREE
;
5229 int nargs
= aggr_init_expr_nargs (call
);
5231 if (call
== error_mark_node
)
5234 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5236 for (i
= 0; i
< nargs
; i
++)
5239 AGGR_INIT_EXPR_ARG (call
, i
) =
5240 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5241 inits
= add_stmt_to_compound (inits
, init
);
5247 /* Like stabilize_expr, but for an initialization.
5249 If the initialization is for an object of class type, this function
5250 takes care not to introduce additional temporaries.
5252 Returns TRUE iff the expression was successfully pre-evaluated,
5253 i.e., if INIT is now side-effect free, except for, possibly, a
5254 single call to a constructor. */
5257 stabilize_init (tree init
, tree
*initp
)
5263 if (t
== error_mark_node
|| processing_template_decl
)
5266 if (TREE_CODE (t
) == INIT_EXPR
)
5267 t
= TREE_OPERAND (t
, 1);
5268 if (TREE_CODE (t
) == TARGET_EXPR
)
5269 t
= TARGET_EXPR_INITIAL (t
);
5271 /* If the RHS can be stabilized without breaking copy elision, stabilize
5272 it. We specifically don't stabilize class prvalues here because that
5273 would mean an extra copy, but they might be stabilized below. */
5274 if (TREE_CODE (init
) == INIT_EXPR
5275 && TREE_CODE (t
) != CONSTRUCTOR
5276 && TREE_CODE (t
) != AGGR_INIT_EXPR
5277 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5280 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5284 if (TREE_CODE (t
) == COMPOUND_EXPR
5285 && TREE_CODE (init
) == INIT_EXPR
)
5287 tree last
= expr_last (t
);
5288 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5289 if (!TREE_SIDE_EFFECTS (last
))
5292 TREE_OPERAND (init
, 1) = last
;
5297 if (TREE_CODE (t
) == CONSTRUCTOR
)
5299 /* Aggregate initialization: stabilize each of the field
5302 constructor_elt
*ce
;
5304 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5305 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5307 tree type
= TREE_TYPE (ce
->value
);
5309 if (TYPE_REF_P (type
)
5310 || SCALAR_TYPE_P (type
))
5311 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5312 else if (!stabilize_init (ce
->value
, &subinit
))
5314 *initp
= add_stmt_to_compound (*initp
, subinit
);
5319 if (TREE_CODE (t
) == CALL_EXPR
)
5321 stabilize_call (t
, initp
);
5325 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5327 stabilize_aggr_init (t
, initp
);
5331 /* The initialization is being performed via a bitwise copy -- and
5332 the item copied may have side effects. */
5333 return !TREE_SIDE_EFFECTS (init
);
5336 /* Returns true if a cast to TYPE may appear in an integral constant
5340 cast_valid_in_integral_constant_expression_p (tree type
)
5342 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5343 || cxx_dialect
>= cxx11
5344 || dependent_type_p (type
)
5345 || type
== error_mark_node
);
5348 /* Return true if we need to fix linkage information of DECL. */
5351 cp_fix_function_decl_p (tree decl
)
5353 /* Skip if DECL is not externally visible. */
5354 if (!TREE_PUBLIC (decl
))
5357 /* We need to fix DECL if it a appears to be exported but with no
5358 function body. Thunks do not have CFGs and we may need to
5359 handle them specially later. */
5360 if (!gimple_has_body_p (decl
)
5361 && !DECL_THUNK_P (decl
)
5362 && !DECL_EXTERNAL (decl
))
5364 struct cgraph_node
*node
= cgraph_node::get (decl
);
5366 /* Don't fix same_body aliases. Although they don't have their own
5367 CFG, they share it with what they alias to. */
5368 if (!node
|| !node
->alias
5369 || !vec_safe_length (node
->ref_list
.references
))
5376 /* Clean the C++ specific parts of the tree T. */
5379 cp_free_lang_data (tree t
)
5381 if (TREE_CODE (t
) == METHOD_TYPE
5382 || TREE_CODE (t
) == FUNCTION_TYPE
)
5384 /* Default args are not interesting anymore. */
5385 tree argtypes
= TYPE_ARG_TYPES (t
);
5388 TREE_PURPOSE (argtypes
) = 0;
5389 argtypes
= TREE_CHAIN (argtypes
);
5392 else if (TREE_CODE (t
) == FUNCTION_DECL
5393 && cp_fix_function_decl_p (t
))
5395 /* If T is used in this translation unit at all, the definition
5396 must exist somewhere else since we have decided to not emit it
5397 in this TU. So make it an external reference. */
5398 DECL_EXTERNAL (t
) = 1;
5399 TREE_STATIC (t
) = 0;
5401 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5402 /* We do not need the leftover chaining of namespaces from the
5404 DECL_CHAIN (t
) = NULL_TREE
;
5407 /* Stub for c-common. Please keep in sync with c-decl.c.
5408 FIXME: If address space support is target specific, then this
5409 should be a C target hook. But currently this is not possible,
5410 because this function is called via REGISTER_TARGET_PRAGMAS. */
5412 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5416 /* Return the number of operands in T that we care about for things like
5420 cp_tree_operand_length (const_tree t
)
5422 enum tree_code code
= TREE_CODE (t
);
5424 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5425 return VL_EXP_OPERAND_LENGTH (t
);
5427 return cp_tree_code_length (code
);
5430 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5433 cp_tree_code_length (enum tree_code code
)
5435 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5439 case PREINCREMENT_EXPR
:
5440 case PREDECREMENT_EXPR
:
5441 case POSTINCREMENT_EXPR
:
5442 case POSTDECREMENT_EXPR
:
5448 case EXPR_PACK_EXPANSION
:
5452 return TREE_CODE_LENGTH (code
);
5456 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5460 cp_expr_location (const_tree t_
)
5462 tree t
= CONST_CAST_TREE (t_
);
5464 return UNKNOWN_LOCATION
;
5465 switch (TREE_CODE (t
))
5468 return LAMBDA_EXPR_LOCATION (t
);
5470 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5472 return EXPR_LOCATION (t
);
5476 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5477 conditions for the warning hold, false otherwise. */
5479 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5481 if (c_inhibit_evaluation_warnings
== 0
5482 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5484 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5485 "zero as null pointer constant");
5491 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5492 /* Complain that some language-specific thing hanging off a tree
5493 node has been accessed improperly. */
5496 lang_check_failed (const char* file
, int line
, const char* function
)
5498 internal_error ("lang_* check: failed in %s, at %s:%d",
5499 function
, trim_filename (file
), line
);
5501 #endif /* ENABLE_TREE_CHECKING */
5505 namespace selftest
{
5507 /* Verify that lvalue_kind () works, for various expressions,
5508 and that location wrappers don't affect the results. */
5513 location_t loc
= BUILTINS_LOCATION
;
5515 /* Verify constants and parameters, without and with
5516 location wrappers. */
5517 tree int_cst
= build_int_cst (integer_type_node
, 42);
5518 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5520 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5521 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5522 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5524 tree string_lit
= build_string (4, "foo");
5525 TREE_TYPE (string_lit
) = char_array_type_node
;
5526 string_lit
= fix_string_type (string_lit
);
5527 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5529 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5530 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5531 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5533 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5534 get_identifier ("some_parm"),
5536 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5538 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5539 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5540 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5542 /* Verify that lvalue_kind of std::move on a parm isn't
5543 affected by location wrappers. */
5544 tree rvalue_ref_of_parm
= move (parm
);
5545 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5546 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5547 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5550 /* Run all of the selftests within this file. */
5555 test_lvalue_kind ();
5558 } // namespace selftest
5560 #endif /* #if CHECKING_P */
5563 #include "gt-cp-tree.h"