1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
35 #include "stringpool.h"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
46 static tree
build_local_temp (tree
);
48 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
55 lvalue_kind (const_tree ref
)
57 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
58 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
64 if (REFERENCE_REF_P (ref
))
65 return lvalue_kind (TREE_OPERAND (ref
, 0));
68 && TYPE_REF_P (TREE_TYPE (ref
)))
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
72 && TREE_CODE (ref
) != PARM_DECL
74 && TREE_CODE (ref
) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
79 /* lvalue references and named rvalue references are lvalues. */
83 if (ref
== current_class_ptr
)
86 switch (TREE_CODE (ref
))
91 /* preincrements and predecrements are valid lvals, provided
92 what they refer to are valid lvals. */
93 case PREINCREMENT_EXPR
:
94 case PREDECREMENT_EXPR
:
98 case VIEW_CONVERT_EXPR
:
99 return lvalue_kind (TREE_OPERAND (ref
, 0));
103 tree op1
= TREE_OPERAND (ref
, 0);
104 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
106 op1_lvalue_kind
= lvalue_kind (op1
);
107 if (op1_lvalue_kind
== clk_class
)
108 /* in the case of an array operand, the result is an lvalue if
109 that operand is an lvalue and an xvalue otherwise */
110 op1_lvalue_kind
= clk_rvalueref
;
111 return op1_lvalue_kind
;
119 if (TREE_CODE (ref
) == MEMBER_REF
)
120 op1_lvalue_kind
= clk_ordinary
;
122 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
123 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
124 op1_lvalue_kind
= clk_none
;
125 else if (op1_lvalue_kind
== clk_class
)
126 /* The result of a .* expression whose second operand is a pointer to a
127 data member is an lvalue if the first operand is an lvalue and an
129 op1_lvalue_kind
= clk_rvalueref
;
130 return op1_lvalue_kind
;
133 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
135 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
137 /* For static member function recurse on the BASELINK, we can get
138 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
139 OVERLOAD, the overload is resolved first if possible through
140 resolve_address_of_overloaded_function. */
141 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
142 return lvalue_kind (TREE_OPERAND (ref
, 1));
144 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
145 if (op1_lvalue_kind
== clk_class
)
146 /* If E1 is an lvalue, then E1.E2 is an lvalue;
147 otherwise E1.E2 is an xvalue. */
148 op1_lvalue_kind
= clk_rvalueref
;
150 /* Look at the member designator. */
151 if (!op1_lvalue_kind
)
153 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
154 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
155 situations. If we're seeing a COMPONENT_REF, it's a non-static
156 member, so it isn't an lvalue. */
157 op1_lvalue_kind
= clk_none
;
158 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
159 /* This can be IDENTIFIER_NODE in a template. */;
160 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
162 /* Clear the ordinary bit. If this object was a class
163 rvalue we want to preserve that information. */
164 op1_lvalue_kind
&= ~clk_ordinary
;
165 /* The lvalue is for a bitfield. */
166 op1_lvalue_kind
|= clk_bitfield
;
168 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
169 op1_lvalue_kind
|= clk_packed
;
171 return op1_lvalue_kind
;
174 case COMPOUND_LITERAL_EXPR
:
178 /* CONST_DECL without TREE_STATIC are enumeration values and
179 thus not lvalues. With TREE_STATIC they are used by ObjC++
180 in objc_build_string_object and need to be considered as
182 if (! TREE_STATIC (ref
))
186 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
187 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
189 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
190 && DECL_LANG_SPECIFIC (ref
)
191 && DECL_IN_AGGR_P (ref
))
198 case PLACEHOLDER_EXPR
:
201 /* A scope ref in a template, left as SCOPE_REF to support later
204 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
206 tree op
= TREE_OPERAND (ref
, 1);
207 if (TREE_CODE (op
) == FIELD_DECL
)
208 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
210 return lvalue_kind (op
);
215 /* Disallow <? and >? as lvalues if either argument side-effects. */
216 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
217 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
219 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
220 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
224 if (processing_template_decl
)
226 /* Within templates, a REFERENCE_TYPE will indicate whether
227 the COND_EXPR result is an ordinary lvalue or rvalueref.
228 Since REFERENCE_TYPEs are handled above, if we reach this
229 point, we know we got a plain rvalue. Unless we have a
230 type-dependent expr, that is, but we shouldn't be testing
231 lvalueness if we can't even tell the types yet! */
232 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
235 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
236 ? TREE_OPERAND (ref
, 1)
237 : TREE_OPERAND (ref
, 0));
238 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
242 /* We expect to see unlowered MODOP_EXPRs only during
243 template processing. */
244 gcc_assert (processing_template_decl
);
252 return lvalue_kind (TREE_OPERAND (ref
, 1));
258 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
261 /* We can see calls outside of TARGET_EXPR in templates. */
262 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
267 /* All functions (except non-static-member functions) are
269 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
270 ? clk_none
: clk_ordinary
);
273 /* We now represent a reference to a single static member function
275 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
276 its argument unmodified and we assign it to a const_tree. */
277 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
279 case NON_DEPENDENT_EXPR
:
281 return lvalue_kind (TREE_OPERAND (ref
, 0));
283 case TEMPLATE_PARM_INDEX
:
284 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
285 /* A template parameter object is an lvalue. */
291 if (!TREE_TYPE (ref
))
293 if (CLASS_TYPE_P (TREE_TYPE (ref
))
294 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
299 /* If one operand is not an lvalue at all, then this expression is
301 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
304 /* Otherwise, it's an lvalue, and it has all the odd properties
305 contributed by either operand. */
306 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
307 /* It's not an ordinary lvalue if it involves any other kind. */
308 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
309 op1_lvalue_kind
&= ~clk_ordinary
;
310 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
311 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
312 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
313 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
314 op1_lvalue_kind
= clk_none
;
315 return op1_lvalue_kind
;
318 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
321 real_lvalue_p (const_tree ref
)
323 cp_lvalue_kind kind
= lvalue_kind (ref
);
324 if (kind
& (clk_rvalueref
|clk_class
))
330 /* c-common wants us to return bool. */
333 lvalue_p (const_tree t
)
335 return real_lvalue_p (t
);
338 /* This differs from lvalue_p in that xvalues are included. */
341 glvalue_p (const_tree ref
)
343 cp_lvalue_kind kind
= lvalue_kind (ref
);
344 if (kind
& clk_class
)
347 return (kind
!= clk_none
);
350 /* This differs from glvalue_p in that class prvalues are included. */
353 obvalue_p (const_tree ref
)
355 return (lvalue_kind (ref
) != clk_none
);
358 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
359 reference), false otherwise. */
362 xvalue_p (const_tree ref
)
364 return (lvalue_kind (ref
) == clk_rvalueref
);
367 /* True if REF is a bit-field. */
370 bitfield_p (const_tree ref
)
372 return (lvalue_kind (ref
) & clk_bitfield
);
375 /* C++-specific version of stabilize_reference. */
378 cp_stabilize_reference (tree ref
)
380 STRIP_ANY_LOCATION_WRAPPER (ref
);
381 switch (TREE_CODE (ref
))
383 case NON_DEPENDENT_EXPR
:
384 /* We aren't actually evaluating this. */
387 /* We need to treat specially anything stabilize_reference doesn't
388 handle specifically. */
399 case ARRAY_RANGE_REF
:
403 cp_lvalue_kind kind
= lvalue_kind (ref
);
404 if ((kind
& ~clk_class
) != clk_none
)
406 tree type
= unlowered_expr_type (ref
);
407 bool rval
= !!(kind
& clk_rvalueref
);
408 type
= cp_build_reference_type (type
, rval
);
409 /* This inhibits warnings in, eg, cxx_mark_addressable
411 warning_sentinel
s (extra_warnings
);
412 ref
= build_static_cast (type
, ref
, tf_error
);
416 return stabilize_reference (ref
);
419 /* Test whether DECL is a builtin that may appear in a
420 constant-expression. */
423 builtin_valid_in_constant_expr_p (const_tree decl
)
425 STRIP_ANY_LOCATION_WRAPPER (decl
);
426 if (TREE_CODE (decl
) != FUNCTION_DECL
)
427 /* Not a function. */
429 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
431 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
434 /* Not a built-in. */
437 switch (DECL_FUNCTION_CODE (decl
))
439 /* These always have constant results like the corresponding
442 case BUILT_IN_FUNCTION
:
445 /* The following built-ins are valid in constant expressions
446 when their arguments are. */
447 case BUILT_IN_ADD_OVERFLOW_P
:
448 case BUILT_IN_SUB_OVERFLOW_P
:
449 case BUILT_IN_MUL_OVERFLOW_P
:
451 /* These have constant results even if their operands are
453 case BUILT_IN_CONSTANT_P
:
454 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
461 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
464 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
467 tree type
= TREE_TYPE (decl
);
469 value
= mark_rvalue_use (value
);
471 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
472 || TREE_TYPE (decl
) == TREE_TYPE (value
)
473 /* On ARM ctors return 'this'. */
474 || (TYPE_PTR_P (TREE_TYPE (value
))
475 && TREE_CODE (value
) == CALL_EXPR
)
476 || useless_type_conversion_p (TREE_TYPE (decl
),
479 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
480 moving a constant aggregate into .rodata. */
481 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
482 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
483 && !VOID_TYPE_P (TREE_TYPE (value
))
484 && reduced_constant_expression_p (value
))
485 TREE_READONLY (decl
) = true;
487 if (complain
& tf_no_cleanup
)
488 /* The caller is building a new-expr and does not need a cleanup. */
492 t
= cxx_maybe_build_cleanup (decl
, complain
);
493 if (t
== error_mark_node
)
494 return error_mark_node
;
496 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
497 if (location_t eloc
= cp_expr_location (value
))
498 SET_EXPR_LOCATION (t
, eloc
);
499 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
500 ignore the TARGET_EXPR. If there really turn out to be no
501 side-effects, then the optimizer should be able to get rid of
502 whatever code is generated anyhow. */
503 TREE_SIDE_EFFECTS (t
) = 1;
508 /* Return an undeclared local temporary of type TYPE for use in building a
512 build_local_temp (tree type
)
514 tree slot
= build_decl (input_location
,
515 VAR_DECL
, NULL_TREE
, type
);
516 DECL_ARTIFICIAL (slot
) = 1;
517 DECL_IGNORED_P (slot
) = 1;
518 DECL_CONTEXT (slot
) = current_function_decl
;
519 layout_decl (slot
, 0);
523 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
526 process_aggr_init_operands (tree t
)
530 side_effects
= TREE_SIDE_EFFECTS (t
);
534 n
= TREE_OPERAND_LENGTH (t
);
535 for (i
= 1; i
< n
; i
++)
537 tree op
= TREE_OPERAND (t
, i
);
538 if (op
&& TREE_SIDE_EFFECTS (op
))
545 TREE_SIDE_EFFECTS (t
) = side_effects
;
548 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
549 FN, and SLOT. NARGS is the number of call arguments which are specified
550 as a tree array ARGS. */
553 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
559 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
560 TREE_TYPE (t
) = return_type
;
561 AGGR_INIT_EXPR_FN (t
) = fn
;
562 AGGR_INIT_EXPR_SLOT (t
) = slot
;
563 for (i
= 0; i
< nargs
; i
++)
564 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
565 process_aggr_init_operands (t
);
569 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
570 target. TYPE is the type to be initialized.
572 Build an AGGR_INIT_EXPR to represent the initialization. This function
573 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
574 to initialize another object, whereas a TARGET_EXPR can either
575 initialize another object or create its own temporary object, and as a
576 result building up a TARGET_EXPR requires that the type's destructor be
580 build_aggr_init_expr (tree type
, tree init
)
587 gcc_assert (!VOID_TYPE_P (type
));
589 /* Don't build AGGR_INIT_EXPR in a template. */
590 if (processing_template_decl
)
593 fn
= cp_get_callee (init
);
595 return convert (type
, init
);
597 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
598 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
599 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
601 /* We split the CALL_EXPR into its function and its arguments here.
602 Then, in expand_expr, we put them back together. The reason for
603 this is that this expression might be a default argument
604 expression. In that case, we need a new temporary every time the
605 expression is used. That's what break_out_target_exprs does; it
606 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
607 temporary slot. Then, expand_expr builds up a call-expression
608 using the new slot. */
610 /* If we don't need to use a constructor to create an object of this
611 type, don't mess with AGGR_INIT_EXPR. */
612 if (is_ctor
|| TREE_ADDRESSABLE (type
))
614 slot
= build_local_temp (type
);
616 if (TREE_CODE (init
) == CALL_EXPR
)
618 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
619 call_expr_nargs (init
),
620 CALL_EXPR_ARGP (init
));
621 AGGR_INIT_FROM_THUNK_P (rval
)
622 = CALL_FROM_THUNK_P (init
);
626 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
627 aggr_init_expr_nargs (init
),
628 AGGR_INIT_EXPR_ARGP (init
));
629 AGGR_INIT_FROM_THUNK_P (rval
)
630 = AGGR_INIT_FROM_THUNK_P (init
);
632 TREE_SIDE_EFFECTS (rval
) = 1;
633 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
634 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
635 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
636 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
637 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
645 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
646 target. TYPE is the type that this initialization should appear to
649 Build an encapsulation of the initialization to perform
650 and return it so that it can be processed by language-independent
651 and language-specific expression expanders. */
654 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
656 tree rval
= build_aggr_init_expr (type
, init
);
659 if (init
== error_mark_node
)
660 return error_mark_node
;
662 if (!complete_type_or_maybe_complain (type
, init
, complain
))
663 return error_mark_node
;
665 /* Make sure that we're not trying to create an instance of an
667 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
668 return error_mark_node
;
670 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
671 slot
= AGGR_INIT_EXPR_SLOT (rval
);
672 else if (TREE_CODE (rval
) == CALL_EXPR
673 || TREE_CODE (rval
) == CONSTRUCTOR
)
674 slot
= build_local_temp (type
);
678 rval
= build_target_expr (slot
, rval
, complain
);
680 if (rval
!= error_mark_node
)
681 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
686 /* Subroutine of build_vec_init_expr: Build up a single element
687 intialization as a proxy for the full array initialization to get things
688 marked as used and any appropriate diagnostics.
690 Since we're deferring building the actual constructor calls until
691 gimplification time, we need to build one now and throw it away so
692 that the relevant constructor gets mark_used before cgraph decides
693 what functions are needed. Here we assume that init is either
694 NULL_TREE, void_type_node (indicating value-initialization), or
695 another array to copy. */
698 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
700 tree inner_type
= strip_array_types (type
);
701 vec
<tree
, va_gc
> *argvec
;
703 if (integer_zerop (array_type_nelts_total (type
))
704 || !CLASS_TYPE_P (inner_type
))
705 /* No interesting initialization to do. */
706 return integer_zero_node
;
707 else if (init
== void_type_node
)
708 return build_value_init (inner_type
, complain
);
710 gcc_assert (init
== NULL_TREE
711 || (same_type_ignoring_top_level_qualifiers_p
712 (type
, TREE_TYPE (init
))));
714 argvec
= make_tree_vector ();
717 tree init_type
= strip_array_types (TREE_TYPE (init
));
718 tree dummy
= build_dummy_object (init_type
);
719 if (!lvalue_p (init
))
720 dummy
= move (dummy
);
721 argvec
->quick_push (dummy
);
723 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
724 &argvec
, inner_type
, LOOKUP_NORMAL
,
726 release_tree_vector (argvec
);
728 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
729 we don't want one here because we aren't creating a temporary. */
730 if (TREE_CODE (init
) == TARGET_EXPR
)
731 init
= TARGET_EXPR_INITIAL (init
);
736 /* Return a TARGET_EXPR which expresses the initialization of an array to
737 be named later, either default-initialization or copy-initialization
738 from another array of the same type. */
741 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
744 bool value_init
= false;
745 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
747 if (init
== void_type_node
)
753 slot
= build_local_temp (type
);
754 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
755 TREE_SIDE_EFFECTS (init
) = true;
756 SET_EXPR_LOCATION (init
, input_location
);
758 if (cxx_dialect
>= cxx11
759 && potential_constant_expression (elt_init
))
760 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
761 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
766 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
767 that requires a constant expression. */
770 diagnose_non_constexpr_vec_init (tree expr
)
772 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
774 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
775 init
= void_type_node
;
777 init
= VEC_INIT_EXPR_INIT (expr
);
779 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
780 require_potential_constant_expression (elt_init
);
784 build_array_copy (tree init
)
786 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
789 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
793 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
795 gcc_assert (!VOID_TYPE_P (type
));
797 if (TREE_CODE (init
) == TARGET_EXPR
798 || init
== error_mark_node
)
800 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
801 && !VOID_TYPE_P (TREE_TYPE (init
))
802 && TREE_CODE (init
) != COND_EXPR
803 && TREE_CODE (init
) != CONSTRUCTOR
804 && TREE_CODE (init
) != VA_ARG_EXPR
)
805 /* We need to build up a copy constructor call. A void initializer
806 means we're being called from bot_manip. COND_EXPR is a special
807 case because we already have copies on the arms and we don't want
808 another one here. A CONSTRUCTOR is aggregate initialization, which
809 is handled separately. A VA_ARG_EXPR is magic creation of an
810 aggregate; there's no additional work to be done. */
811 return force_rvalue (init
, complain
);
813 return force_target_expr (type
, init
, complain
);
816 /* Like the above function, but without the checking. This function should
817 only be used by code which is deliberately trying to subvert the type
818 system, such as call_builtin_trap. Or build_over_call, to avoid
819 infinite recursion. */
822 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
826 gcc_assert (!VOID_TYPE_P (type
));
828 slot
= build_local_temp (type
);
829 return build_target_expr (slot
, init
, complain
);
832 /* Like build_target_expr_with_type, but use the type of INIT. */
835 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
837 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
838 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
839 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
840 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
843 init
= convert_bitfield_to_declared_type (init
);
844 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
849 get_target_expr (tree init
)
851 return get_target_expr_sfinae (init
, tf_warning_or_error
);
854 /* If EXPR is a bitfield reference, convert it to the declared type of
855 the bitfield, and return the resulting expression. Otherwise,
856 return EXPR itself. */
859 convert_bitfield_to_declared_type (tree expr
)
863 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
865 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
870 /* EXPR is being used in an rvalue context. Return a version of EXPR
871 that is marked as an rvalue. */
878 if (error_operand_p (expr
))
881 expr
= mark_rvalue_use (expr
);
885 Non-class rvalues always have cv-unqualified types. */
886 type
= TREE_TYPE (expr
);
887 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
888 type
= cv_unqualified (type
);
890 /* We need to do this for rvalue refs as well to get the right answer
891 from decltype; see c++/36628. */
892 if (!processing_template_decl
&& glvalue_p (expr
))
893 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
894 else if (type
!= TREE_TYPE (expr
))
895 expr
= build_nop (type
, expr
);
901 struct cplus_array_info
907 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
909 typedef cplus_array_info
*compare_type
;
911 static hashval_t
hash (tree t
);
912 static bool equal (tree
, cplus_array_info
*);
915 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
918 cplus_array_hasher::hash (tree t
)
922 hash
= TYPE_UID (TREE_TYPE (t
));
924 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
928 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
929 of type `cplus_array_info*'. */
932 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
934 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
937 /* Hash table containing dependent array types, which are unsuitable for
938 the language-independent type hash table. */
939 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
941 /* Build an ARRAY_TYPE without laying it out. */
944 build_min_array_type (tree elt_type
, tree index_type
)
946 tree t
= cxx_make_type (ARRAY_TYPE
);
947 TREE_TYPE (t
) = elt_type
;
948 TYPE_DOMAIN (t
) = index_type
;
952 /* Set TYPE_CANONICAL like build_array_type_1, but using
953 build_cplus_array_type. */
956 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
958 /* Set the canonical type for this new node. */
959 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
960 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
961 SET_TYPE_STRUCTURAL_EQUALITY (t
);
962 else if (TYPE_CANONICAL (elt_type
) != elt_type
963 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
965 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
967 ? TYPE_CANONICAL (index_type
) : index_type
);
969 TYPE_CANONICAL (t
) = t
;
972 /* Like build_array_type, but handle special C++ semantics: an array of a
973 variant element type is a variant of the array of the main variant of
977 build_cplus_array_type (tree elt_type
, tree index_type
)
981 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
982 return error_mark_node
;
984 bool dependent
= (uses_template_parms (elt_type
)
985 || (index_type
&& uses_template_parms (index_type
)));
987 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
988 /* Start with an array of the TYPE_MAIN_VARIANT. */
989 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
993 /* Since type_hash_canon calls layout_type, we need to use our own
995 cplus_array_info cai
;
998 if (cplus_array_htab
== NULL
)
999 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1001 hash
= TYPE_UID (elt_type
);
1003 hash
^= TYPE_UID (index_type
);
1004 cai
.type
= elt_type
;
1005 cai
.domain
= index_type
;
1007 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1009 /* We have found the type: we're done. */
1013 /* Build a new array type. */
1014 t
= build_min_array_type (elt_type
, index_type
);
1016 /* Store it in the hash table. */
1019 /* Set the canonical type for this new node. */
1020 set_array_type_canon (t
, elt_type
, index_type
);
1025 bool typeless_storage
1026 = (elt_type
== unsigned_char_type_node
1027 || elt_type
== signed_char_type_node
1028 || elt_type
== char_type_node
1029 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
1030 && TYPE_CONTEXT (elt_type
) == std_node
1031 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
1032 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1035 /* Now check whether we already have this array variant. */
1036 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1039 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1040 if (TREE_TYPE (t
) == elt_type
1041 && TYPE_NAME (t
) == NULL_TREE
1042 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1046 t
= build_min_array_type (elt_type
, index_type
);
1047 set_array_type_canon (t
, elt_type
, index_type
);
1051 /* Make sure sizes are shared with the main variant.
1052 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1053 as it will overwrite alignment etc. of all variants. */
1054 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1055 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1056 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1059 TYPE_MAIN_VARIANT (t
) = m
;
1060 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1061 TYPE_NEXT_VARIANT (m
) = t
;
1065 /* Avoid spurious warnings with VLAs (c++/54583). */
1066 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1067 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1069 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1070 place more easily. */
1071 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1072 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1073 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1074 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1076 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1077 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1079 /* The element type has been completed since the last time we saw
1080 this array type; update the layout and 'tor flags for any variants
1083 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1085 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1086 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1093 /* Return an ARRAY_TYPE with element type ELT and length N. */
1096 build_array_of_n_type (tree elt
, int n
)
1098 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1101 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1102 for C++14 but then removed. This should only be used for N3639
1103 specifically; code wondering more generally if something is a VLA should use
1107 array_of_runtime_bound_p (tree t
)
1109 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1111 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1113 tree dom
= TYPE_DOMAIN (t
);
1116 tree max
= TYPE_MAX_VALUE (dom
);
1117 return (!potential_rvalue_constant_expression (max
)
1118 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1121 /* True iff T is a variable length array. */
1126 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1128 if (tree dom
= TYPE_DOMAIN (t
))
1130 tree max
= TYPE_MAX_VALUE (dom
);
1131 if (!potential_rvalue_constant_expression (max
)
1132 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1138 /* Return a reference type node referring to TO_TYPE. If RVAL is
1139 true, return an rvalue reference type, otherwise return an lvalue
1140 reference type. If a type node exists, reuse it, otherwise create
1143 cp_build_reference_type (tree to_type
, bool rval
)
1147 if (to_type
== error_mark_node
)
1148 return error_mark_node
;
1150 if (TYPE_REF_P (to_type
))
1152 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1153 to_type
= TREE_TYPE (to_type
);
1156 lvalue_ref
= build_reference_type (to_type
);
1160 /* This code to create rvalue reference types is based on and tied
1161 to the code creating lvalue reference types in the middle-end
1162 functions build_reference_type_for_mode and build_reference_type.
1164 It works by putting the rvalue reference type nodes after the
1165 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1166 they will effectively be ignored by the middle end. */
1168 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1169 if (TYPE_REF_IS_RVALUE (t
))
1172 t
= build_distinct_type_copy (lvalue_ref
);
1174 TYPE_REF_IS_RVALUE (t
) = true;
1175 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1176 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1178 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1179 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1180 else if (TYPE_CANONICAL (to_type
) != to_type
)
1182 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1184 TYPE_CANONICAL (t
) = t
;
1192 /* Returns EXPR cast to rvalue reference type, like std::move. */
1197 tree type
= TREE_TYPE (expr
);
1198 gcc_assert (!TYPE_REF_P (type
));
1199 type
= cp_build_reference_type (type
, /*rval*/true);
1200 return build_static_cast (type
, expr
, tf_warning_or_error
);
1203 /* Used by the C++ front end to build qualified array types. However,
1204 the C version of this function does not properly maintain canonical
1205 types (which are not used in C). */
1207 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1208 size_t /* orig_qual_indirect */)
1210 return cp_build_qualified_type (type
, type_quals
);
1214 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1215 arrays correctly. In particular, if TYPE is an array of T's, and
1216 TYPE_QUALS is non-empty, returns an array of qualified T's.
1218 FLAGS determines how to deal with ill-formed qualifications. If
1219 tf_ignore_bad_quals is set, then bad qualifications are dropped
1220 (this is permitted if TYPE was introduced via a typedef or template
1221 type parameter). If bad qualifications are dropped and tf_warning
1222 is set, then a warning is issued for non-const qualifications. If
1223 tf_ignore_bad_quals is not set and tf_error is not set, we
1224 return error_mark_node. Otherwise, we issue an error, and ignore
1227 Qualification of a reference type is valid when the reference came
1228 via a typedef or template type argument. [dcl.ref] No such
1229 dispensation is provided for qualifying a function type. [dcl.fct]
1230 DR 295 queries this and the proposed resolution brings it into line
1231 with qualifying a reference. We implement the DR. We also behave
1232 in a similar manner for restricting non-pointer types. */
1235 cp_build_qualified_type_real (tree type
,
1237 tsubst_flags_t complain
)
1240 int bad_quals
= TYPE_UNQUALIFIED
;
1242 if (type
== error_mark_node
)
1245 if (type_quals
== cp_type_quals (type
))
1248 if (TREE_CODE (type
) == ARRAY_TYPE
)
1250 /* In C++, the qualification really applies to the array element
1251 type. Obtain the appropriately qualified element type. */
1254 = cp_build_qualified_type_real (TREE_TYPE (type
),
1258 if (element_type
== error_mark_node
)
1259 return error_mark_node
;
1261 /* See if we already have an identically qualified type. Tests
1262 should be equivalent to those in check_qualified_type. */
1263 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1264 if (TREE_TYPE (t
) == element_type
1265 && TYPE_NAME (t
) == TYPE_NAME (type
)
1266 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1267 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1268 TYPE_ATTRIBUTES (type
)))
1273 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1275 /* Keep the typedef name. */
1276 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1278 t
= build_variant_type_copy (t
);
1279 TYPE_NAME (t
) = TYPE_NAME (type
);
1280 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1281 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1285 /* Even if we already had this variant, we update
1286 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1287 they changed since the variant was originally created.
1289 This seems hokey; if there is some way to use a previous
1290 variant *without* coming through here,
1291 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1292 TYPE_NEEDS_CONSTRUCTING (t
)
1293 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1294 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1295 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1298 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1300 tree t
= PACK_EXPANSION_PATTERN (type
);
1302 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1303 return make_pack_expansion (t
, complain
);
1306 /* A reference or method type shall not be cv-qualified.
1307 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1308 (in CD1) we always ignore extra cv-quals on functions. */
1309 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1310 && (TYPE_REF_P (type
)
1311 || TREE_CODE (type
) == FUNCTION_TYPE
1312 || TREE_CODE (type
) == METHOD_TYPE
))
1314 if (TYPE_REF_P (type
))
1315 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1316 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1319 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1320 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1321 type_quals
|= type_memfn_quals (type
);
1323 /* A restrict-qualified type must be a pointer (or reference)
1324 to object or incomplete type. */
1325 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1326 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1327 && TREE_CODE (type
) != TYPENAME_TYPE
1328 && !INDIRECT_TYPE_P (type
))
1330 bad_quals
|= TYPE_QUAL_RESTRICT
;
1331 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1334 if (bad_quals
== TYPE_UNQUALIFIED
1335 || (complain
& tf_ignore_bad_quals
))
1337 else if (!(complain
& tf_error
))
1338 return error_mark_node
;
1341 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1342 error ("%qV qualifiers cannot be applied to %qT",
1346 /* Retrieve (or create) the appropriately qualified variant. */
1347 result
= build_qualified_type (type
, type_quals
);
1352 /* Return TYPE with const and volatile removed. */
1355 cv_unqualified (tree type
)
1359 if (type
== error_mark_node
)
1362 quals
= cp_type_quals (type
);
1363 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1364 return cp_build_qualified_type (type
, quals
);
1367 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1368 from ATTRIBS that affect type identity, and no others. If any are not
1369 applied, set *remove_attributes to true. */
1372 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1374 tree first_ident
= NULL_TREE
;
1375 tree new_attribs
= NULL_TREE
;
1376 tree
*p
= &new_attribs
;
1378 if (OVERLOAD_TYPE_P (result
))
1380 /* On classes and enums all attributes are ingrained. */
1381 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1385 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1387 const attribute_spec
*as
1388 = lookup_attribute_spec (get_attribute_name (a
));
1389 if (as
&& as
->affects_type_identity
)
1393 else if (first_ident
== error_mark_node
)
1395 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1396 p
= &TREE_CHAIN (*p
);
1399 else if (first_ident
)
1401 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1403 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1404 p
= &TREE_CHAIN (*p
);
1406 first_ident
= error_mark_node
;
1409 if (first_ident
!= error_mark_node
)
1410 new_attribs
= first_ident
;
1412 if (first_ident
== attribs
)
1413 /* All attributes affected type identity. */;
1415 *remove_attributes
= true;
1417 return cp_build_type_attribute_variant (result
, new_attribs
);
1420 /* Builds a qualified variant of T that is not a typedef variant.
1421 E.g. consider the following declarations:
1422 typedef const int ConstInt;
1423 typedef ConstInt* PtrConstInt;
1424 If T is PtrConstInt, this function returns a type representing
1426 In other words, if T is a typedef, the function returns the underlying type.
1427 The cv-qualification and attributes of the type returned match the
1429 They will always be compatible types.
1430 The returned type is built so that all of its subtypes
1431 recursively have their typedefs stripped as well.
1433 This is different from just returning TYPE_CANONICAL (T)
1434 Because of several reasons:
1435 * If T is a type that needs structural equality
1436 its TYPE_CANONICAL (T) will be NULL.
1437 * TYPE_CANONICAL (T) desn't carry type attributes
1438 and loses template parameter names.
1440 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1441 affect type identity, and set the referent to true if any were
1445 strip_typedefs (tree t
, bool *remove_attributes
)
1447 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1449 if (!t
|| t
== error_mark_node
)
1452 if (TREE_CODE (t
) == TREE_LIST
)
1454 bool changed
= false;
1455 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1457 for (; t
; t
= TREE_CHAIN (t
))
1459 gcc_assert (!TREE_PURPOSE (t
));
1460 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1461 if (elt
!= TREE_VALUE (t
))
1463 vec_safe_push (vec
, elt
);
1466 r
= build_tree_list_vec (vec
);
1467 release_tree_vector (vec
);
1471 gcc_assert (TYPE_P (t
));
1473 if (t
== TYPE_CANONICAL (t
))
1476 if (dependent_alias_template_spec_p (t
))
1477 /* DR 1558: However, if the template-id is dependent, subsequent
1478 template argument substitution still applies to the template-id. */
1481 switch (TREE_CODE (t
))
1484 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1485 result
= build_pointer_type (type
);
1487 case REFERENCE_TYPE
:
1488 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1489 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1492 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1493 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1494 result
= build_offset_type (t0
, type
);
1497 if (TYPE_PTRMEMFUNC_P (t
))
1499 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1500 result
= build_ptrmemfunc_type (t0
);
1504 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1505 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1506 result
= build_cplus_array_type (type
, t0
);
1511 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1514 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1515 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1516 can't expect that re-hashing a function type will find a previous
1517 equivalent type, so try to reuse the input type if nothing has
1518 changed. If the type is itself a variant, that will change. */
1519 bool is_variant
= typedef_variant_p (t
);
1520 if (remove_attributes
1521 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1524 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1525 tree canon_spec
= (flag_noexcept_type
1526 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1528 changed
= (type
!= TREE_TYPE (t
) || is_variant
1529 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1531 for (arg_node
= TYPE_ARG_TYPES (t
);
1533 arg_node
= TREE_CHAIN (arg_node
))
1535 if (arg_node
== void_list_node
)
1537 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1539 gcc_assert (arg_type
);
1540 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1546 for (arg_node2
= TYPE_ARG_TYPES (t
);
1547 arg_node2
!= arg_node
;
1548 arg_node2
= TREE_CHAIN (arg_node2
))
1550 = tree_cons (TREE_PURPOSE (arg_node2
),
1551 TREE_VALUE (arg_node2
), arg_types
);
1555 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1562 arg_types
= nreverse (arg_types
);
1564 /* A list of parameters not ending with an ellipsis
1565 must end with void_list_node. */
1567 arg_types
= chainon (arg_types
, void_list_node
);
1569 if (TREE_CODE (t
) == METHOD_TYPE
)
1571 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1572 gcc_assert (class_type
);
1574 build_method_type_directly (class_type
, type
,
1575 TREE_CHAIN (arg_types
));
1579 result
= build_function_type (type
, arg_types
);
1580 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1583 result
= build_cp_fntype_variant (result
,
1584 type_memfn_rqual (t
), canon_spec
,
1585 TYPE_HAS_LATE_RETURN_TYPE (t
));
1590 bool changed
= false;
1591 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1592 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1593 && TREE_OPERAND (fullname
, 1))
1595 tree args
= TREE_OPERAND (fullname
, 1);
1596 tree new_args
= copy_node (args
);
1597 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1599 tree arg
= TREE_VEC_ELT (args
, i
);
1602 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1604 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1605 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1606 if (strip_arg
!= arg
)
1611 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1612 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1614 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1618 ggc_free (new_args
);
1620 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1621 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1623 tree name
= fullname
;
1624 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1625 name
= TREE_OPERAND (fullname
, 0);
1626 /* Use build_typename_type rather than make_typename_type because we
1627 don't want to resolve it here, just strip typedefs. */
1628 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1632 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1634 if (result
== DECLTYPE_TYPE_EXPR (t
))
1637 result
= (finish_decltype_type
1639 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1642 case UNDERLYING_TYPE
:
1643 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1644 result
= finish_underlying_type (type
);
1652 if (typedef_variant_p (t
))
1654 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1655 strip typedefs with attributes. */
1656 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1657 result
= strip_typedefs (result
);
1660 result
= TYPE_MAIN_VARIANT (t
);
1662 gcc_assert (!typedef_variant_p (result
));
1664 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1665 /* If RESULT is complete and T isn't, it's likely the case that T
1666 is a variant of RESULT which hasn't been updated yet. Skip the
1667 attribute handling. */;
1670 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1671 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1673 gcc_assert (TYPE_USER_ALIGN (t
));
1674 if (remove_attributes
)
1675 *remove_attributes
= true;
1678 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1679 result
= build_variant_type_copy (result
);
1681 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1682 TYPE_USER_ALIGN (result
) = true;
1686 if (TYPE_ATTRIBUTES (t
))
1688 if (remove_attributes
)
1689 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1692 result
= cp_build_type_attribute_variant (result
,
1693 TYPE_ATTRIBUTES (t
));
1697 return cp_build_qualified_type (result
, cp_type_quals (t
));
1700 /* Like strip_typedefs above, but works on expressions, so that in
1702 template<class T> struct A
1708 sizeof(TT) is replaced by sizeof(T). */
1711 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1715 enum tree_code code
;
1717 if (t
== NULL_TREE
|| t
== error_mark_node
)
1720 STRIP_ANY_LOCATION_WRAPPER (t
);
1722 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1725 /* Some expressions have type operands, so let's handle types here rather
1726 than check TYPE_P in multiple places below. */
1728 return strip_typedefs (t
, remove_attributes
);
1730 code
= TREE_CODE (t
);
1733 case IDENTIFIER_NODE
:
1734 case TEMPLATE_PARM_INDEX
:
1737 case ARGUMENT_PACK_SELECT
:
1742 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1743 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1744 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1745 && type2
== TRAIT_EXPR_TYPE2 (t
))
1748 TRAIT_EXPR_TYPE1 (r
) = type1
;
1749 TRAIT_EXPR_TYPE2 (r
) = type2
;
1755 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1756 bool changed
= false;
1758 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1760 tree val
= strip_typedefs_expr (TREE_VALUE (it
), remove_attributes
);
1761 vec_safe_push (vec
, val
);
1762 if (val
!= TREE_VALUE (it
))
1764 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1769 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1770 r
= tree_cons (NULL_TREE
, it
, r
);
1774 release_tree_vector (vec
);
1780 bool changed
= false;
1781 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1782 n
= TREE_VEC_LENGTH (t
);
1783 vec_safe_reserve (vec
, n
);
1784 for (i
= 0; i
< n
; ++i
)
1786 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1788 vec
->quick_push (op
);
1789 if (op
!= TREE_VEC_ELT (t
, i
))
1795 for (i
= 0; i
< n
; ++i
)
1796 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1797 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1798 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1802 release_tree_vector (vec
);
1808 bool changed
= false;
1809 vec
<constructor_elt
, va_gc
> *vec
1810 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1811 n
= CONSTRUCTOR_NELTS (t
);
1812 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1813 for (i
= 0; i
< n
; ++i
)
1815 constructor_elt
*e
= &(*vec
)[i
];
1816 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1823 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1826 if (!changed
&& type
== TREE_TYPE (t
))
1834 TREE_TYPE (r
) = type
;
1835 CONSTRUCTOR_ELTS (r
) = vec
;
1843 case STATEMENT_LIST
:
1844 error ("statement-expression in a constant expression");
1845 return error_mark_node
;
1851 gcc_assert (EXPR_P (t
));
1853 n
= cp_tree_operand_length (t
);
1854 ops
= XALLOCAVEC (tree
, n
);
1855 type
= TREE_TYPE (t
);
1860 case IMPLICIT_CONV_EXPR
:
1861 case DYNAMIC_CAST_EXPR
:
1862 case STATIC_CAST_EXPR
:
1863 case CONST_CAST_EXPR
:
1864 case REINTERPRET_CAST_EXPR
:
1867 type
= strip_typedefs (type
, remove_attributes
);
1871 for (i
= 0; i
< n
; ++i
)
1872 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1876 /* If nothing changed, return t. */
1877 for (i
= 0; i
< n
; ++i
)
1878 if (ops
[i
] != TREE_OPERAND (t
, i
))
1880 if (i
== n
&& type
== TREE_TYPE (t
))
1884 TREE_TYPE (r
) = type
;
1885 for (i
= 0; i
< n
; ++i
)
1886 TREE_OPERAND (r
, i
) = ops
[i
];
1890 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1891 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1892 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1893 VIRT indicates whether TYPE is inherited virtually or not.
1894 IGO_PREV points at the previous binfo of the inheritance graph
1895 order chain. The newly copied binfo's TREE_CHAIN forms this
1898 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1899 correct order. That is in the order the bases themselves should be
1902 The BINFO_INHERITANCE of a virtual base class points to the binfo
1903 of the most derived type. ??? We could probably change this so that
1904 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1905 remove a field. They currently can only differ for primary virtual
1909 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1915 /* See if we've already made this virtual base. */
1916 new_binfo
= binfo_for_vbase (type
, t
);
1921 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1922 BINFO_TYPE (new_binfo
) = type
;
1924 /* Chain it into the inheritance graph. */
1925 TREE_CHAIN (*igo_prev
) = new_binfo
;
1926 *igo_prev
= new_binfo
;
1928 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1933 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1935 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1936 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1938 /* We do not need to copy the accesses, as they are read only. */
1939 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1941 /* Recursively copy base binfos of BINFO. */
1942 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1944 tree new_base_binfo
;
1945 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1947 BINFO_VIRTUAL_P (base_binfo
));
1949 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1950 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1951 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1955 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1959 /* Push it onto the list after any virtual bases it contains
1960 will have been pushed. */
1961 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1962 BINFO_VIRTUAL_P (new_binfo
) = 1;
1963 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1969 /* Hashing of lists so that we don't make duplicates.
1970 The entry point is `list_hash_canon'. */
1979 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1981 typedef list_proxy
*compare_type
;
1983 static hashval_t
hash (tree
);
1984 static bool equal (tree
, list_proxy
*);
1987 /* Now here is the hash table. When recording a list, it is added
1988 to the slot whose index is the hash code mod the table size.
1989 Note that the hash table is used for several kinds of lists.
1990 While all these live in the same table, they are completely independent,
1991 and the hash code is computed differently for each of these. */
1993 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1995 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1996 for a node we are thinking about adding). */
1999 list_hasher::equal (tree t
, list_proxy
*proxy
)
2001 return (TREE_VALUE (t
) == proxy
->value
2002 && TREE_PURPOSE (t
) == proxy
->purpose
2003 && TREE_CHAIN (t
) == proxy
->chain
);
2006 /* Compute a hash code for a list (chain of TREE_LIST nodes
2007 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2008 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2011 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2013 hashval_t hashcode
= 0;
2016 hashcode
+= TREE_HASH (chain
);
2019 hashcode
+= TREE_HASH (value
);
2023 hashcode
+= TREE_HASH (purpose
);
2029 /* Hash an already existing TREE_LIST. */
2032 list_hasher::hash (tree t
)
2034 return list_hash_pieces (TREE_PURPOSE (t
),
2039 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2040 object for an identical list if one already exists. Otherwise, build a
2041 new one, and record it as the canonical object. */
2044 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2048 struct list_proxy proxy
;
2050 /* Hash the list node. */
2051 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2052 /* Create a proxy for the TREE_LIST we would like to create. We
2053 don't actually create it so as to avoid creating garbage. */
2054 proxy
.purpose
= purpose
;
2055 proxy
.value
= value
;
2056 proxy
.chain
= chain
;
2057 /* See if it is already in the table. */
2058 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2059 /* If not, create a new node. */
2061 *slot
= tree_cons (purpose
, value
, chain
);
2062 return (tree
) *slot
;
2065 /* Constructor for hashed lists. */
2068 hash_tree_chain (tree value
, tree chain
)
2070 return hash_tree_cons (NULL_TREE
, value
, chain
);
2074 debug_binfo (tree elem
)
2079 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2081 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2082 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2083 debug_tree (BINFO_TYPE (elem
));
2084 if (BINFO_VTABLE (elem
))
2085 fprintf (stderr
, "vtable decl \"%s\"\n",
2086 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2088 fprintf (stderr
, "no vtable decl yet\n");
2089 fprintf (stderr
, "virtuals:\n");
2090 virtuals
= BINFO_VIRTUALS (elem
);
2095 tree fndecl
= TREE_VALUE (virtuals
);
2096 fprintf (stderr
, "%s [%ld =? %ld]\n",
2097 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2098 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2100 virtuals
= TREE_CHAIN (virtuals
);
2104 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2105 the type of the result expression, if known, or NULL_TREE if the
2106 resulting expression is type-dependent. If TEMPLATE_P is true,
2107 NAME is known to be a template because the user explicitly used the
2108 "template" keyword after the "::".
2110 All SCOPE_REFs should be built by use of this function. */
2113 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2116 if (type
== error_mark_node
2117 || scope
== error_mark_node
2118 || name
== error_mark_node
)
2119 return error_mark_node
;
2120 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2121 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2122 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2123 PTRMEM_OK_P (t
) = true;
2125 t
= convert_from_reference (t
);
2129 /* Like check_qualified_type, but also check ref-qualifier, exception
2130 specification, and whether the return type was specified after the
2134 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2135 cp_ref_qualifier rqual
, tree raises
, bool late
)
2137 return (TYPE_QUALS (cand
) == type_quals
2138 && check_base_type (cand
, base
)
2139 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2141 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2142 && type_memfn_rqual (cand
) == rqual
);
2145 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2148 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2150 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2151 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2152 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2155 /* Make a raw overload node containing FN. */
2158 ovl_make (tree fn
, tree next
)
2160 tree result
= make_node (OVERLOAD
);
2162 if (TREE_CODE (fn
) == OVERLOAD
)
2163 OVL_NESTED_P (result
) = true;
2165 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2166 ? unknown_type_node
: TREE_TYPE (fn
));
2167 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2168 OVL_DEDUP_P (result
) = true;
2169 OVL_FUNCTION (result
) = fn
;
2170 OVL_CHAIN (result
) = next
;
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. We keep the hidden decls first, but remaining ones
2180 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2182 tree result
= maybe_ovl
;
2183 tree insert_after
= NULL_TREE
;
2186 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2187 && OVL_HIDDEN_P (maybe_ovl
);
2188 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2190 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2191 insert_after
= maybe_ovl
;
2194 bool hidden_p
= DECL_HIDDEN_P (fn
);
2195 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2197 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2199 OVL_HIDDEN_P (maybe_ovl
) = true;
2201 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2208 OVL_CHAIN (insert_after
) = maybe_ovl
;
2209 TREE_TYPE (insert_after
) = unknown_type_node
;
2217 /* Skip any hidden names at the beginning of OVL. */
2220 ovl_skip_hidden (tree ovl
)
2223 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2224 ovl
= OVL_CHAIN (ovl
))
2225 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2227 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2229 /* Any hidden functions should have been wrapped in an
2230 overload, but injected friend classes will not. */
2231 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2238 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2241 ovl_iterator::reveal_node (tree overload
, tree node
)
2243 /* We cannot have returned NODE as part of a lookup overload, so we
2244 don't have to worry about preserving that. */
2246 OVL_HIDDEN_P (node
) = false;
2247 if (tree chain
= OVL_CHAIN (node
))
2248 if (TREE_CODE (chain
) == OVERLOAD
)
2250 if (OVL_HIDDEN_P (chain
))
2252 /* The node needs moving, and the simplest way is to remove it
2254 overload
= remove_node (overload
, node
);
2255 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2257 else if (OVL_DEDUP_P (chain
))
2258 OVL_DEDUP_P (node
) = true;
2263 /* NODE is on the overloads of OVL. Remove it.
2264 The removed node is unaltered and may continue to be iterated
2265 from (i.e. it is safe to remove a node from an overload one is
2266 currently iterating over). */
2269 ovl_iterator::remove_node (tree overload
, tree node
)
2271 tree
*slot
= &overload
;
2272 while (*slot
!= node
)
2275 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2277 slot
= &OVL_CHAIN (probe
);
2280 /* Stitch out NODE. We don't have to worry about now making a
2281 singleton overload (and consequently maybe setting its type),
2282 because all uses of this function will be followed by inserting a
2283 new node that must follow the place we've cut this out from. */
2284 if (TREE_CODE (node
) != OVERLOAD
)
2285 /* Cloned inherited ctors don't mark themselves as via_using. */
2288 *slot
= OVL_CHAIN (node
);
2293 /* Mark or unmark a lookup set. */
2296 lookup_mark (tree ovl
, bool val
)
2298 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2300 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2301 LOOKUP_SEEN_P (*iter
) = val
;
2305 /* Add a set of new FNS into a lookup. */
2308 lookup_add (tree fns
, tree lookup
)
2310 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2312 lookup
= ovl_make (fns
, lookup
);
2313 OVL_LOOKUP_P (lookup
) = true;
2321 /* FNS is a new overload set, add them to LOOKUP, if they are not
2322 already present there. */
2325 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2328 for (tree next
, probe
= fns
; probe
; probe
= next
)
2333 if (TREE_CODE (probe
) == OVERLOAD
)
2335 fn
= OVL_FUNCTION (probe
);
2336 next
= OVL_CHAIN (probe
);
2339 if (!LOOKUP_SEEN_P (fn
))
2340 LOOKUP_SEEN_P (fn
) = true;
2343 /* This function was already seen. Insert all the
2344 predecessors onto the lookup. */
2345 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2347 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2348 /* Propagate OVL_USING, but OVL_HIDDEN &
2349 OVL_DEDUP_P don't matter. */
2350 if (OVL_USING_P (fns
))
2351 OVL_USING_P (lookup
) = true;
2354 /* And now skip this function. */
2360 /* We ended in a set of new functions. Add them all in one go. */
2361 lookup
= lookup_add (fns
, lookup
);
2366 /* Returns nonzero if X is an expression for a (possibly overloaded)
2367 function. If "f" is a function or function template, "f", "c->f",
2368 "c.f", "C::f", and "f<int>" will all be considered possibly
2369 overloaded functions. Returns 2 if the function is actually
2370 overloaded, i.e., if it is impossible to know the type of the
2371 function without performing overload resolution. */
2374 is_overloaded_fn (tree x
)
2376 STRIP_ANY_LOCATION_WRAPPER (x
);
2378 /* A baselink is also considered an overloaded function. */
2379 if (TREE_CODE (x
) == OFFSET_REF
2380 || TREE_CODE (x
) == COMPONENT_REF
)
2381 x
= TREE_OPERAND (x
, 1);
2382 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2383 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2384 x
= TREE_OPERAND (x
, 0);
2386 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2387 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2390 return (TREE_CODE (x
) == FUNCTION_DECL
2391 || TREE_CODE (x
) == OVERLOAD
);
2394 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2395 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2399 dependent_name (tree x
)
2401 if (identifier_p (x
))
2403 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2404 x
= TREE_OPERAND (x
, 0);
2405 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2406 return OVL_NAME (x
);
2410 /* Returns true iff X is an expression for an overloaded function
2411 whose type cannot be known without performing overload
2415 really_overloaded_fn (tree x
)
2417 return is_overloaded_fn (x
) == 2;
2420 /* Get the overload set FROM refers to. Returns NULL if it's not an
2424 maybe_get_fns (tree from
)
2426 STRIP_ANY_LOCATION_WRAPPER (from
);
2428 /* A baselink is also considered an overloaded function. */
2429 if (TREE_CODE (from
) == OFFSET_REF
2430 || TREE_CODE (from
) == COMPONENT_REF
)
2431 from
= TREE_OPERAND (from
, 1);
2432 if (BASELINK_P (from
))
2433 from
= BASELINK_FUNCTIONS (from
);
2434 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2435 from
= TREE_OPERAND (from
, 0);
2437 if (TREE_CODE (from
) == OVERLOAD
2438 || TREE_CODE (from
) == FUNCTION_DECL
)
2444 /* FROM refers to an overload set. Return that set (or die). */
2449 tree res
= maybe_get_fns (from
);
2455 /* Return the first function of the overload set FROM refers to. */
2458 get_first_fn (tree from
)
2460 return OVL_FIRST (get_fns (from
));
2463 /* Return the scope where the overloaded functions OVL were found. */
2466 ovl_scope (tree ovl
)
2468 if (TREE_CODE (ovl
) == OFFSET_REF
2469 || TREE_CODE (ovl
) == COMPONENT_REF
)
2470 ovl
= TREE_OPERAND (ovl
, 1);
2471 if (TREE_CODE (ovl
) == BASELINK
)
2472 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2473 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2474 ovl
= TREE_OPERAND (ovl
, 0);
2475 /* Skip using-declarations. */
2476 lkp_iterator
iter (ovl
);
2479 while (iter
.using_p () && ++iter
);
2481 return CP_DECL_CONTEXT (ovl
);
2484 #define PRINT_RING_SIZE 4
2487 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2489 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2490 static char *print_ring
[PRINT_RING_SIZE
];
2491 static bool trans_ring
[PRINT_RING_SIZE
];
2492 static int ring_counter
;
2495 /* Only cache functions. */
2497 || TREE_CODE (decl
) != FUNCTION_DECL
2498 || DECL_LANG_SPECIFIC (decl
) == 0)
2499 return lang_decl_name (decl
, v
, translate
);
2501 /* See if this print name is lying around. */
2502 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2503 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2504 /* yes, so return it. */
2505 return print_ring
[i
];
2507 if (++ring_counter
== PRINT_RING_SIZE
)
2510 if (current_function_decl
!= NULL_TREE
)
2512 /* There may be both translated and untranslated versions of the
2514 for (i
= 0; i
< 2; i
++)
2516 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2518 if (ring_counter
== PRINT_RING_SIZE
)
2521 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2524 free (print_ring
[ring_counter
]);
2526 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2527 uid_ring
[ring_counter
] = DECL_UID (decl
);
2528 trans_ring
[ring_counter
] = translate
;
2529 return print_ring
[ring_counter
];
2533 cxx_printable_name (tree decl
, int v
)
2535 return cxx_printable_name_internal (decl
, v
, false);
2539 cxx_printable_name_translate (tree decl
, int v
)
2541 return cxx_printable_name_internal (decl
, v
, true);
2544 /* Return the canonical version of exception-specification RAISES for a C++17
2545 function type, for use in type comparison and building TYPE_CANONICAL. */
2548 canonical_eh_spec (tree raises
)
2550 if (raises
== NULL_TREE
)
2552 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2553 || uses_template_parms (raises
)
2554 || uses_template_parms (TREE_PURPOSE (raises
)))
2555 /* Keep a dependent or deferred exception specification. */
2557 else if (nothrow_spec_p (raises
))
2558 /* throw() -> noexcept. */
2559 return noexcept_true_spec
;
2561 /* For C++17 type matching, anything else -> nothing. */
2566 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2567 tree raises
, bool late
)
2569 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2571 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2574 tree v
= TYPE_MAIN_VARIANT (type
);
2575 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2576 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2579 /* Need to build a new variant. */
2580 v
= build_variant_type_copy (type
);
2581 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2582 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2585 case REF_QUAL_RVALUE
:
2586 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2587 FUNCTION_REF_QUALIFIED (v
) = 1;
2589 case REF_QUAL_LVALUE
:
2590 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2591 FUNCTION_REF_QUALIFIED (v
) = 1;
2594 FUNCTION_REF_QUALIFIED (v
) = 0;
2598 /* Canonicalize the exception specification. */
2599 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2601 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2602 /* Propagate structural equality. */
2603 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2604 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2605 /* Build the underlying canonical type, since it is different
2607 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2610 /* T is its own canonical type. */
2611 TYPE_CANONICAL (v
) = v
;
2616 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2617 listed in RAISES. */
2620 build_exception_variant (tree type
, tree raises
)
2622 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2623 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2624 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2627 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2628 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2632 bind_template_template_parm (tree t
, tree newargs
)
2634 tree decl
= TYPE_NAME (t
);
2637 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2638 decl
= build_decl (input_location
,
2639 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2641 /* These nodes have to be created to reflect new TYPE_DECL and template
2643 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2644 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2645 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2646 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2648 TREE_TYPE (decl
) = t2
;
2649 TYPE_NAME (t2
) = decl
;
2650 TYPE_STUB_DECL (t2
) = decl
;
2652 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2657 /* Called from count_trees via walk_tree. */
2660 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2670 /* Debugging function for measuring the rough complexity of a tree
2674 count_trees (tree t
)
2677 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2681 /* Called from verify_stmt_tree via walk_tree. */
2684 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2687 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2688 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2691 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2694 /* If this statement is already present in the hash table, then
2695 there is a circularity in the statement tree. */
2696 gcc_assert (!statements
->find (t
));
2698 slot
= statements
->find_slot (t
, INSERT
);
2704 /* Debugging function to check that the statement T has not been
2705 corrupted. For now, this function simply checks that T contains no
2709 verify_stmt_tree (tree t
)
2711 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2712 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2715 /* Check if the type T depends on a type with no linkage and if so, return
2716 it. If RELAXED_P then do not consider a class type declared within
2717 a vague-linkage function to have no linkage. */
2720 no_linkage_check (tree t
, bool relaxed_p
)
2724 /* Lambda types that don't have mangling scope have no linkage. We
2725 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2726 when we get here from pushtag none of the lambda information is
2727 set up yet, so we want to assume that the lambda has linkage and
2728 fix it up later if not. We need to check this even in templates so
2729 that we properly handle a lambda-expression in the signature. */
2730 if (LAMBDA_TYPE_P (t
)
2731 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2732 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2735 /* Otherwise there's no point in checking linkage on template functions; we
2736 can't know their complete types. */
2737 if (processing_template_decl
)
2740 switch (TREE_CODE (t
))
2743 if (TYPE_PTRMEMFUNC_P (t
))
2747 if (!CLASS_TYPE_P (t
))
2751 /* Only treat unnamed types as having no linkage if they're at
2752 namespace scope. This is core issue 966. */
2753 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2756 for (r
= CP_TYPE_CONTEXT (t
); ; )
2758 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2759 have linkage, or we might just be in an anonymous namespace.
2760 If we're in a TREE_PUBLIC class, we have linkage. */
2761 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2762 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2763 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2765 if (!relaxed_p
|| !vague_linkage_p (r
))
2768 r
= CP_DECL_CONTEXT (r
);
2778 case REFERENCE_TYPE
:
2780 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2784 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2788 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2793 tree parm
= TYPE_ARG_TYPES (t
);
2794 if (TREE_CODE (t
) == METHOD_TYPE
)
2795 /* The 'this' pointer isn't interesting; a method has the same
2796 linkage (or lack thereof) as its enclosing class. */
2797 parm
= TREE_CHAIN (parm
);
2799 parm
&& parm
!= void_list_node
;
2800 parm
= TREE_CHAIN (parm
))
2802 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2806 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2814 extern int depth_reached
;
2817 cxx_print_statistics (void)
2819 print_template_statistics ();
2820 if (GATHER_STATISTICS
)
2821 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2825 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2826 (which is an ARRAY_TYPE). This counts only elements of the top
2830 array_type_nelts_top (tree type
)
2832 return fold_build2_loc (input_location
,
2833 PLUS_EXPR
, sizetype
,
2834 array_type_nelts (type
),
2838 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2839 (which is an ARRAY_TYPE). This one is a recursive count of all
2840 ARRAY_TYPEs that are clumped together. */
2843 array_type_nelts_total (tree type
)
2845 tree sz
= array_type_nelts_top (type
);
2846 type
= TREE_TYPE (type
);
2847 while (TREE_CODE (type
) == ARRAY_TYPE
)
2849 tree n
= array_type_nelts_top (type
);
2850 sz
= fold_build2_loc (input_location
,
2851 MULT_EXPR
, sizetype
, sz
, n
);
2852 type
= TREE_TYPE (type
);
2859 splay_tree target_remap
;
2860 bool clear_location
;
2863 /* Called from break_out_target_exprs via mapcar. */
2866 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2868 bot_data
&data
= *(bot_data
*)data_
;
2869 splay_tree target_remap
= data
.target_remap
;
2872 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2874 /* There can't be any TARGET_EXPRs or their slot variables below this
2875 point. But we must make a copy, in case subsequent processing
2876 alters any part of it. For example, during gimplification a cast
2877 of the form (T) &X::f (where "f" is a member function) will lead
2878 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2880 *tp
= unshare_expr (t
);
2883 if (TREE_CODE (t
) == TARGET_EXPR
)
2887 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2889 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2890 tf_warning_or_error
);
2891 if (u
== error_mark_node
)
2893 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2894 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2897 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2898 tf_warning_or_error
);
2900 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2901 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2902 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2904 /* Map the old variable to the new one. */
2905 splay_tree_insert (target_remap
,
2906 (splay_tree_key
) TREE_OPERAND (t
, 0),
2907 (splay_tree_value
) TREE_OPERAND (u
, 0));
2909 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
2910 data
.clear_location
);
2911 if (TREE_OPERAND (u
, 1) == error_mark_node
)
2912 return error_mark_node
;
2914 /* Replace the old expression with the new version. */
2916 /* We don't have to go below this point; the recursive call to
2917 break_out_target_exprs will have handled anything below this
2922 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2925 splay_tree_node n
= splay_tree_lookup (target_remap
,
2926 (splay_tree_key
) t
);
2929 *tp
= (tree
)n
->value
;
2934 copy_tree_r (tp
, walk_subtrees
, NULL
);
2935 splay_tree_insert (target_remap
,
2937 (splay_tree_value
)*tp
);
2938 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2939 splay_tree_insert (target_remap
,
2940 (splay_tree_key
)*tp
,
2941 (splay_tree_value
)*tp
);
2946 /* Make a copy of this node. */
2947 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2948 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
2949 if (!processing_template_decl
)
2950 set_flags_from_callee (*tp
);
2951 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
2952 SET_EXPR_LOCATION (*tp
, input_location
);
2956 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2957 DATA is really a splay-tree mapping old variables to new
2961 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
2963 bot_data
&data
= *(bot_data
*)data_
;
2964 splay_tree target_remap
= data
.target_remap
;
2968 splay_tree_node n
= splay_tree_lookup (target_remap
,
2969 (splay_tree_key
) *t
);
2971 *t
= (tree
) n
->value
;
2973 else if (TREE_CODE (*t
) == PARM_DECL
2974 && DECL_NAME (*t
) == this_identifier
2975 && !DECL_CONTEXT (*t
))
2977 /* In an NSDMI we need to replace the 'this' parameter we used for
2978 parsing with the real one for this function. */
2979 *t
= current_class_ptr
;
2981 else if (TREE_CODE (*t
) == CONVERT_EXPR
2982 && CONVERT_EXPR_VBASE_PATH (*t
))
2984 /* In an NSDMI build_base_path defers building conversions to virtual
2985 bases, and we handle it here. */
2986 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2987 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2989 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2990 if (BINFO_TYPE (binfo
) == basetype
)
2992 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2993 tf_warning_or_error
);
2999 /* When we parse a default argument expression, we may create
3000 temporary variables via TARGET_EXPRs. When we actually use the
3001 default-argument expression, we make a copy of the expression
3002 and replace the temporaries with appropriate local versions.
3004 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3008 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3010 static int target_remap_count
;
3011 static splay_tree target_remap
;
3013 if (!target_remap_count
++)
3014 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3015 /*splay_tree_delete_key_fn=*/NULL
,
3016 /*splay_tree_delete_value_fn=*/NULL
);
3017 bot_data data
= { target_remap
, clear_location
};
3018 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3019 t
= error_mark_node
;
3020 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3022 if (!--target_remap_count
)
3024 splay_tree_delete (target_remap
);
3025 target_remap
= NULL
;
3031 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3032 which we expect to have type TYPE. */
3035 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3037 if (index
== NULL_TREE
)
3038 /* Can't refer to a particular member of a vector. */
3040 else if (TREE_CODE (index
) == INTEGER_CST
)
3041 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3043 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3044 /*reference*/false, tf_none
);
3047 tree objtype
= TREE_TYPE (obj
);
3048 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3050 /* When the destination object refers to a flexible array member
3051 verify that it matches the type of the source object except
3052 for its domain and qualifiers. */
3053 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3054 TYPE_MAIN_VARIANT (objtype
),
3055 COMPARE_REDECLARATION
));
3058 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3064 struct replace_placeholders_t
3066 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3067 tree exp
; /* The outermost exp. */
3068 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3069 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3072 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3073 build up subexpressions as we go deeper. */
3076 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3078 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3081 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3083 *walk_subtrees
= false;
3087 switch (TREE_CODE (*t
))
3089 case PLACEHOLDER_EXPR
:
3092 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3094 x
= TREE_OPERAND (x
, 0))
3095 gcc_assert (handled_component_p (x
));
3096 *t
= unshare_expr (x
);
3097 *walk_subtrees
= false;
3104 constructor_elt
*ce
;
3105 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3106 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3107 other than the d->exp one, those have PLACEHOLDER_EXPRs
3108 related to another object. */
3109 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3111 || d
->pset
->add (*t
))
3113 *walk_subtrees
= false;
3116 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3118 tree
*valp
= &ce
->value
;
3119 tree type
= TREE_TYPE (*valp
);
3122 if (TREE_CODE (*valp
) == CONSTRUCTOR
3123 && AGGREGATE_TYPE_P (type
))
3125 /* If we're looking at the initializer for OBJ, then build
3126 a sub-object reference. If we're looking at an
3127 initializer for another object, just pass OBJ down. */
3128 if (same_type_ignoring_top_level_qualifiers_p
3129 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3130 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3131 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3132 valp
= &TARGET_EXPR_INITIAL (*valp
);
3135 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3138 *walk_subtrees
= false;
3143 if (d
->pset
->add (*t
))
3144 *walk_subtrees
= false;
3151 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3152 a PLACEHOLDER_EXPR has been encountered. */
3155 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3157 /* This is only relevant for C++14. */
3158 if (cxx_dialect
< cxx14
)
3161 /* If the object isn't a (member of a) class, do nothing. */
3163 while (TREE_CODE (op0
) == COMPONENT_REF
)
3164 op0
= TREE_OPERAND (op0
, 0);
3165 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3169 if (TREE_CODE (exp
) == TARGET_EXPR
)
3170 tp
= &TARGET_EXPR_INITIAL (exp
);
3171 hash_set
<tree
> pset
;
3172 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3173 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3175 *seen_p
= data
.seen
;
3179 /* Callback function for find_placeholders. */
3182 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3184 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3186 *walk_subtrees
= false;
3190 switch (TREE_CODE (*t
))
3192 case PLACEHOLDER_EXPR
:
3196 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3197 *walk_subtrees
= false;
3207 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3208 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3211 find_placeholders (tree exp
)
3213 /* This is only relevant for C++14. */
3214 if (cxx_dialect
< cxx14
)
3217 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3220 /* Similar to `build_nt', but for template definitions of dependent
3224 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3231 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3235 t
= make_node (code
);
3236 SET_EXPR_LOCATION (t
, loc
);
3237 length
= TREE_CODE_LENGTH (code
);
3239 for (i
= 0; i
< length
; i
++)
3240 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3246 /* Similar to `build', but for template definitions. */
3249 build_min (enum tree_code code
, tree tt
, ...)
3256 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3260 t
= make_node (code
);
3261 length
= TREE_CODE_LENGTH (code
);
3264 for (i
= 0; i
< length
; i
++)
3266 tree x
= va_arg (p
, tree
);
3267 TREE_OPERAND (t
, i
) = x
;
3268 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3269 TREE_SIDE_EFFECTS (t
) = 1;
3277 /* Similar to `build', but for template definitions of non-dependent
3278 expressions. NON_DEP is the non-dependent expression that has been
3282 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3289 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3291 va_start (p
, non_dep
);
3293 if (REFERENCE_REF_P (non_dep
))
3294 non_dep
= TREE_OPERAND (non_dep
, 0);
3296 t
= make_node (code
);
3297 length
= TREE_CODE_LENGTH (code
);
3298 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3299 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3301 for (i
= 0; i
< length
; i
++)
3302 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3304 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3305 /* This should not be considered a COMPOUND_EXPR, because it
3306 resolves to an overload. */
3307 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3310 return convert_from_reference (t
);
3313 /* Similar to build_min_nt, but call expressions */
3316 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3321 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3322 CALL_EXPR_FN (ret
) = fn
;
3323 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3324 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3325 CALL_EXPR_ARG (ret
, ix
) = t
;
3330 /* Similar to `build_min_nt_call_vec', but for template definitions of
3331 non-dependent expressions. NON_DEP is the non-dependent expression
3332 that has been built. */
3335 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3337 tree t
= build_min_nt_call_vec (fn
, argvec
);
3338 if (REFERENCE_REF_P (non_dep
))
3339 non_dep
= TREE_OPERAND (non_dep
, 0);
3340 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3341 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3342 return convert_from_reference (t
);
3345 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3346 a call to an operator overload. OP is the operator that has been
3347 overloaded. NON_DEP is the non-dependent expression that's been built,
3348 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3349 the overload that NON_DEP is calling. */
3352 build_min_non_dep_op_overload (enum tree_code op
,
3357 int nargs
, expected_nargs
;
3359 vec
<tree
, va_gc
> *args
;
3361 non_dep
= extract_call_expr (non_dep
);
3363 nargs
= call_expr_nargs (non_dep
);
3365 expected_nargs
= cp_tree_code_length (op
);
3366 if ((op
== POSTINCREMENT_EXPR
3367 || op
== POSTDECREMENT_EXPR
)
3368 /* With -fpermissive non_dep could be operator++(). */
3369 && (!flag_permissive
|| nargs
!= expected_nargs
))
3370 expected_nargs
+= 1;
3371 gcc_assert (nargs
== expected_nargs
);
3373 args
= make_tree_vector ();
3374 va_start (p
, overload
);
3376 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3379 for (int i
= 0; i
< nargs
; i
++)
3381 tree arg
= va_arg (p
, tree
);
3382 vec_safe_push (args
, arg
);
3385 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3387 tree object
= va_arg (p
, tree
);
3388 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3389 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3390 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3391 object
, method
, NULL_TREE
);
3392 for (int i
= 1; i
< nargs
; i
++)
3394 tree arg
= va_arg (p
, tree
);
3395 vec_safe_push (args
, arg
);
3402 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3403 release_tree_vector (args
);
3405 tree call_expr
= extract_call_expr (call
);
3406 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3407 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3408 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3409 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3414 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3417 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3419 unsigned len
= vec_safe_length (old_vec
);
3420 gcc_assert (idx
<= len
);
3422 vec
<tree
, va_gc
> *new_vec
= NULL
;
3423 vec_alloc (new_vec
, len
+ 1);
3426 for (i
= 0; i
< len
; ++i
)
3429 new_vec
->quick_push (elt
);
3430 new_vec
->quick_push ((*old_vec
)[i
]);
3433 new_vec
->quick_push (elt
);
3439 get_type_decl (tree t
)
3441 if (TREE_CODE (t
) == TYPE_DECL
)
3444 return TYPE_STUB_DECL (t
);
3445 gcc_assert (t
== error_mark_node
);
3449 /* Returns the namespace that contains DECL, whether directly or
3453 decl_namespace_context (tree decl
)
3457 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3459 else if (TYPE_P (decl
))
3460 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3462 decl
= CP_DECL_CONTEXT (decl
);
3466 /* Returns true if decl is within an anonymous namespace, however deeply
3467 nested, or false otherwise. */
3470 decl_anon_ns_mem_p (const_tree decl
)
3472 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3474 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3476 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3478 decl
= CP_DECL_CONTEXT (decl
);
3480 return !TREE_PUBLIC (decl
);
3483 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3484 CALL_EXPRS. Return whether they are equivalent. */
3487 called_fns_equal (tree t1
, tree t2
)
3489 /* Core 1321: dependent names are equivalent even if the overload sets
3490 are different. But do compare explicit template arguments. */
3491 tree name1
= dependent_name (t1
);
3492 tree name2
= dependent_name (t2
);
3495 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3500 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3501 targs1
= TREE_OPERAND (t1
, 1);
3502 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3503 targs2
= TREE_OPERAND (t2
, 1);
3504 return cp_tree_equal (targs1
, targs2
);
3507 return cp_tree_equal (t1
, t2
);
3510 /* Return truthvalue of whether T1 is the same tree structure as T2.
3511 Return 1 if they are the same. Return 0 if they are different. */
3514 cp_tree_equal (tree t1
, tree t2
)
3516 enum tree_code code1
, code2
;
3523 code1
= TREE_CODE (t1
);
3524 code2
= TREE_CODE (t2
);
3529 if (CONSTANT_CLASS_P (t1
)
3530 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3536 /* There's only a single VOID_CST node, so we should never reach
3541 return tree_int_cst_equal (t1
, t2
);
3544 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3547 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3548 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3549 TREE_STRING_LENGTH (t1
));
3552 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3553 TREE_FIXED_CST (t2
));
3556 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3557 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3560 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3563 /* We need to do this when determining whether or not two
3564 non-type pointer to member function template arguments
3566 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3567 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3572 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3574 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3575 if (!cp_tree_equal (field
, elt2
->index
)
3576 || !cp_tree_equal (value
, elt2
->value
))
3583 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3585 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3587 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3590 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3595 call_expr_arg_iterator iter1
, iter2
;
3596 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3598 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3599 arg2
= first_call_expr_arg (t2
, &iter2
);
3601 arg1
= next_call_expr_arg (&iter1
),
3602 arg2
= next_call_expr_arg (&iter2
))
3603 if (!cp_tree_equal (arg1
, arg2
))
3612 tree o1
= TREE_OPERAND (t1
, 0);
3613 tree o2
= TREE_OPERAND (t2
, 0);
3615 /* Special case: if either target is an unallocated VAR_DECL,
3616 it means that it's going to be unified with whatever the
3617 TARGET_EXPR is really supposed to initialize, so treat it
3618 as being equivalent to anything. */
3619 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3620 && !DECL_RTL_SET_P (o1
))
3622 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3623 && !DECL_RTL_SET_P (o2
))
3625 else if (!cp_tree_equal (o1
, o2
))
3628 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3632 /* For comparing uses of parameters in late-specified return types
3633 with an out-of-class definition of the function, but can also come
3634 up for expressions that involve 'this' in a member function
3637 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3638 /* When comparing hash table entries, only an exact match is
3639 good enough; we don't want to replace 'this' with the
3640 version from another function. But be more flexible
3641 with local parameters in a requires-expression. */
3644 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3646 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3648 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3650 if (DECL_ARTIFICIAL (t1
)
3651 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3652 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3662 case IDENTIFIER_NODE
:
3667 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3668 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3669 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3670 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3671 BASELINK_FUNCTIONS (t2
)));
3673 case TEMPLATE_PARM_INDEX
:
3674 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3675 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3676 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3677 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3678 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3679 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3681 case TEMPLATE_ID_EXPR
:
3682 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3683 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3685 case CONSTRAINT_INFO
:
3686 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3687 CI_ASSOCIATED_CONSTRAINTS (t2
));
3690 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3691 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3692 CHECK_CONSTR_ARGS (t2
)));
3697 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3699 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3700 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3701 TREE_VEC_ELT (t2
, ix
)))
3709 tree o1
= TREE_OPERAND (t1
, 0);
3710 tree o2
= TREE_OPERAND (t2
, 0);
3712 if (code1
== SIZEOF_EXPR
)
3714 if (SIZEOF_EXPR_TYPE_P (t1
))
3715 o1
= TREE_TYPE (o1
);
3716 if (SIZEOF_EXPR_TYPE_P (t2
))
3717 o2
= TREE_TYPE (o2
);
3719 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3722 return same_type_p (o1
, o2
);
3724 return cp_tree_equal (o1
, o2
);
3729 tree t1_op1
, t2_op1
;
3731 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3734 t1_op1
= TREE_OPERAND (t1
, 1);
3735 t2_op1
= TREE_OPERAND (t2
, 1);
3736 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3739 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3743 /* Two pointer-to-members are the same if they point to the same
3744 field or function in the same class. */
3745 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3748 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3752 /* Two overloads. Must be exactly the same set of decls. */
3753 lkp_iterator
first (t1
);
3754 lkp_iterator
second (t2
);
3756 for (; first
&& second
; ++first
, ++second
)
3757 if (*first
!= *second
)
3759 return !(first
|| second
);
3763 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3765 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3766 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3769 case STATIC_CAST_EXPR
:
3770 case REINTERPRET_CAST_EXPR
:
3771 case CONST_CAST_EXPR
:
3772 case DYNAMIC_CAST_EXPR
:
3773 case IMPLICIT_CONV_EXPR
:
3776 case NON_LVALUE_EXPR
:
3777 case VIEW_CONVERT_EXPR
:
3778 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3780 /* Now compare operands as usual. */
3783 case DEFERRED_NOEXCEPT
:
3784 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3785 DEFERRED_NOEXCEPT_PATTERN (t2
))
3786 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3787 DEFERRED_NOEXCEPT_ARGS (t2
)));
3791 if (DECL_DEPENDENT_P (t1
) && DECL_DEPENDENT_P (t2
))
3792 return (cp_tree_equal (USING_DECL_SCOPE (t1
),
3793 USING_DECL_SCOPE (t2
))
3794 && cp_tree_equal (DECL_NAME (t1
),
3799 /* Two lambda-expressions are never considered equivalent. */
3806 switch (TREE_CODE_CLASS (code1
))
3810 case tcc_comparison
:
3811 case tcc_expression
:
3818 n
= cp_tree_operand_length (t1
);
3819 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3820 && n
!= TREE_OPERAND_LENGTH (t2
))
3823 for (i
= 0; i
< n
; ++i
)
3824 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3831 return same_type_p (t1
, t2
);
3835 /* We can get here with --disable-checking. */
3839 /* The type of ARG when used as an lvalue. */
3842 lvalue_type (tree arg
)
3844 tree type
= TREE_TYPE (arg
);
3848 /* The type of ARG for printing error messages; denote lvalues with
3852 error_type (tree arg
)
3854 tree type
= TREE_TYPE (arg
);
3856 if (TREE_CODE (type
) == ARRAY_TYPE
)
3858 else if (TREE_CODE (type
) == ERROR_MARK
)
3860 else if (lvalue_p (arg
))
3861 type
= build_reference_type (lvalue_type (arg
));
3862 else if (MAYBE_CLASS_TYPE_P (type
))
3863 type
= lvalue_type (arg
);
3868 /* Does FUNCTION use a variable-length argument list? */
3871 varargs_function_p (const_tree function
)
3873 return stdarg_p (TREE_TYPE (function
));
3876 /* Returns 1 if decl is a member of a class. */
3879 member_p (const_tree decl
)
3881 const_tree
const ctx
= DECL_CONTEXT (decl
);
3882 return (ctx
&& TYPE_P (ctx
));
3885 /* Create a placeholder for member access where we don't actually have an
3886 object that the access is against. */
3889 build_dummy_object (tree type
)
3891 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3892 return cp_build_fold_indirect_ref (decl
);
3895 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3896 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3897 binfo path from current_class_type to TYPE, or 0. */
3900 maybe_dummy_object (tree type
, tree
* binfop
)
3904 tree current
= current_nonlambda_class_type ();
3907 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3908 tf_warning_or_error
)))
3912 /* Reference from a nested class member function. */
3914 binfo
= TYPE_BINFO (type
);
3920 if (current_class_ref
3921 /* current_class_ref might not correspond to current_class_type if
3922 we're in tsubst_default_argument or a lambda-declarator; in either
3923 case, we want to use current_class_ref if it matches CONTEXT. */
3924 && (same_type_ignoring_top_level_qualifiers_p
3925 (TREE_TYPE (current_class_ref
), context
)))
3926 decl
= current_class_ref
;
3928 decl
= build_dummy_object (context
);
3933 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3936 is_dummy_object (const_tree ob
)
3938 if (INDIRECT_REF_P (ob
))
3939 ob
= TREE_OPERAND (ob
, 0);
3940 return (TREE_CODE (ob
) == CONVERT_EXPR
3941 && TREE_OPERAND (ob
, 0) == void_node
);
3944 /* Returns 1 iff type T is something we want to treat as a scalar type for
3945 the purpose of deciding whether it is trivial/POD/standard-layout. */
3948 scalarish_type_p (const_tree t
)
3950 if (t
== error_mark_node
)
3953 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3956 /* Returns true iff T requires non-trivial default initialization. */
3959 type_has_nontrivial_default_init (const_tree t
)
3961 t
= strip_array_types (CONST_CAST_TREE (t
));
3963 if (CLASS_TYPE_P (t
))
3964 return TYPE_HAS_COMPLEX_DFLT (t
);
3969 /* Track classes with only deleted copy/move constructors so that we can warn
3970 if they are used in call/return by value. */
3972 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
3974 remember_deleted_copy (const_tree t
)
3976 if (!deleted_copy_types
)
3977 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
3978 deleted_copy_types
->add (CONST_CAST_TREE (t
));
3981 maybe_warn_parm_abi (tree t
, location_t loc
)
3983 if (!deleted_copy_types
3984 || !deleted_copy_types
->contains (t
))
3987 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
3988 && classtype_has_non_deleted_move_ctor (t
))
3991 auto_diagnostic_group d
;
3992 if (flag_abi_version
> 12)
3993 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=13 (GCC 8.2) fixes the "
3994 "calling convention for %qT, which was accidentally "
3995 "changed in 8.1", t
);
3997 w
= warning_at (loc
, OPT_Wabi
, "-fabi-version=12 (GCC 8.1) accident"
3998 "ally changes the calling convention for %qT", t
);
4000 inform (location_of (t
), " declared here");
4004 auto_diagnostic_group d
;
4005 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4006 "-fabi-version=13 (GCC 8.2)", t
))
4007 inform (location_of (t
), " because all of its copy and move "
4008 "constructors are deleted");
4011 /* Returns true iff copying an object of type T (including via move
4012 constructor) is non-trivial. That is, T has no non-trivial copy
4013 constructors and no non-trivial move constructors, and not all copy/move
4014 constructors are deleted. This function implements the ABI notion of
4015 non-trivial copy, which has diverged from the one in the standard. */
4018 type_has_nontrivial_copy_init (const_tree type
)
4020 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4022 if (CLASS_TYPE_P (t
))
4024 gcc_assert (COMPLETE_TYPE_P (t
));
4026 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4027 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4031 if (cxx_dialect
< cxx11
)
4032 /* No deleted functions before C++11. */
4035 /* Before ABI v12 we did a bitwise copy of types with only deleted
4036 copy/move constructors. */
4037 if (!abi_version_at_least (12)
4038 && !(warn_abi
&& abi_version_crosses (12)))
4041 bool saw_copy
= false;
4042 bool saw_non_deleted
= false;
4043 bool saw_non_deleted_move
= false;
4045 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4046 saw_copy
= saw_non_deleted
= true;
4047 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4050 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4051 /* [class.copy]/8 If the class definition declares a move
4052 constructor or move assignment operator, the implicitly declared
4053 copy constructor is defined as deleted.... */;
4055 /* Any other reason the implicitly-declared function would be
4056 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4058 saw_non_deleted
= true;
4061 if (!saw_non_deleted
)
4062 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4068 if (!DECL_DELETED_FN (fn
))
4070 /* Not deleted, therefore trivial. */
4071 saw_non_deleted
= true;
4075 else if (move_fn_p (fn
))
4076 if (!DECL_DELETED_FN (fn
))
4077 saw_non_deleted_move
= true;
4080 gcc_assert (saw_copy
);
4082 /* ABI v12 buggily ignored move constructors. */
4083 bool v11nontriv
= false;
4084 bool v12nontriv
= !saw_non_deleted
;
4085 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4086 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4087 : flag_abi_version
== 12 ? v12nontriv
4089 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4090 : warn_abi_version
== 12 ? v12nontriv
4092 if (nontriv
!= warn_nontriv
)
4093 remember_deleted_copy (t
);
4101 /* Returns 1 iff type T is a trivially copyable type, as defined in
4102 [basic.types] and [class]. */
4105 trivially_copyable_p (const_tree t
)
4107 t
= strip_array_types (CONST_CAST_TREE (t
));
4109 if (CLASS_TYPE_P (t
))
4110 return ((!TYPE_HAS_COPY_CTOR (t
)
4111 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4112 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4113 && (!TYPE_HAS_COPY_ASSIGN (t
)
4114 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4115 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4116 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4118 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4121 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4125 trivial_type_p (const_tree t
)
4127 t
= strip_array_types (CONST_CAST_TREE (t
));
4129 if (CLASS_TYPE_P (t
))
4130 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4131 && trivially_copyable_p (t
));
4133 return scalarish_type_p (t
);
4136 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4139 pod_type_p (const_tree t
)
4141 /* This CONST_CAST is okay because strip_array_types returns its
4142 argument unmodified and we assign it to a const_tree. */
4143 t
= strip_array_types (CONST_CAST_TREE(t
));
4145 if (!CLASS_TYPE_P (t
))
4146 return scalarish_type_p (t
);
4147 else if (cxx_dialect
> cxx98
)
4148 /* [class]/10: A POD struct is a class that is both a trivial class and a
4149 standard-layout class, and has no non-static data members of type
4150 non-POD struct, non-POD union (or array of such types).
4152 We don't need to check individual members because if a member is
4153 non-std-layout or non-trivial, the class will be too. */
4154 return (std_layout_type_p (t
) && trivial_type_p (t
));
4156 /* The C++98 definition of POD is different. */
4157 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4160 /* Returns true iff T is POD for the purpose of layout, as defined in the
4164 layout_pod_type_p (const_tree t
)
4166 t
= strip_array_types (CONST_CAST_TREE (t
));
4168 if (CLASS_TYPE_P (t
))
4169 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4171 return scalarish_type_p (t
);
4174 /* Returns true iff T is a standard-layout type, as defined in
4178 std_layout_type_p (const_tree t
)
4180 t
= strip_array_types (CONST_CAST_TREE (t
));
4182 if (CLASS_TYPE_P (t
))
4183 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4185 return scalarish_type_p (t
);
4188 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4190 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4191 as defined in [meta.unary.prop]. */
4194 type_has_unique_obj_representations (const_tree t
)
4198 t
= strip_array_types (CONST_CAST_TREE (t
));
4200 if (!trivially_copyable_p (t
))
4203 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4204 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4206 switch (TREE_CODE (t
))
4210 case REFERENCE_TYPE
:
4211 /* If some backend has any paddings in these types, we should add
4212 a target hook for this and handle it there. */
4216 /* For bool values other than 0 and 1 should only appear with
4217 undefined behavior. */
4221 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4224 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4225 when storing long double values, so for that we have to return false.
4226 Other kinds of floating point values are questionable due to +.0/-.0
4227 and NaNs, let's play safe for now. */
4230 case FIXED_POINT_TYPE
:
4238 return type_has_unique_obj_representations (TREE_TYPE (t
));
4241 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4242 if (CLASS_TYPE_P (t
))
4244 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4245 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4253 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4254 if (TREE_CODE (field
) == FIELD_DECL
)
4257 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4258 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4264 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4266 if (CLASS_TYPE_P (t
))
4268 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4269 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4284 /* Helper function for type_has_unique_obj_representations. */
4287 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4289 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4290 if (TREE_CODE (field
) != FIELD_DECL
)
4292 /* For bases, can't use type_has_unique_obj_representations here, as in
4293 struct S { int i : 24; S (); };
4294 struct T : public S { int j : 8; T (); };
4295 S doesn't have unique obj representations, but T does. */
4296 else if (DECL_FIELD_IS_BASE (field
))
4298 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4302 else if (DECL_C_BIT_FIELD (field
))
4304 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4305 if (!type_has_unique_obj_representations (btype
))
4308 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4312 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4313 if (TREE_CODE (field
) == FIELD_DECL
)
4315 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4316 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4317 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4320 if (DECL_SIZE (field
))
4322 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4326 if (cur
!= wi::to_offset (sz
))
4332 /* Nonzero iff type T is a class template implicit specialization. */
4335 class_tmpl_impl_spec_p (const_tree t
)
4337 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4340 /* Returns 1 iff zero initialization of type T means actually storing
4344 zero_init_p (const_tree t
)
4346 /* This CONST_CAST is okay because strip_array_types returns its
4347 argument unmodified and we assign it to a const_tree. */
4348 t
= strip_array_types (CONST_CAST_TREE(t
));
4350 if (t
== error_mark_node
)
4353 /* NULL pointers to data members are initialized with -1. */
4354 if (TYPE_PTRDATAMEM_P (t
))
4357 /* Classes that contain types that can't be zero-initialized, cannot
4358 be zero-initialized themselves. */
4359 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4365 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4366 warn_unused_result attribute. */
4369 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4370 int /*flags*/, bool *no_add_attrs
)
4372 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4374 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4375 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4376 "return type", name
, *node
);
4378 else if (OVERLOAD_TYPE_P (*node
))
4382 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4383 "functions or to class or enumeration types", name
);
4384 *no_add_attrs
= true;
4389 /* Handle a C++2a "no_unique_address" attribute; arguments as in
4390 struct attribute_spec.handler. */
4392 handle_no_unique_addr_attribute (tree
* node
,
4398 if (TREE_CODE (*node
) != FIELD_DECL
)
4400 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4401 "non-static data members", name
);
4402 *no_add_attrs
= true;
4404 else if (DECL_C_BIT_FIELD (*node
))
4406 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4407 "a bit-field", name
);
4408 *no_add_attrs
= true;
4414 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4415 hot/cold attributes. */
4418 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4419 int flags
, bool *no_add_attrs
)
4421 *no_add_attrs
= true;
4422 if (TREE_CODE (*node
) == LABEL_DECL
4423 || TREE_CODE (*node
) == FUNCTION_DECL
)
4426 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4427 tree bname
= (is_attribute_p ("likely", name
)
4428 ? get_identifier ("hot") : get_identifier ("cold"));
4429 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4430 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4431 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4432 tree battr
= build_tree_list (bname
, NULL_TREE
);
4433 decl_attributes (node
, battr
, flags
);
4437 return error_mark_node
;
4440 /* Table of valid C++ attributes. */
4441 const struct attribute_spec cxx_attribute_table
[] =
4443 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4444 affects_type_identity, handler, exclude } */
4445 { "init_priority", 1, 1, true, false, false, false,
4446 handle_init_priority_attribute
, NULL
},
4447 { "abi_tag", 1, -1, false, false, false, true,
4448 handle_abi_tag_attribute
, NULL
},
4449 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4452 /* Table of C++ standard attributes. */
4453 const struct attribute_spec std_attribute_table
[] =
4455 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4456 affects_type_identity, handler, exclude } */
4457 { "maybe_unused", 0, 0, false, false, false, false,
4458 handle_unused_attribute
, NULL
},
4459 { "nodiscard", 0, 0, false, false, false, false,
4460 handle_nodiscard_attribute
, NULL
},
4461 { "no_unique_address", 0, 0, true, false, false, false,
4462 handle_no_unique_addr_attribute
, NULL
},
4463 { "likely", 0, 0, false, false, false, false,
4464 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4465 { "unlikely", 0, 0, false, false, false, false,
4466 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4467 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4470 /* Handle an "init_priority" attribute; arguments as in
4471 struct attribute_spec.handler. */
4473 handle_init_priority_attribute (tree
* node
,
4479 tree initp_expr
= TREE_VALUE (args
);
4481 tree type
= TREE_TYPE (decl
);
4484 STRIP_NOPS (initp_expr
);
4485 initp_expr
= default_conversion (initp_expr
);
4487 initp_expr
= maybe_constant_value (initp_expr
);
4489 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4491 error ("requested init_priority is not an integer constant");
4492 cxx_constant_value (initp_expr
);
4493 *no_add_attrs
= true;
4497 pri
= TREE_INT_CST_LOW (initp_expr
);
4499 type
= strip_array_types (type
);
4501 if (decl
== NULL_TREE
4503 || !TREE_STATIC (decl
)
4504 || DECL_EXTERNAL (decl
)
4505 || (TREE_CODE (type
) != RECORD_TYPE
4506 && TREE_CODE (type
) != UNION_TYPE
)
4507 /* Static objects in functions are initialized the
4508 first time control passes through that
4509 function. This is not precise enough to pin down an
4510 init_priority value, so don't allow it. */
4511 || current_function_decl
)
4513 error ("can only use %qE attribute on file-scope definitions "
4514 "of objects of class type", name
);
4515 *no_add_attrs
= true;
4519 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4521 error ("requested init_priority is out of range");
4522 *no_add_attrs
= true;
4526 /* Check for init_priorities that are reserved for
4527 language and runtime support implementations.*/
4528 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4531 (0, "requested init_priority is reserved for internal use");
4534 if (SUPPORTS_INIT_PRIORITY
)
4536 SET_DECL_INIT_PRIORITY (decl
, pri
);
4537 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4542 error ("%qE attribute is not supported on this platform", name
);
4543 *no_add_attrs
= true;
4548 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4549 and the new one has the tags in NEW_. Give an error if there are tags
4550 in NEW_ that weren't in OLD. */
4553 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4555 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4556 old
= TREE_VALUE (old
);
4557 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4558 new_
= TREE_VALUE (new_
);
4560 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4562 tree str
= TREE_VALUE (t
);
4563 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4565 tree ostr
= TREE_VALUE (in
);
4566 if (cp_tree_equal (str
, ostr
))
4569 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4575 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4581 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4582 ill-formed, give an error and return false; otherwise, return true. */
4585 check_abi_tag_args (tree args
, tree name
)
4589 error ("the %qE attribute requires arguments", name
);
4592 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4594 tree elt
= TREE_VALUE (arg
);
4595 if (TREE_CODE (elt
) != STRING_CST
4596 || (!same_type_ignoring_top_level_qualifiers_p
4597 (strip_array_types (TREE_TYPE (elt
)),
4600 error ("arguments to the %qE attribute must be narrow string "
4604 const char *begin
= TREE_STRING_POINTER (elt
);
4605 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4606 for (const char *p
= begin
; p
!= end
; ++p
)
4611 if (!ISALPHA (c
) && c
!= '_')
4613 error ("arguments to the %qE attribute must contain valid "
4614 "identifiers", name
);
4615 inform (input_location
, "%<%c%> is not a valid first "
4616 "character for an identifier", c
);
4620 else if (p
== end
- 1)
4621 gcc_assert (c
== 0);
4624 if (!ISALNUM (c
) && c
!= '_')
4626 error ("arguments to the %qE attribute must contain valid "
4627 "identifiers", name
);
4628 inform (input_location
, "%<%c%> is not a valid character "
4629 "in an identifier", c
);
4638 /* Handle an "abi_tag" attribute; arguments as in
4639 struct attribute_spec.handler. */
4642 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4643 int flags
, bool* no_add_attrs
)
4645 if (!check_abi_tag_args (args
, name
))
4650 if (!OVERLOAD_TYPE_P (*node
))
4652 error ("%qE attribute applied to non-class, non-enum type %qT",
4656 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4658 error ("%qE attribute applied to %qT after its definition",
4662 else if (CLASS_TYPE_P (*node
)
4663 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4665 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4666 "template instantiation %qT", name
, *node
);
4669 else if (CLASS_TYPE_P (*node
)
4670 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4672 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4673 "template specialization %qT", name
, *node
);
4677 tree attributes
= TYPE_ATTRIBUTES (*node
);
4678 tree decl
= TYPE_NAME (*node
);
4680 /* Make sure all declarations have the same abi tags. */
4681 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4683 if (!check_abi_tag_redeclaration (decl
,
4684 lookup_attribute ("abi_tag",
4692 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4694 error ("%qE attribute applied to non-function, non-variable %qD",
4698 else if (DECL_LANGUAGE (*node
) == lang_c
)
4700 error ("%qE attribute applied to extern \"C\" declaration %qD",
4709 *no_add_attrs
= true;
4713 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4714 thing pointed to by the constant. */
4717 make_ptrmem_cst (tree type
, tree member
)
4719 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4720 TREE_TYPE (ptrmem_cst
) = type
;
4721 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4725 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4726 return an existing type if an appropriate type already exists. */
4729 cp_build_type_attribute_variant (tree type
, tree attributes
)
4733 new_type
= build_type_attribute_variant (type
, attributes
);
4734 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4735 || TREE_CODE (new_type
) == METHOD_TYPE
)
4736 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
4738 /* Making a new main variant of a class type is broken. */
4739 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4744 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4745 Called only after doing all language independent checks. */
4748 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4750 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4751 || TREE_CODE (typea
) == METHOD_TYPE
);
4753 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4755 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
4757 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4758 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4761 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4762 C++, these are the exception-specifier and ref-qualifier. */
4765 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4767 tree type
= CONST_CAST_TREE (typea
);
4768 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4769 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
4770 TYPE_RAISES_EXCEPTIONS (typeb
),
4771 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
4775 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4776 traversal. Called from walk_tree. */
4779 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4780 void *data
, hash_set
<tree
> *pset
)
4782 enum tree_code code
= TREE_CODE (*tp
);
4785 #define WALK_SUBTREE(NODE) \
4788 result = cp_walk_tree (&(NODE), func, data, pset); \
4789 if (result) goto out; \
4793 /* Not one of the easy cases. We must explicitly go through the
4799 case TEMPLATE_TEMPLATE_PARM
:
4800 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4801 case UNBOUND_CLASS_TEMPLATE
:
4802 case TEMPLATE_PARM_INDEX
:
4803 case TEMPLATE_TYPE_PARM
:
4806 case UNDERLYING_TYPE
:
4807 /* None of these have subtrees other than those already walked
4809 *walk_subtrees_p
= 0;
4813 if (BASELINK_QUALIFIED_P (*tp
))
4814 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4815 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4816 *walk_subtrees_p
= 0;
4820 WALK_SUBTREE (TREE_TYPE (*tp
));
4821 *walk_subtrees_p
= 0;
4825 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4829 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4830 WALK_SUBTREE (OVL_CHAIN (*tp
));
4831 *walk_subtrees_p
= 0;
4835 WALK_SUBTREE (DECL_NAME (*tp
));
4836 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4837 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4838 *walk_subtrees_p
= 0;
4842 if (TYPE_PTRMEMFUNC_P (*tp
))
4843 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4846 case TYPE_ARGUMENT_PACK
:
4847 case NONTYPE_ARGUMENT_PACK
:
4849 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4850 int i
, len
= TREE_VEC_LENGTH (args
);
4851 for (i
= 0; i
< len
; i
++)
4852 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4856 case TYPE_PACK_EXPANSION
:
4857 WALK_SUBTREE (TREE_TYPE (*tp
));
4858 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4859 *walk_subtrees_p
= 0;
4862 case EXPR_PACK_EXPANSION
:
4863 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4864 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4865 *walk_subtrees_p
= 0;
4869 case REINTERPRET_CAST_EXPR
:
4870 case STATIC_CAST_EXPR
:
4871 case CONST_CAST_EXPR
:
4872 case DYNAMIC_CAST_EXPR
:
4873 case IMPLICIT_CONV_EXPR
:
4874 if (TREE_TYPE (*tp
))
4875 WALK_SUBTREE (TREE_TYPE (*tp
));
4879 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4880 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4882 *walk_subtrees_p
= 0;
4886 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4887 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4888 *walk_subtrees_p
= 0;
4892 ++cp_unevaluated_operand
;
4893 /* We can't use WALK_SUBTREE here because of the goto. */
4894 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
4895 --cp_unevaluated_operand
;
4896 *walk_subtrees_p
= 0;
4902 ++cp_unevaluated_operand
;
4903 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
4904 --cp_unevaluated_operand
;
4905 *walk_subtrees_p
= 0;
4909 // Only recurse through the nested expression. Do not
4910 // walk the parameter list. Doing so causes false
4911 // positives in the pack expansion checker since the
4912 // requires parameters are introduced as pack expansions.
4913 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4914 *walk_subtrees_p
= 0;
4918 /* User variables should be mentioned in BIND_EXPR_VARS
4919 and their initializers and sizes walked when walking
4920 the containing BIND_EXPR. Compiler temporaries are
4921 handled here. And also normal variables in templates,
4922 since do_poplevel doesn't build a BIND_EXPR then. */
4923 if (VAR_P (TREE_OPERAND (*tp
, 0))
4924 && (processing_template_decl
4925 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4926 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
4928 tree decl
= TREE_OPERAND (*tp
, 0);
4929 WALK_SUBTREE (DECL_INITIAL (decl
));
4930 WALK_SUBTREE (DECL_SIZE (decl
));
4931 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4939 /* We didn't find what we were looking for. */
4946 /* Like save_expr, but for C++. */
4949 cp_save_expr (tree expr
)
4951 /* There is no reason to create a SAVE_EXPR within a template; if
4952 needed, we can create the SAVE_EXPR when instantiating the
4953 template. Furthermore, the middle-end cannot handle C++-specific
4955 if (processing_template_decl
)
4958 /* TARGET_EXPRs are only expanded once. */
4959 if (TREE_CODE (expr
) == TARGET_EXPR
)
4962 return save_expr (expr
);
4965 /* Initialize tree.c. */
4970 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4971 register_scoped_attributes (std_attribute_table
, NULL
);
4974 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4975 is. Note that sfk_none is zero, so this function can be used as a
4976 predicate to test whether or not DECL is a special function. */
4978 special_function_kind
4979 special_function_p (const_tree decl
)
4981 /* Rather than doing all this stuff with magic names, we should
4982 probably have a field of type `special_function_kind' in
4983 DECL_LANG_SPECIFIC. */
4984 if (DECL_INHERITED_CTOR (decl
))
4985 return sfk_inheriting_constructor
;
4986 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4987 return sfk_copy_constructor
;
4988 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4989 return sfk_move_constructor
;
4990 if (DECL_CONSTRUCTOR_P (decl
))
4991 return sfk_constructor
;
4992 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
4993 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
4995 if (copy_fn_p (decl
))
4996 return sfk_copy_assignment
;
4997 if (move_fn_p (decl
))
4998 return sfk_move_assignment
;
5000 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5001 return sfk_destructor
;
5002 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5003 return sfk_complete_destructor
;
5004 if (DECL_BASE_DESTRUCTOR_P (decl
))
5005 return sfk_base_destructor
;
5006 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5007 return sfk_deleting_destructor
;
5008 if (DECL_CONV_FN_P (decl
))
5009 return sfk_conversion
;
5010 if (deduction_guide_p (decl
))
5011 return sfk_deduction_guide
;
5016 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5019 char_type_p (tree type
)
5021 return (same_type_p (type
, char_type_node
)
5022 || same_type_p (type
, unsigned_char_type_node
)
5023 || same_type_p (type
, signed_char_type_node
)
5024 || same_type_p (type
, char16_type_node
)
5025 || same_type_p (type
, char32_type_node
)
5026 || same_type_p (type
, wchar_type_node
));
5029 /* Returns the kind of linkage associated with the indicated DECL. Th
5030 value returned is as specified by the language standard; it is
5031 independent of implementation details regarding template
5032 instantiation, etc. For example, it is possible that a declaration
5033 to which this function assigns external linkage would not show up
5034 as a global symbol when you run `nm' on the resulting object file. */
5037 decl_linkage (tree decl
)
5039 /* This function doesn't attempt to calculate the linkage from first
5040 principles as given in [basic.link]. Instead, it makes use of
5041 the fact that we have already set TREE_PUBLIC appropriately, and
5042 then handles a few special cases. Ideally, we would calculate
5043 linkage first, and then transform that into a concrete
5046 /* Things that don't have names have no linkage. */
5047 if (!DECL_NAME (decl
))
5050 /* Fields have no linkage. */
5051 if (TREE_CODE (decl
) == FIELD_DECL
)
5054 /* Things that are TREE_PUBLIC have external linkage. */
5055 if (TREE_PUBLIC (decl
))
5058 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5059 check one of the "clones" for the real linkage. */
5060 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5061 && DECL_CHAIN (decl
)
5062 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5063 return decl_linkage (DECL_CHAIN (decl
));
5065 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5068 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5070 if (TREE_CODE (decl
) == CONST_DECL
)
5071 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5073 /* Things in local scope do not have linkage, if they don't have
5075 if (decl_function_context (decl
))
5078 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5079 are considered to have external linkage for language purposes, as do
5080 template instantiations on targets without weak symbols. DECLs really
5081 meant to have internal linkage have DECL_THIS_STATIC set. */
5082 if (TREE_CODE (decl
) == TYPE_DECL
)
5084 if (VAR_OR_FUNCTION_DECL_P (decl
))
5086 if (!DECL_THIS_STATIC (decl
))
5089 /* Static data members and static member functions from classes
5090 in anonymous namespace also don't have TREE_PUBLIC set. */
5091 if (DECL_CLASS_CONTEXT (decl
))
5095 /* Everything else has internal linkage. */
5099 /* Returns the storage duration of the object or reference associated with
5100 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5103 decl_storage_duration (tree decl
)
5105 if (TREE_CODE (decl
) == PARM_DECL
)
5107 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5109 gcc_assert (VAR_P (decl
));
5110 if (!TREE_STATIC (decl
)
5111 && !DECL_EXTERNAL (decl
))
5113 if (CP_DECL_THREAD_LOCAL_P (decl
))
5118 /* EXP is an expression that we want to pre-evaluate. Returns (in
5119 *INITP) an expression that will perform the pre-evaluation. The
5120 value returned by this function is a side-effect free expression
5121 equivalent to the pre-evaluated expression. Callers must ensure
5122 that *INITP is evaluated before EXP. */
5125 stabilize_expr (tree exp
, tree
* initp
)
5129 if (!TREE_SIDE_EFFECTS (exp
))
5130 init_expr
= NULL_TREE
;
5131 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5136 /* There are no expressions with REFERENCE_TYPE, but there can be call
5137 arguments with such a type; just treat it as a pointer. */
5138 else if (TYPE_REF_P (TREE_TYPE (exp
))
5139 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5140 || !glvalue_p (exp
))
5142 init_expr
= get_target_expr (exp
);
5143 exp
= TARGET_EXPR_SLOT (init_expr
);
5144 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5151 bool xval
= !lvalue_p (exp
);
5152 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5153 init_expr
= get_target_expr (exp
);
5154 exp
= TARGET_EXPR_SLOT (init_expr
);
5155 exp
= cp_build_fold_indirect_ref (exp
);
5161 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5165 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5166 similar expression ORIG. */
5169 add_stmt_to_compound (tree orig
, tree new_expr
)
5171 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5173 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5175 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5178 /* Like stabilize_expr, but for a call whose arguments we want to
5179 pre-evaluate. CALL is modified in place to use the pre-evaluated
5180 arguments, while, upon return, *INITP contains an expression to
5181 compute the arguments. */
5184 stabilize_call (tree call
, tree
*initp
)
5186 tree inits
= NULL_TREE
;
5188 int nargs
= call_expr_nargs (call
);
5190 if (call
== error_mark_node
|| processing_template_decl
)
5196 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5198 for (i
= 0; i
< nargs
; i
++)
5201 CALL_EXPR_ARG (call
, i
) =
5202 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5203 inits
= add_stmt_to_compound (inits
, init
);
5209 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5210 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5211 arguments, while, upon return, *INITP contains an expression to
5212 compute the arguments. */
5215 stabilize_aggr_init (tree call
, tree
*initp
)
5217 tree inits
= NULL_TREE
;
5219 int nargs
= aggr_init_expr_nargs (call
);
5221 if (call
== error_mark_node
)
5224 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5226 for (i
= 0; i
< nargs
; i
++)
5229 AGGR_INIT_EXPR_ARG (call
, i
) =
5230 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5231 inits
= add_stmt_to_compound (inits
, init
);
5237 /* Like stabilize_expr, but for an initialization.
5239 If the initialization is for an object of class type, this function
5240 takes care not to introduce additional temporaries.
5242 Returns TRUE iff the expression was successfully pre-evaluated,
5243 i.e., if INIT is now side-effect free, except for, possibly, a
5244 single call to a constructor. */
5247 stabilize_init (tree init
, tree
*initp
)
5253 if (t
== error_mark_node
|| processing_template_decl
)
5256 if (TREE_CODE (t
) == INIT_EXPR
)
5257 t
= TREE_OPERAND (t
, 1);
5258 if (TREE_CODE (t
) == TARGET_EXPR
)
5259 t
= TARGET_EXPR_INITIAL (t
);
5261 /* If the RHS can be stabilized without breaking copy elision, stabilize
5262 it. We specifically don't stabilize class prvalues here because that
5263 would mean an extra copy, but they might be stabilized below. */
5264 if (TREE_CODE (init
) == INIT_EXPR
5265 && TREE_CODE (t
) != CONSTRUCTOR
5266 && TREE_CODE (t
) != AGGR_INIT_EXPR
5267 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5270 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5274 if (TREE_CODE (t
) == COMPOUND_EXPR
5275 && TREE_CODE (init
) == INIT_EXPR
)
5277 tree last
= expr_last (t
);
5278 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5279 if (!TREE_SIDE_EFFECTS (last
))
5282 TREE_OPERAND (init
, 1) = last
;
5287 if (TREE_CODE (t
) == CONSTRUCTOR
)
5289 /* Aggregate initialization: stabilize each of the field
5292 constructor_elt
*ce
;
5294 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5295 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5297 tree type
= TREE_TYPE (ce
->value
);
5299 if (TYPE_REF_P (type
)
5300 || SCALAR_TYPE_P (type
))
5301 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5302 else if (!stabilize_init (ce
->value
, &subinit
))
5304 *initp
= add_stmt_to_compound (*initp
, subinit
);
5309 if (TREE_CODE (t
) == CALL_EXPR
)
5311 stabilize_call (t
, initp
);
5315 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5317 stabilize_aggr_init (t
, initp
);
5321 /* The initialization is being performed via a bitwise copy -- and
5322 the item copied may have side effects. */
5323 return !TREE_SIDE_EFFECTS (init
);
5326 /* Returns true if a cast to TYPE may appear in an integral constant
5330 cast_valid_in_integral_constant_expression_p (tree type
)
5332 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5333 || cxx_dialect
>= cxx11
5334 || dependent_type_p (type
)
5335 || type
== error_mark_node
);
5338 /* Return true if we need to fix linkage information of DECL. */
5341 cp_fix_function_decl_p (tree decl
)
5343 /* Skip if DECL is not externally visible. */
5344 if (!TREE_PUBLIC (decl
))
5347 /* We need to fix DECL if it a appears to be exported but with no
5348 function body. Thunks do not have CFGs and we may need to
5349 handle them specially later. */
5350 if (!gimple_has_body_p (decl
)
5351 && !DECL_THUNK_P (decl
)
5352 && !DECL_EXTERNAL (decl
))
5354 struct cgraph_node
*node
= cgraph_node::get (decl
);
5356 /* Don't fix same_body aliases. Although they don't have their own
5357 CFG, they share it with what they alias to. */
5358 if (!node
|| !node
->alias
5359 || !vec_safe_length (node
->ref_list
.references
))
5366 /* Clean the C++ specific parts of the tree T. */
5369 cp_free_lang_data (tree t
)
5371 if (TREE_CODE (t
) == METHOD_TYPE
5372 || TREE_CODE (t
) == FUNCTION_TYPE
)
5374 /* Default args are not interesting anymore. */
5375 tree argtypes
= TYPE_ARG_TYPES (t
);
5378 TREE_PURPOSE (argtypes
) = 0;
5379 argtypes
= TREE_CHAIN (argtypes
);
5382 else if (TREE_CODE (t
) == FUNCTION_DECL
5383 && cp_fix_function_decl_p (t
))
5385 /* If T is used in this translation unit at all, the definition
5386 must exist somewhere else since we have decided to not emit it
5387 in this TU. So make it an external reference. */
5388 DECL_EXTERNAL (t
) = 1;
5389 TREE_STATIC (t
) = 0;
5391 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5392 /* We do not need the leftover chaining of namespaces from the
5394 DECL_CHAIN (t
) = NULL_TREE
;
5397 /* Stub for c-common. Please keep in sync with c-decl.c.
5398 FIXME: If address space support is target specific, then this
5399 should be a C target hook. But currently this is not possible,
5400 because this function is called via REGISTER_TARGET_PRAGMAS. */
5402 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5406 /* Return the number of operands in T that we care about for things like
5410 cp_tree_operand_length (const_tree t
)
5412 enum tree_code code
= TREE_CODE (t
);
5414 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5415 return VL_EXP_OPERAND_LENGTH (t
);
5417 return cp_tree_code_length (code
);
5420 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5423 cp_tree_code_length (enum tree_code code
)
5425 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5429 case PREINCREMENT_EXPR
:
5430 case PREDECREMENT_EXPR
:
5431 case POSTINCREMENT_EXPR
:
5432 case POSTDECREMENT_EXPR
:
5438 case EXPR_PACK_EXPANSION
:
5442 return TREE_CODE_LENGTH (code
);
5446 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5450 cp_expr_location (const_tree t_
)
5452 tree t
= CONST_CAST_TREE (t_
);
5454 return UNKNOWN_LOCATION
;
5455 switch (TREE_CODE (t
))
5458 return LAMBDA_EXPR_LOCATION (t
);
5460 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5462 return EXPR_LOCATION (t
);
5466 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5467 conditions for the warning hold, false otherwise. */
5469 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5471 if (c_inhibit_evaluation_warnings
== 0
5472 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5474 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5475 "zero as null pointer constant");
5481 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5482 /* Complain that some language-specific thing hanging off a tree
5483 node has been accessed improperly. */
5486 lang_check_failed (const char* file
, int line
, const char* function
)
5488 internal_error ("lang_* check: failed in %s, at %s:%d",
5489 function
, trim_filename (file
), line
);
5491 #endif /* ENABLE_TREE_CHECKING */
5495 namespace selftest
{
5497 /* Verify that lvalue_kind () works, for various expressions,
5498 and that location wrappers don't affect the results. */
5503 location_t loc
= BUILTINS_LOCATION
;
5505 /* Verify constants and parameters, without and with
5506 location wrappers. */
5507 tree int_cst
= build_int_cst (integer_type_node
, 42);
5508 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5510 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5511 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5512 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5514 tree string_lit
= build_string (4, "foo");
5515 TREE_TYPE (string_lit
) = char_array_type_node
;
5516 string_lit
= fix_string_type (string_lit
);
5517 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5519 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5520 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5521 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5523 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5524 get_identifier ("some_parm"),
5526 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5528 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5529 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5530 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5532 /* Verify that lvalue_kind of std::move on a parm isn't
5533 affected by location wrappers. */
5534 tree rvalue_ref_of_parm
= move (parm
);
5535 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5536 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5537 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5539 /* Verify lvalue_p. */
5540 ASSERT_FALSE (lvalue_p (int_cst
));
5541 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5542 ASSERT_TRUE (lvalue_p (parm
));
5543 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5544 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5545 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5548 /* Run all of the selftests within this file. */
5553 test_lvalue_kind ();
5556 } // namespace selftest
5558 #endif /* #if CHECKING_P */
5561 #include "gt-cp-tree.h"