1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2016 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"
37 static tree
bot_manip (tree
*, int *, void *);
38 static tree
bot_replace (tree
*, int *, void *);
39 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
40 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
41 static tree
count_trees_r (tree
*, int *, void *);
42 static tree
verify_stmt_tree_r (tree
*, int *, void *);
43 static tree
build_local_temp (tree
);
45 static tree
handle_java_interface_attribute (tree
*, tree
, tree
, int, bool *);
46 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
47 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
49 /* If REF is an lvalue, returns the kind of lvalue that REF is.
50 Otherwise, returns clk_none. */
53 lvalue_kind (const_tree ref
)
55 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
56 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
58 /* Expressions of reference type are sometimes wrapped in
59 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
60 representation, not part of the language, so we have to look
62 if (REFERENCE_REF_P (ref
))
63 return lvalue_kind (TREE_OPERAND (ref
, 0));
66 && TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
68 /* unnamed rvalue references are rvalues */
69 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
70 && TREE_CODE (ref
) != PARM_DECL
72 && TREE_CODE (ref
) != COMPONENT_REF
73 /* Functions are always lvalues. */
74 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
77 /* lvalue references and named rvalue references are lvalues. */
81 if (ref
== current_class_ptr
)
84 switch (TREE_CODE (ref
))
88 /* preincrements and predecrements are valid lvals, provided
89 what they refer to are valid lvals. */
90 case PREINCREMENT_EXPR
:
91 case PREDECREMENT_EXPR
:
93 case WITH_CLEANUP_EXPR
:
96 return lvalue_kind (TREE_OPERAND (ref
, 0));
100 if (TREE_CODE (ref
) == MEMBER_REF
)
101 op1_lvalue_kind
= clk_ordinary
;
103 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
104 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
105 op1_lvalue_kind
= clk_none
;
106 return op1_lvalue_kind
;
109 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
110 /* Look at the member designator. */
111 if (!op1_lvalue_kind
)
113 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
114 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
115 situations. If we're seeing a COMPONENT_REF, it's a non-static
116 member, so it isn't an lvalue. */
117 op1_lvalue_kind
= clk_none
;
118 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
119 /* This can be IDENTIFIER_NODE in a template. */;
120 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
122 /* Clear the ordinary bit. If this object was a class
123 rvalue we want to preserve that information. */
124 op1_lvalue_kind
&= ~clk_ordinary
;
125 /* The lvalue is for a bitfield. */
126 op1_lvalue_kind
|= clk_bitfield
;
128 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
129 op1_lvalue_kind
|= clk_packed
;
131 return op1_lvalue_kind
;
134 case COMPOUND_LITERAL_EXPR
:
138 /* CONST_DECL without TREE_STATIC are enumeration values and
139 thus not lvalues. With TREE_STATIC they are used by ObjC++
140 in objc_build_string_object and need to be considered as
142 if (! TREE_STATIC (ref
))
146 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
147 && DECL_LANG_SPECIFIC (ref
)
148 && DECL_IN_AGGR_P (ref
))
154 case ARRAY_NOTATION_REF
:
157 case PLACEHOLDER_EXPR
:
160 /* A scope ref in a template, left as SCOPE_REF to support later
163 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
165 tree op
= TREE_OPERAND (ref
, 1);
166 if (TREE_CODE (op
) == FIELD_DECL
)
167 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
169 return lvalue_kind (op
);
174 /* Disallow <? and >? as lvalues if either argument side-effects. */
175 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
176 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
178 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
179 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
183 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
184 ? TREE_OPERAND (ref
, 1)
185 : TREE_OPERAND (ref
, 0));
186 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
190 /* We expect to see unlowered MODOP_EXPRs only during
191 template processing. */
192 gcc_assert (processing_template_decl
);
200 return lvalue_kind (TREE_OPERAND (ref
, 1));
206 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
209 /* We can see calls outside of TARGET_EXPR in templates. */
210 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
215 /* All functions (except non-static-member functions) are
217 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
218 ? clk_none
: clk_ordinary
);
221 /* We now represent a reference to a single static member function
223 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
224 its argument unmodified and we assign it to a const_tree. */
225 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
227 case NON_DEPENDENT_EXPR
:
228 return lvalue_kind (TREE_OPERAND (ref
, 0));
231 if (!TREE_TYPE (ref
))
233 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
238 /* If one operand is not an lvalue at all, then this expression is
240 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
243 /* Otherwise, it's an lvalue, and it has all the odd properties
244 contributed by either operand. */
245 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
246 /* It's not an ordinary lvalue if it involves any other kind. */
247 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
248 op1_lvalue_kind
&= ~clk_ordinary
;
249 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
250 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
251 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
252 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
253 op1_lvalue_kind
= clk_none
;
254 return op1_lvalue_kind
;
257 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
260 real_lvalue_p (const_tree ref
)
262 cp_lvalue_kind kind
= lvalue_kind (ref
);
263 if (kind
& (clk_rvalueref
|clk_class
))
269 /* c-common wants us to return bool. */
272 lvalue_p (const_tree t
)
274 return real_lvalue_p (t
);
277 /* This differs from lvalue_p in that xvalues are included. */
280 glvalue_p (const_tree ref
)
282 cp_lvalue_kind kind
= lvalue_kind (ref
);
283 if (kind
& clk_class
)
286 return (kind
!= clk_none
);
289 /* This differs from glvalue_p in that class prvalues are included. */
292 obvalue_p (const_tree ref
)
294 return (lvalue_kind (ref
) != clk_none
);
297 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
298 reference), false otherwise. */
301 xvalue_p (const_tree ref
)
303 return (lvalue_kind (ref
) == clk_rvalueref
);
306 /* C++-specific version of stabilize_reference. */
309 cp_stabilize_reference (tree ref
)
311 switch (TREE_CODE (ref
))
313 /* We need to treat specially anything stabilize_reference doesn't
314 handle specifically. */
325 case ARRAY_RANGE_REF
:
329 cp_lvalue_kind kind
= lvalue_kind (ref
);
330 if ((kind
& ~clk_class
) != clk_none
)
332 tree type
= unlowered_expr_type (ref
);
333 bool rval
= !!(kind
& clk_rvalueref
);
334 type
= cp_build_reference_type (type
, rval
);
335 /* This inhibits warnings in, eg, cxx_mark_addressable
337 warning_sentinel
s (extra_warnings
);
338 ref
= build_static_cast (type
, ref
, tf_error
);
342 return stabilize_reference (ref
);
345 /* Test whether DECL is a builtin that may appear in a
346 constant-expression. */
349 builtin_valid_in_constant_expr_p (const_tree decl
)
351 if (!(TREE_CODE (decl
) == FUNCTION_DECL
352 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
))
353 /* Not a built-in. */
355 switch (DECL_FUNCTION_CODE (decl
))
357 /* These always have constant results like the corresponding
360 case BUILT_IN_FUNCTION
:
363 /* The following built-ins are valid in constant expressions
364 when their arguments are. */
365 case BUILT_IN_ADD_OVERFLOW_P
:
366 case BUILT_IN_SUB_OVERFLOW_P
:
367 case BUILT_IN_MUL_OVERFLOW_P
:
369 /* These have constant results even if their operands are
371 case BUILT_IN_CONSTANT_P
:
372 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
379 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
382 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
385 tree type
= TREE_TYPE (decl
);
387 value
= mark_rvalue_use (value
);
389 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
390 || TREE_TYPE (decl
) == TREE_TYPE (value
)
391 /* On ARM ctors return 'this'. */
392 || (TYPE_PTR_P (TREE_TYPE (value
))
393 && TREE_CODE (value
) == CALL_EXPR
)
394 || useless_type_conversion_p (TREE_TYPE (decl
),
397 t
= cxx_maybe_build_cleanup (decl
, complain
);
398 if (t
== error_mark_node
)
399 return error_mark_node
;
400 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
401 if (EXPR_HAS_LOCATION (value
))
402 SET_EXPR_LOCATION (t
, EXPR_LOCATION (value
));
403 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
404 ignore the TARGET_EXPR. If there really turn out to be no
405 side-effects, then the optimizer should be able to get rid of
406 whatever code is generated anyhow. */
407 TREE_SIDE_EFFECTS (t
) = 1;
412 /* Return an undeclared local temporary of type TYPE for use in building a
416 build_local_temp (tree type
)
418 tree slot
= build_decl (input_location
,
419 VAR_DECL
, NULL_TREE
, type
);
420 DECL_ARTIFICIAL (slot
) = 1;
421 DECL_IGNORED_P (slot
) = 1;
422 DECL_CONTEXT (slot
) = current_function_decl
;
423 layout_decl (slot
, 0);
427 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
430 process_aggr_init_operands (tree t
)
434 side_effects
= TREE_SIDE_EFFECTS (t
);
438 n
= TREE_OPERAND_LENGTH (t
);
439 for (i
= 1; i
< n
; i
++)
441 tree op
= TREE_OPERAND (t
, i
);
442 if (op
&& TREE_SIDE_EFFECTS (op
))
449 TREE_SIDE_EFFECTS (t
) = side_effects
;
452 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
453 FN, and SLOT. NARGS is the number of call arguments which are specified
454 as a tree array ARGS. */
457 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
463 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
464 TREE_TYPE (t
) = return_type
;
465 AGGR_INIT_EXPR_FN (t
) = fn
;
466 AGGR_INIT_EXPR_SLOT (t
) = slot
;
467 for (i
= 0; i
< nargs
; i
++)
468 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
469 process_aggr_init_operands (t
);
473 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
474 target. TYPE is the type to be initialized.
476 Build an AGGR_INIT_EXPR to represent the initialization. This function
477 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
478 to initialize another object, whereas a TARGET_EXPR can either
479 initialize another object or create its own temporary object, and as a
480 result building up a TARGET_EXPR requires that the type's destructor be
484 build_aggr_init_expr (tree type
, tree init
)
491 /* Don't build AGGR_INIT_EXPR in a template. */
492 if (processing_template_decl
)
495 fn
= cp_get_callee (init
);
497 return convert (type
, init
);
499 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
500 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
501 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
503 /* We split the CALL_EXPR into its function and its arguments here.
504 Then, in expand_expr, we put them back together. The reason for
505 this is that this expression might be a default argument
506 expression. In that case, we need a new temporary every time the
507 expression is used. That's what break_out_target_exprs does; it
508 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
509 temporary slot. Then, expand_expr builds up a call-expression
510 using the new slot. */
512 /* If we don't need to use a constructor to create an object of this
513 type, don't mess with AGGR_INIT_EXPR. */
514 if (is_ctor
|| TREE_ADDRESSABLE (type
))
516 slot
= build_local_temp (type
);
518 if (TREE_CODE (init
) == CALL_EXPR
)
520 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
521 call_expr_nargs (init
),
522 CALL_EXPR_ARGP (init
));
523 AGGR_INIT_FROM_THUNK_P (rval
)
524 = CALL_FROM_THUNK_P (init
);
528 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
529 aggr_init_expr_nargs (init
),
530 AGGR_INIT_EXPR_ARGP (init
));
531 AGGR_INIT_FROM_THUNK_P (rval
)
532 = AGGR_INIT_FROM_THUNK_P (init
);
534 TREE_SIDE_EFFECTS (rval
) = 1;
535 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
536 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
537 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
538 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
539 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
547 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
548 target. TYPE is the type that this initialization should appear to
551 Build an encapsulation of the initialization to perform
552 and return it so that it can be processed by language-independent
553 and language-specific expression expanders. */
556 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
558 tree rval
= build_aggr_init_expr (type
, init
);
561 if (!complete_type_or_maybe_complain (type
, init
, complain
))
562 return error_mark_node
;
564 /* Make sure that we're not trying to create an instance of an
566 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
567 return error_mark_node
;
569 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
570 slot
= AGGR_INIT_EXPR_SLOT (rval
);
571 else if (TREE_CODE (rval
) == CALL_EXPR
572 || TREE_CODE (rval
) == CONSTRUCTOR
)
573 slot
= build_local_temp (type
);
577 rval
= build_target_expr (slot
, rval
, complain
);
579 if (rval
!= error_mark_node
)
580 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
585 /* Subroutine of build_vec_init_expr: Build up a single element
586 intialization as a proxy for the full array initialization to get things
587 marked as used and any appropriate diagnostics.
589 Since we're deferring building the actual constructor calls until
590 gimplification time, we need to build one now and throw it away so
591 that the relevant constructor gets mark_used before cgraph decides
592 what functions are needed. Here we assume that init is either
593 NULL_TREE, void_type_node (indicating value-initialization), or
594 another array to copy. */
597 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
599 tree inner_type
= strip_array_types (type
);
600 vec
<tree
, va_gc
> *argvec
;
602 if (integer_zerop (array_type_nelts_total (type
))
603 || !CLASS_TYPE_P (inner_type
))
604 /* No interesting initialization to do. */
605 return integer_zero_node
;
606 else if (init
== void_type_node
)
607 return build_value_init (inner_type
, complain
);
609 gcc_assert (init
== NULL_TREE
610 || (same_type_ignoring_top_level_qualifiers_p
611 (type
, TREE_TYPE (init
))));
613 argvec
= make_tree_vector ();
616 tree init_type
= strip_array_types (TREE_TYPE (init
));
617 tree dummy
= build_dummy_object (init_type
);
618 if (!lvalue_p (init
))
619 dummy
= move (dummy
);
620 argvec
->quick_push (dummy
);
622 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
623 &argvec
, inner_type
, LOOKUP_NORMAL
,
625 release_tree_vector (argvec
);
627 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
628 we don't want one here because we aren't creating a temporary. */
629 if (TREE_CODE (init
) == TARGET_EXPR
)
630 init
= TARGET_EXPR_INITIAL (init
);
635 /* Return a TARGET_EXPR which expresses the initialization of an array to
636 be named later, either default-initialization or copy-initialization
637 from another array of the same type. */
640 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
643 bool value_init
= false;
644 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
646 if (init
== void_type_node
)
652 slot
= build_local_temp (type
);
653 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
654 TREE_SIDE_EFFECTS (init
) = true;
655 SET_EXPR_LOCATION (init
, input_location
);
657 if (cxx_dialect
>= cxx11
658 && potential_constant_expression (elt_init
))
659 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
660 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
665 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
666 that requires a constant expression. */
669 diagnose_non_constexpr_vec_init (tree expr
)
671 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
673 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
674 init
= void_type_node
;
676 init
= VEC_INIT_EXPR_INIT (expr
);
678 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
679 require_potential_constant_expression (elt_init
);
683 build_array_copy (tree init
)
685 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
688 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
692 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
694 gcc_assert (!VOID_TYPE_P (type
));
696 if (TREE_CODE (init
) == TARGET_EXPR
697 || init
== error_mark_node
)
699 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
700 && !VOID_TYPE_P (TREE_TYPE (init
))
701 && TREE_CODE (init
) != COND_EXPR
702 && TREE_CODE (init
) != CONSTRUCTOR
703 && TREE_CODE (init
) != VA_ARG_EXPR
)
704 /* We need to build up a copy constructor call. A void initializer
705 means we're being called from bot_manip. COND_EXPR is a special
706 case because we already have copies on the arms and we don't want
707 another one here. A CONSTRUCTOR is aggregate initialization, which
708 is handled separately. A VA_ARG_EXPR is magic creation of an
709 aggregate; there's no additional work to be done. */
710 return force_rvalue (init
, complain
);
712 return force_target_expr (type
, init
, complain
);
715 /* Like the above function, but without the checking. This function should
716 only be used by code which is deliberately trying to subvert the type
717 system, such as call_builtin_trap. Or build_over_call, to avoid
718 infinite recursion. */
721 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
725 gcc_assert (!VOID_TYPE_P (type
));
727 slot
= build_local_temp (type
);
728 return build_target_expr (slot
, init
, complain
);
731 /* Like build_target_expr_with_type, but use the type of INIT. */
734 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
736 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
737 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
738 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
739 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
742 init
= convert_bitfield_to_declared_type (init
);
743 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
748 get_target_expr (tree init
)
750 return get_target_expr_sfinae (init
, tf_warning_or_error
);
753 /* If EXPR is a bitfield reference, convert it to the declared type of
754 the bitfield, and return the resulting expression. Otherwise,
755 return EXPR itself. */
758 convert_bitfield_to_declared_type (tree expr
)
762 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
764 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
769 /* EXPR is being used in an rvalue context. Return a version of EXPR
770 that is marked as an rvalue. */
777 if (error_operand_p (expr
))
780 expr
= mark_rvalue_use (expr
);
784 Non-class rvalues always have cv-unqualified types. */
785 type
= TREE_TYPE (expr
);
786 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
787 type
= cv_unqualified (type
);
789 /* We need to do this for rvalue refs as well to get the right answer
790 from decltype; see c++/36628. */
791 if (!processing_template_decl
&& glvalue_p (expr
))
792 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
793 else if (type
!= TREE_TYPE (expr
))
794 expr
= build_nop (type
, expr
);
800 struct cplus_array_info
806 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
808 typedef cplus_array_info
*compare_type
;
810 static hashval_t
hash (tree t
);
811 static bool equal (tree
, cplus_array_info
*);
814 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
817 cplus_array_hasher::hash (tree t
)
821 hash
= TYPE_UID (TREE_TYPE (t
));
823 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
827 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
828 of type `cplus_array_info*'. */
831 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
833 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
836 /* Hash table containing dependent array types, which are unsuitable for
837 the language-independent type hash table. */
838 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
840 /* Build an ARRAY_TYPE without laying it out. */
843 build_min_array_type (tree elt_type
, tree index_type
)
845 tree t
= cxx_make_type (ARRAY_TYPE
);
846 TREE_TYPE (t
) = elt_type
;
847 TYPE_DOMAIN (t
) = index_type
;
851 /* Set TYPE_CANONICAL like build_array_type_1, but using
852 build_cplus_array_type. */
855 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
857 /* Set the canonical type for this new node. */
858 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
859 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
860 SET_TYPE_STRUCTURAL_EQUALITY (t
);
861 else if (TYPE_CANONICAL (elt_type
) != elt_type
862 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
864 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
866 ? TYPE_CANONICAL (index_type
) : index_type
);
868 TYPE_CANONICAL (t
) = t
;
871 /* Like build_array_type, but handle special C++ semantics: an array of a
872 variant element type is a variant of the array of the main variant of
876 build_cplus_array_type (tree elt_type
, tree index_type
)
880 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
881 return error_mark_node
;
883 bool dependent
= (uses_template_parms (elt_type
)
884 || (index_type
&& uses_template_parms (index_type
)));
886 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
887 /* Start with an array of the TYPE_MAIN_VARIANT. */
888 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
892 /* Since type_hash_canon calls layout_type, we need to use our own
894 cplus_array_info cai
;
897 if (cplus_array_htab
== NULL
)
898 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
900 hash
= TYPE_UID (elt_type
);
902 hash
^= TYPE_UID (index_type
);
904 cai
.domain
= index_type
;
906 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
908 /* We have found the type: we're done. */
912 /* Build a new array type. */
913 t
= build_min_array_type (elt_type
, index_type
);
915 /* Store it in the hash table. */
918 /* Set the canonical type for this new node. */
919 set_array_type_canon (t
, elt_type
, index_type
);
924 t
= build_array_type (elt_type
, index_type
);
927 /* Now check whether we already have this array variant. */
928 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
931 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
932 if (TREE_TYPE (t
) == elt_type
933 && TYPE_NAME (t
) == NULL_TREE
934 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
938 t
= build_min_array_type (elt_type
, index_type
);
939 set_array_type_canon (t
, elt_type
, index_type
);
943 /* Make sure sizes are shared with the main variant.
944 layout_type can't be called after setting TYPE_NEXT_VARIANT,
945 as it will overwrite alignment etc. of all variants. */
946 TYPE_SIZE (t
) = TYPE_SIZE (m
);
947 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
950 TYPE_MAIN_VARIANT (t
) = m
;
951 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
952 TYPE_NEXT_VARIANT (m
) = t
;
956 /* Avoid spurious warnings with VLAs (c++/54583). */
957 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
958 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
960 /* Push these needs up to the ARRAY_TYPE so that initialization takes
961 place more easily. */
962 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
963 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
964 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
965 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
967 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
968 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
970 /* The element type has been completed since the last time we saw
971 this array type; update the layout and 'tor flags for any variants
974 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
976 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
977 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
984 /* Return an ARRAY_TYPE with element type ELT and length N. */
987 build_array_of_n_type (tree elt
, int n
)
989 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
992 /* True iff T is an N3639 array of runtime bound (VLA). These were
993 approved for C++14 but then removed. */
996 array_of_runtime_bound_p (tree t
)
998 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1000 tree dom
= TYPE_DOMAIN (t
);
1003 tree max
= TYPE_MAX_VALUE (dom
);
1004 return (!potential_rvalue_constant_expression (max
)
1005 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1008 /* Return a reference type node referring to TO_TYPE. If RVAL is
1009 true, return an rvalue reference type, otherwise return an lvalue
1010 reference type. If a type node exists, reuse it, otherwise create
1013 cp_build_reference_type (tree to_type
, bool rval
)
1016 lvalue_ref
= build_reference_type (to_type
);
1020 /* This code to create rvalue reference types is based on and tied
1021 to the code creating lvalue reference types in the middle-end
1022 functions build_reference_type_for_mode and build_reference_type.
1024 It works by putting the rvalue reference type nodes after the
1025 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1026 they will effectively be ignored by the middle end. */
1028 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1029 if (TYPE_REF_IS_RVALUE (t
))
1032 t
= build_distinct_type_copy (lvalue_ref
);
1034 TYPE_REF_IS_RVALUE (t
) = true;
1035 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1036 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1038 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1039 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1040 else if (TYPE_CANONICAL (to_type
) != to_type
)
1042 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1044 TYPE_CANONICAL (t
) = t
;
1052 /* Returns EXPR cast to rvalue reference type, like std::move. */
1057 tree type
= TREE_TYPE (expr
);
1058 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
1059 type
= cp_build_reference_type (type
, /*rval*/true);
1060 return build_static_cast (type
, expr
, tf_warning_or_error
);
1063 /* Used by the C++ front end to build qualified array types. However,
1064 the C version of this function does not properly maintain canonical
1065 types (which are not used in C). */
1067 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1068 size_t /* orig_qual_indirect */)
1070 return cp_build_qualified_type (type
, type_quals
);
1074 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1075 arrays correctly. In particular, if TYPE is an array of T's, and
1076 TYPE_QUALS is non-empty, returns an array of qualified T's.
1078 FLAGS determines how to deal with ill-formed qualifications. If
1079 tf_ignore_bad_quals is set, then bad qualifications are dropped
1080 (this is permitted if TYPE was introduced via a typedef or template
1081 type parameter). If bad qualifications are dropped and tf_warning
1082 is set, then a warning is issued for non-const qualifications. If
1083 tf_ignore_bad_quals is not set and tf_error is not set, we
1084 return error_mark_node. Otherwise, we issue an error, and ignore
1087 Qualification of a reference type is valid when the reference came
1088 via a typedef or template type argument. [dcl.ref] No such
1089 dispensation is provided for qualifying a function type. [dcl.fct]
1090 DR 295 queries this and the proposed resolution brings it into line
1091 with qualifying a reference. We implement the DR. We also behave
1092 in a similar manner for restricting non-pointer types. */
1095 cp_build_qualified_type_real (tree type
,
1097 tsubst_flags_t complain
)
1100 int bad_quals
= TYPE_UNQUALIFIED
;
1102 if (type
== error_mark_node
)
1105 if (type_quals
== cp_type_quals (type
))
1108 if (TREE_CODE (type
) == ARRAY_TYPE
)
1110 /* In C++, the qualification really applies to the array element
1111 type. Obtain the appropriately qualified element type. */
1114 = cp_build_qualified_type_real (TREE_TYPE (type
),
1118 if (element_type
== error_mark_node
)
1119 return error_mark_node
;
1121 /* See if we already have an identically qualified type. Tests
1122 should be equivalent to those in check_qualified_type. */
1123 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1124 if (TREE_TYPE (t
) == element_type
1125 && TYPE_NAME (t
) == TYPE_NAME (type
)
1126 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1127 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1128 TYPE_ATTRIBUTES (type
)))
1133 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1135 /* Keep the typedef name. */
1136 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1138 t
= build_variant_type_copy (t
);
1139 TYPE_NAME (t
) = TYPE_NAME (type
);
1140 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1141 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1145 /* Even if we already had this variant, we update
1146 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1147 they changed since the variant was originally created.
1149 This seems hokey; if there is some way to use a previous
1150 variant *without* coming through here,
1151 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1152 TYPE_NEEDS_CONSTRUCTING (t
)
1153 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1154 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1155 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1158 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1160 tree t
= PACK_EXPANSION_PATTERN (type
);
1162 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1163 return make_pack_expansion (t
);
1166 /* A reference or method type shall not be cv-qualified.
1167 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1168 (in CD1) we always ignore extra cv-quals on functions. */
1169 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1170 && (TREE_CODE (type
) == REFERENCE_TYPE
1171 || TREE_CODE (type
) == FUNCTION_TYPE
1172 || TREE_CODE (type
) == METHOD_TYPE
))
1174 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1175 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1176 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1179 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1180 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1181 type_quals
|= type_memfn_quals (type
);
1183 /* A restrict-qualified type must be a pointer (or reference)
1184 to object or incomplete type. */
1185 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1186 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1187 && TREE_CODE (type
) != TYPENAME_TYPE
1188 && !POINTER_TYPE_P (type
))
1190 bad_quals
|= TYPE_QUAL_RESTRICT
;
1191 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1194 if (bad_quals
== TYPE_UNQUALIFIED
1195 || (complain
& tf_ignore_bad_quals
))
1197 else if (!(complain
& tf_error
))
1198 return error_mark_node
;
1201 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1202 error ("%qV qualifiers cannot be applied to %qT",
1206 /* Retrieve (or create) the appropriately qualified variant. */
1207 result
= build_qualified_type (type
, type_quals
);
1209 /* Preserve exception specs and ref-qualifier since build_qualified_type
1210 doesn't know about them. */
1211 if (TREE_CODE (result
) == FUNCTION_TYPE
1212 || TREE_CODE (result
) == METHOD_TYPE
)
1214 result
= build_exception_variant (result
, TYPE_RAISES_EXCEPTIONS (type
));
1215 result
= build_ref_qualified_type (result
, type_memfn_rqual (type
));
1221 /* Return TYPE with const and volatile removed. */
1224 cv_unqualified (tree type
)
1228 if (type
== error_mark_node
)
1231 quals
= cp_type_quals (type
);
1232 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1233 return cp_build_qualified_type (type
, quals
);
1236 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1237 from ATTRIBS that affect type identity, and no others. If any are not
1238 applied, set *remove_attributes to true. */
1241 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1243 tree first_ident
= NULL_TREE
;
1244 tree new_attribs
= NULL_TREE
;
1245 tree
*p
= &new_attribs
;
1247 if (OVERLOAD_TYPE_P (result
))
1249 /* On classes and enums all attributes are ingrained. */
1250 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1254 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1256 const attribute_spec
*as
1257 = lookup_attribute_spec (get_attribute_name (a
));
1258 if (as
&& as
->affects_type_identity
)
1262 else if (first_ident
== error_mark_node
)
1264 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1265 p
= &TREE_CHAIN (*p
);
1268 else if (first_ident
)
1270 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1272 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1273 p
= &TREE_CHAIN (*p
);
1275 first_ident
= error_mark_node
;
1278 if (first_ident
!= error_mark_node
)
1279 new_attribs
= first_ident
;
1281 if (first_ident
== attribs
)
1282 /* All attributes affected type identity. */;
1284 *remove_attributes
= true;
1286 return cp_build_type_attribute_variant (result
, new_attribs
);
1289 /* Builds a qualified variant of T that is not a typedef variant.
1290 E.g. consider the following declarations:
1291 typedef const int ConstInt;
1292 typedef ConstInt* PtrConstInt;
1293 If T is PtrConstInt, this function returns a type representing
1295 In other words, if T is a typedef, the function returns the underlying type.
1296 The cv-qualification and attributes of the type returned match the
1298 They will always be compatible types.
1299 The returned type is built so that all of its subtypes
1300 recursively have their typedefs stripped as well.
1302 This is different from just returning TYPE_CANONICAL (T)
1303 Because of several reasons:
1304 * If T is a type that needs structural equality
1305 its TYPE_CANONICAL (T) will be NULL.
1306 * TYPE_CANONICAL (T) desn't carry type attributes
1307 and loses template parameter names.
1309 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1310 affect type identity, and set the referent to true if any were
1314 strip_typedefs (tree t
, bool *remove_attributes
)
1316 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1318 if (!t
|| t
== error_mark_node
)
1321 if (TREE_CODE (t
) == TREE_LIST
)
1323 bool changed
= false;
1324 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1326 for (; t
; t
= TREE_CHAIN (t
))
1328 gcc_assert (!TREE_PURPOSE (t
));
1329 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1330 if (elt
!= TREE_VALUE (t
))
1332 vec_safe_push (vec
, elt
);
1335 r
= build_tree_list_vec (vec
);
1336 release_tree_vector (vec
);
1340 gcc_assert (TYPE_P (t
));
1342 if (t
== TYPE_CANONICAL (t
))
1345 if (dependent_alias_template_spec_p (t
))
1346 /* DR 1558: However, if the template-id is dependent, subsequent
1347 template argument substitution still applies to the template-id. */
1350 switch (TREE_CODE (t
))
1353 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1354 result
= build_pointer_type (type
);
1356 case REFERENCE_TYPE
:
1357 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1358 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1361 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1362 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1363 result
= build_offset_type (t0
, type
);
1366 if (TYPE_PTRMEMFUNC_P (t
))
1368 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1369 result
= build_ptrmemfunc_type (t0
);
1373 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1374 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1375 result
= build_cplus_array_type (type
, t0
);
1380 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1383 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1384 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1385 can't expect that re-hashing a function type will find a previous
1386 equivalent type, so try to reuse the input type if nothing has
1387 changed. If the type is itself a variant, that will change. */
1388 bool is_variant
= typedef_variant_p (t
);
1389 if (remove_attributes
1390 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1393 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1394 changed
= type
!= TREE_TYPE (t
) || is_variant
;
1396 for (arg_node
= TYPE_ARG_TYPES (t
);
1398 arg_node
= TREE_CHAIN (arg_node
))
1400 if (arg_node
== void_list_node
)
1402 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1404 gcc_assert (arg_type
);
1405 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1411 for (arg_node2
= TYPE_ARG_TYPES (t
);
1412 arg_node2
!= arg_node
;
1413 arg_node2
= TREE_CHAIN (arg_node2
))
1415 = tree_cons (TREE_PURPOSE (arg_node2
),
1416 TREE_VALUE (arg_node2
), arg_types
);
1420 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1427 arg_types
= nreverse (arg_types
);
1429 /* A list of parameters not ending with an ellipsis
1430 must end with void_list_node. */
1432 arg_types
= chainon (arg_types
, void_list_node
);
1434 if (TREE_CODE (t
) == METHOD_TYPE
)
1436 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1437 gcc_assert (class_type
);
1439 build_method_type_directly (class_type
, type
,
1440 TREE_CHAIN (arg_types
));
1442 = build_ref_qualified_type (result
, type_memfn_rqual (t
));
1446 result
= build_function_type (type
,
1448 result
= apply_memfn_quals (result
,
1449 type_memfn_quals (t
),
1450 type_memfn_rqual (t
));
1453 if (TYPE_RAISES_EXCEPTIONS (t
))
1454 result
= build_exception_variant (result
,
1455 TYPE_RAISES_EXCEPTIONS (t
));
1456 if (TYPE_HAS_LATE_RETURN_TYPE (t
))
1457 TYPE_HAS_LATE_RETURN_TYPE (result
) = 1;
1462 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1463 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1464 && TREE_OPERAND (fullname
, 1))
1466 tree args
= TREE_OPERAND (fullname
, 1);
1467 tree new_args
= copy_node (args
);
1468 bool changed
= false;
1469 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1471 tree arg
= TREE_VEC_ELT (args
, i
);
1474 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1476 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1477 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1478 if (strip_arg
!= arg
)
1483 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1484 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1486 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1490 ggc_free (new_args
);
1492 result
= make_typename_type (strip_typedefs (TYPE_CONTEXT (t
),
1494 fullname
, typename_type
, tf_none
);
1495 /* Handle 'typedef typename A::N N;' */
1496 if (typedef_variant_p (result
))
1497 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (result
)));
1501 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1503 if (result
== DECLTYPE_TYPE_EXPR (t
))
1506 result
= (finish_decltype_type
1508 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1517 if (typedef_variant_p (t
))
1519 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1520 strip typedefs with attributes. */
1521 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1522 result
= strip_typedefs (result
);
1525 result
= TYPE_MAIN_VARIANT (t
);
1527 gcc_assert (!typedef_variant_p (result
));
1528 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1529 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1531 gcc_assert (TYPE_USER_ALIGN (t
));
1532 if (remove_attributes
)
1533 *remove_attributes
= true;
1536 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1537 result
= build_variant_type_copy (result
);
1539 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1540 TYPE_USER_ALIGN (result
) = true;
1543 if (TYPE_ATTRIBUTES (t
))
1545 if (remove_attributes
)
1546 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1549 result
= cp_build_type_attribute_variant (result
, TYPE_ATTRIBUTES (t
));
1551 return cp_build_qualified_type (result
, cp_type_quals (t
));
1554 /* Like strip_typedefs above, but works on expressions, so that in
1556 template<class T> struct A
1562 sizeof(TT) is replaced by sizeof(T). */
1565 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1569 enum tree_code code
;
1571 if (t
== NULL_TREE
|| t
== error_mark_node
)
1574 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1577 /* Some expressions have type operands, so let's handle types here rather
1578 than check TYPE_P in multiple places below. */
1580 return strip_typedefs (t
, remove_attributes
);
1582 code
= TREE_CODE (t
);
1585 case IDENTIFIER_NODE
:
1586 case TEMPLATE_PARM_INDEX
:
1589 case ARGUMENT_PACK_SELECT
:
1594 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1595 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1596 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1597 && type2
== TRAIT_EXPR_TYPE2 (t
))
1600 TRAIT_EXPR_TYPE1 (r
) = type1
;
1601 TRAIT_EXPR_TYPE2 (r
) = type2
;
1607 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1608 bool changed
= false;
1610 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1612 tree val
= strip_typedefs_expr (TREE_VALUE (t
), remove_attributes
);
1613 vec_safe_push (vec
, val
);
1614 if (val
!= TREE_VALUE (t
))
1616 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1621 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1622 r
= tree_cons (NULL_TREE
, it
, r
);
1626 release_tree_vector (vec
);
1632 bool changed
= false;
1633 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1634 n
= TREE_VEC_LENGTH (t
);
1635 vec_safe_reserve (vec
, n
);
1636 for (i
= 0; i
< n
; ++i
)
1638 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1640 vec
->quick_push (op
);
1641 if (op
!= TREE_VEC_ELT (t
, i
))
1647 for (i
= 0; i
< n
; ++i
)
1648 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1649 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1650 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1654 release_tree_vector (vec
);
1660 bool changed
= false;
1661 vec
<constructor_elt
, va_gc
> *vec
1662 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1663 n
= CONSTRUCTOR_NELTS (t
);
1664 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1665 for (i
= 0; i
< n
; ++i
)
1667 constructor_elt
*e
= &(*vec
)[i
];
1668 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1675 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1678 if (!changed
&& type
== TREE_TYPE (t
))
1686 TREE_TYPE (r
) = type
;
1687 CONSTRUCTOR_ELTS (r
) = vec
;
1693 error ("lambda-expression in a constant expression");
1694 return error_mark_node
;
1700 gcc_assert (EXPR_P (t
));
1702 n
= TREE_OPERAND_LENGTH (t
);
1703 ops
= XALLOCAVEC (tree
, n
);
1704 type
= TREE_TYPE (t
);
1709 case IMPLICIT_CONV_EXPR
:
1710 case DYNAMIC_CAST_EXPR
:
1711 case STATIC_CAST_EXPR
:
1712 case CONST_CAST_EXPR
:
1713 case REINTERPRET_CAST_EXPR
:
1716 type
= strip_typedefs (type
, remove_attributes
);
1720 for (i
= 0; i
< n
; ++i
)
1721 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1725 /* If nothing changed, return t. */
1726 for (i
= 0; i
< n
; ++i
)
1727 if (ops
[i
] != TREE_OPERAND (t
, i
))
1729 if (i
== n
&& type
== TREE_TYPE (t
))
1733 TREE_TYPE (r
) = type
;
1734 for (i
= 0; i
< n
; ++i
)
1735 TREE_OPERAND (r
, i
) = ops
[i
];
1739 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1740 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1741 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1742 VIRT indicates whether TYPE is inherited virtually or not.
1743 IGO_PREV points at the previous binfo of the inheritance graph
1744 order chain. The newly copied binfo's TREE_CHAIN forms this
1747 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1748 correct order. That is in the order the bases themselves should be
1751 The BINFO_INHERITANCE of a virtual base class points to the binfo
1752 of the most derived type. ??? We could probably change this so that
1753 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1754 remove a field. They currently can only differ for primary virtual
1758 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1764 /* See if we've already made this virtual base. */
1765 new_binfo
= binfo_for_vbase (type
, t
);
1770 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1771 BINFO_TYPE (new_binfo
) = type
;
1773 /* Chain it into the inheritance graph. */
1774 TREE_CHAIN (*igo_prev
) = new_binfo
;
1775 *igo_prev
= new_binfo
;
1777 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1782 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1784 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1785 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1787 /* We do not need to copy the accesses, as they are read only. */
1788 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1790 /* Recursively copy base binfos of BINFO. */
1791 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1793 tree new_base_binfo
;
1794 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1796 BINFO_VIRTUAL_P (base_binfo
));
1798 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1799 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1800 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1804 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1808 /* Push it onto the list after any virtual bases it contains
1809 will have been pushed. */
1810 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1811 BINFO_VIRTUAL_P (new_binfo
) = 1;
1812 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1818 /* Hashing of lists so that we don't make duplicates.
1819 The entry point is `list_hash_canon'. */
1828 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1830 typedef list_proxy
*compare_type
;
1832 static hashval_t
hash (tree
);
1833 static bool equal (tree
, list_proxy
*);
1836 /* Now here is the hash table. When recording a list, it is added
1837 to the slot whose index is the hash code mod the table size.
1838 Note that the hash table is used for several kinds of lists.
1839 While all these live in the same table, they are completely independent,
1840 and the hash code is computed differently for each of these. */
1842 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1844 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1845 for a node we are thinking about adding). */
1848 list_hasher::equal (tree t
, list_proxy
*proxy
)
1850 return (TREE_VALUE (t
) == proxy
->value
1851 && TREE_PURPOSE (t
) == proxy
->purpose
1852 && TREE_CHAIN (t
) == proxy
->chain
);
1855 /* Compute a hash code for a list (chain of TREE_LIST nodes
1856 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1857 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1860 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1862 hashval_t hashcode
= 0;
1865 hashcode
+= TREE_HASH (chain
);
1868 hashcode
+= TREE_HASH (value
);
1872 hashcode
+= TREE_HASH (purpose
);
1878 /* Hash an already existing TREE_LIST. */
1881 list_hasher::hash (tree t
)
1883 return list_hash_pieces (TREE_PURPOSE (t
),
1888 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1889 object for an identical list if one already exists. Otherwise, build a
1890 new one, and record it as the canonical object. */
1893 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1897 struct list_proxy proxy
;
1899 /* Hash the list node. */
1900 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1901 /* Create a proxy for the TREE_LIST we would like to create. We
1902 don't actually create it so as to avoid creating garbage. */
1903 proxy
.purpose
= purpose
;
1904 proxy
.value
= value
;
1905 proxy
.chain
= chain
;
1906 /* See if it is already in the table. */
1907 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
1908 /* If not, create a new node. */
1910 *slot
= tree_cons (purpose
, value
, chain
);
1911 return (tree
) *slot
;
1914 /* Constructor for hashed lists. */
1917 hash_tree_chain (tree value
, tree chain
)
1919 return hash_tree_cons (NULL_TREE
, value
, chain
);
1923 debug_binfo (tree elem
)
1928 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1930 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1931 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1932 debug_tree (BINFO_TYPE (elem
));
1933 if (BINFO_VTABLE (elem
))
1934 fprintf (stderr
, "vtable decl \"%s\"\n",
1935 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
1937 fprintf (stderr
, "no vtable decl yet\n");
1938 fprintf (stderr
, "virtuals:\n");
1939 virtuals
= BINFO_VIRTUALS (elem
);
1944 tree fndecl
= TREE_VALUE (virtuals
);
1945 fprintf (stderr
, "%s [%ld =? %ld]\n",
1946 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1947 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1949 virtuals
= TREE_CHAIN (virtuals
);
1953 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1954 the type of the result expression, if known, or NULL_TREE if the
1955 resulting expression is type-dependent. If TEMPLATE_P is true,
1956 NAME is known to be a template because the user explicitly used the
1957 "template" keyword after the "::".
1959 All SCOPE_REFs should be built by use of this function. */
1962 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
1965 if (type
== error_mark_node
1966 || scope
== error_mark_node
1967 || name
== error_mark_node
)
1968 return error_mark_node
;
1969 t
= build2 (SCOPE_REF
, type
, scope
, name
);
1970 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
1971 PTRMEM_OK_P (t
) = true;
1973 t
= convert_from_reference (t
);
1977 /* Like check_qualified_type, but also check ref-qualifier and exception
1981 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
1982 cp_ref_qualifier rqual
, tree raises
)
1984 return (check_qualified_type (cand
, base
, type_quals
)
1985 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
1987 && type_memfn_rqual (cand
) == rqual
);
1990 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
1993 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
1997 if (rqual
== type_memfn_rqual (type
))
2000 int type_quals
= TYPE_QUALS (type
);
2001 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2002 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
2003 if (cp_check_qualified_type (t
, type
, type_quals
, rqual
, raises
))
2006 t
= build_variant_type_copy (type
);
2009 case REF_QUAL_RVALUE
:
2010 FUNCTION_RVALUE_QUALIFIED (t
) = 1;
2011 FUNCTION_REF_QUALIFIED (t
) = 1;
2013 case REF_QUAL_LVALUE
:
2014 FUNCTION_RVALUE_QUALIFIED (t
) = 0;
2015 FUNCTION_REF_QUALIFIED (t
) = 1;
2018 FUNCTION_REF_QUALIFIED (t
) = 0;
2022 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2023 /* Propagate structural equality. */
2024 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2025 else if (TYPE_CANONICAL (type
) != type
)
2026 /* Build the underlying canonical type, since it is different
2028 TYPE_CANONICAL (t
) = build_ref_qualified_type (TYPE_CANONICAL (type
),
2031 /* T is its own canonical type. */
2032 TYPE_CANONICAL (t
) = t
;
2037 /* Returns nonzero if X is an expression for a (possibly overloaded)
2038 function. If "f" is a function or function template, "f", "c->f",
2039 "c.f", "C::f", and "f<int>" will all be considered possibly
2040 overloaded functions. Returns 2 if the function is actually
2041 overloaded, i.e., if it is impossible to know the type of the
2042 function without performing overload resolution. */
2045 is_overloaded_fn (tree x
)
2047 /* A baselink is also considered an overloaded function. */
2048 if (TREE_CODE (x
) == OFFSET_REF
2049 || TREE_CODE (x
) == COMPONENT_REF
)
2050 x
= TREE_OPERAND (x
, 1);
2052 x
= BASELINK_FUNCTIONS (x
);
2053 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2054 x
= TREE_OPERAND (x
, 0);
2055 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x
))
2056 || (TREE_CODE (x
) == OVERLOAD
&& OVL_CHAIN (x
)))
2058 return (TREE_CODE (x
) == FUNCTION_DECL
2059 || TREE_CODE (x
) == OVERLOAD
);
2062 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2063 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2067 dependent_name (tree x
)
2069 if (identifier_p (x
))
2071 if (TREE_CODE (x
) != COMPONENT_REF
2072 && TREE_CODE (x
) != OFFSET_REF
2073 && TREE_CODE (x
) != BASELINK
2074 && is_overloaded_fn (x
))
2075 return DECL_NAME (get_first_fn (x
));
2079 /* Returns true iff X is an expression for an overloaded function
2080 whose type cannot be known without performing overload
2084 really_overloaded_fn (tree x
)
2086 return is_overloaded_fn (x
) == 2;
2092 gcc_assert (is_overloaded_fn (from
));
2093 /* A baselink is also considered an overloaded function. */
2094 if (TREE_CODE (from
) == OFFSET_REF
2095 || TREE_CODE (from
) == COMPONENT_REF
)
2096 from
= TREE_OPERAND (from
, 1);
2097 if (BASELINK_P (from
))
2098 from
= BASELINK_FUNCTIONS (from
);
2099 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2100 from
= TREE_OPERAND (from
, 0);
2105 get_first_fn (tree from
)
2107 return OVL_CURRENT (get_fns (from
));
2110 /* Return a new OVL node, concatenating it with the old one. */
2113 ovl_cons (tree decl
, tree chain
)
2115 tree result
= make_node (OVERLOAD
);
2116 TREE_TYPE (result
) = unknown_type_node
;
2117 OVL_FUNCTION (result
) = decl
;
2118 TREE_CHAIN (result
) = chain
;
2123 /* Build a new overloaded function. If this is the first one,
2124 just return it; otherwise, ovl_cons the _DECLs */
2127 build_overload (tree decl
, tree chain
)
2129 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
2131 return ovl_cons (decl
, chain
);
2134 /* Return the scope where the overloaded functions OVL were found. */
2137 ovl_scope (tree ovl
)
2139 if (TREE_CODE (ovl
) == OFFSET_REF
2140 || TREE_CODE (ovl
) == COMPONENT_REF
)
2141 ovl
= TREE_OPERAND (ovl
, 1);
2142 if (TREE_CODE (ovl
) == BASELINK
)
2143 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2144 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2145 ovl
= TREE_OPERAND (ovl
, 0);
2146 /* Skip using-declarations. */
2147 while (TREE_CODE (ovl
) == OVERLOAD
&& OVL_USED (ovl
) && OVL_CHAIN (ovl
))
2148 ovl
= OVL_CHAIN (ovl
);
2149 return CP_DECL_CONTEXT (OVL_CURRENT (ovl
));
2152 #define PRINT_RING_SIZE 4
2155 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2157 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2158 static char *print_ring
[PRINT_RING_SIZE
];
2159 static bool trans_ring
[PRINT_RING_SIZE
];
2160 static int ring_counter
;
2163 /* Only cache functions. */
2165 || TREE_CODE (decl
) != FUNCTION_DECL
2166 || DECL_LANG_SPECIFIC (decl
) == 0)
2167 return lang_decl_name (decl
, v
, translate
);
2169 /* See if this print name is lying around. */
2170 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2171 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2172 /* yes, so return it. */
2173 return print_ring
[i
];
2175 if (++ring_counter
== PRINT_RING_SIZE
)
2178 if (current_function_decl
!= NULL_TREE
)
2180 /* There may be both translated and untranslated versions of the
2182 for (i
= 0; i
< 2; i
++)
2184 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2186 if (ring_counter
== PRINT_RING_SIZE
)
2189 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2192 free (print_ring
[ring_counter
]);
2194 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2195 uid_ring
[ring_counter
] = DECL_UID (decl
);
2196 trans_ring
[ring_counter
] = translate
;
2197 return print_ring
[ring_counter
];
2201 cxx_printable_name (tree decl
, int v
)
2203 return cxx_printable_name_internal (decl
, v
, false);
2207 cxx_printable_name_translate (tree decl
, int v
)
2209 return cxx_printable_name_internal (decl
, v
, true);
2212 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2213 listed in RAISES. */
2216 build_exception_variant (tree type
, tree raises
)
2221 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
2224 type_quals
= TYPE_QUALS (type
);
2225 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2226 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
2227 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
))
2230 /* Need to build a new variant. */
2231 v
= build_variant_type_copy (type
);
2232 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2236 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2237 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2241 bind_template_template_parm (tree t
, tree newargs
)
2243 tree decl
= TYPE_NAME (t
);
2246 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2247 decl
= build_decl (input_location
,
2248 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2250 /* These nodes have to be created to reflect new TYPE_DECL and template
2252 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2253 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2254 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2255 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2257 TREE_TYPE (decl
) = t2
;
2258 TYPE_NAME (t2
) = decl
;
2259 TYPE_STUB_DECL (t2
) = decl
;
2261 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2266 /* Called from count_trees via walk_tree. */
2269 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2279 /* Debugging function for measuring the rough complexity of a tree
2283 count_trees (tree t
)
2286 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2290 /* Called from verify_stmt_tree via walk_tree. */
2293 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2296 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2297 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2300 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2303 /* If this statement is already present in the hash table, then
2304 there is a circularity in the statement tree. */
2305 gcc_assert (!statements
->find (t
));
2307 slot
= statements
->find_slot (t
, INSERT
);
2313 /* Debugging function to check that the statement T has not been
2314 corrupted. For now, this function simply checks that T contains no
2318 verify_stmt_tree (tree t
)
2320 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2321 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2324 /* Check if the type T depends on a type with no linkage and if so, return
2325 it. If RELAXED_P then do not consider a class type declared within
2326 a vague-linkage function to have no linkage. */
2329 no_linkage_check (tree t
, bool relaxed_p
)
2333 /* There's no point in checking linkage on template functions; we
2334 can't know their complete types. */
2335 if (processing_template_decl
)
2338 switch (TREE_CODE (t
))
2341 if (TYPE_PTRMEMFUNC_P (t
))
2343 /* Lambda types that don't have mangling scope have no linkage. We
2344 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2345 when we get here from pushtag none of the lambda information is
2346 set up yet, so we want to assume that the lambda has linkage and
2347 fix it up later if not. */
2348 if (CLASSTYPE_LAMBDA_EXPR (t
)
2349 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2350 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2354 if (!CLASS_TYPE_P (t
))
2358 /* Only treat unnamed types as having no linkage if they're at
2359 namespace scope. This is core issue 966. */
2360 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2363 for (r
= CP_TYPE_CONTEXT (t
); ; )
2365 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2366 have linkage, or we might just be in an anonymous namespace.
2367 If we're in a TREE_PUBLIC class, we have linkage. */
2368 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2369 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2370 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2372 if (!relaxed_p
|| !vague_linkage_p (r
))
2375 r
= CP_DECL_CONTEXT (r
);
2385 case REFERENCE_TYPE
:
2387 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2391 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2395 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2400 tree parm
= TYPE_ARG_TYPES (t
);
2401 if (TREE_CODE (t
) == METHOD_TYPE
)
2402 /* The 'this' pointer isn't interesting; a method has the same
2403 linkage (or lack thereof) as its enclosing class. */
2404 parm
= TREE_CHAIN (parm
);
2406 parm
&& parm
!= void_list_node
;
2407 parm
= TREE_CHAIN (parm
))
2409 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2413 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2421 extern int depth_reached
;
2424 cxx_print_statistics (void)
2426 print_search_statistics ();
2427 print_class_statistics ();
2428 print_template_statistics ();
2429 if (GATHER_STATISTICS
)
2430 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2434 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2435 (which is an ARRAY_TYPE). This counts only elements of the top
2439 array_type_nelts_top (tree type
)
2441 return fold_build2_loc (input_location
,
2442 PLUS_EXPR
, sizetype
,
2443 array_type_nelts (type
),
2447 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2448 (which is an ARRAY_TYPE). This one is a recursive count of all
2449 ARRAY_TYPEs that are clumped together. */
2452 array_type_nelts_total (tree type
)
2454 tree sz
= array_type_nelts_top (type
);
2455 type
= TREE_TYPE (type
);
2456 while (TREE_CODE (type
) == ARRAY_TYPE
)
2458 tree n
= array_type_nelts_top (type
);
2459 sz
= fold_build2_loc (input_location
,
2460 MULT_EXPR
, sizetype
, sz
, n
);
2461 type
= TREE_TYPE (type
);
2466 /* Called from break_out_target_exprs via mapcar. */
2469 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
2471 splay_tree target_remap
= ((splay_tree
) data
);
2474 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2476 /* There can't be any TARGET_EXPRs or their slot variables below this
2477 point. But we must make a copy, in case subsequent processing
2478 alters any part of it. For example, during gimplification a cast
2479 of the form (T) &X::f (where "f" is a member function) will lead
2480 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2482 *tp
= unshare_expr (t
);
2485 if (TREE_CODE (t
) == TARGET_EXPR
)
2489 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2491 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2492 tf_warning_or_error
);
2493 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2494 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2497 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2498 tf_warning_or_error
);
2500 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2501 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2502 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2504 /* Map the old variable to the new one. */
2505 splay_tree_insert (target_remap
,
2506 (splay_tree_key
) TREE_OPERAND (t
, 0),
2507 (splay_tree_value
) TREE_OPERAND (u
, 0));
2509 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
2511 /* Replace the old expression with the new version. */
2513 /* We don't have to go below this point; the recursive call to
2514 break_out_target_exprs will have handled anything below this
2519 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2522 splay_tree_node n
= splay_tree_lookup (target_remap
,
2523 (splay_tree_key
) t
);
2526 *tp
= (tree
)n
->value
;
2531 copy_tree_r (tp
, walk_subtrees
, NULL
);
2532 splay_tree_insert (target_remap
,
2534 (splay_tree_value
)*tp
);
2535 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2536 splay_tree_insert (target_remap
,
2537 (splay_tree_key
)*tp
,
2538 (splay_tree_value
)*tp
);
2543 /* Make a copy of this node. */
2544 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2545 if (TREE_CODE (*tp
) == CALL_EXPR
)
2547 set_flags_from_callee (*tp
);
2549 /* builtin_LINE and builtin_FILE get the location where the default
2550 argument is expanded, not where the call was written. */
2551 tree callee
= get_callee_fndecl (*tp
);
2552 if (callee
&& DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
2553 switch (DECL_FUNCTION_CODE (callee
))
2557 SET_EXPR_LOCATION (*tp
, input_location
);
2565 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2566 DATA is really a splay-tree mapping old variables to new
2570 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data
)
2572 splay_tree target_remap
= ((splay_tree
) data
);
2576 splay_tree_node n
= splay_tree_lookup (target_remap
,
2577 (splay_tree_key
) *t
);
2579 *t
= (tree
) n
->value
;
2581 else if (TREE_CODE (*t
) == PARM_DECL
2582 && DECL_NAME (*t
) == this_identifier
2583 && !DECL_CONTEXT (*t
))
2585 /* In an NSDMI we need to replace the 'this' parameter we used for
2586 parsing with the real one for this function. */
2587 *t
= current_class_ptr
;
2589 else if (TREE_CODE (*t
) == CONVERT_EXPR
2590 && CONVERT_EXPR_VBASE_PATH (*t
))
2592 /* In an NSDMI build_base_path defers building conversions to virtual
2593 bases, and we handle it here. */
2594 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2595 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2597 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2598 if (BINFO_TYPE (binfo
) == basetype
)
2600 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2601 tf_warning_or_error
);
2607 /* When we parse a default argument expression, we may create
2608 temporary variables via TARGET_EXPRs. When we actually use the
2609 default-argument expression, we make a copy of the expression
2610 and replace the temporaries with appropriate local versions. */
2613 break_out_target_exprs (tree t
)
2615 static int target_remap_count
;
2616 static splay_tree target_remap
;
2618 if (!target_remap_count
++)
2619 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
2620 /*splay_tree_delete_key_fn=*/NULL
,
2621 /*splay_tree_delete_value_fn=*/NULL
);
2622 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
2623 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
2625 if (!--target_remap_count
)
2627 splay_tree_delete (target_remap
);
2628 target_remap
= NULL
;
2634 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
2635 which we expect to have type TYPE. */
2638 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
2640 if (index
== NULL_TREE
)
2641 /* Can't refer to a particular member of a vector. */
2643 else if (TREE_CODE (index
) == INTEGER_CST
)
2644 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
2646 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
2647 /*reference*/false, tf_none
);
2650 tree objtype
= TREE_TYPE (obj
);
2651 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
2653 /* When the destination object refers to a flexible array member
2654 verify that it matches the type of the source object except
2655 for its domain and qualifiers. */
2656 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
2657 TYPE_MAIN_VARIANT (objtype
),
2658 COMPARE_REDECLARATION
));
2661 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
2667 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
2668 build up subexpressions as we go deeper. */
2671 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
2673 tree obj
= static_cast<tree
>(data_
);
2675 if (TREE_CONSTANT (*t
))
2677 *walk_subtrees
= false;
2681 switch (TREE_CODE (*t
))
2683 case PLACEHOLDER_EXPR
:
2686 for (; !(same_type_ignoring_top_level_qualifiers_p
2687 (TREE_TYPE (*t
), TREE_TYPE (x
)));
2688 x
= TREE_OPERAND (x
, 0))
2689 gcc_assert (TREE_CODE (x
) == COMPONENT_REF
);
2691 *walk_subtrees
= false;
2697 constructor_elt
*ce
;
2698 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
2699 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2701 tree
*valp
= &ce
->value
;
2702 tree type
= TREE_TYPE (*valp
);
2705 if (TREE_CODE (*valp
) == CONSTRUCTOR
2706 && AGGREGATE_TYPE_P (type
))
2708 /* If we're looking at the initializer for OBJ, then build
2709 a sub-object reference. If we're looking at an
2710 initializer for another object, just pass OBJ down. */
2711 if (same_type_ignoring_top_level_qualifiers_p
2712 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
2713 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
2714 if (TREE_CODE (*valp
) == TARGET_EXPR
)
2715 valp
= &TARGET_EXPR_INITIAL (*valp
);
2718 cp_walk_tree (valp
, replace_placeholders_r
,
2721 *walk_subtrees
= false;
2733 replace_placeholders (tree exp
, tree obj
)
2736 if (TREE_CODE (exp
) == TARGET_EXPR
)
2737 tp
= &TARGET_EXPR_INITIAL (exp
);
2738 cp_walk_tree (tp
, replace_placeholders_r
, obj
, NULL
);
2742 /* Similar to `build_nt', but for template definitions of dependent
2746 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
2753 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2757 t
= make_node (code
);
2758 SET_EXPR_LOCATION (t
, loc
);
2759 length
= TREE_CODE_LENGTH (code
);
2761 for (i
= 0; i
< length
; i
++)
2763 tree x
= va_arg (p
, tree
);
2764 TREE_OPERAND (t
, i
) = x
;
2772 /* Similar to `build', but for template definitions. */
2775 build_min (enum tree_code code
, tree tt
, ...)
2782 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2786 t
= make_node (code
);
2787 length
= TREE_CODE_LENGTH (code
);
2790 for (i
= 0; i
< length
; i
++)
2792 tree x
= va_arg (p
, tree
);
2793 TREE_OPERAND (t
, i
) = x
;
2794 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
2795 TREE_SIDE_EFFECTS (t
) = 1;
2802 /* Similar to `build', but for template definitions of non-dependent
2803 expressions. NON_DEP is the non-dependent expression that has been
2807 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
2814 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2816 va_start (p
, non_dep
);
2818 if (REFERENCE_REF_P (non_dep
))
2819 non_dep
= TREE_OPERAND (non_dep
, 0);
2821 t
= make_node (code
);
2822 length
= TREE_CODE_LENGTH (code
);
2823 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2824 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2826 for (i
= 0; i
< length
; i
++)
2828 tree x
= va_arg (p
, tree
);
2829 TREE_OPERAND (t
, i
) = x
;
2832 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
2833 /* This should not be considered a COMPOUND_EXPR, because it
2834 resolves to an overload. */
2835 COMPOUND_EXPR_OVERLOADED (t
) = 1;
2838 return convert_from_reference (t
);
2841 /* Similar to `build_nt_call_vec', but for template definitions of
2842 non-dependent expressions. NON_DEP is the non-dependent expression
2843 that has been built. */
2846 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
2848 tree t
= build_nt_call_vec (fn
, argvec
);
2849 if (REFERENCE_REF_P (non_dep
))
2850 non_dep
= TREE_OPERAND (non_dep
, 0);
2851 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2852 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2853 return convert_from_reference (t
);
2856 /* Similar to build_min_non_dep, but for expressions that have been resolved to
2857 a call to an operator overload. OP is the operator that has been
2858 overloaded. NON_DEP is the non-dependent expression that's been built,
2859 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
2860 the overload that NON_DEP is calling. */
2863 build_min_non_dep_op_overload (enum tree_code op
,
2868 int nargs
, expected_nargs
;
2870 vec
<tree
, va_gc
> *args
;
2872 non_dep
= extract_call_expr (non_dep
);
2874 nargs
= call_expr_nargs (non_dep
);
2876 expected_nargs
= cp_tree_code_length (op
);
2877 if (op
== POSTINCREMENT_EXPR
2878 || op
== POSTDECREMENT_EXPR
)
2879 expected_nargs
+= 1;
2880 gcc_assert (nargs
== expected_nargs
);
2882 args
= make_tree_vector ();
2883 va_start (p
, overload
);
2885 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
2888 for (int i
= 0; i
< nargs
; i
++)
2890 tree arg
= va_arg (p
, tree
);
2891 vec_safe_push (args
, arg
);
2894 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
2896 tree object
= va_arg (p
, tree
);
2897 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
2898 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
2899 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
2900 object
, method
, NULL_TREE
);
2901 for (int i
= 1; i
< nargs
; i
++)
2903 tree arg
= va_arg (p
, tree
);
2904 vec_safe_push (args
, arg
);
2911 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
2912 release_tree_vector (args
);
2914 tree call_expr
= extract_call_expr (call
);
2915 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
2916 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
2917 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
2918 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
2923 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
2926 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
2928 unsigned len
= vec_safe_length (old_vec
);
2929 gcc_assert (idx
<= len
);
2931 vec
<tree
, va_gc
> *new_vec
= NULL
;
2932 vec_alloc (new_vec
, len
+ 1);
2935 for (i
= 0; i
< len
; ++i
)
2938 new_vec
->quick_push (elt
);
2939 new_vec
->quick_push ((*old_vec
)[i
]);
2942 new_vec
->quick_push (elt
);
2948 get_type_decl (tree t
)
2950 if (TREE_CODE (t
) == TYPE_DECL
)
2953 return TYPE_STUB_DECL (t
);
2954 gcc_assert (t
== error_mark_node
);
2958 /* Returns the namespace that contains DECL, whether directly or
2962 decl_namespace_context (tree decl
)
2966 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2968 else if (TYPE_P (decl
))
2969 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
2971 decl
= CP_DECL_CONTEXT (decl
);
2975 /* Returns true if decl is within an anonymous namespace, however deeply
2976 nested, or false otherwise. */
2979 decl_anon_ns_mem_p (const_tree decl
)
2983 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
2985 if (TREE_CODE (decl
) == NAMESPACE_DECL
2986 && DECL_NAME (decl
) == NULL_TREE
)
2988 /* Classes and namespaces inside anonymous namespaces have
2989 TREE_PUBLIC == 0, so we can shortcut the search. */
2990 else if (TYPE_P (decl
))
2991 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl
)) == 0);
2992 else if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2993 return (TREE_PUBLIC (decl
) == 0);
2995 decl
= DECL_CONTEXT (decl
);
2999 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3000 CALL_EXPRS. Return whether they are equivalent. */
3003 called_fns_equal (tree t1
, tree t2
)
3005 /* Core 1321: dependent names are equivalent even if the overload sets
3006 are different. But do compare explicit template arguments. */
3007 tree name1
= dependent_name (t1
);
3008 tree name2
= dependent_name (t2
);
3011 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3016 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3017 targs1
= TREE_OPERAND (t1
, 1);
3018 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3019 targs2
= TREE_OPERAND (t2
, 1);
3020 return cp_tree_equal (targs1
, targs2
);
3023 return cp_tree_equal (t1
, t2
);
3026 /* Return truthvalue of whether T1 is the same tree structure as T2.
3027 Return 1 if they are the same. Return 0 if they are different. */
3030 cp_tree_equal (tree t1
, tree t2
)
3032 enum tree_code code1
, code2
;
3039 code1
= TREE_CODE (t1
);
3040 code2
= TREE_CODE (t2
);
3048 /* There's only a single VOID_CST node, so we should never reach
3053 return tree_int_cst_equal (t1
, t2
);
3056 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3059 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3060 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3061 TREE_STRING_LENGTH (t1
));
3064 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3065 TREE_FIXED_CST (t2
));
3068 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3069 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3072 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3075 /* We need to do this when determining whether or not two
3076 non-type pointer to member function template arguments
3078 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3079 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3084 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3086 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3087 if (!cp_tree_equal (field
, elt2
->index
)
3088 || !cp_tree_equal (value
, elt2
->value
))
3095 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3097 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3099 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3102 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3107 call_expr_arg_iterator iter1
, iter2
;
3108 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3110 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3111 arg2
= first_call_expr_arg (t2
, &iter2
);
3113 arg1
= next_call_expr_arg (&iter1
),
3114 arg2
= next_call_expr_arg (&iter2
))
3115 if (!cp_tree_equal (arg1
, arg2
))
3124 tree o1
= TREE_OPERAND (t1
, 0);
3125 tree o2
= TREE_OPERAND (t2
, 0);
3127 /* Special case: if either target is an unallocated VAR_DECL,
3128 it means that it's going to be unified with whatever the
3129 TARGET_EXPR is really supposed to initialize, so treat it
3130 as being equivalent to anything. */
3131 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3132 && !DECL_RTL_SET_P (o1
))
3134 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3135 && !DECL_RTL_SET_P (o2
))
3137 else if (!cp_tree_equal (o1
, o2
))
3140 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3143 case WITH_CLEANUP_EXPR
:
3144 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3146 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
3149 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
3151 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3154 /* For comparing uses of parameters in late-specified return types
3155 with an out-of-class definition of the function, but can also come
3156 up for expressions that involve 'this' in a member function
3159 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3160 /* When comparing hash table entries, only an exact match is
3161 good enough; we don't want to replace 'this' with the
3162 version from another function. But be more flexible
3163 with local parameters in a requires-expression. */
3166 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3168 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3170 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3172 if (DECL_ARTIFICIAL (t1
)
3173 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3174 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3184 case IDENTIFIER_NODE
:
3189 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3190 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3191 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3192 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3193 BASELINK_FUNCTIONS (t2
)));
3195 case TEMPLATE_PARM_INDEX
:
3196 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3197 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3198 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3199 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3200 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3201 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3203 case TEMPLATE_ID_EXPR
:
3204 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3205 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3207 case CONSTRAINT_INFO
:
3208 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3209 CI_ASSOCIATED_CONSTRAINTS (t2
));
3212 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3213 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3214 CHECK_CONSTR_ARGS (t2
)));
3219 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3221 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3222 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3223 TREE_VEC_ELT (t2
, ix
)))
3231 tree o1
= TREE_OPERAND (t1
, 0);
3232 tree o2
= TREE_OPERAND (t2
, 0);
3234 if (code1
== SIZEOF_EXPR
)
3236 if (SIZEOF_EXPR_TYPE_P (t1
))
3237 o1
= TREE_TYPE (o1
);
3238 if (SIZEOF_EXPR_TYPE_P (t2
))
3239 o2
= TREE_TYPE (o2
);
3241 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3244 return same_type_p (o1
, o2
);
3246 return cp_tree_equal (o1
, o2
);
3251 tree t1_op1
, t2_op1
;
3253 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3256 t1_op1
= TREE_OPERAND (t1
, 1);
3257 t2_op1
= TREE_OPERAND (t2
, 1);
3258 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3261 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3265 /* Two pointer-to-members are the same if they point to the same
3266 field or function in the same class. */
3267 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3270 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3273 if (OVL_FUNCTION (t1
) != OVL_FUNCTION (t2
))
3275 return cp_tree_equal (OVL_CHAIN (t1
), OVL_CHAIN (t2
));
3278 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3280 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3281 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3284 case STATIC_CAST_EXPR
:
3285 case REINTERPRET_CAST_EXPR
:
3286 case CONST_CAST_EXPR
:
3287 case DYNAMIC_CAST_EXPR
:
3288 case IMPLICIT_CONV_EXPR
:
3291 case NON_LVALUE_EXPR
:
3292 case VIEW_CONVERT_EXPR
:
3293 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3295 /* Now compare operands as usual. */
3298 case DEFERRED_NOEXCEPT
:
3299 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3300 DEFERRED_NOEXCEPT_PATTERN (t2
))
3301 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3302 DEFERRED_NOEXCEPT_ARGS (t2
)));
3309 switch (TREE_CODE_CLASS (code1
))
3313 case tcc_comparison
:
3314 case tcc_expression
:
3321 n
= cp_tree_operand_length (t1
);
3322 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3323 && n
!= TREE_OPERAND_LENGTH (t2
))
3326 for (i
= 0; i
< n
; ++i
)
3327 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3334 return same_type_p (t1
, t2
);
3338 /* We can get here with --disable-checking. */
3342 /* The type of ARG when used as an lvalue. */
3345 lvalue_type (tree arg
)
3347 tree type
= TREE_TYPE (arg
);
3351 /* The type of ARG for printing error messages; denote lvalues with
3355 error_type (tree arg
)
3357 tree type
= TREE_TYPE (arg
);
3359 if (TREE_CODE (type
) == ARRAY_TYPE
)
3361 else if (TREE_CODE (type
) == ERROR_MARK
)
3363 else if (lvalue_p (arg
))
3364 type
= build_reference_type (lvalue_type (arg
));
3365 else if (MAYBE_CLASS_TYPE_P (type
))
3366 type
= lvalue_type (arg
);
3371 /* Does FUNCTION use a variable-length argument list? */
3374 varargs_function_p (const_tree function
)
3376 return stdarg_p (TREE_TYPE (function
));
3379 /* Returns 1 if decl is a member of a class. */
3382 member_p (const_tree decl
)
3384 const_tree
const ctx
= DECL_CONTEXT (decl
);
3385 return (ctx
&& TYPE_P (ctx
));
3388 /* Create a placeholder for member access where we don't actually have an
3389 object that the access is against. */
3392 build_dummy_object (tree type
)
3394 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3395 return cp_build_indirect_ref (decl
, RO_NULL
, tf_warning_or_error
);
3398 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3399 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3400 binfo path from current_class_type to TYPE, or 0. */
3403 maybe_dummy_object (tree type
, tree
* binfop
)
3407 tree current
= current_nonlambda_class_type ();
3410 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3411 tf_warning_or_error
)))
3415 /* Reference from a nested class member function. */
3417 binfo
= TYPE_BINFO (type
);
3423 if (current_class_ref
3424 /* current_class_ref might not correspond to current_class_type if
3425 we're in tsubst_default_argument or a lambda-declarator; in either
3426 case, we want to use current_class_ref if it matches CONTEXT. */
3427 && (same_type_ignoring_top_level_qualifiers_p
3428 (TREE_TYPE (current_class_ref
), context
)))
3429 decl
= current_class_ref
;
3431 decl
= build_dummy_object (context
);
3436 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3439 is_dummy_object (const_tree ob
)
3441 if (INDIRECT_REF_P (ob
))
3442 ob
= TREE_OPERAND (ob
, 0);
3443 return (TREE_CODE (ob
) == CONVERT_EXPR
3444 && TREE_OPERAND (ob
, 0) == void_node
);
3447 /* Returns 1 iff type T is something we want to treat as a scalar type for
3448 the purpose of deciding whether it is trivial/POD/standard-layout. */
3451 scalarish_type_p (const_tree t
)
3453 if (t
== error_mark_node
)
3456 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3459 /* Returns true iff T requires non-trivial default initialization. */
3462 type_has_nontrivial_default_init (const_tree t
)
3464 t
= strip_array_types (CONST_CAST_TREE (t
));
3466 if (CLASS_TYPE_P (t
))
3467 return TYPE_HAS_COMPLEX_DFLT (t
);
3472 /* Returns true iff copying an object of type T (including via move
3473 constructor) is non-trivial. That is, T has no non-trivial copy
3474 constructors and no non-trivial move constructors. */
3477 type_has_nontrivial_copy_init (const_tree t
)
3479 t
= strip_array_types (CONST_CAST_TREE (t
));
3481 if (CLASS_TYPE_P (t
))
3483 gcc_assert (COMPLETE_TYPE_P (t
));
3484 return ((TYPE_HAS_COPY_CTOR (t
)
3485 && TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3486 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
));
3492 /* Returns 1 iff type T is a trivially copyable type, as defined in
3493 [basic.types] and [class]. */
3496 trivially_copyable_p (const_tree t
)
3498 t
= strip_array_types (CONST_CAST_TREE (t
));
3500 if (CLASS_TYPE_P (t
))
3501 return ((!TYPE_HAS_COPY_CTOR (t
)
3502 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3503 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
3504 && (!TYPE_HAS_COPY_ASSIGN (t
)
3505 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
3506 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
3507 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
3509 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
3512 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
3516 trivial_type_p (const_tree t
)
3518 t
= strip_array_types (CONST_CAST_TREE (t
));
3520 if (CLASS_TYPE_P (t
))
3521 return (TYPE_HAS_TRIVIAL_DFLT (t
)
3522 && trivially_copyable_p (t
));
3524 return scalarish_type_p (t
);
3527 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
3530 pod_type_p (const_tree t
)
3532 /* This CONST_CAST is okay because strip_array_types returns its
3533 argument unmodified and we assign it to a const_tree. */
3534 t
= strip_array_types (CONST_CAST_TREE(t
));
3536 if (!CLASS_TYPE_P (t
))
3537 return scalarish_type_p (t
);
3538 else if (cxx_dialect
> cxx98
)
3539 /* [class]/10: A POD struct is a class that is both a trivial class and a
3540 standard-layout class, and has no non-static data members of type
3541 non-POD struct, non-POD union (or array of such types).
3543 We don't need to check individual members because if a member is
3544 non-std-layout or non-trivial, the class will be too. */
3545 return (std_layout_type_p (t
) && trivial_type_p (t
));
3547 /* The C++98 definition of POD is different. */
3548 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3551 /* Returns true iff T is POD for the purpose of layout, as defined in the
3555 layout_pod_type_p (const_tree t
)
3557 t
= strip_array_types (CONST_CAST_TREE (t
));
3559 if (CLASS_TYPE_P (t
))
3560 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3562 return scalarish_type_p (t
);
3565 /* Returns true iff T is a standard-layout type, as defined in
3569 std_layout_type_p (const_tree t
)
3571 t
= strip_array_types (CONST_CAST_TREE (t
));
3573 if (CLASS_TYPE_P (t
))
3574 return !CLASSTYPE_NON_STD_LAYOUT (t
);
3576 return scalarish_type_p (t
);
3579 /* Nonzero iff type T is a class template implicit specialization. */
3582 class_tmpl_impl_spec_p (const_tree t
)
3584 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
3587 /* Returns 1 iff zero initialization of type T means actually storing
3591 zero_init_p (const_tree t
)
3593 /* This CONST_CAST is okay because strip_array_types returns its
3594 argument unmodified and we assign it to a const_tree. */
3595 t
= strip_array_types (CONST_CAST_TREE(t
));
3597 if (t
== error_mark_node
)
3600 /* NULL pointers to data members are initialized with -1. */
3601 if (TYPE_PTRDATAMEM_P (t
))
3604 /* Classes that contain types that can't be zero-initialized, cannot
3605 be zero-initialized themselves. */
3606 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
3612 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
3613 warn_unused_result attribute. */
3616 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
3617 int /*flags*/, bool *no_add_attrs
)
3619 if (TREE_CODE (*node
) == FUNCTION_DECL
)
3621 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
3622 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
3623 "return type", name
, *node
);
3625 else if (OVERLOAD_TYPE_P (*node
))
3629 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
3630 "functions or to class or enumeration types", name
);
3631 *no_add_attrs
= true;
3636 /* Table of valid C++ attributes. */
3637 const struct attribute_spec cxx_attribute_table
[] =
3639 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3640 affects_type_identity } */
3641 { "java_interface", 0, 0, false, false, false,
3642 handle_java_interface_attribute
, false },
3643 { "init_priority", 1, 1, true, false, false,
3644 handle_init_priority_attribute
, false },
3645 { "abi_tag", 1, -1, false, false, false,
3646 handle_abi_tag_attribute
, true },
3647 { NULL
, 0, 0, false, false, false, NULL
, false }
3650 /* Table of C++ standard attributes. */
3651 const struct attribute_spec std_attribute_table
[] =
3653 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3654 affects_type_identity } */
3655 { "maybe_unused", 0, 0, false, false, false,
3656 handle_unused_attribute
, false },
3657 { "nodiscard", 0, 0, false, false, false,
3658 handle_nodiscard_attribute
, false },
3659 { NULL
, 0, 0, false, false, false, NULL
, false }
3662 /* Handle a "java_interface" attribute; arguments as in
3663 struct attribute_spec.handler. */
3665 handle_java_interface_attribute (tree
* node
,
3672 || !CLASS_TYPE_P (*node
)
3673 || !TYPE_FOR_JAVA (*node
))
3675 error ("%qE attribute can only be applied to Java class definitions",
3677 *no_add_attrs
= true;
3680 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
3681 *node
= build_variant_type_copy (*node
);
3682 TYPE_JAVA_INTERFACE (*node
) = 1;
3687 /* Handle an "init_priority" attribute; arguments as in
3688 struct attribute_spec.handler. */
3690 handle_init_priority_attribute (tree
* node
,
3696 tree initp_expr
= TREE_VALUE (args
);
3698 tree type
= TREE_TYPE (decl
);
3701 STRIP_NOPS (initp_expr
);
3702 initp_expr
= default_conversion (initp_expr
);
3704 initp_expr
= maybe_constant_value (initp_expr
);
3706 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
3708 error ("requested init_priority is not an integer constant");
3709 cxx_constant_value (initp_expr
);
3710 *no_add_attrs
= true;
3714 pri
= TREE_INT_CST_LOW (initp_expr
);
3716 type
= strip_array_types (type
);
3718 if (decl
== NULL_TREE
3720 || !TREE_STATIC (decl
)
3721 || DECL_EXTERNAL (decl
)
3722 || (TREE_CODE (type
) != RECORD_TYPE
3723 && TREE_CODE (type
) != UNION_TYPE
)
3724 /* Static objects in functions are initialized the
3725 first time control passes through that
3726 function. This is not precise enough to pin down an
3727 init_priority value, so don't allow it. */
3728 || current_function_decl
)
3730 error ("can only use %qE attribute on file-scope definitions "
3731 "of objects of class type", name
);
3732 *no_add_attrs
= true;
3736 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
3738 error ("requested init_priority is out of range");
3739 *no_add_attrs
= true;
3743 /* Check for init_priorities that are reserved for
3744 language and runtime support implementations.*/
3745 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
3748 (0, "requested init_priority is reserved for internal use");
3751 if (SUPPORTS_INIT_PRIORITY
)
3753 SET_DECL_INIT_PRIORITY (decl
, pri
);
3754 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
3759 error ("%qE attribute is not supported on this platform", name
);
3760 *no_add_attrs
= true;
3765 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
3766 and the new one has the tags in NEW_. Give an error if there are tags
3767 in NEW_ that weren't in OLD. */
3770 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
3772 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
3773 old
= TREE_VALUE (old
);
3774 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
3775 new_
= TREE_VALUE (new_
);
3777 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
3779 tree str
= TREE_VALUE (t
);
3780 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
3782 tree ostr
= TREE_VALUE (in
);
3783 if (cp_tree_equal (str
, ostr
))
3786 error ("redeclaration of %qD adds abi tag %E", decl
, str
);
3792 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
3798 /* The abi_tag attribute with the name NAME was given ARGS. If they are
3799 ill-formed, give an error and return false; otherwise, return true. */
3802 check_abi_tag_args (tree args
, tree name
)
3806 error ("the %qE attribute requires arguments", name
);
3809 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
3811 tree elt
= TREE_VALUE (arg
);
3812 if (TREE_CODE (elt
) != STRING_CST
3813 || (!same_type_ignoring_top_level_qualifiers_p
3814 (strip_array_types (TREE_TYPE (elt
)),
3817 error ("arguments to the %qE attribute must be narrow string "
3821 const char *begin
= TREE_STRING_POINTER (elt
);
3822 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
3823 for (const char *p
= begin
; p
!= end
; ++p
)
3828 if (!ISALPHA (c
) && c
!= '_')
3830 error ("arguments to the %qE attribute must contain valid "
3831 "identifiers", name
);
3832 inform (input_location
, "%<%c%> is not a valid first "
3833 "character for an identifier", c
);
3837 else if (p
== end
- 1)
3838 gcc_assert (c
== 0);
3841 if (!ISALNUM (c
) && c
!= '_')
3843 error ("arguments to the %qE attribute must contain valid "
3844 "identifiers", name
);
3845 inform (input_location
, "%<%c%> is not a valid character "
3846 "in an identifier", c
);
3855 /* Handle an "abi_tag" attribute; arguments as in
3856 struct attribute_spec.handler. */
3859 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
3860 int flags
, bool* no_add_attrs
)
3862 if (!check_abi_tag_args (args
, name
))
3867 if (!OVERLOAD_TYPE_P (*node
))
3869 error ("%qE attribute applied to non-class, non-enum type %qT",
3873 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
3875 error ("%qE attribute applied to %qT after its definition",
3879 else if (CLASS_TYPE_P (*node
)
3880 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
3882 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3883 "template instantiation %qT", name
, *node
);
3886 else if (CLASS_TYPE_P (*node
)
3887 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
3889 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3890 "template specialization %qT", name
, *node
);
3894 tree attributes
= TYPE_ATTRIBUTES (*node
);
3895 tree decl
= TYPE_NAME (*node
);
3897 /* Make sure all declarations have the same abi tags. */
3898 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
3900 if (!check_abi_tag_redeclaration (decl
,
3901 lookup_attribute ("abi_tag",
3909 if (!VAR_OR_FUNCTION_DECL_P (*node
))
3911 error ("%qE attribute applied to non-function, non-variable %qD",
3915 else if (DECL_LANGUAGE (*node
) == lang_c
)
3917 error ("%qE attribute applied to extern \"C\" declaration %qD",
3926 *no_add_attrs
= true;
3930 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
3931 thing pointed to by the constant. */
3934 make_ptrmem_cst (tree type
, tree member
)
3936 tree ptrmem_cst
= make_node (PTRMEM_CST
);
3937 TREE_TYPE (ptrmem_cst
) = type
;
3938 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
3942 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
3943 return an existing type if an appropriate type already exists. */
3946 cp_build_type_attribute_variant (tree type
, tree attributes
)
3950 new_type
= build_type_attribute_variant (type
, attributes
);
3951 if (TREE_CODE (new_type
) == FUNCTION_TYPE
3952 || TREE_CODE (new_type
) == METHOD_TYPE
)
3954 new_type
= build_exception_variant (new_type
,
3955 TYPE_RAISES_EXCEPTIONS (type
));
3956 new_type
= build_ref_qualified_type (new_type
,
3957 type_memfn_rqual (type
));
3960 /* Making a new main variant of a class type is broken. */
3961 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
3966 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3967 Called only after doing all language independent checks. Only
3968 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3969 compared in type_hash_eq. */
3972 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
3974 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
3975 || TREE_CODE (typea
) == METHOD_TYPE
);
3977 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
3978 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
3981 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3982 traversal. Called from walk_tree. */
3985 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
3986 void *data
, hash_set
<tree
> *pset
)
3988 enum tree_code code
= TREE_CODE (*tp
);
3991 #define WALK_SUBTREE(NODE) \
3994 result = cp_walk_tree (&(NODE), func, data, pset); \
3995 if (result) goto out; \
3999 /* Not one of the easy cases. We must explicitly go through the
4005 case TEMPLATE_TEMPLATE_PARM
:
4006 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4007 case UNBOUND_CLASS_TEMPLATE
:
4008 case TEMPLATE_PARM_INDEX
:
4009 case TEMPLATE_TYPE_PARM
:
4012 case UNDERLYING_TYPE
:
4013 /* None of these have subtrees other than those already walked
4015 *walk_subtrees_p
= 0;
4019 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4020 *walk_subtrees_p
= 0;
4024 WALK_SUBTREE (TREE_TYPE (*tp
));
4025 *walk_subtrees_p
= 0;
4029 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4033 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4034 WALK_SUBTREE (OVL_CHAIN (*tp
));
4035 *walk_subtrees_p
= 0;
4039 WALK_SUBTREE (DECL_NAME (*tp
));
4040 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4041 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4042 *walk_subtrees_p
= 0;
4046 if (TYPE_PTRMEMFUNC_P (*tp
))
4047 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4050 case TYPE_ARGUMENT_PACK
:
4051 case NONTYPE_ARGUMENT_PACK
:
4053 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4054 int i
, len
= TREE_VEC_LENGTH (args
);
4055 for (i
= 0; i
< len
; i
++)
4056 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4060 case TYPE_PACK_EXPANSION
:
4061 WALK_SUBTREE (TREE_TYPE (*tp
));
4062 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4063 *walk_subtrees_p
= 0;
4066 case EXPR_PACK_EXPANSION
:
4067 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4068 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4069 *walk_subtrees_p
= 0;
4073 case REINTERPRET_CAST_EXPR
:
4074 case STATIC_CAST_EXPR
:
4075 case CONST_CAST_EXPR
:
4076 case DYNAMIC_CAST_EXPR
:
4077 case IMPLICIT_CONV_EXPR
:
4078 if (TREE_TYPE (*tp
))
4079 WALK_SUBTREE (TREE_TYPE (*tp
));
4083 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4084 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4086 *walk_subtrees_p
= 0;
4090 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4091 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4092 *walk_subtrees_p
= 0;
4096 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
4097 *walk_subtrees_p
= 0;
4101 // Only recurse through the nested expression. Do not
4102 // walk the parameter list. Doing so causes false
4103 // positives in the pack expansion checker since the
4104 // requires parameters are introduced as pack expansions.
4105 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4106 *walk_subtrees_p
= 0;
4110 /* User variables should be mentioned in BIND_EXPR_VARS
4111 and their initializers and sizes walked when walking
4112 the containing BIND_EXPR. Compiler temporaries are
4114 if (VAR_P (TREE_OPERAND (*tp
, 0))
4115 && DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4116 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))
4118 tree decl
= TREE_OPERAND (*tp
, 0);
4119 WALK_SUBTREE (DECL_INITIAL (decl
));
4120 WALK_SUBTREE (DECL_SIZE (decl
));
4121 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4129 /* We didn't find what we were looking for. */
4136 /* Like save_expr, but for C++. */
4139 cp_save_expr (tree expr
)
4141 /* There is no reason to create a SAVE_EXPR within a template; if
4142 needed, we can create the SAVE_EXPR when instantiating the
4143 template. Furthermore, the middle-end cannot handle C++-specific
4145 if (processing_template_decl
)
4147 return save_expr (expr
);
4150 /* Initialize tree.c. */
4155 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4156 register_scoped_attributes (std_attribute_table
, NULL
);
4159 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4160 is. Note that sfk_none is zero, so this function can be used as a
4161 predicate to test whether or not DECL is a special function. */
4163 special_function_kind
4164 special_function_p (const_tree decl
)
4166 /* Rather than doing all this stuff with magic names, we should
4167 probably have a field of type `special_function_kind' in
4168 DECL_LANG_SPECIFIC. */
4169 if (DECL_INHERITED_CTOR_BASE (decl
))
4170 return sfk_inheriting_constructor
;
4171 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4172 return sfk_copy_constructor
;
4173 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4174 return sfk_move_constructor
;
4175 if (DECL_CONSTRUCTOR_P (decl
))
4176 return sfk_constructor
;
4177 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
4179 if (copy_fn_p (decl
))
4180 return sfk_copy_assignment
;
4181 if (move_fn_p (decl
))
4182 return sfk_move_assignment
;
4184 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
4185 return sfk_destructor
;
4186 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
4187 return sfk_complete_destructor
;
4188 if (DECL_BASE_DESTRUCTOR_P (decl
))
4189 return sfk_base_destructor
;
4190 if (DECL_DELETING_DESTRUCTOR_P (decl
))
4191 return sfk_deleting_destructor
;
4192 if (DECL_CONV_FN_P (decl
))
4193 return sfk_conversion
;
4198 /* Returns nonzero if TYPE is a character type, including wchar_t. */
4201 char_type_p (tree type
)
4203 return (same_type_p (type
, char_type_node
)
4204 || same_type_p (type
, unsigned_char_type_node
)
4205 || same_type_p (type
, signed_char_type_node
)
4206 || same_type_p (type
, char16_type_node
)
4207 || same_type_p (type
, char32_type_node
)
4208 || same_type_p (type
, wchar_type_node
));
4211 /* Returns the kind of linkage associated with the indicated DECL. Th
4212 value returned is as specified by the language standard; it is
4213 independent of implementation details regarding template
4214 instantiation, etc. For example, it is possible that a declaration
4215 to which this function assigns external linkage would not show up
4216 as a global symbol when you run `nm' on the resulting object file. */
4219 decl_linkage (tree decl
)
4221 /* This function doesn't attempt to calculate the linkage from first
4222 principles as given in [basic.link]. Instead, it makes use of
4223 the fact that we have already set TREE_PUBLIC appropriately, and
4224 then handles a few special cases. Ideally, we would calculate
4225 linkage first, and then transform that into a concrete
4228 /* Things that don't have names have no linkage. */
4229 if (!DECL_NAME (decl
))
4232 /* Fields have no linkage. */
4233 if (TREE_CODE (decl
) == FIELD_DECL
)
4236 /* Things that are TREE_PUBLIC have external linkage. */
4237 if (TREE_PUBLIC (decl
))
4240 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4243 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4245 if (TREE_CODE (decl
) == CONST_DECL
)
4246 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
4248 /* Things in local scope do not have linkage, if they don't have
4250 if (decl_function_context (decl
))
4253 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4254 are considered to have external linkage for language purposes, as do
4255 template instantiations on targets without weak symbols. DECLs really
4256 meant to have internal linkage have DECL_THIS_STATIC set. */
4257 if (TREE_CODE (decl
) == TYPE_DECL
)
4259 if (VAR_OR_FUNCTION_DECL_P (decl
))
4261 if (!DECL_THIS_STATIC (decl
))
4264 /* Static data members and static member functions from classes
4265 in anonymous namespace also don't have TREE_PUBLIC set. */
4266 if (DECL_CLASS_CONTEXT (decl
))
4270 /* Everything else has internal linkage. */
4274 /* Returns the storage duration of the object or reference associated with
4275 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
4278 decl_storage_duration (tree decl
)
4280 if (TREE_CODE (decl
) == PARM_DECL
)
4282 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4284 gcc_assert (VAR_P (decl
));
4285 if (!TREE_STATIC (decl
)
4286 && !DECL_EXTERNAL (decl
))
4288 if (CP_DECL_THREAD_LOCAL_P (decl
))
4293 /* EXP is an expression that we want to pre-evaluate. Returns (in
4294 *INITP) an expression that will perform the pre-evaluation. The
4295 value returned by this function is a side-effect free expression
4296 equivalent to the pre-evaluated expression. Callers must ensure
4297 that *INITP is evaluated before EXP. */
4300 stabilize_expr (tree exp
, tree
* initp
)
4304 if (!TREE_SIDE_EFFECTS (exp
))
4305 init_expr
= NULL_TREE
;
4306 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
4311 /* There are no expressions with REFERENCE_TYPE, but there can be call
4312 arguments with such a type; just treat it as a pointer. */
4313 else if (TREE_CODE (TREE_TYPE (exp
)) == REFERENCE_TYPE
4314 || SCALAR_TYPE_P (TREE_TYPE (exp
))
4315 || !glvalue_p (exp
))
4317 init_expr
= get_target_expr (exp
);
4318 exp
= TARGET_EXPR_SLOT (init_expr
);
4319 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
4326 bool xval
= !lvalue_p (exp
);
4327 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
4328 init_expr
= get_target_expr (exp
);
4329 exp
= TARGET_EXPR_SLOT (init_expr
);
4330 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
4336 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
4340 /* Add NEW_EXPR, an expression whose value we don't care about, after the
4341 similar expression ORIG. */
4344 add_stmt_to_compound (tree orig
, tree new_expr
)
4346 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
4348 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
4350 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
4353 /* Like stabilize_expr, but for a call whose arguments we want to
4354 pre-evaluate. CALL is modified in place to use the pre-evaluated
4355 arguments, while, upon return, *INITP contains an expression to
4356 compute the arguments. */
4359 stabilize_call (tree call
, tree
*initp
)
4361 tree inits
= NULL_TREE
;
4363 int nargs
= call_expr_nargs (call
);
4365 if (call
== error_mark_node
|| processing_template_decl
)
4371 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
4373 for (i
= 0; i
< nargs
; i
++)
4376 CALL_EXPR_ARG (call
, i
) =
4377 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
4378 inits
= add_stmt_to_compound (inits
, init
);
4384 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
4385 to pre-evaluate. CALL is modified in place to use the pre-evaluated
4386 arguments, while, upon return, *INITP contains an expression to
4387 compute the arguments. */
4390 stabilize_aggr_init (tree call
, tree
*initp
)
4392 tree inits
= NULL_TREE
;
4394 int nargs
= aggr_init_expr_nargs (call
);
4396 if (call
== error_mark_node
)
4399 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
4401 for (i
= 0; i
< nargs
; i
++)
4404 AGGR_INIT_EXPR_ARG (call
, i
) =
4405 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
4406 inits
= add_stmt_to_compound (inits
, init
);
4412 /* Like stabilize_expr, but for an initialization.
4414 If the initialization is for an object of class type, this function
4415 takes care not to introduce additional temporaries.
4417 Returns TRUE iff the expression was successfully pre-evaluated,
4418 i.e., if INIT is now side-effect free, except for, possibly, a
4419 single call to a constructor. */
4422 stabilize_init (tree init
, tree
*initp
)
4428 if (t
== error_mark_node
|| processing_template_decl
)
4431 if (TREE_CODE (t
) == INIT_EXPR
)
4432 t
= TREE_OPERAND (t
, 1);
4433 if (TREE_CODE (t
) == TARGET_EXPR
)
4434 t
= TARGET_EXPR_INITIAL (t
);
4436 /* If the RHS can be stabilized without breaking copy elision, stabilize
4437 it. We specifically don't stabilize class prvalues here because that
4438 would mean an extra copy, but they might be stabilized below. */
4439 if (TREE_CODE (init
) == INIT_EXPR
4440 && TREE_CODE (t
) != CONSTRUCTOR
4441 && TREE_CODE (t
) != AGGR_INIT_EXPR
4442 && (SCALAR_TYPE_P (TREE_TYPE (t
))
4445 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
4449 if (TREE_CODE (t
) == COMPOUND_EXPR
4450 && TREE_CODE (init
) == INIT_EXPR
)
4452 tree last
= expr_last (t
);
4453 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
4454 if (!TREE_SIDE_EFFECTS (last
))
4457 TREE_OPERAND (init
, 1) = last
;
4462 if (TREE_CODE (t
) == CONSTRUCTOR
)
4464 /* Aggregate initialization: stabilize each of the field
4467 constructor_elt
*ce
;
4469 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4470 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4472 tree type
= TREE_TYPE (ce
->value
);
4474 if (TREE_CODE (type
) == REFERENCE_TYPE
4475 || SCALAR_TYPE_P (type
))
4476 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
4477 else if (!stabilize_init (ce
->value
, &subinit
))
4479 *initp
= add_stmt_to_compound (*initp
, subinit
);
4484 if (TREE_CODE (t
) == CALL_EXPR
)
4486 stabilize_call (t
, initp
);
4490 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4492 stabilize_aggr_init (t
, initp
);
4496 /* The initialization is being performed via a bitwise copy -- and
4497 the item copied may have side effects. */
4498 return !TREE_SIDE_EFFECTS (init
);
4501 /* Returns true if a cast to TYPE may appear in an integral constant
4505 cast_valid_in_integral_constant_expression_p (tree type
)
4507 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
4508 || cxx_dialect
>= cxx11
4509 || dependent_type_p (type
)
4510 || type
== error_mark_node
);
4513 /* Return true if we need to fix linkage information of DECL. */
4516 cp_fix_function_decl_p (tree decl
)
4518 /* Skip if DECL is not externally visible. */
4519 if (!TREE_PUBLIC (decl
))
4522 /* We need to fix DECL if it a appears to be exported but with no
4523 function body. Thunks do not have CFGs and we may need to
4524 handle them specially later. */
4525 if (!gimple_has_body_p (decl
)
4526 && !DECL_THUNK_P (decl
)
4527 && !DECL_EXTERNAL (decl
))
4529 struct cgraph_node
*node
= cgraph_node::get (decl
);
4531 /* Don't fix same_body aliases. Although they don't have their own
4532 CFG, they share it with what they alias to. */
4533 if (!node
|| !node
->alias
4534 || !vec_safe_length (node
->ref_list
.references
))
4541 /* Clean the C++ specific parts of the tree T. */
4544 cp_free_lang_data (tree t
)
4546 if (TREE_CODE (t
) == METHOD_TYPE
4547 || TREE_CODE (t
) == FUNCTION_TYPE
)
4549 /* Default args are not interesting anymore. */
4550 tree argtypes
= TYPE_ARG_TYPES (t
);
4553 TREE_PURPOSE (argtypes
) = 0;
4554 argtypes
= TREE_CHAIN (argtypes
);
4557 else if (TREE_CODE (t
) == FUNCTION_DECL
4558 && cp_fix_function_decl_p (t
))
4560 /* If T is used in this translation unit at all, the definition
4561 must exist somewhere else since we have decided to not emit it
4562 in this TU. So make it an external reference. */
4563 DECL_EXTERNAL (t
) = 1;
4564 TREE_STATIC (t
) = 0;
4566 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4568 /* The list of users of a namespace isn't useful for the middle-end
4569 or debug generators. */
4570 DECL_NAMESPACE_USERS (t
) = NULL_TREE
;
4571 /* Neither do we need the leftover chaining of namespaces
4572 from the binding level. */
4573 DECL_CHAIN (t
) = NULL_TREE
;
4577 /* Stub for c-common. Please keep in sync with c-decl.c.
4578 FIXME: If address space support is target specific, then this
4579 should be a C target hook. But currently this is not possible,
4580 because this function is called via REGISTER_TARGET_PRAGMAS. */
4582 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
4586 /* Return the number of operands in T that we care about for things like
4590 cp_tree_operand_length (const_tree t
)
4592 enum tree_code code
= TREE_CODE (t
);
4594 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
4595 return VL_EXP_OPERAND_LENGTH (t
);
4597 return cp_tree_code_length (code
);
4600 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
4603 cp_tree_code_length (enum tree_code code
)
4605 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4609 case PREINCREMENT_EXPR
:
4610 case PREDECREMENT_EXPR
:
4611 case POSTINCREMENT_EXPR
:
4612 case POSTDECREMENT_EXPR
:
4618 case EXPR_PACK_EXPANSION
:
4622 return TREE_CODE_LENGTH (code
);
4626 /* Implement -Wzero_as_null_pointer_constant. Return true if the
4627 conditions for the warning hold, false otherwise. */
4629 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
4631 if (c_inhibit_evaluation_warnings
== 0
4632 && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
4634 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
4635 "zero as null pointer constant");
4641 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4642 /* Complain that some language-specific thing hanging off a tree
4643 node has been accessed improperly. */
4646 lang_check_failed (const char* file
, int line
, const char* function
)
4648 internal_error ("lang_* check: failed in %s, at %s:%d",
4649 function
, trim_filename (file
), line
);
4651 #endif /* ENABLE_TREE_CHECKING */
4653 #include "gt-cp-tree.h"