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 /* Don't build AGGR_INIT_EXPR in a template. */
580 if (processing_template_decl
)
583 fn
= cp_get_callee (init
);
585 return convert (type
, init
);
587 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
588 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
589 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
591 /* We split the CALL_EXPR into its function and its arguments here.
592 Then, in expand_expr, we put them back together. The reason for
593 this is that this expression might be a default argument
594 expression. In that case, we need a new temporary every time the
595 expression is used. That's what break_out_target_exprs does; it
596 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
597 temporary slot. Then, expand_expr builds up a call-expression
598 using the new slot. */
600 /* If we don't need to use a constructor to create an object of this
601 type, don't mess with AGGR_INIT_EXPR. */
602 if (is_ctor
|| TREE_ADDRESSABLE (type
))
604 slot
= build_local_temp (type
);
606 if (TREE_CODE (init
) == CALL_EXPR
)
608 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
609 call_expr_nargs (init
),
610 CALL_EXPR_ARGP (init
));
611 AGGR_INIT_FROM_THUNK_P (rval
)
612 = CALL_FROM_THUNK_P (init
);
616 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
617 aggr_init_expr_nargs (init
),
618 AGGR_INIT_EXPR_ARGP (init
));
619 AGGR_INIT_FROM_THUNK_P (rval
)
620 = AGGR_INIT_FROM_THUNK_P (init
);
622 TREE_SIDE_EFFECTS (rval
) = 1;
623 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
624 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
625 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
626 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
627 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
635 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
636 target. TYPE is the type that this initialization should appear to
639 Build an encapsulation of the initialization to perform
640 and return it so that it can be processed by language-independent
641 and language-specific expression expanders. */
644 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
646 tree rval
= build_aggr_init_expr (type
, init
);
649 if (!complete_type_or_maybe_complain (type
, init
, complain
))
650 return error_mark_node
;
652 /* Make sure that we're not trying to create an instance of an
654 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
655 return error_mark_node
;
657 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
658 slot
= AGGR_INIT_EXPR_SLOT (rval
);
659 else if (TREE_CODE (rval
) == CALL_EXPR
660 || TREE_CODE (rval
) == CONSTRUCTOR
)
661 slot
= build_local_temp (type
);
665 rval
= build_target_expr (slot
, rval
, complain
);
667 if (rval
!= error_mark_node
)
668 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
673 /* Subroutine of build_vec_init_expr: Build up a single element
674 intialization as a proxy for the full array initialization to get things
675 marked as used and any appropriate diagnostics.
677 Since we're deferring building the actual constructor calls until
678 gimplification time, we need to build one now and throw it away so
679 that the relevant constructor gets mark_used before cgraph decides
680 what functions are needed. Here we assume that init is either
681 NULL_TREE, void_type_node (indicating value-initialization), or
682 another array to copy. */
685 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
687 tree inner_type
= strip_array_types (type
);
688 vec
<tree
, va_gc
> *argvec
;
690 if (integer_zerop (array_type_nelts_total (type
))
691 || !CLASS_TYPE_P (inner_type
))
692 /* No interesting initialization to do. */
693 return integer_zero_node
;
694 else if (init
== void_type_node
)
695 return build_value_init (inner_type
, complain
);
697 gcc_assert (init
== NULL_TREE
698 || (same_type_ignoring_top_level_qualifiers_p
699 (type
, TREE_TYPE (init
))));
701 argvec
= make_tree_vector ();
704 tree init_type
= strip_array_types (TREE_TYPE (init
));
705 tree dummy
= build_dummy_object (init_type
);
706 if (!lvalue_p (init
))
707 dummy
= move (dummy
);
708 argvec
->quick_push (dummy
);
710 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
711 &argvec
, inner_type
, LOOKUP_NORMAL
,
713 release_tree_vector (argvec
);
715 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
716 we don't want one here because we aren't creating a temporary. */
717 if (TREE_CODE (init
) == TARGET_EXPR
)
718 init
= TARGET_EXPR_INITIAL (init
);
723 /* Return a TARGET_EXPR which expresses the initialization of an array to
724 be named later, either default-initialization or copy-initialization
725 from another array of the same type. */
728 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
731 bool value_init
= false;
732 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
734 if (init
== void_type_node
)
740 slot
= build_local_temp (type
);
741 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
742 TREE_SIDE_EFFECTS (init
) = true;
743 SET_EXPR_LOCATION (init
, input_location
);
745 if (cxx_dialect
>= cxx11
746 && potential_constant_expression (elt_init
))
747 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
748 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
753 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
754 that requires a constant expression. */
757 diagnose_non_constexpr_vec_init (tree expr
)
759 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
761 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
762 init
= void_type_node
;
764 init
= VEC_INIT_EXPR_INIT (expr
);
766 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
767 require_potential_constant_expression (elt_init
);
771 build_array_copy (tree init
)
773 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
776 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
780 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
782 gcc_assert (!VOID_TYPE_P (type
));
784 if (TREE_CODE (init
) == TARGET_EXPR
785 || init
== error_mark_node
)
787 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
788 && !VOID_TYPE_P (TREE_TYPE (init
))
789 && TREE_CODE (init
) != COND_EXPR
790 && TREE_CODE (init
) != CONSTRUCTOR
791 && TREE_CODE (init
) != VA_ARG_EXPR
)
792 /* We need to build up a copy constructor call. A void initializer
793 means we're being called from bot_manip. COND_EXPR is a special
794 case because we already have copies on the arms and we don't want
795 another one here. A CONSTRUCTOR is aggregate initialization, which
796 is handled separately. A VA_ARG_EXPR is magic creation of an
797 aggregate; there's no additional work to be done. */
798 return force_rvalue (init
, complain
);
800 return force_target_expr (type
, init
, complain
);
803 /* Like the above function, but without the checking. This function should
804 only be used by code which is deliberately trying to subvert the type
805 system, such as call_builtin_trap. Or build_over_call, to avoid
806 infinite recursion. */
809 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
813 gcc_assert (!VOID_TYPE_P (type
));
815 slot
= build_local_temp (type
);
816 return build_target_expr (slot
, init
, complain
);
819 /* Like build_target_expr_with_type, but use the type of INIT. */
822 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
824 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
825 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
826 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
827 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
830 init
= convert_bitfield_to_declared_type (init
);
831 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
836 get_target_expr (tree init
)
838 return get_target_expr_sfinae (init
, tf_warning_or_error
);
841 /* If EXPR is a bitfield reference, convert it to the declared type of
842 the bitfield, and return the resulting expression. Otherwise,
843 return EXPR itself. */
846 convert_bitfield_to_declared_type (tree expr
)
850 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
852 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
857 /* EXPR is being used in an rvalue context. Return a version of EXPR
858 that is marked as an rvalue. */
865 if (error_operand_p (expr
))
868 expr
= mark_rvalue_use (expr
);
872 Non-class rvalues always have cv-unqualified types. */
873 type
= TREE_TYPE (expr
);
874 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
875 type
= cv_unqualified (type
);
877 /* We need to do this for rvalue refs as well to get the right answer
878 from decltype; see c++/36628. */
879 if (!processing_template_decl
&& glvalue_p (expr
))
880 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
881 else if (type
!= TREE_TYPE (expr
))
882 expr
= build_nop (type
, expr
);
888 struct cplus_array_info
894 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
896 typedef cplus_array_info
*compare_type
;
898 static hashval_t
hash (tree t
);
899 static bool equal (tree
, cplus_array_info
*);
902 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
905 cplus_array_hasher::hash (tree t
)
909 hash
= TYPE_UID (TREE_TYPE (t
));
911 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
915 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
916 of type `cplus_array_info*'. */
919 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
921 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
924 /* Hash table containing dependent array types, which are unsuitable for
925 the language-independent type hash table. */
926 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
928 /* Build an ARRAY_TYPE without laying it out. */
931 build_min_array_type (tree elt_type
, tree index_type
)
933 tree t
= cxx_make_type (ARRAY_TYPE
);
934 TREE_TYPE (t
) = elt_type
;
935 TYPE_DOMAIN (t
) = index_type
;
939 /* Set TYPE_CANONICAL like build_array_type_1, but using
940 build_cplus_array_type. */
943 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
945 /* Set the canonical type for this new node. */
946 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
947 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
948 SET_TYPE_STRUCTURAL_EQUALITY (t
);
949 else if (TYPE_CANONICAL (elt_type
) != elt_type
950 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
952 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
954 ? TYPE_CANONICAL (index_type
) : index_type
);
956 TYPE_CANONICAL (t
) = t
;
959 /* Like build_array_type, but handle special C++ semantics: an array of a
960 variant element type is a variant of the array of the main variant of
964 build_cplus_array_type (tree elt_type
, tree index_type
)
968 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
969 return error_mark_node
;
971 bool dependent
= (uses_template_parms (elt_type
)
972 || (index_type
&& uses_template_parms (index_type
)));
974 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
975 /* Start with an array of the TYPE_MAIN_VARIANT. */
976 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
980 /* Since type_hash_canon calls layout_type, we need to use our own
982 cplus_array_info cai
;
985 if (cplus_array_htab
== NULL
)
986 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
988 hash
= TYPE_UID (elt_type
);
990 hash
^= TYPE_UID (index_type
);
992 cai
.domain
= index_type
;
994 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
996 /* We have found the type: we're done. */
1000 /* Build a new array type. */
1001 t
= build_min_array_type (elt_type
, index_type
);
1003 /* Store it in the hash table. */
1006 /* Set the canonical type for this new node. */
1007 set_array_type_canon (t
, elt_type
, index_type
);
1012 bool typeless_storage
1013 = (elt_type
== unsigned_char_type_node
1014 || elt_type
== signed_char_type_node
1015 || elt_type
== char_type_node
1016 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1017 && TYPE_CONTEXT (elt_type
) == std_node
1018 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1019 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1022 /* Now check whether we already have this array variant. */
1023 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1026 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1027 if (TREE_TYPE (t
) == elt_type
1028 && TYPE_NAME (t
) == NULL_TREE
1029 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1033 t
= build_min_array_type (elt_type
, index_type
);
1034 set_array_type_canon (t
, elt_type
, index_type
);
1038 /* Make sure sizes are shared with the main variant.
1039 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1040 as it will overwrite alignment etc. of all variants. */
1041 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1042 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1043 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1046 TYPE_MAIN_VARIANT (t
) = m
;
1047 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1048 TYPE_NEXT_VARIANT (m
) = t
;
1052 /* Avoid spurious warnings with VLAs (c++/54583). */
1053 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1054 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1056 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1057 place more easily. */
1058 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1059 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1060 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1061 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1063 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1064 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1066 /* The element type has been completed since the last time we saw
1067 this array type; update the layout and 'tor flags for any variants
1070 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1072 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1073 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1080 /* Return an ARRAY_TYPE with element type ELT and length N. */
1083 build_array_of_n_type (tree elt
, int n
)
1085 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1088 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1089 for C++14 but then removed. This should only be used for N3639
1090 specifically; code wondering more generally if something is a VLA should use
1094 array_of_runtime_bound_p (tree t
)
1096 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1098 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1100 tree dom
= TYPE_DOMAIN (t
);
1103 tree max
= TYPE_MAX_VALUE (dom
);
1104 return (!potential_rvalue_constant_expression (max
)
1105 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1108 /* True iff T is a variable length array. */
1113 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1115 if (tree dom
= TYPE_DOMAIN (t
))
1117 tree max
= TYPE_MAX_VALUE (dom
);
1118 if (!potential_rvalue_constant_expression (max
)
1119 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1125 /* Return a reference type node referring to TO_TYPE. If RVAL is
1126 true, return an rvalue reference type, otherwise return an lvalue
1127 reference type. If a type node exists, reuse it, otherwise create
1130 cp_build_reference_type (tree to_type
, bool rval
)
1134 if (to_type
== error_mark_node
)
1135 return error_mark_node
;
1137 if (TYPE_REF_P (to_type
))
1139 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1140 to_type
= TREE_TYPE (to_type
);
1143 lvalue_ref
= build_reference_type (to_type
);
1147 /* This code to create rvalue reference types is based on and tied
1148 to the code creating lvalue reference types in the middle-end
1149 functions build_reference_type_for_mode and build_reference_type.
1151 It works by putting the rvalue reference type nodes after the
1152 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1153 they will effectively be ignored by the middle end. */
1155 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1156 if (TYPE_REF_IS_RVALUE (t
))
1159 t
= build_distinct_type_copy (lvalue_ref
);
1161 TYPE_REF_IS_RVALUE (t
) = true;
1162 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1163 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1165 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1166 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1167 else if (TYPE_CANONICAL (to_type
) != to_type
)
1169 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1171 TYPE_CANONICAL (t
) = t
;
1179 /* Returns EXPR cast to rvalue reference type, like std::move. */
1184 tree type
= TREE_TYPE (expr
);
1185 gcc_assert (!TYPE_REF_P (type
));
1186 type
= cp_build_reference_type (type
, /*rval*/true);
1187 return build_static_cast (type
, expr
, tf_warning_or_error
);
1190 /* Used by the C++ front end to build qualified array types. However,
1191 the C version of this function does not properly maintain canonical
1192 types (which are not used in C). */
1194 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1195 size_t /* orig_qual_indirect */)
1197 return cp_build_qualified_type (type
, type_quals
);
1201 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1202 arrays correctly. In particular, if TYPE is an array of T's, and
1203 TYPE_QUALS is non-empty, returns an array of qualified T's.
1205 FLAGS determines how to deal with ill-formed qualifications. If
1206 tf_ignore_bad_quals is set, then bad qualifications are dropped
1207 (this is permitted if TYPE was introduced via a typedef or template
1208 type parameter). If bad qualifications are dropped and tf_warning
1209 is set, then a warning is issued for non-const qualifications. If
1210 tf_ignore_bad_quals is not set and tf_error is not set, we
1211 return error_mark_node. Otherwise, we issue an error, and ignore
1214 Qualification of a reference type is valid when the reference came
1215 via a typedef or template type argument. [dcl.ref] No such
1216 dispensation is provided for qualifying a function type. [dcl.fct]
1217 DR 295 queries this and the proposed resolution brings it into line
1218 with qualifying a reference. We implement the DR. We also behave
1219 in a similar manner for restricting non-pointer types. */
1222 cp_build_qualified_type_real (tree type
,
1224 tsubst_flags_t complain
)
1227 int bad_quals
= TYPE_UNQUALIFIED
;
1229 if (type
== error_mark_node
)
1232 if (type_quals
== cp_type_quals (type
))
1235 if (TREE_CODE (type
) == ARRAY_TYPE
)
1237 /* In C++, the qualification really applies to the array element
1238 type. Obtain the appropriately qualified element type. */
1241 = cp_build_qualified_type_real (TREE_TYPE (type
),
1245 if (element_type
== error_mark_node
)
1246 return error_mark_node
;
1248 /* See if we already have an identically qualified type. Tests
1249 should be equivalent to those in check_qualified_type. */
1250 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1251 if (TREE_TYPE (t
) == element_type
1252 && TYPE_NAME (t
) == TYPE_NAME (type
)
1253 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1254 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1255 TYPE_ATTRIBUTES (type
)))
1260 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1262 /* Keep the typedef name. */
1263 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1265 t
= build_variant_type_copy (t
);
1266 TYPE_NAME (t
) = TYPE_NAME (type
);
1267 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1268 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1272 /* Even if we already had this variant, we update
1273 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1274 they changed since the variant was originally created.
1276 This seems hokey; if there is some way to use a previous
1277 variant *without* coming through here,
1278 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1279 TYPE_NEEDS_CONSTRUCTING (t
)
1280 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1281 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1282 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1285 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1287 tree t
= PACK_EXPANSION_PATTERN (type
);
1289 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1290 return make_pack_expansion (t
, complain
);
1293 /* A reference or method type shall not be cv-qualified.
1294 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1295 (in CD1) we always ignore extra cv-quals on functions. */
1296 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1297 && (TYPE_REF_P (type
)
1298 || TREE_CODE (type
) == FUNCTION_TYPE
1299 || TREE_CODE (type
) == METHOD_TYPE
))
1301 if (TYPE_REF_P (type
))
1302 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1303 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1306 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1307 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1308 type_quals
|= type_memfn_quals (type
);
1310 /* A restrict-qualified type must be a pointer (or reference)
1311 to object or incomplete type. */
1312 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1313 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1314 && TREE_CODE (type
) != TYPENAME_TYPE
1315 && !INDIRECT_TYPE_P (type
))
1317 bad_quals
|= TYPE_QUAL_RESTRICT
;
1318 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1321 if (bad_quals
== TYPE_UNQUALIFIED
1322 || (complain
& tf_ignore_bad_quals
))
1324 else if (!(complain
& tf_error
))
1325 return error_mark_node
;
1328 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1329 error ("%qV qualifiers cannot be applied to %qT",
1333 /* Retrieve (or create) the appropriately qualified variant. */
1334 result
= build_qualified_type (type
, type_quals
);
1339 /* Return TYPE with const and volatile removed. */
1342 cv_unqualified (tree type
)
1346 if (type
== error_mark_node
)
1349 quals
= cp_type_quals (type
);
1350 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1351 return cp_build_qualified_type (type
, quals
);
1354 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1355 from ATTRIBS that affect type identity, and no others. If any are not
1356 applied, set *remove_attributes to true. */
1359 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1361 tree first_ident
= NULL_TREE
;
1362 tree new_attribs
= NULL_TREE
;
1363 tree
*p
= &new_attribs
;
1365 if (OVERLOAD_TYPE_P (result
))
1367 /* On classes and enums all attributes are ingrained. */
1368 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1372 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1374 const attribute_spec
*as
1375 = lookup_attribute_spec (get_attribute_name (a
));
1376 if (as
&& as
->affects_type_identity
)
1380 else if (first_ident
== error_mark_node
)
1382 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1383 p
= &TREE_CHAIN (*p
);
1386 else if (first_ident
)
1388 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1390 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1391 p
= &TREE_CHAIN (*p
);
1393 first_ident
= error_mark_node
;
1396 if (first_ident
!= error_mark_node
)
1397 new_attribs
= first_ident
;
1399 if (first_ident
== attribs
)
1400 /* All attributes affected type identity. */;
1402 *remove_attributes
= true;
1404 return cp_build_type_attribute_variant (result
, new_attribs
);
1407 /* Builds a qualified variant of T that is not a typedef variant.
1408 E.g. consider the following declarations:
1409 typedef const int ConstInt;
1410 typedef ConstInt* PtrConstInt;
1411 If T is PtrConstInt, this function returns a type representing
1413 In other words, if T is a typedef, the function returns the underlying type.
1414 The cv-qualification and attributes of the type returned match the
1416 They will always be compatible types.
1417 The returned type is built so that all of its subtypes
1418 recursively have their typedefs stripped as well.
1420 This is different from just returning TYPE_CANONICAL (T)
1421 Because of several reasons:
1422 * If T is a type that needs structural equality
1423 its TYPE_CANONICAL (T) will be NULL.
1424 * TYPE_CANONICAL (T) desn't carry type attributes
1425 and loses template parameter names.
1427 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1428 affect type identity, and set the referent to true if any were
1432 strip_typedefs (tree t
, bool *remove_attributes
)
1434 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1436 if (!t
|| t
== error_mark_node
)
1439 if (TREE_CODE (t
) == TREE_LIST
)
1441 bool changed
= false;
1442 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1444 for (; t
; t
= TREE_CHAIN (t
))
1446 gcc_assert (!TREE_PURPOSE (t
));
1447 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1448 if (elt
!= TREE_VALUE (t
))
1450 vec_safe_push (vec
, elt
);
1453 r
= build_tree_list_vec (vec
);
1454 release_tree_vector (vec
);
1458 gcc_assert (TYPE_P (t
));
1460 if (t
== TYPE_CANONICAL (t
))
1463 if (dependent_alias_template_spec_p (t
))
1464 /* DR 1558: However, if the template-id is dependent, subsequent
1465 template argument substitution still applies to the template-id. */
1468 switch (TREE_CODE (t
))
1471 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1472 result
= build_pointer_type (type
);
1474 case REFERENCE_TYPE
:
1475 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1476 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1479 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1480 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1481 result
= build_offset_type (t0
, type
);
1484 if (TYPE_PTRMEMFUNC_P (t
))
1486 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1487 result
= build_ptrmemfunc_type (t0
);
1491 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1492 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1493 result
= build_cplus_array_type (type
, t0
);
1498 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1501 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1502 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1503 can't expect that re-hashing a function type will find a previous
1504 equivalent type, so try to reuse the input type if nothing has
1505 changed. If the type is itself a variant, that will change. */
1506 bool is_variant
= typedef_variant_p (t
);
1507 if (remove_attributes
1508 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1511 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1512 tree canon_spec
= (flag_noexcept_type
1513 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1515 changed
= (type
!= TREE_TYPE (t
) || is_variant
1516 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1518 for (arg_node
= TYPE_ARG_TYPES (t
);
1520 arg_node
= TREE_CHAIN (arg_node
))
1522 if (arg_node
== void_list_node
)
1524 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1526 gcc_assert (arg_type
);
1527 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1533 for (arg_node2
= TYPE_ARG_TYPES (t
);
1534 arg_node2
!= arg_node
;
1535 arg_node2
= TREE_CHAIN (arg_node2
))
1537 = tree_cons (TREE_PURPOSE (arg_node2
),
1538 TREE_VALUE (arg_node2
), arg_types
);
1542 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1549 arg_types
= nreverse (arg_types
);
1551 /* A list of parameters not ending with an ellipsis
1552 must end with void_list_node. */
1554 arg_types
= chainon (arg_types
, void_list_node
);
1556 if (TREE_CODE (t
) == METHOD_TYPE
)
1558 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1559 gcc_assert (class_type
);
1561 build_method_type_directly (class_type
, type
,
1562 TREE_CHAIN (arg_types
));
1566 result
= build_function_type (type
, arg_types
);
1567 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1570 result
= build_cp_fntype_variant (result
,
1571 type_memfn_rqual (t
), canon_spec
,
1572 TYPE_HAS_LATE_RETURN_TYPE (t
));
1577 bool changed
= false;
1578 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1579 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1580 && TREE_OPERAND (fullname
, 1))
1582 tree args
= TREE_OPERAND (fullname
, 1);
1583 tree new_args
= copy_node (args
);
1584 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1586 tree arg
= TREE_VEC_ELT (args
, i
);
1589 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1591 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1592 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1593 if (strip_arg
!= arg
)
1598 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1599 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1601 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1605 ggc_free (new_args
);
1607 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1608 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1610 tree name
= fullname
;
1611 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1612 name
= TREE_OPERAND (fullname
, 0);
1613 /* Use build_typename_type rather than make_typename_type because we
1614 don't want to resolve it here, just strip typedefs. */
1615 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1619 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1621 if (result
== DECLTYPE_TYPE_EXPR (t
))
1624 result
= (finish_decltype_type
1626 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1629 case UNDERLYING_TYPE
:
1630 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1631 result
= finish_underlying_type (type
);
1639 if (typedef_variant_p (t
))
1641 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1642 strip typedefs with attributes. */
1643 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1644 result
= strip_typedefs (result
);
1647 result
= TYPE_MAIN_VARIANT (t
);
1649 gcc_assert (!typedef_variant_p (result
));
1651 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1652 /* If RESULT is complete and T isn't, it's likely the case that T
1653 is a variant of RESULT which hasn't been updated yet. Skip the
1654 attribute handling. */;
1657 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1658 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1660 gcc_assert (TYPE_USER_ALIGN (t
));
1661 if (remove_attributes
)
1662 *remove_attributes
= true;
1665 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1666 result
= build_variant_type_copy (result
);
1668 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1669 TYPE_USER_ALIGN (result
) = true;
1673 if (TYPE_ATTRIBUTES (t
))
1675 if (remove_attributes
)
1676 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1679 result
= cp_build_type_attribute_variant (result
,
1680 TYPE_ATTRIBUTES (t
));
1684 return cp_build_qualified_type (result
, cp_type_quals (t
));
1687 /* Like strip_typedefs above, but works on expressions, so that in
1689 template<class T> struct A
1695 sizeof(TT) is replaced by sizeof(T). */
1698 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1702 enum tree_code code
;
1704 if (t
== NULL_TREE
|| t
== error_mark_node
)
1707 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1710 /* Some expressions have type operands, so let's handle types here rather
1711 than check TYPE_P in multiple places below. */
1713 return strip_typedefs (t
, remove_attributes
);
1715 code
= TREE_CODE (t
);
1718 case IDENTIFIER_NODE
:
1719 case TEMPLATE_PARM_INDEX
:
1722 case ARGUMENT_PACK_SELECT
:
1727 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1728 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1729 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1730 && type2
== TRAIT_EXPR_TYPE2 (t
))
1733 TRAIT_EXPR_TYPE1 (r
) = type1
;
1734 TRAIT_EXPR_TYPE2 (r
) = type2
;
1740 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1741 bool changed
= false;
1743 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1745 tree val
= strip_typedefs_expr (TREE_VALUE (it
), remove_attributes
);
1746 vec_safe_push (vec
, val
);
1747 if (val
!= TREE_VALUE (it
))
1749 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1754 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1755 r
= tree_cons (NULL_TREE
, it
, r
);
1759 release_tree_vector (vec
);
1765 bool changed
= false;
1766 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1767 n
= TREE_VEC_LENGTH (t
);
1768 vec_safe_reserve (vec
, n
);
1769 for (i
= 0; i
< n
; ++i
)
1771 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1773 vec
->quick_push (op
);
1774 if (op
!= TREE_VEC_ELT (t
, i
))
1780 for (i
= 0; i
< n
; ++i
)
1781 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1782 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1783 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1787 release_tree_vector (vec
);
1793 bool changed
= false;
1794 vec
<constructor_elt
, va_gc
> *vec
1795 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1796 n
= CONSTRUCTOR_NELTS (t
);
1797 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1798 for (i
= 0; i
< n
; ++i
)
1800 constructor_elt
*e
= &(*vec
)[i
];
1801 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1808 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1811 if (!changed
&& type
== TREE_TYPE (t
))
1819 TREE_TYPE (r
) = type
;
1820 CONSTRUCTOR_ELTS (r
) = vec
;
1826 error ("lambda-expression in a constant expression");
1827 return error_mark_node
;
1829 case STATEMENT_LIST
:
1830 error ("statement-expression in a constant expression");
1831 return error_mark_node
;
1837 gcc_assert (EXPR_P (t
));
1839 n
= cp_tree_operand_length (t
);
1840 ops
= XALLOCAVEC (tree
, n
);
1841 type
= TREE_TYPE (t
);
1846 case IMPLICIT_CONV_EXPR
:
1847 case DYNAMIC_CAST_EXPR
:
1848 case STATIC_CAST_EXPR
:
1849 case CONST_CAST_EXPR
:
1850 case REINTERPRET_CAST_EXPR
:
1853 type
= strip_typedefs (type
, remove_attributes
);
1857 for (i
= 0; i
< n
; ++i
)
1858 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1862 /* If nothing changed, return t. */
1863 for (i
= 0; i
< n
; ++i
)
1864 if (ops
[i
] != TREE_OPERAND (t
, i
))
1866 if (i
== n
&& type
== TREE_TYPE (t
))
1870 TREE_TYPE (r
) = type
;
1871 for (i
= 0; i
< n
; ++i
)
1872 TREE_OPERAND (r
, i
) = ops
[i
];
1876 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1877 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1878 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1879 VIRT indicates whether TYPE is inherited virtually or not.
1880 IGO_PREV points at the previous binfo of the inheritance graph
1881 order chain. The newly copied binfo's TREE_CHAIN forms this
1884 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1885 correct order. That is in the order the bases themselves should be
1888 The BINFO_INHERITANCE of a virtual base class points to the binfo
1889 of the most derived type. ??? We could probably change this so that
1890 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1891 remove a field. They currently can only differ for primary virtual
1895 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1901 /* See if we've already made this virtual base. */
1902 new_binfo
= binfo_for_vbase (type
, t
);
1907 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1908 BINFO_TYPE (new_binfo
) = type
;
1910 /* Chain it into the inheritance graph. */
1911 TREE_CHAIN (*igo_prev
) = new_binfo
;
1912 *igo_prev
= new_binfo
;
1914 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1919 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1921 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1922 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1924 /* We do not need to copy the accesses, as they are read only. */
1925 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1927 /* Recursively copy base binfos of BINFO. */
1928 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1930 tree new_base_binfo
;
1931 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1933 BINFO_VIRTUAL_P (base_binfo
));
1935 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1936 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1937 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1941 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1945 /* Push it onto the list after any virtual bases it contains
1946 will have been pushed. */
1947 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1948 BINFO_VIRTUAL_P (new_binfo
) = 1;
1949 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1955 /* Hashing of lists so that we don't make duplicates.
1956 The entry point is `list_hash_canon'. */
1965 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1967 typedef list_proxy
*compare_type
;
1969 static hashval_t
hash (tree
);
1970 static bool equal (tree
, list_proxy
*);
1973 /* Now here is the hash table. When recording a list, it is added
1974 to the slot whose index is the hash code mod the table size.
1975 Note that the hash table is used for several kinds of lists.
1976 While all these live in the same table, they are completely independent,
1977 and the hash code is computed differently for each of these. */
1979 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1981 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1982 for a node we are thinking about adding). */
1985 list_hasher::equal (tree t
, list_proxy
*proxy
)
1987 return (TREE_VALUE (t
) == proxy
->value
1988 && TREE_PURPOSE (t
) == proxy
->purpose
1989 && TREE_CHAIN (t
) == proxy
->chain
);
1992 /* Compute a hash code for a list (chain of TREE_LIST nodes
1993 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1994 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1997 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1999 hashval_t hashcode
= 0;
2002 hashcode
+= TREE_HASH (chain
);
2005 hashcode
+= TREE_HASH (value
);
2009 hashcode
+= TREE_HASH (purpose
);
2015 /* Hash an already existing TREE_LIST. */
2018 list_hasher::hash (tree t
)
2020 return list_hash_pieces (TREE_PURPOSE (t
),
2025 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2026 object for an identical list if one already exists. Otherwise, build a
2027 new one, and record it as the canonical object. */
2030 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2034 struct list_proxy proxy
;
2036 /* Hash the list node. */
2037 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2038 /* Create a proxy for the TREE_LIST we would like to create. We
2039 don't actually create it so as to avoid creating garbage. */
2040 proxy
.purpose
= purpose
;
2041 proxy
.value
= value
;
2042 proxy
.chain
= chain
;
2043 /* See if it is already in the table. */
2044 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2045 /* If not, create a new node. */
2047 *slot
= tree_cons (purpose
, value
, chain
);
2048 return (tree
) *slot
;
2051 /* Constructor for hashed lists. */
2054 hash_tree_chain (tree value
, tree chain
)
2056 return hash_tree_cons (NULL_TREE
, value
, chain
);
2060 debug_binfo (tree elem
)
2065 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2067 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2068 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2069 debug_tree (BINFO_TYPE (elem
));
2070 if (BINFO_VTABLE (elem
))
2071 fprintf (stderr
, "vtable decl \"%s\"\n",
2072 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2074 fprintf (stderr
, "no vtable decl yet\n");
2075 fprintf (stderr
, "virtuals:\n");
2076 virtuals
= BINFO_VIRTUALS (elem
);
2081 tree fndecl
= TREE_VALUE (virtuals
);
2082 fprintf (stderr
, "%s [%ld =? %ld]\n",
2083 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2084 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2086 virtuals
= TREE_CHAIN (virtuals
);
2090 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2091 the type of the result expression, if known, or NULL_TREE if the
2092 resulting expression is type-dependent. If TEMPLATE_P is true,
2093 NAME is known to be a template because the user explicitly used the
2094 "template" keyword after the "::".
2096 All SCOPE_REFs should be built by use of this function. */
2099 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2102 if (type
== error_mark_node
2103 || scope
== error_mark_node
2104 || name
== error_mark_node
)
2105 return error_mark_node
;
2106 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2107 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2108 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2109 PTRMEM_OK_P (t
) = true;
2111 t
= convert_from_reference (t
);
2115 /* Like check_qualified_type, but also check ref-qualifier, exception
2116 specification, and whether the return type was specified after the
2120 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2121 cp_ref_qualifier rqual
, tree raises
, bool late
)
2123 return (TYPE_QUALS (cand
) == type_quals
2124 && check_base_type (cand
, base
)
2125 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2127 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2128 && type_memfn_rqual (cand
) == rqual
);
2131 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2134 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2136 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2137 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2138 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2141 /* Make a raw overload node containing FN. */
2144 ovl_make (tree fn
, tree next
)
2146 tree result
= make_node (OVERLOAD
);
2148 if (TREE_CODE (fn
) == OVERLOAD
)
2149 OVL_NESTED_P (result
) = true;
2151 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2152 ? unknown_type_node
: TREE_TYPE (fn
));
2153 OVL_FUNCTION (result
) = fn
;
2154 OVL_CHAIN (result
) = next
;
2161 tree result
= make_node (OVERLOAD
);
2163 gcc_checking_assert (!OVL_NESTED_P (ovl
) && OVL_USED_P (ovl
));
2164 TREE_TYPE (result
) = TREE_TYPE (ovl
);
2165 OVL_FUNCTION (result
) = OVL_FUNCTION (ovl
);
2166 OVL_CHAIN (result
) = OVL_CHAIN (ovl
);
2167 OVL_HIDDEN_P (result
) = OVL_HIDDEN_P (ovl
);
2168 OVL_USING_P (result
) = OVL_USING_P (ovl
);
2169 OVL_LOOKUP_P (result
) = OVL_LOOKUP_P (ovl
);
2174 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2175 true, if FN is via a using declaration. We also pay attention to
2176 DECL_HIDDEN. Overloads are ordered as hidden, using, regular. */
2179 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2181 bool copying
= false; /* Checking use only. */
2182 bool hidden_p
= DECL_HIDDEN_P (fn
);
2183 int weight
= (hidden_p
<< 1) | (using_p
<< 0);
2185 tree result
= NULL_TREE
;
2186 tree insert_after
= NULL_TREE
;
2188 /* Find insertion point. */
2189 while (maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2190 && (weight
< ((OVL_HIDDEN_P (maybe_ovl
) << 1)
2191 | (OVL_USING_P (maybe_ovl
) << 0))))
2193 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
)
2194 && (!copying
|| OVL_USED_P (maybe_ovl
)));
2195 if (OVL_USED_P (maybe_ovl
))
2198 maybe_ovl
= ovl_copy (maybe_ovl
);
2200 OVL_CHAIN (insert_after
) = maybe_ovl
;
2204 insert_after
= maybe_ovl
;
2205 maybe_ovl
= OVL_CHAIN (maybe_ovl
);
2209 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2211 trail
= ovl_make (fn
, maybe_ovl
);
2213 OVL_HIDDEN_P (trail
) = true;
2215 OVL_USING_P (trail
) = true;
2220 OVL_CHAIN (insert_after
) = trail
;
2221 TREE_TYPE (insert_after
) = unknown_type_node
;
2229 /* Skip any hidden names at the beginning of OVL. */
2232 ovl_skip_hidden (tree ovl
)
2235 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2236 ovl
= OVL_CHAIN (ovl
))
2237 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2239 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2241 /* Any hidden functions should have been wrapped in an
2242 overload, but injected friend classes will not. */
2243 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2250 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2253 ovl_iterator::reveal_node (tree overload
, tree node
)
2255 /* We cannot have returned NODE as part of a lookup overload, so it
2257 gcc_checking_assert (!OVL_USED_P (node
));
2259 OVL_HIDDEN_P (node
) = false;
2260 if (tree chain
= OVL_CHAIN (node
))
2261 if (TREE_CODE (chain
) == OVERLOAD
2262 && (OVL_USING_P (chain
) || OVL_HIDDEN_P (chain
)))
2264 /* The node needs moving, and the simplest way is to remove it
2266 overload
= remove_node (overload
, node
);
2267 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2272 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2273 OVL_USED_P we must copy OVL nodes, because those are immutable.
2274 The removed node is unaltered and may continue to be iterated
2275 from (i.e. it is safe to remove a node from an overload one is
2276 currently iterating over). */
2279 ovl_iterator::remove_node (tree overload
, tree node
)
2281 bool copying
= false; /* Checking use only. */
2283 tree
*slot
= &overload
;
2284 while (*slot
!= node
)
2287 gcc_checking_assert (!OVL_LOOKUP_P (probe
)
2288 && (!copying
|| OVL_USED_P (probe
)));
2289 if (OVL_USED_P (probe
))
2292 probe
= ovl_copy (probe
);
2296 slot
= &OVL_CHAIN (probe
);
2299 /* Stitch out NODE. We don't have to worry about now making a
2300 singleton overload (and consequently maybe setting its type),
2301 because all uses of this function will be followed by inserting a
2302 new node that must follow the place we've cut this out from. */
2303 if (TREE_CODE (node
) != OVERLOAD
)
2304 /* Cloned inherited ctors don't mark themselves as via_using. */
2307 *slot
= OVL_CHAIN (node
);
2312 /* Mark or unmark a lookup set. */
2315 lookup_mark (tree ovl
, bool val
)
2317 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2319 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2320 LOOKUP_SEEN_P (*iter
) = val
;
2324 /* Add a set of new FNS into a lookup. */
2327 lookup_add (tree fns
, tree lookup
)
2329 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2331 lookup
= ovl_make (fns
, lookup
);
2332 OVL_LOOKUP_P (lookup
) = true;
2340 /* FNS is a new overload set, add them to LOOKUP, if they are not
2341 already present there. */
2344 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2347 for (tree next
, probe
= fns
; probe
; probe
= next
)
2352 if (TREE_CODE (probe
) == OVERLOAD
)
2354 fn
= OVL_FUNCTION (probe
);
2355 next
= OVL_CHAIN (probe
);
2358 if (!LOOKUP_SEEN_P (fn
))
2359 LOOKUP_SEEN_P (fn
) = true;
2362 /* This function was already seen. Insert all the
2363 predecessors onto the lookup. */
2364 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2366 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2367 /* Propagate OVL_USING, but OVL_HIDDEN doesn't matter. */
2368 if (OVL_USING_P (fns
))
2369 OVL_USING_P (lookup
) = true;
2372 /* And now skip this function. */
2378 /* We ended in a set of new functions. Add them all in one go. */
2379 lookup
= lookup_add (fns
, lookup
);
2384 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2391 ovl
&& TREE_CODE (ovl
) == OVERLOAD
2392 && !OVL_USED_P (ovl
);
2393 ovl
= OVL_CHAIN (ovl
))
2395 gcc_checking_assert (!OVL_LOOKUP_P (ovl
));
2396 OVL_USED_P (ovl
) = true;
2400 /* Preserve the contents of a lookup so that it is available for a
2401 later instantiation. */
2404 lookup_keep (tree lookup
)
2407 lookup
&& TREE_CODE (lookup
) == OVERLOAD
2408 && OVL_LOOKUP_P (lookup
) && !OVL_USED_P (lookup
);
2409 lookup
= OVL_CHAIN (lookup
))
2411 OVL_USED_P (lookup
) = true;
2412 ovl_used (OVL_FUNCTION (lookup
));
2418 /* Returns nonzero if X is an expression for a (possibly overloaded)
2419 function. If "f" is a function or function template, "f", "c->f",
2420 "c.f", "C::f", and "f<int>" will all be considered possibly
2421 overloaded functions. Returns 2 if the function is actually
2422 overloaded, i.e., if it is impossible to know the type of the
2423 function without performing overload resolution. */
2426 is_overloaded_fn (tree x
)
2428 /* A baselink is also considered an overloaded function. */
2429 if (TREE_CODE (x
) == OFFSET_REF
2430 || TREE_CODE (x
) == COMPONENT_REF
)
2431 x
= TREE_OPERAND (x
, 1);
2432 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2433 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2434 x
= TREE_OPERAND (x
, 0);
2436 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2437 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2440 return (TREE_CODE (x
) == FUNCTION_DECL
2441 || TREE_CODE (x
) == OVERLOAD
);
2444 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2445 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2449 dependent_name (tree x
)
2451 if (identifier_p (x
))
2453 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2454 x
= TREE_OPERAND (x
, 0);
2455 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2456 return OVL_NAME (x
);
2460 /* Returns true iff X is an expression for an overloaded function
2461 whose type cannot be known without performing overload
2465 really_overloaded_fn (tree x
)
2467 return is_overloaded_fn (x
) == 2;
2470 /* Get the overload set FROM refers to. Returns NULL if it's not an
2474 maybe_get_fns (tree from
)
2476 /* A baselink is also considered an overloaded function. */
2477 if (TREE_CODE (from
) == OFFSET_REF
2478 || TREE_CODE (from
) == COMPONENT_REF
)
2479 from
= TREE_OPERAND (from
, 1);
2480 if (BASELINK_P (from
))
2481 from
= BASELINK_FUNCTIONS (from
);
2482 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2483 from
= TREE_OPERAND (from
, 0);
2485 if (TREE_CODE (from
) == OVERLOAD
2486 || TREE_CODE (from
) == FUNCTION_DECL
)
2492 /* FROM refers to an overload set. Return that set (or die). */
2497 tree res
= maybe_get_fns (from
);
2503 /* Return the first function of the overload set FROM refers to. */
2506 get_first_fn (tree from
)
2508 return OVL_FIRST (get_fns (from
));
2511 /* Return the scope where the overloaded functions OVL were found. */
2514 ovl_scope (tree ovl
)
2516 if (TREE_CODE (ovl
) == OFFSET_REF
2517 || TREE_CODE (ovl
) == COMPONENT_REF
)
2518 ovl
= TREE_OPERAND (ovl
, 1);
2519 if (TREE_CODE (ovl
) == BASELINK
)
2520 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2521 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2522 ovl
= TREE_OPERAND (ovl
, 0);
2523 /* Skip using-declarations. */
2524 lkp_iterator
iter (ovl
);
2527 while (iter
.using_p () && ++iter
);
2529 return CP_DECL_CONTEXT (ovl
);
2532 #define PRINT_RING_SIZE 4
2535 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2537 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2538 static char *print_ring
[PRINT_RING_SIZE
];
2539 static bool trans_ring
[PRINT_RING_SIZE
];
2540 static int ring_counter
;
2543 /* Only cache functions. */
2545 || TREE_CODE (decl
) != FUNCTION_DECL
2546 || DECL_LANG_SPECIFIC (decl
) == 0)
2547 return lang_decl_name (decl
, v
, translate
);
2549 /* See if this print name is lying around. */
2550 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2551 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2552 /* yes, so return it. */
2553 return print_ring
[i
];
2555 if (++ring_counter
== PRINT_RING_SIZE
)
2558 if (current_function_decl
!= NULL_TREE
)
2560 /* There may be both translated and untranslated versions of the
2562 for (i
= 0; i
< 2; i
++)
2564 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2566 if (ring_counter
== PRINT_RING_SIZE
)
2569 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2572 free (print_ring
[ring_counter
]);
2574 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2575 uid_ring
[ring_counter
] = DECL_UID (decl
);
2576 trans_ring
[ring_counter
] = translate
;
2577 return print_ring
[ring_counter
];
2581 cxx_printable_name (tree decl
, int v
)
2583 return cxx_printable_name_internal (decl
, v
, false);
2587 cxx_printable_name_translate (tree decl
, int v
)
2589 return cxx_printable_name_internal (decl
, v
, true);
2592 /* Return the canonical version of exception-specification RAISES for a C++17
2593 function type, for use in type comparison and building TYPE_CANONICAL. */
2596 canonical_eh_spec (tree raises
)
2598 if (raises
== NULL_TREE
)
2600 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2601 || uses_template_parms (raises
)
2602 || uses_template_parms (TREE_PURPOSE (raises
)))
2603 /* Keep a dependent or deferred exception specification. */
2605 else if (nothrow_spec_p (raises
))
2606 /* throw() -> noexcept. */
2607 return noexcept_true_spec
;
2609 /* For C++17 type matching, anything else -> nothing. */
2614 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2615 tree raises
, bool late
)
2617 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2619 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2622 tree v
= TYPE_MAIN_VARIANT (type
);
2623 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2624 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2627 /* Need to build a new variant. */
2628 v
= build_variant_type_copy (type
);
2629 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2630 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2633 case REF_QUAL_RVALUE
:
2634 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2635 FUNCTION_REF_QUALIFIED (v
) = 1;
2637 case REF_QUAL_LVALUE
:
2638 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2639 FUNCTION_REF_QUALIFIED (v
) = 1;
2642 FUNCTION_REF_QUALIFIED (v
) = 0;
2646 /* Canonicalize the exception specification. */
2647 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2649 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2650 /* Propagate structural equality. */
2651 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2652 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2653 /* Build the underlying canonical type, since it is different
2655 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2658 /* T is its own canonical type. */
2659 TYPE_CANONICAL (v
) = v
;
2664 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2665 listed in RAISES. */
2668 build_exception_variant (tree type
, tree raises
)
2670 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2671 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2672 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2675 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2676 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2680 bind_template_template_parm (tree t
, tree newargs
)
2682 tree decl
= TYPE_NAME (t
);
2685 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2686 decl
= build_decl (input_location
,
2687 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2689 /* These nodes have to be created to reflect new TYPE_DECL and template
2691 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2692 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2693 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2694 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2696 TREE_TYPE (decl
) = t2
;
2697 TYPE_NAME (t2
) = decl
;
2698 TYPE_STUB_DECL (t2
) = decl
;
2700 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2705 /* Called from count_trees via walk_tree. */
2708 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2718 /* Debugging function for measuring the rough complexity of a tree
2722 count_trees (tree t
)
2725 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2729 /* Called from verify_stmt_tree via walk_tree. */
2732 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2735 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2736 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2739 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2742 /* If this statement is already present in the hash table, then
2743 there is a circularity in the statement tree. */
2744 gcc_assert (!statements
->find (t
));
2746 slot
= statements
->find_slot (t
, INSERT
);
2752 /* Debugging function to check that the statement T has not been
2753 corrupted. For now, this function simply checks that T contains no
2757 verify_stmt_tree (tree t
)
2759 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2760 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2763 /* Check if the type T depends on a type with no linkage and if so, return
2764 it. If RELAXED_P then do not consider a class type declared within
2765 a vague-linkage function to have no linkage. */
2768 no_linkage_check (tree t
, bool relaxed_p
)
2772 /* There's no point in checking linkage on template functions; we
2773 can't know their complete types. */
2774 if (processing_template_decl
)
2777 switch (TREE_CODE (t
))
2780 if (TYPE_PTRMEMFUNC_P (t
))
2782 /* Lambda types that don't have mangling scope have no linkage. We
2783 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2784 when we get here from pushtag none of the lambda information is
2785 set up yet, so we want to assume that the lambda has linkage and
2786 fix it up later if not. */
2787 if (CLASSTYPE_LAMBDA_EXPR (t
)
2788 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2789 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2793 if (!CLASS_TYPE_P (t
))
2797 /* Only treat unnamed types as having no linkage if they're at
2798 namespace scope. This is core issue 966. */
2799 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2802 for (r
= CP_TYPE_CONTEXT (t
); ; )
2804 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2805 have linkage, or we might just be in an anonymous namespace.
2806 If we're in a TREE_PUBLIC class, we have linkage. */
2807 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2808 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2809 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2811 if (!relaxed_p
|| !vague_linkage_p (r
))
2814 r
= CP_DECL_CONTEXT (r
);
2824 case REFERENCE_TYPE
:
2826 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2830 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2834 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2839 tree parm
= TYPE_ARG_TYPES (t
);
2840 if (TREE_CODE (t
) == METHOD_TYPE
)
2841 /* The 'this' pointer isn't interesting; a method has the same
2842 linkage (or lack thereof) as its enclosing class. */
2843 parm
= TREE_CHAIN (parm
);
2845 parm
&& parm
!= void_list_node
;
2846 parm
= TREE_CHAIN (parm
))
2848 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2852 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2860 extern int depth_reached
;
2863 cxx_print_statistics (void)
2865 print_template_statistics ();
2866 if (GATHER_STATISTICS
)
2867 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2871 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2872 (which is an ARRAY_TYPE). This counts only elements of the top
2876 array_type_nelts_top (tree type
)
2878 return fold_build2_loc (input_location
,
2879 PLUS_EXPR
, sizetype
,
2880 array_type_nelts (type
),
2884 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2885 (which is an ARRAY_TYPE). This one is a recursive count of all
2886 ARRAY_TYPEs that are clumped together. */
2889 array_type_nelts_total (tree type
)
2891 tree sz
= array_type_nelts_top (type
);
2892 type
= TREE_TYPE (type
);
2893 while (TREE_CODE (type
) == ARRAY_TYPE
)
2895 tree n
= array_type_nelts_top (type
);
2896 sz
= fold_build2_loc (input_location
,
2897 MULT_EXPR
, sizetype
, sz
, n
);
2898 type
= TREE_TYPE (type
);
2905 splay_tree target_remap
;
2906 bool clear_location
;
2909 /* Called from break_out_target_exprs via mapcar. */
2912 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2914 bot_data
&data
= *(bot_data
*)data_
;
2915 splay_tree target_remap
= data
.target_remap
;
2918 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2920 /* There can't be any TARGET_EXPRs or their slot variables below this
2921 point. But we must make a copy, in case subsequent processing
2922 alters any part of it. For example, during gimplification a cast
2923 of the form (T) &X::f (where "f" is a member function) will lead
2924 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2926 *tp
= unshare_expr (t
);
2929 if (TREE_CODE (t
) == TARGET_EXPR
)
2933 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2935 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2936 tf_warning_or_error
);
2937 if (u
== error_mark_node
)
2939 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2940 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2943 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2944 tf_warning_or_error
);
2946 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2947 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2948 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2950 /* Map the old variable to the new one. */
2951 splay_tree_insert (target_remap
,
2952 (splay_tree_key
) TREE_OPERAND (t
, 0),
2953 (splay_tree_value
) TREE_OPERAND (u
, 0));
2955 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2956 data
.clear_location
);
2957 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2958 return error_mark_node
;
2960 /* Replace the old expression with the new version. */
2962 /* We don't have to go below this point; the recursive call to
2963 break_out_target_exprs will have handled anything below this
2968 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2971 splay_tree_node n
= splay_tree_lookup (target_remap
,
2972 (splay_tree_key
) t
);
2975 *tp
= (tree
)n
->value
;
2980 copy_tree_r (tp
, walk_subtrees
, NULL
);
2981 splay_tree_insert (target_remap
,
2983 (splay_tree_value
)*tp
);
2984 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2985 splay_tree_insert (target_remap
,
2986 (splay_tree_key
)*tp
,
2987 (splay_tree_value
)*tp
);
2992 /* Make a copy of this node. */
2993 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2994 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2995 if (!processing_template_decl
)
2996 set_flags_from_callee (*tp
);
2997 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2998 SET_EXPR_LOCATION (*tp
, input_location
);
3002 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3003 DATA is really a splay-tree mapping old variables to new
3007 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3009 bot_data
&data
= *(bot_data
*)data_
;
3010 splay_tree target_remap
= data
.target_remap
;
3014 splay_tree_node n
= splay_tree_lookup (target_remap
,
3015 (splay_tree_key
) *t
);
3017 *t
= (tree
) n
->value
;
3019 else if (TREE_CODE (*t
) == PARM_DECL
3020 && DECL_NAME (*t
) == this_identifier
3021 && !DECL_CONTEXT (*t
))
3023 /* In an NSDMI we need to replace the 'this' parameter we used for
3024 parsing with the real one for this function. */
3025 *t
= current_class_ptr
;
3027 else if (TREE_CODE (*t
) == CONVERT_EXPR
3028 && CONVERT_EXPR_VBASE_PATH (*t
))
3030 /* In an NSDMI build_base_path defers building conversions to virtual
3031 bases, and we handle it here. */
3032 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3033 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3035 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3036 if (BINFO_TYPE (binfo
) == basetype
)
3038 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3039 tf_warning_or_error
);
3045 /* When we parse a default argument expression, we may create
3046 temporary variables via TARGET_EXPRs. When we actually use the
3047 default-argument expression, we make a copy of the expression
3048 and replace the temporaries with appropriate local versions.
3050 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3054 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3056 static int target_remap_count
;
3057 static splay_tree target_remap
;
3059 if (!target_remap_count
++)
3060 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3061 /*splay_tree_delete_key_fn=*/NULL
,
3062 /*splay_tree_delete_value_fn=*/NULL
);
3063 bot_data data
= { target_remap
, clear_location
};
3064 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3065 t
= error_mark_node
;
3066 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3068 if (!--target_remap_count
)
3070 splay_tree_delete (target_remap
);
3071 target_remap
= NULL
;
3077 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3078 which we expect to have type TYPE. */
3081 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3083 if (index
== NULL_TREE
)
3084 /* Can't refer to a particular member of a vector. */
3086 else if (TREE_CODE (index
) == INTEGER_CST
)
3087 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3089 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3090 /*reference*/false, tf_none
);
3093 tree objtype
= TREE_TYPE (obj
);
3094 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3096 /* When the destination object refers to a flexible array member
3097 verify that it matches the type of the source object except
3098 for its domain and qualifiers. */
3099 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3100 TYPE_MAIN_VARIANT (objtype
),
3101 COMPARE_REDECLARATION
));
3104 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3110 struct replace_placeholders_t
3112 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3113 tree exp
; /* The outermost exp. */
3114 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3115 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3118 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3119 build up subexpressions as we go deeper. */
3122 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3124 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3127 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3129 *walk_subtrees
= false;
3133 switch (TREE_CODE (*t
))
3135 case PLACEHOLDER_EXPR
:
3138 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3140 x
= TREE_OPERAND (x
, 0))
3141 gcc_assert (handled_component_p (x
));
3142 *t
= unshare_expr (x
);
3143 *walk_subtrees
= false;
3150 constructor_elt
*ce
;
3151 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3152 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3153 other than the d->exp one, those have PLACEHOLDER_EXPRs
3154 related to another object. */
3155 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3157 || d
->pset
->add (*t
))
3159 *walk_subtrees
= false;
3162 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3164 tree
*valp
= &ce
->value
;
3165 tree type
= TREE_TYPE (*valp
);
3168 if (TREE_CODE (*valp
) == CONSTRUCTOR
3169 && AGGREGATE_TYPE_P (type
))
3171 /* If we're looking at the initializer for OBJ, then build
3172 a sub-object reference. If we're looking at an
3173 initializer for another object, just pass OBJ down. */
3174 if (same_type_ignoring_top_level_qualifiers_p
3175 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3176 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3177 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3178 valp
= &TARGET_EXPR_INITIAL (*valp
);
3181 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3184 *walk_subtrees
= false;
3189 if (d
->pset
->add (*t
))
3190 *walk_subtrees
= false;
3197 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3198 a PLACEHOLDER_EXPR has been encountered. */
3201 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3203 /* This is only relevant for C++14. */
3204 if (cxx_dialect
< cxx14
)
3207 /* If the object isn't a (member of a) class, do nothing. */
3209 while (TREE_CODE (op0
) == COMPONENT_REF
)
3210 op0
= TREE_OPERAND (op0
, 0);
3211 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3215 if (TREE_CODE (exp
) == TARGET_EXPR
)
3216 tp
= &TARGET_EXPR_INITIAL (exp
);
3217 hash_set
<tree
> pset
;
3218 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3219 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3221 *seen_p
= data
.seen
;
3225 /* Callback function for find_placeholders. */
3228 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3230 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3232 *walk_subtrees
= false;
3236 switch (TREE_CODE (*t
))
3238 case PLACEHOLDER_EXPR
:
3242 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3243 *walk_subtrees
= false;
3253 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3254 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3257 find_placeholders (tree exp
)
3259 /* This is only relevant for C++14. */
3260 if (cxx_dialect
< cxx14
)
3263 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3266 /* Similar to `build_nt', but for template definitions of dependent
3270 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3277 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3281 t
= make_node (code
);
3282 SET_EXPR_LOCATION (t
, loc
);
3283 length
= TREE_CODE_LENGTH (code
);
3285 for (i
= 0; i
< length
; i
++)
3286 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3292 /* Similar to `build', but for template definitions. */
3295 build_min (enum tree_code code
, tree tt
, ...)
3302 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3306 t
= make_node (code
);
3307 length
= TREE_CODE_LENGTH (code
);
3310 for (i
= 0; i
< length
; i
++)
3312 tree x
= va_arg (p
, tree
);
3313 TREE_OPERAND (t
, i
) = x
;
3314 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3315 TREE_SIDE_EFFECTS (t
) = 1;
3323 /* Similar to `build', but for template definitions of non-dependent
3324 expressions. NON_DEP is the non-dependent expression that has been
3328 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3335 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3337 va_start (p
, non_dep
);
3339 if (REFERENCE_REF_P (non_dep
))
3340 non_dep
= TREE_OPERAND (non_dep
, 0);
3342 t
= make_node (code
);
3343 length
= TREE_CODE_LENGTH (code
);
3344 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3345 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3347 for (i
= 0; i
< length
; i
++)
3348 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3350 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3351 /* This should not be considered a COMPOUND_EXPR, because it
3352 resolves to an overload. */
3353 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3356 return convert_from_reference (t
);
3359 /* Similar to build_min_nt, but call expressions */
3362 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3367 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3368 CALL_EXPR_FN (ret
) = fn
;
3369 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3370 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3371 CALL_EXPR_ARG (ret
, ix
) = t
;
3376 /* Similar to `build_min_nt_call_vec', but for template definitions of
3377 non-dependent expressions. NON_DEP is the non-dependent expression
3378 that has been built. */
3381 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3383 tree t
= build_min_nt_call_vec (fn
, argvec
);
3384 if (REFERENCE_REF_P (non_dep
))
3385 non_dep
= TREE_OPERAND (non_dep
, 0);
3386 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3387 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3388 return convert_from_reference (t
);
3391 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3392 a call to an operator overload. OP is the operator that has been
3393 overloaded. NON_DEP is the non-dependent expression that's been built,
3394 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3395 the overload that NON_DEP is calling. */
3398 build_min_non_dep_op_overload (enum tree_code op
,
3403 int nargs
, expected_nargs
;
3405 vec
<tree
, va_gc
> *args
;
3407 non_dep
= extract_call_expr (non_dep
);
3409 nargs
= call_expr_nargs (non_dep
);
3411 expected_nargs
= cp_tree_code_length (op
);
3412 if ((op
== POSTINCREMENT_EXPR
3413 || op
== POSTDECREMENT_EXPR
)
3414 /* With -fpermissive non_dep could be operator++(). */
3415 && (!flag_permissive
|| nargs
!= expected_nargs
))
3416 expected_nargs
+= 1;
3417 gcc_assert (nargs
== expected_nargs
);
3419 args
= make_tree_vector ();
3420 va_start (p
, overload
);
3422 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3425 for (int i
= 0; i
< nargs
; i
++)
3427 tree arg
= va_arg (p
, tree
);
3428 vec_safe_push (args
, arg
);
3431 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3433 tree object
= va_arg (p
, tree
);
3434 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3435 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3436 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3437 object
, method
, NULL_TREE
);
3438 for (int i
= 1; i
< nargs
; i
++)
3440 tree arg
= va_arg (p
, tree
);
3441 vec_safe_push (args
, arg
);
3448 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3449 release_tree_vector (args
);
3451 tree call_expr
= extract_call_expr (call
);
3452 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3453 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3454 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3455 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3460 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3463 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3465 unsigned len
= vec_safe_length (old_vec
);
3466 gcc_assert (idx
<= len
);
3468 vec
<tree
, va_gc
> *new_vec
= NULL
;
3469 vec_alloc (new_vec
, len
+ 1);
3472 for (i
= 0; i
< len
; ++i
)
3475 new_vec
->quick_push (elt
);
3476 new_vec
->quick_push ((*old_vec
)[i
]);
3479 new_vec
->quick_push (elt
);
3485 get_type_decl (tree t
)
3487 if (TREE_CODE (t
) == TYPE_DECL
)
3490 return TYPE_STUB_DECL (t
);
3491 gcc_assert (t
== error_mark_node
);
3495 /* Returns the namespace that contains DECL, whether directly or
3499 decl_namespace_context (tree decl
)
3503 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3505 else if (TYPE_P (decl
))
3506 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3508 decl
= CP_DECL_CONTEXT (decl
);
3512 /* Returns true if decl is within an anonymous namespace, however deeply
3513 nested, or false otherwise. */
3516 decl_anon_ns_mem_p (const_tree decl
)
3518 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3520 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3522 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3524 decl
= CP_DECL_CONTEXT (decl
);
3526 return !TREE_PUBLIC (decl
);
3529 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3530 CALL_EXPRS. Return whether they are equivalent. */
3533 called_fns_equal (tree t1
, tree t2
)
3535 /* Core 1321: dependent names are equivalent even if the overload sets
3536 are different. But do compare explicit template arguments. */
3537 tree name1
= dependent_name (t1
);
3538 tree name2
= dependent_name (t2
);
3541 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3546 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3547 targs1
= TREE_OPERAND (t1
, 1);
3548 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3549 targs2
= TREE_OPERAND (t2
, 1);
3550 return cp_tree_equal (targs1
, targs2
);
3553 return cp_tree_equal (t1
, t2
);
3556 /* Return truthvalue of whether T1 is the same tree structure as T2.
3557 Return 1 if they are the same. Return 0 if they are different. */
3560 cp_tree_equal (tree t1
, tree t2
)
3562 enum tree_code code1
, code2
;
3569 code1
= TREE_CODE (t1
);
3570 code2
= TREE_CODE (t2
);
3575 if (CONSTANT_CLASS_P (t1
)
3576 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3582 /* There's only a single VOID_CST node, so we should never reach
3587 return tree_int_cst_equal (t1
, t2
);
3590 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3593 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3594 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3595 TREE_STRING_LENGTH (t1
));
3598 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3599 TREE_FIXED_CST (t2
));
3602 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3603 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3606 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3609 /* We need to do this when determining whether or not two
3610 non-type pointer to member function template arguments
3612 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3613 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3618 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3620 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3621 if (!cp_tree_equal (field
, elt2
->index
)
3622 || !cp_tree_equal (value
, elt2
->value
))
3629 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3631 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3633 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3636 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3641 call_expr_arg_iterator iter1
, iter2
;
3642 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3644 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3645 arg2
= first_call_expr_arg (t2
, &iter2
);
3647 arg1
= next_call_expr_arg (&iter1
),
3648 arg2
= next_call_expr_arg (&iter2
))
3649 if (!cp_tree_equal (arg1
, arg2
))
3658 tree o1
= TREE_OPERAND (t1
, 0);
3659 tree o2
= TREE_OPERAND (t2
, 0);
3661 /* Special case: if either target is an unallocated VAR_DECL,
3662 it means that it's going to be unified with whatever the
3663 TARGET_EXPR is really supposed to initialize, so treat it
3664 as being equivalent to anything. */
3665 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3666 && !DECL_RTL_SET_P (o1
))
3668 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3669 && !DECL_RTL_SET_P (o2
))
3671 else if (!cp_tree_equal (o1
, o2
))
3674 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3678 /* For comparing uses of parameters in late-specified return types
3679 with an out-of-class definition of the function, but can also come
3680 up for expressions that involve 'this' in a member function
3683 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3684 /* When comparing hash table entries, only an exact match is
3685 good enough; we don't want to replace 'this' with the
3686 version from another function. But be more flexible
3687 with local parameters in a requires-expression. */
3690 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3692 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3694 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3696 if (DECL_ARTIFICIAL (t1
)
3697 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3698 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3708 case IDENTIFIER_NODE
:
3713 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3714 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3715 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3716 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3717 BASELINK_FUNCTIONS (t2
)));
3719 case TEMPLATE_PARM_INDEX
:
3720 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3721 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3722 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3723 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3724 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3725 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3727 case TEMPLATE_ID_EXPR
:
3728 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3729 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3731 case CONSTRAINT_INFO
:
3732 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3733 CI_ASSOCIATED_CONSTRAINTS (t2
));
3736 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3737 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3738 CHECK_CONSTR_ARGS (t2
)));
3743 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3745 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3746 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3747 TREE_VEC_ELT (t2
, ix
)))
3755 tree o1
= TREE_OPERAND (t1
, 0);
3756 tree o2
= TREE_OPERAND (t2
, 0);
3758 if (code1
== SIZEOF_EXPR
)
3760 if (SIZEOF_EXPR_TYPE_P (t1
))
3761 o1
= TREE_TYPE (o1
);
3762 if (SIZEOF_EXPR_TYPE_P (t2
))
3763 o2
= TREE_TYPE (o2
);
3765 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3768 return same_type_p (o1
, o2
);
3770 return cp_tree_equal (o1
, o2
);
3775 tree t1_op1
, t2_op1
;
3777 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3780 t1_op1
= TREE_OPERAND (t1
, 1);
3781 t2_op1
= TREE_OPERAND (t2
, 1);
3782 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3785 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3789 /* Two pointer-to-members are the same if they point to the same
3790 field or function in the same class. */
3791 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3794 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3798 /* Two overloads. Must be exactly the same set of decls. */
3799 lkp_iterator
first (t1
);
3800 lkp_iterator
second (t2
);
3802 for (; first
&& second
; ++first
, ++second
)
3803 if (*first
!= *second
)
3805 return !(first
|| second
);
3809 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3811 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3812 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3815 case STATIC_CAST_EXPR
:
3816 case REINTERPRET_CAST_EXPR
:
3817 case CONST_CAST_EXPR
:
3818 case DYNAMIC_CAST_EXPR
:
3819 case IMPLICIT_CONV_EXPR
:
3822 case NON_LVALUE_EXPR
:
3823 case VIEW_CONVERT_EXPR
:
3824 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3826 /* Now compare operands as usual. */
3829 case DEFERRED_NOEXCEPT
:
3830 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3831 DEFERRED_NOEXCEPT_PATTERN (t2
))
3832 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3833 DEFERRED_NOEXCEPT_ARGS (t2
)));
3837 if (DECL_DEPENDENT_P (t1
) && DECL_DEPENDENT_P (t2
))
3838 return (cp_tree_equal (USING_DECL_SCOPE (t1
),
3839 USING_DECL_SCOPE (t2
))
3840 && cp_tree_equal (DECL_NAME (t1
),
3848 switch (TREE_CODE_CLASS (code1
))
3852 case tcc_comparison
:
3853 case tcc_expression
:
3860 n
= cp_tree_operand_length (t1
);
3861 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3862 && n
!= TREE_OPERAND_LENGTH (t2
))
3865 for (i
= 0; i
< n
; ++i
)
3866 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3873 return same_type_p (t1
, t2
);
3877 /* We can get here with --disable-checking. */
3881 /* The type of ARG when used as an lvalue. */
3884 lvalue_type (tree arg
)
3886 tree type
= TREE_TYPE (arg
);
3890 /* The type of ARG for printing error messages; denote lvalues with
3894 error_type (tree arg
)
3896 tree type
= TREE_TYPE (arg
);
3898 if (TREE_CODE (type
) == ARRAY_TYPE
)
3900 else if (TREE_CODE (type
) == ERROR_MARK
)
3902 else if (lvalue_p (arg
))
3903 type
= build_reference_type (lvalue_type (arg
));
3904 else if (MAYBE_CLASS_TYPE_P (type
))
3905 type
= lvalue_type (arg
);
3910 /* Does FUNCTION use a variable-length argument list? */
3913 varargs_function_p (const_tree function
)
3915 return stdarg_p (TREE_TYPE (function
));
3918 /* Returns 1 if decl is a member of a class. */
3921 member_p (const_tree decl
)
3923 const_tree
const ctx
= DECL_CONTEXT (decl
);
3924 return (ctx
&& TYPE_P (ctx
));
3927 /* Create a placeholder for member access where we don't actually have an
3928 object that the access is against. */
3931 build_dummy_object (tree type
)
3933 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3934 return cp_build_fold_indirect_ref (decl
);
3937 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3938 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3939 binfo path from current_class_type to TYPE, or 0. */
3942 maybe_dummy_object (tree type
, tree
* binfop
)
3946 tree current
= current_nonlambda_class_type ();
3949 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3950 tf_warning_or_error
)))
3954 /* Reference from a nested class member function. */
3956 binfo
= TYPE_BINFO (type
);
3962 if (current_class_ref
3963 /* current_class_ref might not correspond to current_class_type if
3964 we're in tsubst_default_argument or a lambda-declarator; in either
3965 case, we want to use current_class_ref if it matches CONTEXT. */
3966 && (same_type_ignoring_top_level_qualifiers_p
3967 (TREE_TYPE (current_class_ref
), context
)))
3968 decl
= current_class_ref
;
3970 decl
= build_dummy_object (context
);
3975 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3978 is_dummy_object (const_tree ob
)
3980 if (INDIRECT_REF_P (ob
))
3981 ob
= TREE_OPERAND (ob
, 0);
3982 return (TREE_CODE (ob
) == CONVERT_EXPR
3983 && TREE_OPERAND (ob
, 0) == void_node
);
3986 /* Returns 1 iff type T is something we want to treat as a scalar type for
3987 the purpose of deciding whether it is trivial/POD/standard-layout. */
3990 scalarish_type_p (const_tree t
)
3992 if (t
== error_mark_node
)
3995 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3998 /* Returns true iff T requires non-trivial default initialization. */
4001 type_has_nontrivial_default_init (const_tree t
)
4003 t
= strip_array_types (CONST_CAST_TREE (t
));
4005 if (CLASS_TYPE_P (t
))
4006 return TYPE_HAS_COMPLEX_DFLT (t
);
4011 /* Track classes with only deleted copy/move constructors so that we can warn
4012 if they are used in call/return by value. */
4014 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4016 remember_deleted_copy (const_tree t
)
4018 if (!deleted_copy_types
)
4019 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4020 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4023 maybe_warn_parm_abi (tree t
, location_t loc
)
4025 if (!deleted_copy_types
4026 || !deleted_copy_types
->contains (t
))
4029 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4030 && classtype_has_non_deleted_move_ctor (t
))
4033 auto_diagnostic_group d
;
4034 if (flag_abi_version
> 12)
4035 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=13 (GCC 8.2) fixes the "
4036 "calling convention for %qT, which was accidentally "
4037 "changed in 8.1", t
);
4039 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=12 (GCC 8.1) accident"
4040 "ally changes the calling convention for %qT", t
);
4042 inform (location_of (t
), " declared here");
4046 auto_diagnostic_group d
;
4047 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4048 "-fabi-version=13 (GCC 8.2)", t
))
4049 inform (location_of (t
), " because all of its copy and move "
4050 "constructors are deleted");
4053 /* Returns true iff copying an object of type T (including via move
4054 constructor) is non-trivial. That is, T has no non-trivial copy
4055 constructors and no non-trivial move constructors, and not all copy/move
4056 constructors are deleted. This function implements the ABI notion of
4057 non-trivial copy, which has diverged from the one in the standard. */
4060 type_has_nontrivial_copy_init (const_tree type
)
4062 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4064 if (CLASS_TYPE_P (t
))
4066 gcc_assert (COMPLETE_TYPE_P (t
));
4068 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4069 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4073 if (cxx_dialect
< cxx11
)
4074 /* No deleted functions before C++11. */
4077 /* Before ABI v12 we did a bitwise copy of types with only deleted
4078 copy/move constructors. */
4079 if (!abi_version_at_least (12)
4080 && !(warn_abi
&& abi_version_crosses (12)))
4083 bool saw_copy
= false;
4084 bool saw_non_deleted
= false;
4085 bool saw_non_deleted_move
= false;
4087 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4088 saw_copy
= saw_non_deleted
= true;
4089 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4092 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4093 /* [class.copy]/8 If the class definition declares a move
4094 constructor or move assignment operator, the implicitly declared
4095 copy constructor is defined as deleted.... */;
4097 /* Any other reason the implicitly-declared function would be
4098 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4100 saw_non_deleted
= true;
4103 if (!saw_non_deleted
)
4104 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4110 if (!DECL_DELETED_FN (fn
))
4112 /* Not deleted, therefore trivial. */
4113 saw_non_deleted
= true;
4117 else if (move_fn_p (fn
))
4118 if (!DECL_DELETED_FN (fn
))
4119 saw_non_deleted_move
= true;
4122 gcc_assert (saw_copy
);
4124 /* ABI v12 buggily ignored move constructors. */
4125 bool v11nontriv
= false;
4126 bool v12nontriv
= !saw_non_deleted
;
4127 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4128 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4129 : flag_abi_version
== 12 ? v12nontriv
4131 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4132 : warn_abi_version
== 12 ? v12nontriv
4134 if (nontriv
!= warn_nontriv
)
4135 remember_deleted_copy (t
);
4143 /* Returns 1 iff type T is a trivially copyable type, as defined in
4144 [basic.types] and [class]. */
4147 trivially_copyable_p (const_tree t
)
4149 t
= strip_array_types (CONST_CAST_TREE (t
));
4151 if (CLASS_TYPE_P (t
))
4152 return ((!TYPE_HAS_COPY_CTOR (t
)
4153 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4154 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4155 && (!TYPE_HAS_COPY_ASSIGN (t
)
4156 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4157 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4158 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4160 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4163 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4167 trivial_type_p (const_tree t
)
4169 t
= strip_array_types (CONST_CAST_TREE (t
));
4171 if (CLASS_TYPE_P (t
))
4172 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4173 && trivially_copyable_p (t
));
4175 return scalarish_type_p (t
);
4178 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4181 pod_type_p (const_tree t
)
4183 /* This CONST_CAST is okay because strip_array_types returns its
4184 argument unmodified and we assign it to a const_tree. */
4185 t
= strip_array_types (CONST_CAST_TREE(t
));
4187 if (!CLASS_TYPE_P (t
))
4188 return scalarish_type_p (t
);
4189 else if (cxx_dialect
> cxx98
)
4190 /* [class]/10: A POD struct is a class that is both a trivial class and a
4191 standard-layout class, and has no non-static data members of type
4192 non-POD struct, non-POD union (or array of such types).
4194 We don't need to check individual members because if a member is
4195 non-std-layout or non-trivial, the class will be too. */
4196 return (std_layout_type_p (t
) && trivial_type_p (t
));
4198 /* The C++98 definition of POD is different. */
4199 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4202 /* Returns true iff T is POD for the purpose of layout, as defined in the
4206 layout_pod_type_p (const_tree t
)
4208 t
= strip_array_types (CONST_CAST_TREE (t
));
4210 if (CLASS_TYPE_P (t
))
4211 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4213 return scalarish_type_p (t
);
4216 /* Returns true iff T is a standard-layout type, as defined in
4220 std_layout_type_p (const_tree t
)
4222 t
= strip_array_types (CONST_CAST_TREE (t
));
4224 if (CLASS_TYPE_P (t
))
4225 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4227 return scalarish_type_p (t
);
4230 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4232 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4233 as defined in [meta.unary.prop]. */
4236 type_has_unique_obj_representations (const_tree t
)
4240 t
= strip_array_types (CONST_CAST_TREE (t
));
4242 if (!trivially_copyable_p (t
))
4245 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4246 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4248 switch (TREE_CODE (t
))
4252 case REFERENCE_TYPE
:
4253 /* If some backend has any paddings in these types, we should add
4254 a target hook for this and handle it there. */
4258 /* For bool values other than 0 and 1 should only appear with
4259 undefined behavior. */
4263 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4266 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4267 when storing long double values, so for that we have to return false.
4268 Other kinds of floating point values are questionable due to +.0/-.0
4269 and NaNs, let's play safe for now. */
4272 case FIXED_POINT_TYPE
:
4280 return type_has_unique_obj_representations (TREE_TYPE (t
));
4283 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4284 if (CLASS_TYPE_P (t
))
4286 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4287 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4295 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4296 if (TREE_CODE (field
) == FIELD_DECL
)
4299 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4300 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4306 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4308 if (CLASS_TYPE_P (t
))
4310 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4311 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4326 /* Helper function for type_has_unique_obj_representations. */
4329 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4331 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4332 if (TREE_CODE (field
) != FIELD_DECL
)
4334 /* For bases, can't use type_has_unique_obj_representations here, as in
4335 struct S { int i : 24; S (); };
4336 struct T : public S { int j : 8; T (); };
4337 S doesn't have unique obj representations, but T does. */
4338 else if (DECL_FIELD_IS_BASE (field
))
4340 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4344 else if (DECL_C_BIT_FIELD (field
))
4346 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4347 if (!type_has_unique_obj_representations (btype
))
4350 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4354 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4355 if (TREE_CODE (field
) == FIELD_DECL
)
4357 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4358 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4359 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4362 if (DECL_SIZE (field
))
4364 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4368 if (cur
!= wi::to_offset (sz
))
4374 /* Nonzero iff type T is a class template implicit specialization. */
4377 class_tmpl_impl_spec_p (const_tree t
)
4379 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4382 /* Returns 1 iff zero initialization of type T means actually storing
4386 zero_init_p (const_tree t
)
4388 /* This CONST_CAST is okay because strip_array_types returns its
4389 argument unmodified and we assign it to a const_tree. */
4390 t
= strip_array_types (CONST_CAST_TREE(t
));
4392 if (t
== error_mark_node
)
4395 /* NULL pointers to data members are initialized with -1. */
4396 if (TYPE_PTRDATAMEM_P (t
))
4399 /* Classes that contain types that can't be zero-initialized, cannot
4400 be zero-initialized themselves. */
4401 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4407 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4408 warn_unused_result attribute. */
4411 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4412 int /*flags*/, bool *no_add_attrs
)
4414 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4416 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4417 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4418 "return type", name
, *node
);
4420 else if (OVERLOAD_TYPE_P (*node
))
4424 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4425 "functions or to class or enumeration types", name
);
4426 *no_add_attrs
= true;
4431 /* Table of valid C++ attributes. */
4432 const struct attribute_spec cxx_attribute_table
[] =
4434 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4435 affects_type_identity, handler, exclude } */
4436 { "init_priority", 1, 1, true, false, false, false,
4437 handle_init_priority_attribute
, NULL
},
4438 { "abi_tag", 1, -1, false, false, false, true,
4439 handle_abi_tag_attribute
, NULL
},
4440 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4443 /* Table of C++ standard attributes. */
4444 const struct attribute_spec std_attribute_table
[] =
4446 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4447 affects_type_identity, handler, exclude } */
4448 { "maybe_unused", 0, 0, false, false, false, false,
4449 handle_unused_attribute
, NULL
},
4450 { "nodiscard", 0, 0, false, false, false, false,
4451 handle_nodiscard_attribute
, NULL
},
4452 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4455 /* Handle an "init_priority" attribute; arguments as in
4456 struct attribute_spec.handler. */
4458 handle_init_priority_attribute (tree
* node
,
4464 tree initp_expr
= TREE_VALUE (args
);
4466 tree type
= TREE_TYPE (decl
);
4469 STRIP_NOPS (initp_expr
);
4470 initp_expr
= default_conversion (initp_expr
);
4472 initp_expr
= maybe_constant_value (initp_expr
);
4474 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4476 error ("requested init_priority is not an integer constant");
4477 cxx_constant_value (initp_expr
);
4478 *no_add_attrs
= true;
4482 pri
= TREE_INT_CST_LOW (initp_expr
);
4484 type
= strip_array_types (type
);
4486 if (decl
== NULL_TREE
4488 || !TREE_STATIC (decl
)
4489 || DECL_EXTERNAL (decl
)
4490 || (TREE_CODE (type
) != RECORD_TYPE
4491 && TREE_CODE (type
) != UNION_TYPE
)
4492 /* Static objects in functions are initialized the
4493 first time control passes through that
4494 function. This is not precise enough to pin down an
4495 init_priority value, so don't allow it. */
4496 || current_function_decl
)
4498 error ("can only use %qE attribute on file-scope definitions "
4499 "of objects of class type", name
);
4500 *no_add_attrs
= true;
4504 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4506 error ("requested init_priority is out of range");
4507 *no_add_attrs
= true;
4511 /* Check for init_priorities that are reserved for
4512 language and runtime support implementations.*/
4513 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4516 (0, "requested init_priority is reserved for internal use");
4519 if (SUPPORTS_INIT_PRIORITY
)
4521 SET_DECL_INIT_PRIORITY (decl
, pri
);
4522 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4527 error ("%qE attribute is not supported on this platform", name
);
4528 *no_add_attrs
= true;
4533 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4534 and the new one has the tags in NEW_. Give an error if there are tags
4535 in NEW_ that weren't in OLD. */
4538 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4540 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4541 old
= TREE_VALUE (old
);
4542 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4543 new_
= TREE_VALUE (new_
);
4545 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4547 tree str
= TREE_VALUE (t
);
4548 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4550 tree ostr
= TREE_VALUE (in
);
4551 if (cp_tree_equal (str
, ostr
))
4554 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4560 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4566 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4567 ill-formed, give an error and return false; otherwise, return true. */
4570 check_abi_tag_args (tree args
, tree name
)
4574 error ("the %qE attribute requires arguments", name
);
4577 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4579 tree elt
= TREE_VALUE (arg
);
4580 if (TREE_CODE (elt
) != STRING_CST
4581 || (!same_type_ignoring_top_level_qualifiers_p
4582 (strip_array_types (TREE_TYPE (elt
)),
4585 error ("arguments to the %qE attribute must be narrow string "
4589 const char *begin
= TREE_STRING_POINTER (elt
);
4590 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4591 for (const char *p
= begin
; p
!= end
; ++p
)
4596 if (!ISALPHA (c
) && c
!= '_')
4598 error ("arguments to the %qE attribute must contain valid "
4599 "identifiers", name
);
4600 inform (input_location
, "%<%c%> is not a valid first "
4601 "character for an identifier", c
);
4605 else if (p
== end
- 1)
4606 gcc_assert (c
== 0);
4609 if (!ISALNUM (c
) && c
!= '_')
4611 error ("arguments to the %qE attribute must contain valid "
4612 "identifiers", name
);
4613 inform (input_location
, "%<%c%> is not a valid character "
4614 "in an identifier", c
);
4623 /* Handle an "abi_tag" attribute; arguments as in
4624 struct attribute_spec.handler. */
4627 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4628 int flags
, bool* no_add_attrs
)
4630 if (!check_abi_tag_args (args
, name
))
4635 if (!OVERLOAD_TYPE_P (*node
))
4637 error ("%qE attribute applied to non-class, non-enum type %qT",
4641 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4643 error ("%qE attribute applied to %qT after its definition",
4647 else if (CLASS_TYPE_P (*node
)
4648 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4650 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4651 "template instantiation %qT", name
, *node
);
4654 else if (CLASS_TYPE_P (*node
)
4655 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4657 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4658 "template specialization %qT", name
, *node
);
4662 tree attributes
= TYPE_ATTRIBUTES (*node
);
4663 tree decl
= TYPE_NAME (*node
);
4665 /* Make sure all declarations have the same abi tags. */
4666 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4668 if (!check_abi_tag_redeclaration (decl
,
4669 lookup_attribute ("abi_tag",
4677 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4679 error ("%qE attribute applied to non-function, non-variable %qD",
4683 else if (DECL_LANGUAGE (*node
) == lang_c
)
4685 error ("%qE attribute applied to extern \"C\" declaration %qD",
4694 *no_add_attrs
= true;
4698 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4699 thing pointed to by the constant. */
4702 make_ptrmem_cst (tree type
, tree member
)
4704 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4705 TREE_TYPE (ptrmem_cst
) = type
;
4706 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4710 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4711 return an existing type if an appropriate type already exists. */
4714 cp_build_type_attribute_variant (tree type
, tree attributes
)
4718 new_type
= build_type_attribute_variant (type
, attributes
);
4719 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4720 || TREE_CODE (new_type
) == METHOD_TYPE
)
4721 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4723 /* Making a new main variant of a class type is broken. */
4724 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4729 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4730 Called only after doing all language independent checks. */
4733 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4735 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4736 || TREE_CODE (typea
) == METHOD_TYPE
);
4738 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4740 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4742 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4743 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4746 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4747 C++, these are the exception-specifier and ref-qualifier. */
4750 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4752 tree type
= CONST_CAST_TREE (typea
);
4753 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4754 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4755 TYPE_RAISES_EXCEPTIONS (typeb
),
4756 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4760 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4761 traversal. Called from walk_tree. */
4764 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4765 void *data
, hash_set
<tree
> *pset
)
4767 enum tree_code code
= TREE_CODE (*tp
);
4770 #define WALK_SUBTREE(NODE) \
4773 result = cp_walk_tree (&(NODE), func, data, pset); \
4774 if (result) goto out; \
4778 /* Not one of the easy cases. We must explicitly go through the
4784 case TEMPLATE_TEMPLATE_PARM
:
4785 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4786 case UNBOUND_CLASS_TEMPLATE
:
4787 case TEMPLATE_PARM_INDEX
:
4788 case TEMPLATE_TYPE_PARM
:
4791 case UNDERLYING_TYPE
:
4792 /* None of these have subtrees other than those already walked
4794 *walk_subtrees_p
= 0;
4798 if (BASELINK_QUALIFIED_P (*tp
))
4799 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4800 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4801 *walk_subtrees_p
= 0;
4805 WALK_SUBTREE (TREE_TYPE (*tp
));
4806 *walk_subtrees_p
= 0;
4810 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4814 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4815 WALK_SUBTREE (OVL_CHAIN (*tp
));
4816 *walk_subtrees_p
= 0;
4820 WALK_SUBTREE (DECL_NAME (*tp
));
4821 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4822 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4823 *walk_subtrees_p
= 0;
4827 if (TYPE_PTRMEMFUNC_P (*tp
))
4828 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4831 case TYPE_ARGUMENT_PACK
:
4832 case NONTYPE_ARGUMENT_PACK
:
4834 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4835 int i
, len
= TREE_VEC_LENGTH (args
);
4836 for (i
= 0; i
< len
; i
++)
4837 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4841 case TYPE_PACK_EXPANSION
:
4842 WALK_SUBTREE (TREE_TYPE (*tp
));
4843 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4844 *walk_subtrees_p
= 0;
4847 case EXPR_PACK_EXPANSION
:
4848 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4849 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4850 *walk_subtrees_p
= 0;
4854 case REINTERPRET_CAST_EXPR
:
4855 case STATIC_CAST_EXPR
:
4856 case CONST_CAST_EXPR
:
4857 case DYNAMIC_CAST_EXPR
:
4858 case IMPLICIT_CONV_EXPR
:
4859 if (TREE_TYPE (*tp
))
4860 WALK_SUBTREE (TREE_TYPE (*tp
));
4864 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4865 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4867 *walk_subtrees_p
= 0;
4871 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4872 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4873 *walk_subtrees_p
= 0;
4877 ++cp_unevaluated_operand
;
4878 /* We can't use WALK_SUBTREE here because of the goto. */
4879 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4880 --cp_unevaluated_operand
;
4881 *walk_subtrees_p
= 0;
4887 ++cp_unevaluated_operand
;
4888 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4889 --cp_unevaluated_operand
;
4890 *walk_subtrees_p
= 0;
4894 // Only recurse through the nested expression. Do not
4895 // walk the parameter list. Doing so causes false
4896 // positives in the pack expansion checker since the
4897 // requires parameters are introduced as pack expansions.
4898 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4899 *walk_subtrees_p
= 0;
4903 /* User variables should be mentioned in BIND_EXPR_VARS
4904 and their initializers and sizes walked when walking
4905 the containing BIND_EXPR. Compiler temporaries are
4906 handled here. And also normal variables in templates,
4907 since do_poplevel doesn't build a BIND_EXPR then. */
4908 if (VAR_P (TREE_OPERAND (*tp
, 0))
4909 && (processing_template_decl
4910 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4911 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4913 tree decl
= TREE_OPERAND (*tp
, 0);
4914 WALK_SUBTREE (DECL_INITIAL (decl
));
4915 WALK_SUBTREE (DECL_SIZE (decl
));
4916 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4924 /* We didn't find what we were looking for. */
4931 /* Like save_expr, but for C++. */
4934 cp_save_expr (tree expr
)
4936 /* There is no reason to create a SAVE_EXPR within a template; if
4937 needed, we can create the SAVE_EXPR when instantiating the
4938 template. Furthermore, the middle-end cannot handle C++-specific
4940 if (processing_template_decl
)
4943 /* TARGET_EXPRs are only expanded once. */
4944 if (TREE_CODE (expr
) == TARGET_EXPR
)
4947 return save_expr (expr
);
4950 /* Initialize tree.c. */
4955 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4956 register_scoped_attributes (std_attribute_table
, NULL
);
4959 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4960 is. Note that sfk_none is zero, so this function can be used as a
4961 predicate to test whether or not DECL is a special function. */
4963 special_function_kind
4964 special_function_p (const_tree decl
)
4966 /* Rather than doing all this stuff with magic names, we should
4967 probably have a field of type `special_function_kind' in
4968 DECL_LANG_SPECIFIC. */
4969 if (DECL_INHERITED_CTOR (decl
))
4970 return sfk_inheriting_constructor
;
4971 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4972 return sfk_copy_constructor
;
4973 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4974 return sfk_move_constructor
;
4975 if (DECL_CONSTRUCTOR_P (decl
))
4976 return sfk_constructor
;
4977 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
4978 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
4980 if (copy_fn_p (decl
))
4981 return sfk_copy_assignment
;
4982 if (move_fn_p (decl
))
4983 return sfk_move_assignment
;
4985 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
4986 return sfk_destructor
;
4987 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
4988 return sfk_complete_destructor
;
4989 if (DECL_BASE_DESTRUCTOR_P (decl
))
4990 return sfk_base_destructor
;
4991 if (DECL_DELETING_DESTRUCTOR_P (decl
))
4992 return sfk_deleting_destructor
;
4993 if (DECL_CONV_FN_P (decl
))
4994 return sfk_conversion
;
4995 if (deduction_guide_p (decl
))
4996 return sfk_deduction_guide
;
5001 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5004 char_type_p (tree type
)
5006 return (same_type_p (type
, char_type_node
)
5007 || same_type_p (type
, unsigned_char_type_node
)
5008 || same_type_p (type
, signed_char_type_node
)
5009 || same_type_p (type
, char16_type_node
)
5010 || same_type_p (type
, char32_type_node
)
5011 || same_type_p (type
, wchar_type_node
));
5014 /* Returns the kind of linkage associated with the indicated DECL. Th
5015 value returned is as specified by the language standard; it is
5016 independent of implementation details regarding template
5017 instantiation, etc. For example, it is possible that a declaration
5018 to which this function assigns external linkage would not show up
5019 as a global symbol when you run `nm' on the resulting object file. */
5022 decl_linkage (tree decl
)
5024 /* This function doesn't attempt to calculate the linkage from first
5025 principles as given in [basic.link]. Instead, it makes use of
5026 the fact that we have already set TREE_PUBLIC appropriately, and
5027 then handles a few special cases. Ideally, we would calculate
5028 linkage first, and then transform that into a concrete
5031 /* Things that don't have names have no linkage. */
5032 if (!DECL_NAME (decl
))
5035 /* Fields have no linkage. */
5036 if (TREE_CODE (decl
) == FIELD_DECL
)
5039 /* Things that are TREE_PUBLIC have external linkage. */
5040 if (TREE_PUBLIC (decl
))
5043 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5044 check one of the "clones" for the real linkage. */
5045 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5046 && DECL_CHAIN (decl
)
5047 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5048 return decl_linkage (DECL_CHAIN (decl
));
5050 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5053 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5055 if (TREE_CODE (decl
) == CONST_DECL
)
5056 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5058 /* Things in local scope do not have linkage, if they don't have
5060 if (decl_function_context (decl
))
5063 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5064 are considered to have external linkage for language purposes, as do
5065 template instantiations on targets without weak symbols. DECLs really
5066 meant to have internal linkage have DECL_THIS_STATIC set. */
5067 if (TREE_CODE (decl
) == TYPE_DECL
)
5069 if (VAR_OR_FUNCTION_DECL_P (decl
))
5071 if (!DECL_THIS_STATIC (decl
))
5074 /* Static data members and static member functions from classes
5075 in anonymous namespace also don't have TREE_PUBLIC set. */
5076 if (DECL_CLASS_CONTEXT (decl
))
5080 /* Everything else has internal linkage. */
5084 /* Returns the storage duration of the object or reference associated with
5085 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5088 decl_storage_duration (tree decl
)
5090 if (TREE_CODE (decl
) == PARM_DECL
)
5092 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5094 gcc_assert (VAR_P (decl
));
5095 if (!TREE_STATIC (decl
)
5096 && !DECL_EXTERNAL (decl
))
5098 if (CP_DECL_THREAD_LOCAL_P (decl
))
5103 /* EXP is an expression that we want to pre-evaluate. Returns (in
5104 *INITP) an expression that will perform the pre-evaluation. The
5105 value returned by this function is a side-effect free expression
5106 equivalent to the pre-evaluated expression. Callers must ensure
5107 that *INITP is evaluated before EXP. */
5110 stabilize_expr (tree exp
, tree
* initp
)
5114 if (!TREE_SIDE_EFFECTS (exp
))
5115 init_expr
= NULL_TREE
;
5116 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5121 /* There are no expressions with REFERENCE_TYPE, but there can be call
5122 arguments with such a type; just treat it as a pointer. */
5123 else if (TYPE_REF_P (TREE_TYPE (exp
))
5124 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5125 || !glvalue_p (exp
))
5127 init_expr
= get_target_expr (exp
);
5128 exp
= TARGET_EXPR_SLOT (init_expr
);
5129 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5136 bool xval
= !lvalue_p (exp
);
5137 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5138 init_expr
= get_target_expr (exp
);
5139 exp
= TARGET_EXPR_SLOT (init_expr
);
5140 exp
= cp_build_fold_indirect_ref (exp
);
5146 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5150 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5151 similar expression ORIG. */
5154 add_stmt_to_compound (tree orig
, tree new_expr
)
5156 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5158 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5160 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5163 /* Like stabilize_expr, but for a call whose arguments we want to
5164 pre-evaluate. CALL is modified in place to use the pre-evaluated
5165 arguments, while, upon return, *INITP contains an expression to
5166 compute the arguments. */
5169 stabilize_call (tree call
, tree
*initp
)
5171 tree inits
= NULL_TREE
;
5173 int nargs
= call_expr_nargs (call
);
5175 if (call
== error_mark_node
|| processing_template_decl
)
5181 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5183 for (i
= 0; i
< nargs
; i
++)
5186 CALL_EXPR_ARG (call
, i
) =
5187 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5188 inits
= add_stmt_to_compound (inits
, init
);
5194 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5195 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5196 arguments, while, upon return, *INITP contains an expression to
5197 compute the arguments. */
5200 stabilize_aggr_init (tree call
, tree
*initp
)
5202 tree inits
= NULL_TREE
;
5204 int nargs
= aggr_init_expr_nargs (call
);
5206 if (call
== error_mark_node
)
5209 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5211 for (i
= 0; i
< nargs
; i
++)
5214 AGGR_INIT_EXPR_ARG (call
, i
) =
5215 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5216 inits
= add_stmt_to_compound (inits
, init
);
5222 /* Like stabilize_expr, but for an initialization.
5224 If the initialization is for an object of class type, this function
5225 takes care not to introduce additional temporaries.
5227 Returns TRUE iff the expression was successfully pre-evaluated,
5228 i.e., if INIT is now side-effect free, except for, possibly, a
5229 single call to a constructor. */
5232 stabilize_init (tree init
, tree
*initp
)
5238 if (t
== error_mark_node
|| processing_template_decl
)
5241 if (TREE_CODE (t
) == INIT_EXPR
)
5242 t
= TREE_OPERAND (t
, 1);
5243 if (TREE_CODE (t
) == TARGET_EXPR
)
5244 t
= TARGET_EXPR_INITIAL (t
);
5246 /* If the RHS can be stabilized without breaking copy elision, stabilize
5247 it. We specifically don't stabilize class prvalues here because that
5248 would mean an extra copy, but they might be stabilized below. */
5249 if (TREE_CODE (init
) == INIT_EXPR
5250 && TREE_CODE (t
) != CONSTRUCTOR
5251 && TREE_CODE (t
) != AGGR_INIT_EXPR
5252 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5255 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5259 if (TREE_CODE (t
) == COMPOUND_EXPR
5260 && TREE_CODE (init
) == INIT_EXPR
)
5262 tree last
= expr_last (t
);
5263 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5264 if (!TREE_SIDE_EFFECTS (last
))
5267 TREE_OPERAND (init
, 1) = last
;
5272 if (TREE_CODE (t
) == CONSTRUCTOR
)
5274 /* Aggregate initialization: stabilize each of the field
5277 constructor_elt
*ce
;
5279 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5280 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5282 tree type
= TREE_TYPE (ce
->value
);
5284 if (TYPE_REF_P (type
)
5285 || SCALAR_TYPE_P (type
))
5286 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5287 else if (!stabilize_init (ce
->value
, &subinit
))
5289 *initp
= add_stmt_to_compound (*initp
, subinit
);
5294 if (TREE_CODE (t
) == CALL_EXPR
)
5296 stabilize_call (t
, initp
);
5300 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5302 stabilize_aggr_init (t
, initp
);
5306 /* The initialization is being performed via a bitwise copy -- and
5307 the item copied may have side effects. */
5308 return !TREE_SIDE_EFFECTS (init
);
5311 /* Returns true if a cast to TYPE may appear in an integral constant
5315 cast_valid_in_integral_constant_expression_p (tree type
)
5317 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5318 || cxx_dialect
>= cxx11
5319 || dependent_type_p (type
)
5320 || type
== error_mark_node
);
5323 /* Return true if we need to fix linkage information of DECL. */
5326 cp_fix_function_decl_p (tree decl
)
5328 /* Skip if DECL is not externally visible. */
5329 if (!TREE_PUBLIC (decl
))
5332 /* We need to fix DECL if it a appears to be exported but with no
5333 function body. Thunks do not have CFGs and we may need to
5334 handle them specially later. */
5335 if (!gimple_has_body_p (decl
)
5336 && !DECL_THUNK_P (decl
)
5337 && !DECL_EXTERNAL (decl
))
5339 struct cgraph_node
*node
= cgraph_node::get (decl
);
5341 /* Don't fix same_body aliases. Although they don't have their own
5342 CFG, they share it with what they alias to. */
5343 if (!node
|| !node
->alias
5344 || !vec_safe_length (node
->ref_list
.references
))
5351 /* Clean the C++ specific parts of the tree T. */
5354 cp_free_lang_data (tree t
)
5356 if (TREE_CODE (t
) == METHOD_TYPE
5357 || TREE_CODE (t
) == FUNCTION_TYPE
)
5359 /* Default args are not interesting anymore. */
5360 tree argtypes
= TYPE_ARG_TYPES (t
);
5363 TREE_PURPOSE (argtypes
) = 0;
5364 argtypes
= TREE_CHAIN (argtypes
);
5367 else if (TREE_CODE (t
) == FUNCTION_DECL
5368 && cp_fix_function_decl_p (t
))
5370 /* If T is used in this translation unit at all, the definition
5371 must exist somewhere else since we have decided to not emit it
5372 in this TU. So make it an external reference. */
5373 DECL_EXTERNAL (t
) = 1;
5374 TREE_STATIC (t
) = 0;
5376 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5377 /* We do not need the leftover chaining of namespaces from the
5379 DECL_CHAIN (t
) = NULL_TREE
;
5382 /* Stub for c-common. Please keep in sync with c-decl.c.
5383 FIXME: If address space support is target specific, then this
5384 should be a C target hook. But currently this is not possible,
5385 because this function is called via REGISTER_TARGET_PRAGMAS. */
5387 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5391 /* Return the number of operands in T that we care about for things like
5395 cp_tree_operand_length (const_tree t
)
5397 enum tree_code code
= TREE_CODE (t
);
5399 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5400 return VL_EXP_OPERAND_LENGTH (t
);
5402 return cp_tree_code_length (code
);
5405 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5408 cp_tree_code_length (enum tree_code code
)
5410 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5414 case PREINCREMENT_EXPR
:
5415 case PREDECREMENT_EXPR
:
5416 case POSTINCREMENT_EXPR
:
5417 case POSTDECREMENT_EXPR
:
5423 case EXPR_PACK_EXPANSION
:
5427 return TREE_CODE_LENGTH (code
);
5431 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5435 cp_expr_location (const_tree t_
)
5437 tree t
= CONST_CAST_TREE (t_
);
5439 return UNKNOWN_LOCATION
;
5440 switch (TREE_CODE (t
))
5443 return LAMBDA_EXPR_LOCATION (t
);
5445 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5447 return EXPR_LOCATION (t
);
5451 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5452 conditions for the warning hold, false otherwise. */
5454 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5456 if (c_inhibit_evaluation_warnings
== 0
5457 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5459 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5460 "zero as null pointer constant");
5466 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5467 /* Complain that some language-specific thing hanging off a tree
5468 node has been accessed improperly. */
5471 lang_check_failed (const char* file
, int line
, const char* function
)
5473 internal_error ("lang_* check: failed in %s, at %s:%d",
5474 function
, trim_filename (file
), line
);
5476 #endif /* ENABLE_TREE_CHECKING */
5480 namespace selftest
{
5482 /* Verify that lvalue_kind () works, for various expressions,
5483 and that location wrappers don't affect the results. */
5488 location_t loc
= BUILTINS_LOCATION
;
5490 /* Verify constants and parameters, without and with
5491 location wrappers. */
5492 tree int_cst
= build_int_cst (integer_type_node
, 42);
5493 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5495 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5496 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5497 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5499 tree string_lit
= build_string (4, "foo");
5500 TREE_TYPE (string_lit
) = char_array_type_node
;
5501 string_lit
= fix_string_type (string_lit
);
5502 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5504 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5505 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5506 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5508 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5509 get_identifier ("some_parm"),
5511 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5513 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5514 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5515 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5517 /* Verify that lvalue_kind of std::move on a parm isn't
5518 affected by location wrappers. */
5519 tree rvalue_ref_of_parm
= move (parm
);
5520 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5521 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5522 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5525 /* Run all of the selftests within this file. */
5530 test_lvalue_kind ();
5533 } // namespace selftest
5535 #endif /* #if CHECKING_P */
5538 #include "gt-cp-tree.h"