1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2014 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 "tree-hasher.h"
27 #include "stor-layout.h"
28 #include "print-tree.h"
29 #include "tree-iterator.h"
32 #include "tree-inline.h"
37 #include "plugin-api.h"
42 #include "hard-reg-set.h"
47 #include "splay-tree.h"
48 #include "hash-table.h"
49 #include "gimple-expr.h"
53 static tree
bot_manip (tree
*, int *, void *);
54 static tree
bot_replace (tree
*, int *, void *);
55 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
56 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
57 static tree
count_trees_r (tree
*, int *, void *);
58 static tree
verify_stmt_tree_r (tree
*, int *, void *);
59 static tree
build_local_temp (tree
);
61 static tree
handle_java_interface_decl_attribute (tree
*, tree
, tree
, int,
63 static tree
handle_java_interface_type_attribute (tree
*, tree
, tree
, int,
65 static tree
handle_com_interface_decl_attribute (tree
*, tree
, tree
, int,
67 static tree
handle_com_interface_type_attribute (tree
*, tree
, tree
, int,
69 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
70 static tree
handle_abi_tag_decl_attribute (tree
*, tree
, tree
, int, bool *);
71 static tree
handle_abi_tag_type_attribute (tree
*, tree
, tree
, int, bool *);
73 /* If REF is an lvalue, returns the kind of lvalue that REF is.
74 Otherwise, returns clk_none. */
77 lvalue_kind (const_tree ref
)
79 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
80 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
82 /* Expressions of reference type are sometimes wrapped in
83 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
84 representation, not part of the language, so we have to look
86 if (REFERENCE_REF_P (ref
))
87 return lvalue_kind (TREE_OPERAND (ref
, 0));
90 && TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
92 /* unnamed rvalue references are rvalues */
93 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
94 && TREE_CODE (ref
) != PARM_DECL
96 && TREE_CODE (ref
) != COMPONENT_REF
97 /* Functions are always lvalues. */
98 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
101 /* lvalue references and named rvalue references are lvalues. */
105 if (ref
== current_class_ptr
)
108 switch (TREE_CODE (ref
))
112 /* preincrements and predecrements are valid lvals, provided
113 what they refer to are valid lvals. */
114 case PREINCREMENT_EXPR
:
115 case PREDECREMENT_EXPR
:
117 case WITH_CLEANUP_EXPR
:
120 return lvalue_kind (TREE_OPERAND (ref
, 0));
124 if (TREE_CODE (ref
) == MEMBER_REF
)
125 op1_lvalue_kind
= clk_ordinary
;
127 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
128 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
129 op1_lvalue_kind
= clk_none
;
130 return op1_lvalue_kind
;
133 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
134 /* Look at the member designator. */
135 if (!op1_lvalue_kind
)
137 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
138 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
139 situations. If we're seeing a COMPONENT_REF, it's a non-static
140 member, so it isn't an lvalue. */
141 op1_lvalue_kind
= clk_none
;
142 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
143 /* This can be IDENTIFIER_NODE in a template. */;
144 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
146 /* Clear the ordinary bit. If this object was a class
147 rvalue we want to preserve that information. */
148 op1_lvalue_kind
&= ~clk_ordinary
;
149 /* The lvalue is for a bitfield. */
150 op1_lvalue_kind
|= clk_bitfield
;
152 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
153 op1_lvalue_kind
|= clk_packed
;
155 return op1_lvalue_kind
;
158 case COMPOUND_LITERAL_EXPR
:
162 /* CONST_DECL without TREE_STATIC are enumeration values and
163 thus not lvalues. With TREE_STATIC they are used by ObjC++
164 in objc_build_string_object and need to be considered as
166 if (! TREE_STATIC (ref
))
169 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
170 && DECL_LANG_SPECIFIC (ref
)
171 && DECL_IN_AGGR_P (ref
))
176 case ARRAY_NOTATION_REF
:
179 case PLACEHOLDER_EXPR
:
182 /* A scope ref in a template, left as SCOPE_REF to support later
185 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
187 tree op
= TREE_OPERAND (ref
, 1);
188 if (TREE_CODE (op
) == FIELD_DECL
)
189 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
191 return lvalue_kind (op
);
196 /* Disallow <? and >? as lvalues if either argument side-effects. */
197 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
198 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
200 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
201 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
205 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
206 ? TREE_OPERAND (ref
, 1)
207 : TREE_OPERAND (ref
, 0));
208 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
216 return lvalue_kind (TREE_OPERAND (ref
, 1));
222 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
225 /* We can see calls outside of TARGET_EXPR in templates. */
226 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
231 /* All functions (except non-static-member functions) are
233 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
234 ? clk_none
: clk_ordinary
);
237 /* We now represent a reference to a single static member function
239 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
240 its argument unmodified and we assign it to a const_tree. */
241 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
243 case NON_DEPENDENT_EXPR
:
244 /* We just return clk_ordinary for NON_DEPENDENT_EXPR in C++98, but
245 in C++11 lvalues don't bind to rvalue references, so we need to
246 work harder to avoid bogus errors (c++/44870). */
247 if (cxx_dialect
< cxx11
)
250 return lvalue_kind (TREE_OPERAND (ref
, 0));
253 if (!TREE_TYPE (ref
))
255 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
260 /* If one operand is not an lvalue at all, then this expression is
262 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
265 /* Otherwise, it's an lvalue, and it has all the odd properties
266 contributed by either operand. */
267 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
268 /* It's not an ordinary lvalue if it involves any other kind. */
269 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
270 op1_lvalue_kind
&= ~clk_ordinary
;
271 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
272 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
273 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
274 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
275 op1_lvalue_kind
= clk_none
;
276 return op1_lvalue_kind
;
279 /* Returns the kind of lvalue that REF is, in the sense of
280 [basic.lval]. This function should really be named lvalue_p; it
281 computes the C++ definition of lvalue. */
284 real_lvalue_p (const_tree ref
)
286 cp_lvalue_kind kind
= lvalue_kind (ref
);
287 if (kind
& (clk_rvalueref
|clk_class
))
293 /* This differs from real_lvalue_p in that class rvalues are considered
297 lvalue_p (const_tree ref
)
299 return (lvalue_kind (ref
) != clk_none
);
302 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
303 rvalue references are considered rvalues. */
306 lvalue_or_rvalue_with_address_p (const_tree ref
)
308 cp_lvalue_kind kind
= lvalue_kind (ref
);
309 if (kind
& clk_class
)
312 return (kind
!= clk_none
);
315 /* Returns true if REF is an xvalue, false otherwise. */
318 xvalue_p (const_tree ref
)
320 return (lvalue_kind (ref
) == clk_rvalueref
);
323 /* Test whether DECL is a builtin that may appear in a
324 constant-expression. */
327 builtin_valid_in_constant_expr_p (const_tree decl
)
329 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
330 in constant-expressions. We may want to add other builtins later. */
331 return DECL_IS_BUILTIN_CONSTANT_P (decl
);
334 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
337 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
340 tree type
= TREE_TYPE (decl
);
342 #ifdef ENABLE_CHECKING
343 gcc_assert (VOID_TYPE_P (TREE_TYPE (value
))
344 || TREE_TYPE (decl
) == TREE_TYPE (value
)
345 /* On ARM ctors return 'this'. */
346 || (TYPE_PTR_P (TREE_TYPE (value
))
347 && TREE_CODE (value
) == CALL_EXPR
)
348 || useless_type_conversion_p (TREE_TYPE (decl
),
352 t
= cxx_maybe_build_cleanup (decl
, complain
);
353 if (t
== error_mark_node
)
354 return error_mark_node
;
355 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
356 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
357 ignore the TARGET_EXPR. If there really turn out to be no
358 side-effects, then the optimizer should be able to get rid of
359 whatever code is generated anyhow. */
360 TREE_SIDE_EFFECTS (t
) = 1;
365 /* Return an undeclared local temporary of type TYPE for use in building a
369 build_local_temp (tree type
)
371 tree slot
= build_decl (input_location
,
372 VAR_DECL
, NULL_TREE
, type
);
373 DECL_ARTIFICIAL (slot
) = 1;
374 DECL_IGNORED_P (slot
) = 1;
375 DECL_CONTEXT (slot
) = current_function_decl
;
376 layout_decl (slot
, 0);
380 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
383 process_aggr_init_operands (tree t
)
387 side_effects
= TREE_SIDE_EFFECTS (t
);
391 n
= TREE_OPERAND_LENGTH (t
);
392 for (i
= 1; i
< n
; i
++)
394 tree op
= TREE_OPERAND (t
, i
);
395 if (op
&& TREE_SIDE_EFFECTS (op
))
402 TREE_SIDE_EFFECTS (t
) = side_effects
;
405 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
406 FN, and SLOT. NARGS is the number of call arguments which are specified
407 as a tree array ARGS. */
410 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
416 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
417 TREE_TYPE (t
) = return_type
;
418 AGGR_INIT_EXPR_FN (t
) = fn
;
419 AGGR_INIT_EXPR_SLOT (t
) = slot
;
420 for (i
= 0; i
< nargs
; i
++)
421 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
422 process_aggr_init_operands (t
);
426 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
427 target. TYPE is the type to be initialized.
429 Build an AGGR_INIT_EXPR to represent the initialization. This function
430 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
431 to initialize another object, whereas a TARGET_EXPR can either
432 initialize another object or create its own temporary object, and as a
433 result building up a TARGET_EXPR requires that the type's destructor be
437 build_aggr_init_expr (tree type
, tree init
)
444 /* Don't build AGGR_INIT_EXPR in a template. */
445 if (processing_template_decl
)
448 if (TREE_CODE (init
) == CALL_EXPR
)
449 fn
= CALL_EXPR_FN (init
);
450 else if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
451 fn
= AGGR_INIT_EXPR_FN (init
);
453 return convert (type
, init
);
455 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
456 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
457 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
459 /* We split the CALL_EXPR into its function and its arguments here.
460 Then, in expand_expr, we put them back together. The reason for
461 this is that this expression might be a default argument
462 expression. In that case, we need a new temporary every time the
463 expression is used. That's what break_out_target_exprs does; it
464 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
465 temporary slot. Then, expand_expr builds up a call-expression
466 using the new slot. */
468 /* If we don't need to use a constructor to create an object of this
469 type, don't mess with AGGR_INIT_EXPR. */
470 if (is_ctor
|| TREE_ADDRESSABLE (type
))
472 slot
= build_local_temp (type
);
474 if (TREE_CODE(init
) == CALL_EXPR
)
475 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
476 call_expr_nargs (init
),
477 CALL_EXPR_ARGP (init
));
479 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
480 aggr_init_expr_nargs (init
),
481 AGGR_INIT_EXPR_ARGP (init
));
482 TREE_SIDE_EFFECTS (rval
) = 1;
483 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
484 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
485 CALL_EXPR_LIST_INIT_P (rval
) = CALL_EXPR_LIST_INIT_P (init
);
493 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
494 target. TYPE is the type that this initialization should appear to
497 Build an encapsulation of the initialization to perform
498 and return it so that it can be processed by language-independent
499 and language-specific expression expanders. */
502 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
504 tree rval
= build_aggr_init_expr (type
, init
);
507 if (!complete_type_or_maybe_complain (type
, init
, complain
))
508 return error_mark_node
;
510 /* Make sure that we're not trying to create an instance of an
512 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
513 return error_mark_node
;
515 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
516 slot
= AGGR_INIT_EXPR_SLOT (rval
);
517 else if (TREE_CODE (rval
) == CALL_EXPR
518 || TREE_CODE (rval
) == CONSTRUCTOR
)
519 slot
= build_local_temp (type
);
523 rval
= build_target_expr (slot
, rval
, complain
);
525 if (rval
!= error_mark_node
)
526 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
531 /* Subroutine of build_vec_init_expr: Build up a single element
532 intialization as a proxy for the full array initialization to get things
533 marked as used and any appropriate diagnostics.
535 Since we're deferring building the actual constructor calls until
536 gimplification time, we need to build one now and throw it away so
537 that the relevant constructor gets mark_used before cgraph decides
538 what functions are needed. Here we assume that init is either
539 NULL_TREE, void_type_node (indicating value-initialization), or
540 another array to copy. */
543 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
545 tree inner_type
= strip_array_types (type
);
546 vec
<tree
, va_gc
> *argvec
;
548 if (integer_zerop (array_type_nelts_total (type
))
549 || !CLASS_TYPE_P (inner_type
))
550 /* No interesting initialization to do. */
551 return integer_zero_node
;
552 else if (init
== void_type_node
)
553 return build_value_init (inner_type
, complain
);
555 gcc_assert (init
== NULL_TREE
556 || (same_type_ignoring_top_level_qualifiers_p
557 (type
, TREE_TYPE (init
))));
559 argvec
= make_tree_vector ();
562 tree init_type
= strip_array_types (TREE_TYPE (init
));
563 tree dummy
= build_dummy_object (init_type
);
564 if (!real_lvalue_p (init
))
565 dummy
= move (dummy
);
566 argvec
->quick_push (dummy
);
568 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
569 &argvec
, inner_type
, LOOKUP_NORMAL
,
571 release_tree_vector (argvec
);
573 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
574 we don't want one here because we aren't creating a temporary. */
575 if (TREE_CODE (init
) == TARGET_EXPR
)
576 init
= TARGET_EXPR_INITIAL (init
);
581 /* Return a TARGET_EXPR which expresses the initialization of an array to
582 be named later, either default-initialization or copy-initialization
583 from another array of the same type. */
586 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
589 bool value_init
= false;
590 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
592 if (init
== void_type_node
)
598 slot
= build_local_temp (type
);
599 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
600 TREE_SIDE_EFFECTS (init
) = true;
601 SET_EXPR_LOCATION (init
, input_location
);
603 if (cxx_dialect
>= cxx11
604 && potential_constant_expression (elt_init
))
605 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
606 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
611 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
612 that requires a constant expression. */
615 diagnose_non_constexpr_vec_init (tree expr
)
617 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
619 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
620 init
= void_type_node
;
622 init
= VEC_INIT_EXPR_INIT (expr
);
624 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
625 require_potential_constant_expression (elt_init
);
629 build_array_copy (tree init
)
631 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
634 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
638 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
640 gcc_assert (!VOID_TYPE_P (type
));
642 if (TREE_CODE (init
) == TARGET_EXPR
643 || init
== error_mark_node
)
645 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
646 && !VOID_TYPE_P (TREE_TYPE (init
))
647 && TREE_CODE (init
) != COND_EXPR
648 && TREE_CODE (init
) != CONSTRUCTOR
649 && TREE_CODE (init
) != VA_ARG_EXPR
)
650 /* We need to build up a copy constructor call. A void initializer
651 means we're being called from bot_manip. COND_EXPR is a special
652 case because we already have copies on the arms and we don't want
653 another one here. A CONSTRUCTOR is aggregate initialization, which
654 is handled separately. A VA_ARG_EXPR is magic creation of an
655 aggregate; there's no additional work to be done. */
656 return force_rvalue (init
, complain
);
658 return force_target_expr (type
, init
, complain
);
661 /* Like the above function, but without the checking. This function should
662 only be used by code which is deliberately trying to subvert the type
663 system, such as call_builtin_trap. Or build_over_call, to avoid
664 infinite recursion. */
667 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
671 gcc_assert (!VOID_TYPE_P (type
));
673 slot
= build_local_temp (type
);
674 return build_target_expr (slot
, init
, complain
);
677 /* Like build_target_expr_with_type, but use the type of INIT. */
680 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
682 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
683 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
684 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
685 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
687 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
691 get_target_expr (tree init
)
693 return get_target_expr_sfinae (init
, tf_warning_or_error
);
696 /* If EXPR is a bitfield reference, convert it to the declared type of
697 the bitfield, and return the resulting expression. Otherwise,
698 return EXPR itself. */
701 convert_bitfield_to_declared_type (tree expr
)
705 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
707 expr
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
),
712 /* EXPR is being used in an rvalue context. Return a version of EXPR
713 that is marked as an rvalue. */
720 if (error_operand_p (expr
))
723 expr
= mark_rvalue_use (expr
);
727 Non-class rvalues always have cv-unqualified types. */
728 type
= TREE_TYPE (expr
);
729 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
730 type
= cv_unqualified (type
);
732 /* We need to do this for rvalue refs as well to get the right answer
733 from decltype; see c++/36628. */
734 if (!processing_template_decl
&& lvalue_or_rvalue_with_address_p (expr
))
735 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
736 else if (type
!= TREE_TYPE (expr
))
737 expr
= build_nop (type
, expr
);
743 struct cplus_array_info
749 struct cplus_array_hasher
: ggc_hasher
<tree
>
751 typedef cplus_array_info
*compare_type
;
753 static hashval_t
hash (tree t
);
754 static bool equal (tree
, cplus_array_info
*);
757 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
760 cplus_array_hasher::hash (tree t
)
764 hash
= TYPE_UID (TREE_TYPE (t
));
766 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
770 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
771 of type `cplus_array_info*'. */
774 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
776 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
779 /* Hash table containing dependent array types, which are unsuitable for
780 the language-independent type hash table. */
781 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
783 /* Build an ARRAY_TYPE without laying it out. */
786 build_min_array_type (tree elt_type
, tree index_type
)
788 tree t
= cxx_make_type (ARRAY_TYPE
);
789 TREE_TYPE (t
) = elt_type
;
790 TYPE_DOMAIN (t
) = index_type
;
794 /* Set TYPE_CANONICAL like build_array_type_1, but using
795 build_cplus_array_type. */
798 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
800 /* Set the canonical type for this new node. */
801 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
802 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
803 SET_TYPE_STRUCTURAL_EQUALITY (t
);
804 else if (TYPE_CANONICAL (elt_type
) != elt_type
805 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
807 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
809 ? TYPE_CANONICAL (index_type
) : index_type
);
811 TYPE_CANONICAL (t
) = t
;
814 /* Like build_array_type, but handle special C++ semantics: an array of a
815 variant element type is a variant of the array of the main variant of
819 build_cplus_array_type (tree elt_type
, tree index_type
)
823 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
824 return error_mark_node
;
827 = (processing_template_decl
828 && (dependent_type_p (elt_type
)
829 || (index_type
&& !TREE_CONSTANT (TYPE_MAX_VALUE (index_type
)))));
831 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
832 /* Start with an array of the TYPE_MAIN_VARIANT. */
833 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
837 /* Since type_hash_canon calls layout_type, we need to use our own
839 cplus_array_info cai
;
842 if (cplus_array_htab
== NULL
)
843 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
845 hash
= TYPE_UID (elt_type
);
847 hash
^= TYPE_UID (index_type
);
849 cai
.domain
= index_type
;
851 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
853 /* We have found the type: we're done. */
857 /* Build a new array type. */
858 t
= build_min_array_type (elt_type
, index_type
);
860 /* Store it in the hash table. */
863 /* Set the canonical type for this new node. */
864 set_array_type_canon (t
, elt_type
, index_type
);
869 t
= build_array_type (elt_type
, index_type
);
872 /* Now check whether we already have this array variant. */
873 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
876 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
877 if (TREE_TYPE (t
) == elt_type
878 && TYPE_NAME (t
) == NULL_TREE
879 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
883 t
= build_min_array_type (elt_type
, index_type
);
884 set_array_type_canon (t
, elt_type
, index_type
);
888 TYPE_MAIN_VARIANT (t
) = m
;
889 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
890 TYPE_NEXT_VARIANT (m
) = t
;
894 /* Avoid spurious warnings with VLAs (c++/54583). */
895 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
896 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
898 /* Push these needs up to the ARRAY_TYPE so that initialization takes
899 place more easily. */
900 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
901 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
902 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
903 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
905 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
906 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
908 /* The element type has been completed since the last time we saw
909 this array type; update the layout and 'tor flags for any variants
912 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
914 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
915 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
922 /* Return an ARRAY_TYPE with element type ELT and length N. */
925 build_array_of_n_type (tree elt
, int n
)
927 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
930 /* True iff T is an N3639 array of runtime bound (VLA). These were
931 approved for C++14 but then removed. */
934 array_of_runtime_bound_p (tree t
)
936 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
938 tree dom
= TYPE_DOMAIN (t
);
941 tree max
= TYPE_MAX_VALUE (dom
);
942 return (!potential_rvalue_constant_expression (max
)
943 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
946 /* Return a reference type node referring to TO_TYPE. If RVAL is
947 true, return an rvalue reference type, otherwise return an lvalue
948 reference type. If a type node exists, reuse it, otherwise create
951 cp_build_reference_type (tree to_type
, bool rval
)
954 lvalue_ref
= build_reference_type (to_type
);
958 /* This code to create rvalue reference types is based on and tied
959 to the code creating lvalue reference types in the middle-end
960 functions build_reference_type_for_mode and build_reference_type.
962 It works by putting the rvalue reference type nodes after the
963 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
964 they will effectively be ignored by the middle end. */
966 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
967 if (TYPE_REF_IS_RVALUE (t
))
970 t
= build_distinct_type_copy (lvalue_ref
);
972 TYPE_REF_IS_RVALUE (t
) = true;
973 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
974 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
976 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
977 SET_TYPE_STRUCTURAL_EQUALITY (t
);
978 else if (TYPE_CANONICAL (to_type
) != to_type
)
980 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
982 TYPE_CANONICAL (t
) = t
;
990 /* Returns EXPR cast to rvalue reference type, like std::move. */
995 tree type
= TREE_TYPE (expr
);
996 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
997 type
= cp_build_reference_type (type
, /*rval*/true);
998 return build_static_cast (type
, expr
, tf_warning_or_error
);
1001 /* Used by the C++ front end to build qualified array types. However,
1002 the C version of this function does not properly maintain canonical
1003 types (which are not used in C). */
1005 c_build_qualified_type (tree type
, int type_quals
)
1007 return cp_build_qualified_type (type
, type_quals
);
1011 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1012 arrays correctly. In particular, if TYPE is an array of T's, and
1013 TYPE_QUALS is non-empty, returns an array of qualified T's.
1015 FLAGS determines how to deal with ill-formed qualifications. If
1016 tf_ignore_bad_quals is set, then bad qualifications are dropped
1017 (this is permitted if TYPE was introduced via a typedef or template
1018 type parameter). If bad qualifications are dropped and tf_warning
1019 is set, then a warning is issued for non-const qualifications. If
1020 tf_ignore_bad_quals is not set and tf_error is not set, we
1021 return error_mark_node. Otherwise, we issue an error, and ignore
1024 Qualification of a reference type is valid when the reference came
1025 via a typedef or template type argument. [dcl.ref] No such
1026 dispensation is provided for qualifying a function type. [dcl.fct]
1027 DR 295 queries this and the proposed resolution brings it into line
1028 with qualifying a reference. We implement the DR. We also behave
1029 in a similar manner for restricting non-pointer types. */
1032 cp_build_qualified_type_real (tree type
,
1034 tsubst_flags_t complain
)
1037 int bad_quals
= TYPE_UNQUALIFIED
;
1039 if (type
== error_mark_node
)
1042 if (type_quals
== cp_type_quals (type
))
1045 if (TREE_CODE (type
) == ARRAY_TYPE
)
1047 /* In C++, the qualification really applies to the array element
1048 type. Obtain the appropriately qualified element type. */
1051 = cp_build_qualified_type_real (TREE_TYPE (type
),
1055 if (element_type
== error_mark_node
)
1056 return error_mark_node
;
1058 /* See if we already have an identically qualified type. Tests
1059 should be equivalent to those in check_qualified_type. */
1060 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1061 if (TREE_TYPE (t
) == element_type
1062 && TYPE_NAME (t
) == TYPE_NAME (type
)
1063 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1064 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1065 TYPE_ATTRIBUTES (type
)))
1070 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1072 /* Keep the typedef name. */
1073 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1075 t
= build_variant_type_copy (t
);
1076 TYPE_NAME (t
) = TYPE_NAME (type
);
1080 /* Even if we already had this variant, we update
1081 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1082 they changed since the variant was originally created.
1084 This seems hokey; if there is some way to use a previous
1085 variant *without* coming through here,
1086 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1087 TYPE_NEEDS_CONSTRUCTING (t
)
1088 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1089 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1090 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1093 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1095 tree t
= PACK_EXPANSION_PATTERN (type
);
1097 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1098 return make_pack_expansion (t
);
1101 /* A reference or method type shall not be cv-qualified.
1102 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1103 (in CD1) we always ignore extra cv-quals on functions. */
1104 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1105 && (TREE_CODE (type
) == REFERENCE_TYPE
1106 || TREE_CODE (type
) == FUNCTION_TYPE
1107 || TREE_CODE (type
) == METHOD_TYPE
))
1109 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1110 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1111 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1114 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1115 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1116 type_quals
|= type_memfn_quals (type
);
1118 /* A restrict-qualified type must be a pointer (or reference)
1119 to object or incomplete type. */
1120 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1121 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1122 && TREE_CODE (type
) != TYPENAME_TYPE
1123 && !POINTER_TYPE_P (type
))
1125 bad_quals
|= TYPE_QUAL_RESTRICT
;
1126 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1129 if (bad_quals
== TYPE_UNQUALIFIED
1130 || (complain
& tf_ignore_bad_quals
))
1132 else if (!(complain
& tf_error
))
1133 return error_mark_node
;
1136 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1137 error ("%qV qualifiers cannot be applied to %qT",
1141 /* Retrieve (or create) the appropriately qualified variant. */
1142 result
= build_qualified_type (type
, type_quals
);
1144 /* Preserve exception specs and ref-qualifier since build_qualified_type
1145 doesn't know about them. */
1146 if (TREE_CODE (result
) == FUNCTION_TYPE
1147 || TREE_CODE (result
) == METHOD_TYPE
)
1149 result
= build_exception_variant (result
, TYPE_RAISES_EXCEPTIONS (type
));
1150 result
= build_ref_qualified_type (result
, type_memfn_rqual (type
));
1156 /* Return TYPE with const and volatile removed. */
1159 cv_unqualified (tree type
)
1163 if (type
== error_mark_node
)
1166 quals
= cp_type_quals (type
);
1167 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1168 return cp_build_qualified_type (type
, quals
);
1171 /* Builds a qualified variant of T that is not a typedef variant.
1172 E.g. consider the following declarations:
1173 typedef const int ConstInt;
1174 typedef ConstInt* PtrConstInt;
1175 If T is PtrConstInt, this function returns a type representing
1177 In other words, if T is a typedef, the function returns the underlying type.
1178 The cv-qualification and attributes of the type returned match the
1180 They will always be compatible types.
1181 The returned type is built so that all of its subtypes
1182 recursively have their typedefs stripped as well.
1184 This is different from just returning TYPE_CANONICAL (T)
1185 Because of several reasons:
1186 * If T is a type that needs structural equality
1187 its TYPE_CANONICAL (T) will be NULL.
1188 * TYPE_CANONICAL (T) desn't carry type attributes
1189 and loses template parameter names. */
1192 strip_typedefs (tree t
)
1194 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1196 if (!t
|| t
== error_mark_node
)
1199 if (TREE_CODE (t
) == TREE_LIST
)
1201 bool changed
= false;
1202 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1203 for (; t
; t
= TREE_CHAIN (t
))
1205 gcc_assert (!TREE_PURPOSE (t
));
1206 tree elt
= strip_typedefs (TREE_VALUE (t
));
1207 if (elt
!= TREE_VALUE (t
))
1209 vec_safe_push (vec
, elt
);
1213 r
= build_tree_list_vec (vec
);
1214 release_tree_vector (vec
);
1218 gcc_assert (TYPE_P (t
));
1220 if (t
== TYPE_CANONICAL (t
))
1223 if (dependent_alias_template_spec_p (t
))
1224 /* DR 1558: However, if the template-id is dependent, subsequent
1225 template argument substitution still applies to the template-id. */
1228 switch (TREE_CODE (t
))
1231 type
= strip_typedefs (TREE_TYPE (t
));
1232 result
= build_pointer_type (type
);
1234 case REFERENCE_TYPE
:
1235 type
= strip_typedefs (TREE_TYPE (t
));
1236 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1239 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
));
1240 type
= strip_typedefs (TREE_TYPE (t
));
1241 result
= build_offset_type (t0
, type
);
1244 if (TYPE_PTRMEMFUNC_P (t
))
1246 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
));
1247 result
= build_ptrmemfunc_type (t0
);
1251 type
= strip_typedefs (TREE_TYPE (t
));
1252 t0
= strip_typedefs (TYPE_DOMAIN (t
));;
1253 result
= build_cplus_array_type (type
, t0
);
1258 tree arg_types
= NULL
, arg_node
, arg_type
;
1259 for (arg_node
= TYPE_ARG_TYPES (t
);
1261 arg_node
= TREE_CHAIN (arg_node
))
1263 if (arg_node
== void_list_node
)
1265 arg_type
= strip_typedefs (TREE_VALUE (arg_node
));
1266 gcc_assert (arg_type
);
1269 tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1273 arg_types
= nreverse (arg_types
);
1275 /* A list of parameters not ending with an ellipsis
1276 must end with void_list_node. */
1278 arg_types
= chainon (arg_types
, void_list_node
);
1280 type
= strip_typedefs (TREE_TYPE (t
));
1281 if (TREE_CODE (t
) == METHOD_TYPE
)
1283 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1284 gcc_assert (class_type
);
1286 build_method_type_directly (class_type
, type
,
1287 TREE_CHAIN (arg_types
));
1289 = build_ref_qualified_type (result
, type_memfn_rqual (t
));
1293 result
= build_function_type (type
,
1295 result
= apply_memfn_quals (result
,
1296 type_memfn_quals (t
),
1297 type_memfn_rqual (t
));
1300 if (TYPE_RAISES_EXCEPTIONS (t
))
1301 result
= build_exception_variant (result
,
1302 TYPE_RAISES_EXCEPTIONS (t
));
1303 if (TYPE_HAS_LATE_RETURN_TYPE (t
))
1304 TYPE_HAS_LATE_RETURN_TYPE (result
) = 1;
1309 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1310 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1311 && TREE_OPERAND (fullname
, 1))
1313 tree args
= TREE_OPERAND (fullname
, 1);
1314 tree new_args
= copy_node (args
);
1315 bool changed
= false;
1316 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1318 tree arg
= TREE_VEC_ELT (args
, i
);
1321 strip_arg
= strip_typedefs (arg
);
1323 strip_arg
= strip_typedefs_expr (arg
);
1324 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1325 if (strip_arg
!= arg
)
1330 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1331 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1333 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1337 ggc_free (new_args
);
1339 result
= make_typename_type (strip_typedefs (TYPE_CONTEXT (t
)),
1340 fullname
, typename_type
, tf_none
);
1344 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
));
1345 if (result
== DECLTYPE_TYPE_EXPR (t
))
1348 result
= (finish_decltype_type
1350 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1358 result
= TYPE_MAIN_VARIANT (t
);
1359 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1360 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1362 gcc_assert (TYPE_USER_ALIGN (t
));
1363 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1364 result
= build_variant_type_copy (result
);
1366 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1367 TYPE_USER_ALIGN (result
) = true;
1369 if (TYPE_ATTRIBUTES (t
))
1370 result
= cp_build_type_attribute_variant (result
, TYPE_ATTRIBUTES (t
));
1371 return cp_build_qualified_type (result
, cp_type_quals (t
));
1374 /* Like strip_typedefs above, but works on expressions, so that in
1376 template<class T> struct A
1382 sizeof(TT) is replaced by sizeof(T). */
1385 strip_typedefs_expr (tree t
)
1389 enum tree_code code
;
1391 if (t
== NULL_TREE
|| t
== error_mark_node
)
1394 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1397 /* Some expressions have type operands, so let's handle types here rather
1398 than check TYPE_P in multiple places below. */
1400 return strip_typedefs (t
);
1402 code
= TREE_CODE (t
);
1405 case IDENTIFIER_NODE
:
1406 case TEMPLATE_PARM_INDEX
:
1409 case ARGUMENT_PACK_SELECT
:
1414 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
));
1415 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
));
1416 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1417 && type2
== TRAIT_EXPR_TYPE2 (t
))
1420 TRAIT_EXPR_TYPE1 (t
) = type1
;
1421 TRAIT_EXPR_TYPE2 (t
) = type2
;
1427 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1428 bool changed
= false;
1430 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1432 tree val
= strip_typedefs_expr (TREE_VALUE (t
));
1433 vec_safe_push (vec
, val
);
1434 if (val
!= TREE_VALUE (t
))
1436 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1441 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1442 r
= tree_cons (NULL_TREE
, it
, r
);
1446 release_tree_vector (vec
);
1452 bool changed
= false;
1453 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1454 n
= TREE_VEC_LENGTH (t
);
1455 vec_safe_reserve (vec
, n
);
1456 for (i
= 0; i
< n
; ++i
)
1458 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
));
1459 vec
->quick_push (op
);
1460 if (op
!= TREE_VEC_ELT (t
, i
))
1466 for (i
= 0; i
< n
; ++i
)
1467 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1468 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1469 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1473 release_tree_vector (vec
);
1479 bool changed
= false;
1480 vec
<constructor_elt
, va_gc
> *vec
1481 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1482 n
= CONSTRUCTOR_NELTS (t
);
1483 type
= strip_typedefs (TREE_TYPE (t
));
1484 for (i
= 0; i
< n
; ++i
)
1486 constructor_elt
*e
= &(*vec
)[i
];
1487 tree op
= strip_typedefs_expr (e
->value
);
1493 gcc_checking_assert (e
->index
== strip_typedefs_expr (e
->index
));
1496 if (!changed
&& type
== TREE_TYPE (t
))
1504 TREE_TYPE (r
) = type
;
1505 CONSTRUCTOR_ELTS (r
) = vec
;
1511 error ("lambda-expression in a constant expression");
1512 return error_mark_node
;
1518 gcc_assert (EXPR_P (t
));
1520 n
= TREE_OPERAND_LENGTH (t
);
1521 ops
= XALLOCAVEC (tree
, n
);
1522 type
= TREE_TYPE (t
);
1527 case IMPLICIT_CONV_EXPR
:
1528 case DYNAMIC_CAST_EXPR
:
1529 case STATIC_CAST_EXPR
:
1530 case CONST_CAST_EXPR
:
1531 case REINTERPRET_CAST_EXPR
:
1534 type
= strip_typedefs (type
);
1538 for (i
= 0; i
< n
; ++i
)
1539 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
));
1543 /* If nothing changed, return t. */
1544 for (i
= 0; i
< n
; ++i
)
1545 if (ops
[i
] != TREE_OPERAND (t
, i
))
1547 if (i
== n
&& type
== TREE_TYPE (t
))
1551 TREE_TYPE (r
) = type
;
1552 for (i
= 0; i
< n
; ++i
)
1553 TREE_OPERAND (r
, i
) = ops
[i
];
1557 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1558 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1559 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1560 VIRT indicates whether TYPE is inherited virtually or not.
1561 IGO_PREV points at the previous binfo of the inheritance graph
1562 order chain. The newly copied binfo's TREE_CHAIN forms this
1565 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1566 correct order. That is in the order the bases themselves should be
1569 The BINFO_INHERITANCE of a virtual base class points to the binfo
1570 of the most derived type. ??? We could probably change this so that
1571 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1572 remove a field. They currently can only differ for primary virtual
1576 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1582 /* See if we've already made this virtual base. */
1583 new_binfo
= binfo_for_vbase (type
, t
);
1588 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1589 BINFO_TYPE (new_binfo
) = type
;
1591 /* Chain it into the inheritance graph. */
1592 TREE_CHAIN (*igo_prev
) = new_binfo
;
1593 *igo_prev
= new_binfo
;
1595 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1600 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1602 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1603 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1605 /* We do not need to copy the accesses, as they are read only. */
1606 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1608 /* Recursively copy base binfos of BINFO. */
1609 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1611 tree new_base_binfo
;
1612 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1614 BINFO_VIRTUAL_P (base_binfo
));
1616 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1617 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1618 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1622 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1626 /* Push it onto the list after any virtual bases it contains
1627 will have been pushed. */
1628 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1629 BINFO_VIRTUAL_P (new_binfo
) = 1;
1630 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1636 /* Hashing of lists so that we don't make duplicates.
1637 The entry point is `list_hash_canon'. */
1646 struct list_hasher
: ggc_hasher
<tree
>
1648 typedef list_proxy
*compare_type
;
1650 static hashval_t
hash (tree
);
1651 static bool equal (tree
, list_proxy
*);
1654 /* Now here is the hash table. When recording a list, it is added
1655 to the slot whose index is the hash code mod the table size.
1656 Note that the hash table is used for several kinds of lists.
1657 While all these live in the same table, they are completely independent,
1658 and the hash code is computed differently for each of these. */
1660 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1662 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1663 for a node we are thinking about adding). */
1666 list_hasher::equal (tree t
, list_proxy
*proxy
)
1668 return (TREE_VALUE (t
) == proxy
->value
1669 && TREE_PURPOSE (t
) == proxy
->purpose
1670 && TREE_CHAIN (t
) == proxy
->chain
);
1673 /* Compute a hash code for a list (chain of TREE_LIST nodes
1674 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1675 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1678 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1680 hashval_t hashcode
= 0;
1683 hashcode
+= TREE_HASH (chain
);
1686 hashcode
+= TREE_HASH (value
);
1690 hashcode
+= TREE_HASH (purpose
);
1696 /* Hash an already existing TREE_LIST. */
1699 list_hasher::hash (tree t
)
1701 return list_hash_pieces (TREE_PURPOSE (t
),
1706 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1707 object for an identical list if one already exists. Otherwise, build a
1708 new one, and record it as the canonical object. */
1711 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1715 struct list_proxy proxy
;
1717 /* Hash the list node. */
1718 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1719 /* Create a proxy for the TREE_LIST we would like to create. We
1720 don't actually create it so as to avoid creating garbage. */
1721 proxy
.purpose
= purpose
;
1722 proxy
.value
= value
;
1723 proxy
.chain
= chain
;
1724 /* See if it is already in the table. */
1725 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
1726 /* If not, create a new node. */
1728 *slot
= tree_cons (purpose
, value
, chain
);
1729 return (tree
) *slot
;
1732 /* Constructor for hashed lists. */
1735 hash_tree_chain (tree value
, tree chain
)
1737 return hash_tree_cons (NULL_TREE
, value
, chain
);
1741 debug_binfo (tree elem
)
1746 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1748 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1749 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1750 debug_tree (BINFO_TYPE (elem
));
1751 if (BINFO_VTABLE (elem
))
1752 fprintf (stderr
, "vtable decl \"%s\"\n",
1753 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
1755 fprintf (stderr
, "no vtable decl yet\n");
1756 fprintf (stderr
, "virtuals:\n");
1757 virtuals
= BINFO_VIRTUALS (elem
);
1762 tree fndecl
= TREE_VALUE (virtuals
);
1763 fprintf (stderr
, "%s [%ld =? %ld]\n",
1764 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1765 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1767 virtuals
= TREE_CHAIN (virtuals
);
1771 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1772 the type of the result expression, if known, or NULL_TREE if the
1773 resulting expression is type-dependent. If TEMPLATE_P is true,
1774 NAME is known to be a template because the user explicitly used the
1775 "template" keyword after the "::".
1777 All SCOPE_REFs should be built by use of this function. */
1780 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
1783 if (type
== error_mark_node
1784 || scope
== error_mark_node
1785 || name
== error_mark_node
)
1786 return error_mark_node
;
1787 t
= build2 (SCOPE_REF
, type
, scope
, name
);
1788 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
1789 PTRMEM_OK_P (t
) = true;
1791 t
= convert_from_reference (t
);
1795 /* Like check_qualified_type, but also check ref-qualifier and exception
1799 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
1800 cp_ref_qualifier rqual
, tree raises
)
1802 return (check_qualified_type (cand
, base
, type_quals
)
1803 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
1805 && type_memfn_rqual (cand
) == rqual
);
1808 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
1811 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
1815 if (rqual
== type_memfn_rqual (type
))
1818 int type_quals
= TYPE_QUALS (type
);
1819 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
1820 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1821 if (cp_check_qualified_type (t
, type
, type_quals
, rqual
, raises
))
1824 t
= build_variant_type_copy (type
);
1827 case REF_QUAL_RVALUE
:
1828 FUNCTION_RVALUE_QUALIFIED (t
) = 1;
1829 FUNCTION_REF_QUALIFIED (t
) = 1;
1831 case REF_QUAL_LVALUE
:
1832 FUNCTION_RVALUE_QUALIFIED (t
) = 0;
1833 FUNCTION_REF_QUALIFIED (t
) = 1;
1836 FUNCTION_REF_QUALIFIED (t
) = 0;
1840 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
1841 /* Propagate structural equality. */
1842 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1843 else if (TYPE_CANONICAL (type
) != type
)
1844 /* Build the underlying canonical type, since it is different
1846 TYPE_CANONICAL (t
) = build_ref_qualified_type (TYPE_CANONICAL (type
),
1849 /* T is its own canonical type. */
1850 TYPE_CANONICAL (t
) = t
;
1855 /* Returns nonzero if X is an expression for a (possibly overloaded)
1856 function. If "f" is a function or function template, "f", "c->f",
1857 "c.f", "C::f", and "f<int>" will all be considered possibly
1858 overloaded functions. Returns 2 if the function is actually
1859 overloaded, i.e., if it is impossible to know the type of the
1860 function without performing overload resolution. */
1863 is_overloaded_fn (tree x
)
1865 /* A baselink is also considered an overloaded function. */
1866 if (TREE_CODE (x
) == OFFSET_REF
1867 || TREE_CODE (x
) == COMPONENT_REF
)
1868 x
= TREE_OPERAND (x
, 1);
1870 x
= BASELINK_FUNCTIONS (x
);
1871 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1872 x
= TREE_OPERAND (x
, 0);
1873 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x
))
1874 || (TREE_CODE (x
) == OVERLOAD
&& OVL_CHAIN (x
)))
1876 return (TREE_CODE (x
) == FUNCTION_DECL
1877 || TREE_CODE (x
) == OVERLOAD
);
1880 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
1881 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
1885 dependent_name (tree x
)
1887 if (identifier_p (x
))
1889 if (TREE_CODE (x
) != COMPONENT_REF
1890 && TREE_CODE (x
) != OFFSET_REF
1891 && TREE_CODE (x
) != BASELINK
1892 && is_overloaded_fn (x
))
1893 return DECL_NAME (get_first_fn (x
));
1897 /* Returns true iff X is an expression for an overloaded function
1898 whose type cannot be known without performing overload
1902 really_overloaded_fn (tree x
)
1904 return is_overloaded_fn (x
) == 2;
1910 gcc_assert (is_overloaded_fn (from
));
1911 /* A baselink is also considered an overloaded function. */
1912 if (TREE_CODE (from
) == OFFSET_REF
1913 || TREE_CODE (from
) == COMPONENT_REF
)
1914 from
= TREE_OPERAND (from
, 1);
1915 if (BASELINK_P (from
))
1916 from
= BASELINK_FUNCTIONS (from
);
1917 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
1918 from
= TREE_OPERAND (from
, 0);
1923 get_first_fn (tree from
)
1925 return OVL_CURRENT (get_fns (from
));
1928 /* Return a new OVL node, concatenating it with the old one. */
1931 ovl_cons (tree decl
, tree chain
)
1933 tree result
= make_node (OVERLOAD
);
1934 TREE_TYPE (result
) = unknown_type_node
;
1935 OVL_FUNCTION (result
) = decl
;
1936 TREE_CHAIN (result
) = chain
;
1941 /* Build a new overloaded function. If this is the first one,
1942 just return it; otherwise, ovl_cons the _DECLs */
1945 build_overload (tree decl
, tree chain
)
1947 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1949 return ovl_cons (decl
, chain
);
1952 /* Return the scope where the overloaded functions OVL were found. */
1955 ovl_scope (tree ovl
)
1957 if (TREE_CODE (ovl
) == OFFSET_REF
1958 || TREE_CODE (ovl
) == COMPONENT_REF
)
1959 ovl
= TREE_OPERAND (ovl
, 1);
1960 if (TREE_CODE (ovl
) == BASELINK
)
1961 return BINFO_TYPE (BASELINK_BINFO (ovl
));
1962 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
1963 ovl
= TREE_OPERAND (ovl
, 0);
1964 /* Skip using-declarations. */
1965 while (TREE_CODE (ovl
) == OVERLOAD
&& OVL_USED (ovl
) && OVL_CHAIN (ovl
))
1966 ovl
= OVL_CHAIN (ovl
);
1967 return CP_DECL_CONTEXT (OVL_CURRENT (ovl
));
1970 /* Return TRUE if FN is a non-static member function, FALSE otherwise.
1971 This function looks into BASELINK and OVERLOAD nodes. */
1974 non_static_member_function_p (tree fn
)
1976 if (fn
== NULL_TREE
)
1979 if (is_overloaded_fn (fn
))
1980 fn
= get_first_fn (fn
);
1983 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
));
1987 #define PRINT_RING_SIZE 4
1990 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
1992 static unsigned int uid_ring
[PRINT_RING_SIZE
];
1993 static char *print_ring
[PRINT_RING_SIZE
];
1994 static bool trans_ring
[PRINT_RING_SIZE
];
1995 static int ring_counter
;
1998 /* Only cache functions. */
2000 || TREE_CODE (decl
) != FUNCTION_DECL
2001 || DECL_LANG_SPECIFIC (decl
) == 0)
2002 return lang_decl_name (decl
, v
, translate
);
2004 /* See if this print name is lying around. */
2005 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2006 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2007 /* yes, so return it. */
2008 return print_ring
[i
];
2010 if (++ring_counter
== PRINT_RING_SIZE
)
2013 if (current_function_decl
!= NULL_TREE
)
2015 /* There may be both translated and untranslated versions of the
2017 for (i
= 0; i
< 2; i
++)
2019 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2021 if (ring_counter
== PRINT_RING_SIZE
)
2024 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2027 free (print_ring
[ring_counter
]);
2029 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2030 uid_ring
[ring_counter
] = DECL_UID (decl
);
2031 trans_ring
[ring_counter
] = translate
;
2032 return print_ring
[ring_counter
];
2036 cxx_printable_name (tree decl
, int v
)
2038 return cxx_printable_name_internal (decl
, v
, false);
2042 cxx_printable_name_translate (tree decl
, int v
)
2044 return cxx_printable_name_internal (decl
, v
, true);
2047 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2048 listed in RAISES. */
2051 build_exception_variant (tree type
, tree raises
)
2056 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
2059 type_quals
= TYPE_QUALS (type
);
2060 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2061 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
2062 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
))
2065 /* Need to build a new variant. */
2066 v
= build_variant_type_copy (type
);
2067 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2071 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2072 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2076 bind_template_template_parm (tree t
, tree newargs
)
2078 tree decl
= TYPE_NAME (t
);
2081 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2082 decl
= build_decl (input_location
,
2083 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2085 /* These nodes have to be created to reflect new TYPE_DECL and template
2087 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2088 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2089 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2090 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2092 TREE_TYPE (decl
) = t2
;
2093 TYPE_NAME (t2
) = decl
;
2094 TYPE_STUB_DECL (t2
) = decl
;
2096 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2101 /* Called from count_trees via walk_tree. */
2104 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2114 /* Debugging function for measuring the rough complexity of a tree
2118 count_trees (tree t
)
2121 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2125 /* Called from verify_stmt_tree via walk_tree. */
2128 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2131 hash_table
<pointer_hash
<tree_node
> > *statements
2132 = static_cast <hash_table
<pointer_hash
<tree_node
> > *> (data
);
2135 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2138 /* If this statement is already present in the hash table, then
2139 there is a circularity in the statement tree. */
2140 gcc_assert (!statements
->find (t
));
2142 slot
= statements
->find_slot (t
, INSERT
);
2148 /* Debugging function to check that the statement T has not been
2149 corrupted. For now, this function simply checks that T contains no
2153 verify_stmt_tree (tree t
)
2155 hash_table
<pointer_hash
<tree_node
> > statements (37);
2156 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2159 /* Check if the type T depends on a type with no linkage and if so, return
2160 it. If RELAXED_P then do not consider a class type declared within
2161 a vague-linkage function to have no linkage. */
2164 no_linkage_check (tree t
, bool relaxed_p
)
2168 /* There's no point in checking linkage on template functions; we
2169 can't know their complete types. */
2170 if (processing_template_decl
)
2173 switch (TREE_CODE (t
))
2176 if (TYPE_PTRMEMFUNC_P (t
))
2178 /* Lambda types that don't have mangling scope have no linkage. We
2179 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2180 when we get here from pushtag none of the lambda information is
2181 set up yet, so we want to assume that the lambda has linkage and
2182 fix it up later if not. */
2183 if (CLASSTYPE_LAMBDA_EXPR (t
)
2184 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2185 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2189 if (!CLASS_TYPE_P (t
))
2193 /* Only treat anonymous types as having no linkage if they're at
2194 namespace scope. This is core issue 966. */
2195 if (TYPE_ANONYMOUS_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2198 for (r
= CP_TYPE_CONTEXT (t
); ; )
2200 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2201 have linkage, or we might just be in an anonymous namespace.
2202 If we're in a TREE_PUBLIC class, we have linkage. */
2203 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2204 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2205 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2207 if (!relaxed_p
|| !vague_linkage_p (r
))
2210 r
= CP_DECL_CONTEXT (r
);
2220 case REFERENCE_TYPE
:
2222 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2226 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2230 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2233 r
= no_linkage_check (TYPE_METHOD_BASETYPE (t
), relaxed_p
);
2240 for (parm
= TYPE_ARG_TYPES (t
);
2241 parm
&& parm
!= void_list_node
;
2242 parm
= TREE_CHAIN (parm
))
2244 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2248 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2256 extern int depth_reached
;
2259 cxx_print_statistics (void)
2261 print_search_statistics ();
2262 print_class_statistics ();
2263 print_template_statistics ();
2264 if (GATHER_STATISTICS
)
2265 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2269 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2270 (which is an ARRAY_TYPE). This counts only elements of the top
2274 array_type_nelts_top (tree type
)
2276 return fold_build2_loc (input_location
,
2277 PLUS_EXPR
, sizetype
,
2278 array_type_nelts (type
),
2282 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2283 (which is an ARRAY_TYPE). This one is a recursive count of all
2284 ARRAY_TYPEs that are clumped together. */
2287 array_type_nelts_total (tree type
)
2289 tree sz
= array_type_nelts_top (type
);
2290 type
= TREE_TYPE (type
);
2291 while (TREE_CODE (type
) == ARRAY_TYPE
)
2293 tree n
= array_type_nelts_top (type
);
2294 sz
= fold_build2_loc (input_location
,
2295 MULT_EXPR
, sizetype
, sz
, n
);
2296 type
= TREE_TYPE (type
);
2301 /* Called from break_out_target_exprs via mapcar. */
2304 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
2306 splay_tree target_remap
= ((splay_tree
) data
);
2309 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2311 /* There can't be any TARGET_EXPRs or their slot variables below this
2312 point. But we must make a copy, in case subsequent processing
2313 alters any part of it. For example, during gimplification a cast
2314 of the form (T) &X::f (where "f" is a member function) will lead
2315 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2317 *tp
= unshare_expr (t
);
2320 if (TREE_CODE (t
) == TARGET_EXPR
)
2324 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2326 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2327 tf_warning_or_error
);
2328 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2329 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2332 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2333 tf_warning_or_error
);
2335 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2336 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2337 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2339 /* Map the old variable to the new one. */
2340 splay_tree_insert (target_remap
,
2341 (splay_tree_key
) TREE_OPERAND (t
, 0),
2342 (splay_tree_value
) TREE_OPERAND (u
, 0));
2344 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
2346 /* Replace the old expression with the new version. */
2348 /* We don't have to go below this point; the recursive call to
2349 break_out_target_exprs will have handled anything below this
2355 /* Make a copy of this node. */
2356 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2357 if (TREE_CODE (*tp
) == CALL_EXPR
)
2359 set_flags_from_callee (*tp
);
2361 /* builtin_LINE and builtin_FILE get the location where the default
2362 argument is expanded, not where the call was written. */
2363 tree callee
= get_callee_fndecl (*tp
);
2364 if (callee
&& DECL_BUILT_IN (callee
))
2365 switch (DECL_FUNCTION_CODE (callee
))
2369 SET_EXPR_LOCATION (*tp
, input_location
);
2377 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2378 DATA is really a splay-tree mapping old variables to new
2382 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data
)
2384 splay_tree target_remap
= ((splay_tree
) data
);
2388 splay_tree_node n
= splay_tree_lookup (target_remap
,
2389 (splay_tree_key
) *t
);
2391 *t
= (tree
) n
->value
;
2393 else if (TREE_CODE (*t
) == PARM_DECL
2394 && DECL_NAME (*t
) == this_identifier
2395 && !DECL_CONTEXT (*t
))
2397 /* In an NSDMI we need to replace the 'this' parameter we used for
2398 parsing with the real one for this function. */
2399 *t
= current_class_ptr
;
2401 else if (TREE_CODE (*t
) == CONVERT_EXPR
2402 && CONVERT_EXPR_VBASE_PATH (*t
))
2404 /* In an NSDMI build_base_path defers building conversions to virtual
2405 bases, and we handle it here. */
2406 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2407 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2409 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2410 if (BINFO_TYPE (binfo
) == basetype
)
2412 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2413 tf_warning_or_error
);
2419 /* When we parse a default argument expression, we may create
2420 temporary variables via TARGET_EXPRs. When we actually use the
2421 default-argument expression, we make a copy of the expression
2422 and replace the temporaries with appropriate local versions. */
2425 break_out_target_exprs (tree t
)
2427 static int target_remap_count
;
2428 static splay_tree target_remap
;
2430 if (!target_remap_count
++)
2431 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
2432 /*splay_tree_delete_key_fn=*/NULL
,
2433 /*splay_tree_delete_value_fn=*/NULL
);
2434 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
2435 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
2437 if (!--target_remap_count
)
2439 splay_tree_delete (target_remap
);
2440 target_remap
= NULL
;
2446 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
2447 which we expect to have type TYPE. */
2450 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
2452 if (index
== NULL_TREE
)
2453 /* Can't refer to a particular member of a vector. */
2455 else if (TREE_CODE (index
) == INTEGER_CST
)
2456 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
2458 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
2459 /*reference*/false, tf_none
);
2461 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
,
2466 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
2467 build up subexpressions as we go deeper. */
2469 struct replace_placeholders_t
2472 hash_set
<tree
> *pset
;
2476 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
2478 tree obj
= static_cast<tree
>(data_
);
2480 if (TREE_CONSTANT (*t
))
2482 *walk_subtrees
= false;
2486 switch (TREE_CODE (*t
))
2488 case PLACEHOLDER_EXPR
:
2489 gcc_assert (same_type_ignoring_top_level_qualifiers_p
2490 (TREE_TYPE (*t
), TREE_TYPE (obj
)));
2492 *walk_subtrees
= false;
2496 /* Don't mess with placeholders in an unrelated object. */
2497 *walk_subtrees
= false;
2502 constructor_elt
*ce
;
2503 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
2504 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2506 tree
*valp
= &ce
->value
;
2507 tree type
= TREE_TYPE (*valp
);
2510 if (TREE_CODE (*valp
) == CONSTRUCTOR
2511 && AGGREGATE_TYPE_P (type
))
2513 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
2514 if (TREE_CODE (*valp
) == TARGET_EXPR
)
2515 valp
= &TARGET_EXPR_INITIAL (*valp
);
2518 cp_walk_tree (valp
, replace_placeholders_r
,
2521 *walk_subtrees
= false;
2533 replace_placeholders (tree exp
, tree obj
)
2535 hash_set
<tree
> pset
;
2537 if (TREE_CODE (exp
) == TARGET_EXPR
)
2538 tp
= &TARGET_EXPR_INITIAL (exp
);
2539 cp_walk_tree (tp
, replace_placeholders_r
, obj
, NULL
);
2543 /* Similar to `build_nt', but for template definitions of dependent
2547 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
2554 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2558 t
= make_node (code
);
2559 SET_EXPR_LOCATION (t
, loc
);
2560 length
= TREE_CODE_LENGTH (code
);
2562 for (i
= 0; i
< length
; i
++)
2564 tree x
= va_arg (p
, tree
);
2565 TREE_OPERAND (t
, i
) = x
;
2573 /* Similar to `build', but for template definitions. */
2576 build_min (enum tree_code code
, tree tt
, ...)
2583 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2587 t
= make_node (code
);
2588 length
= TREE_CODE_LENGTH (code
);
2591 for (i
= 0; i
< length
; i
++)
2593 tree x
= va_arg (p
, tree
);
2594 TREE_OPERAND (t
, i
) = x
;
2595 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
2596 TREE_SIDE_EFFECTS (t
) = 1;
2603 /* Similar to `build', but for template definitions of non-dependent
2604 expressions. NON_DEP is the non-dependent expression that has been
2608 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
2615 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2617 va_start (p
, non_dep
);
2619 if (REFERENCE_REF_P (non_dep
))
2620 non_dep
= TREE_OPERAND (non_dep
, 0);
2622 t
= make_node (code
);
2623 length
= TREE_CODE_LENGTH (code
);
2624 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2625 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2627 for (i
= 0; i
< length
; i
++)
2629 tree x
= va_arg (p
, tree
);
2630 TREE_OPERAND (t
, i
) = x
;
2633 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
2634 /* This should not be considered a COMPOUND_EXPR, because it
2635 resolves to an overload. */
2636 COMPOUND_EXPR_OVERLOADED (t
) = 1;
2639 return convert_from_reference (t
);
2642 /* Similar to `build_nt_call_vec', but for template definitions of
2643 non-dependent expressions. NON_DEP is the non-dependent expression
2644 that has been built. */
2647 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
2649 tree t
= build_nt_call_vec (fn
, argvec
);
2650 if (REFERENCE_REF_P (non_dep
))
2651 non_dep
= TREE_OPERAND (non_dep
, 0);
2652 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2653 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2654 return convert_from_reference (t
);
2658 get_type_decl (tree t
)
2660 if (TREE_CODE (t
) == TYPE_DECL
)
2663 return TYPE_STUB_DECL (t
);
2664 gcc_assert (t
== error_mark_node
);
2668 /* Returns the namespace that contains DECL, whether directly or
2672 decl_namespace_context (tree decl
)
2676 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2678 else if (TYPE_P (decl
))
2679 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
2681 decl
= CP_DECL_CONTEXT (decl
);
2685 /* Returns true if decl is within an anonymous namespace, however deeply
2686 nested, or false otherwise. */
2689 decl_anon_ns_mem_p (const_tree decl
)
2693 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
2695 if (TREE_CODE (decl
) == NAMESPACE_DECL
2696 && DECL_NAME (decl
) == NULL_TREE
)
2698 /* Classes and namespaces inside anonymous namespaces have
2699 TREE_PUBLIC == 0, so we can shortcut the search. */
2700 else if (TYPE_P (decl
))
2701 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl
)) == 0);
2702 else if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2703 return (TREE_PUBLIC (decl
) == 0);
2705 decl
= DECL_CONTEXT (decl
);
2709 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2710 CALL_EXPRS. Return whether they are equivalent. */
2713 called_fns_equal (tree t1
, tree t2
)
2715 /* Core 1321: dependent names are equivalent even if the overload sets
2716 are different. But do compare explicit template arguments. */
2717 tree name1
= dependent_name (t1
);
2718 tree name2
= dependent_name (t2
);
2721 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
2726 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
2727 targs1
= TREE_OPERAND (t1
, 1);
2728 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
2729 targs2
= TREE_OPERAND (t2
, 1);
2730 return cp_tree_equal (targs1
, targs2
);
2733 return cp_tree_equal (t1
, t2
);
2736 /* Return truthvalue of whether T1 is the same tree structure as T2.
2737 Return 1 if they are the same. Return 0 if they are different. */
2740 cp_tree_equal (tree t1
, tree t2
)
2742 enum tree_code code1
, code2
;
2749 for (code1
= TREE_CODE (t1
);
2750 CONVERT_EXPR_CODE_P (code1
)
2751 || code1
== NON_LVALUE_EXPR
;
2752 code1
= TREE_CODE (t1
))
2753 t1
= TREE_OPERAND (t1
, 0);
2754 for (code2
= TREE_CODE (t2
);
2755 CONVERT_EXPR_CODE_P (code2
)
2756 || code2
== NON_LVALUE_EXPR
;
2757 code2
= TREE_CODE (t2
))
2758 t2
= TREE_OPERAND (t2
, 0);
2760 /* They might have become equal now. */
2770 /* There's only a single VOID_CST node, so we should never reach
2775 return tree_int_cst_equal (t1
, t2
);
2778 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2781 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2782 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2783 TREE_STRING_LENGTH (t1
));
2786 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
2787 TREE_FIXED_CST (t2
));
2790 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
2791 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
2794 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
2797 /* We need to do this when determining whether or not two
2798 non-type pointer to member function template arguments
2800 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2801 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
2806 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
2808 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
2809 if (!cp_tree_equal (field
, elt2
->index
)
2810 || !cp_tree_equal (value
, elt2
->value
))
2817 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
2819 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
2821 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
2824 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2829 call_expr_arg_iterator iter1
, iter2
;
2830 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
2832 for (arg1
= first_call_expr_arg (t1
, &iter1
),
2833 arg2
= first_call_expr_arg (t2
, &iter2
);
2835 arg1
= next_call_expr_arg (&iter1
),
2836 arg2
= next_call_expr_arg (&iter2
))
2837 if (!cp_tree_equal (arg1
, arg2
))
2846 tree o1
= TREE_OPERAND (t1
, 0);
2847 tree o2
= TREE_OPERAND (t2
, 0);
2849 /* Special case: if either target is an unallocated VAR_DECL,
2850 it means that it's going to be unified with whatever the
2851 TARGET_EXPR is really supposed to initialize, so treat it
2852 as being equivalent to anything. */
2853 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
2854 && !DECL_RTL_SET_P (o1
))
2856 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
2857 && !DECL_RTL_SET_P (o2
))
2859 else if (!cp_tree_equal (o1
, o2
))
2862 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2865 case WITH_CLEANUP_EXPR
:
2866 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
2868 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
2871 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
2873 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2876 /* For comparing uses of parameters in late-specified return types
2877 with an out-of-class definition of the function, but can also come
2878 up for expressions that involve 'this' in a member function
2881 if (comparing_specializations
)
2882 /* When comparing hash table entries, only an exact match is
2883 good enough; we don't want to replace 'this' with the
2884 version from another function. */
2887 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
2889 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
2891 if (DECL_ARTIFICIAL (t1
)
2892 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
2893 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
2903 case IDENTIFIER_NODE
:
2908 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
2909 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
2910 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
2911 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
2912 BASELINK_FUNCTIONS (t2
)));
2914 case TEMPLATE_PARM_INDEX
:
2915 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2916 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
2917 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
2918 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
2919 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
2920 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
2922 case TEMPLATE_ID_EXPR
:
2923 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
2924 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
2929 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2931 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
2932 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
2933 TREE_VEC_ELT (t2
, ix
)))
2941 tree o1
= TREE_OPERAND (t1
, 0);
2942 tree o2
= TREE_OPERAND (t2
, 0);
2944 if (code1
== SIZEOF_EXPR
)
2946 if (SIZEOF_EXPR_TYPE_P (t1
))
2947 o1
= TREE_TYPE (o1
);
2948 if (SIZEOF_EXPR_TYPE_P (t2
))
2949 o2
= TREE_TYPE (o2
);
2951 if (TREE_CODE (o1
) != TREE_CODE (o2
))
2954 return same_type_p (o1
, o2
);
2956 return cp_tree_equal (o1
, o2
);
2961 tree t1_op1
, t2_op1
;
2963 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
2966 t1_op1
= TREE_OPERAND (t1
, 1);
2967 t2_op1
= TREE_OPERAND (t2
, 1);
2968 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
2971 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
2975 /* Two pointer-to-members are the same if they point to the same
2976 field or function in the same class. */
2977 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
2980 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
2983 if (OVL_FUNCTION (t1
) != OVL_FUNCTION (t2
))
2985 return cp_tree_equal (OVL_CHAIN (t1
), OVL_CHAIN (t2
));
2988 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
2990 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
2991 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
2994 case STATIC_CAST_EXPR
:
2995 case REINTERPRET_CAST_EXPR
:
2996 case CONST_CAST_EXPR
:
2997 case DYNAMIC_CAST_EXPR
:
2998 case IMPLICIT_CONV_EXPR
:
3000 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3002 /* Now compare operands as usual. */
3005 case DEFERRED_NOEXCEPT
:
3006 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3007 DEFERRED_NOEXCEPT_PATTERN (t2
))
3008 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3009 DEFERRED_NOEXCEPT_ARGS (t2
)));
3016 switch (TREE_CODE_CLASS (code1
))
3020 case tcc_comparison
:
3021 case tcc_expression
:
3028 n
= cp_tree_operand_length (t1
);
3029 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3030 && n
!= TREE_OPERAND_LENGTH (t2
))
3033 for (i
= 0; i
< n
; ++i
)
3034 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3041 return same_type_p (t1
, t2
);
3045 /* We can get here with --disable-checking. */
3049 /* The type of ARG when used as an lvalue. */
3052 lvalue_type (tree arg
)
3054 tree type
= TREE_TYPE (arg
);
3058 /* The type of ARG for printing error messages; denote lvalues with
3062 error_type (tree arg
)
3064 tree type
= TREE_TYPE (arg
);
3066 if (TREE_CODE (type
) == ARRAY_TYPE
)
3068 else if (TREE_CODE (type
) == ERROR_MARK
)
3070 else if (real_lvalue_p (arg
))
3071 type
= build_reference_type (lvalue_type (arg
));
3072 else if (MAYBE_CLASS_TYPE_P (type
))
3073 type
= lvalue_type (arg
);
3078 /* Does FUNCTION use a variable-length argument list? */
3081 varargs_function_p (const_tree function
)
3083 return stdarg_p (TREE_TYPE (function
));
3086 /* Returns 1 if decl is a member of a class. */
3089 member_p (const_tree decl
)
3091 const_tree
const ctx
= DECL_CONTEXT (decl
);
3092 return (ctx
&& TYPE_P (ctx
));
3095 /* Create a placeholder for member access where we don't actually have an
3096 object that the access is against. */
3099 build_dummy_object (tree type
)
3101 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3102 return cp_build_indirect_ref (decl
, RO_NULL
, tf_warning_or_error
);
3105 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3106 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3107 binfo path from current_class_type to TYPE, or 0. */
3110 maybe_dummy_object (tree type
, tree
* binfop
)
3114 tree current
= current_nonlambda_class_type ();
3117 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3118 tf_warning_or_error
)))
3122 /* Reference from a nested class member function. */
3124 binfo
= TYPE_BINFO (type
);
3130 if (current_class_ref
3131 /* current_class_ref might not correspond to current_class_type if
3132 we're in tsubst_default_argument or a lambda-declarator; in either
3133 case, we want to use current_class_ref if it matches CONTEXT. */
3134 && (same_type_ignoring_top_level_qualifiers_p
3135 (TREE_TYPE (current_class_ref
), context
)))
3136 decl
= current_class_ref
;
3138 decl
= build_dummy_object (context
);
3143 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3146 is_dummy_object (const_tree ob
)
3148 if (INDIRECT_REF_P (ob
))
3149 ob
= TREE_OPERAND (ob
, 0);
3150 return (TREE_CODE (ob
) == CONVERT_EXPR
3151 && TREE_OPERAND (ob
, 0) == void_node
);
3154 /* Returns 1 iff type T is something we want to treat as a scalar type for
3155 the purpose of deciding whether it is trivial/POD/standard-layout. */
3158 scalarish_type_p (const_tree t
)
3160 if (t
== error_mark_node
)
3163 return (SCALAR_TYPE_P (t
)
3164 || TREE_CODE (t
) == VECTOR_TYPE
);
3167 /* Returns true iff T requires non-trivial default initialization. */
3170 type_has_nontrivial_default_init (const_tree t
)
3172 t
= strip_array_types (CONST_CAST_TREE (t
));
3174 if (CLASS_TYPE_P (t
))
3175 return TYPE_HAS_COMPLEX_DFLT (t
);
3180 /* Returns true iff copying an object of type T (including via move
3181 constructor) is non-trivial. That is, T has no non-trivial copy
3182 constructors and no non-trivial move constructors. */
3185 type_has_nontrivial_copy_init (const_tree t
)
3187 t
= strip_array_types (CONST_CAST_TREE (t
));
3189 if (CLASS_TYPE_P (t
))
3191 gcc_assert (COMPLETE_TYPE_P (t
));
3192 return ((TYPE_HAS_COPY_CTOR (t
)
3193 && TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3194 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
));
3200 /* Returns 1 iff type T is a trivially copyable type, as defined in
3201 [basic.types] and [class]. */
3204 trivially_copyable_p (const_tree t
)
3206 t
= strip_array_types (CONST_CAST_TREE (t
));
3208 if (CLASS_TYPE_P (t
))
3209 return ((!TYPE_HAS_COPY_CTOR (t
)
3210 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3211 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
3212 && (!TYPE_HAS_COPY_ASSIGN (t
)
3213 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
3214 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
3215 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
3217 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
3220 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
3224 trivial_type_p (const_tree t
)
3226 t
= strip_array_types (CONST_CAST_TREE (t
));
3228 if (CLASS_TYPE_P (t
))
3229 return (TYPE_HAS_TRIVIAL_DFLT (t
)
3230 && trivially_copyable_p (t
));
3232 return scalarish_type_p (t
);
3235 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
3238 pod_type_p (const_tree t
)
3240 /* This CONST_CAST is okay because strip_array_types returns its
3241 argument unmodified and we assign it to a const_tree. */
3242 t
= strip_array_types (CONST_CAST_TREE(t
));
3244 if (!CLASS_TYPE_P (t
))
3245 return scalarish_type_p (t
);
3246 else if (cxx_dialect
> cxx98
)
3247 /* [class]/10: A POD struct is a class that is both a trivial class and a
3248 standard-layout class, and has no non-static data members of type
3249 non-POD struct, non-POD union (or array of such types).
3251 We don't need to check individual members because if a member is
3252 non-std-layout or non-trivial, the class will be too. */
3253 return (std_layout_type_p (t
) && trivial_type_p (t
));
3255 /* The C++98 definition of POD is different. */
3256 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3259 /* Returns true iff T is POD for the purpose of layout, as defined in the
3263 layout_pod_type_p (const_tree t
)
3265 t
= strip_array_types (CONST_CAST_TREE (t
));
3267 if (CLASS_TYPE_P (t
))
3268 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3270 return scalarish_type_p (t
);
3273 /* Returns true iff T is a standard-layout type, as defined in
3277 std_layout_type_p (const_tree t
)
3279 t
= strip_array_types (CONST_CAST_TREE (t
));
3281 if (CLASS_TYPE_P (t
))
3282 return !CLASSTYPE_NON_STD_LAYOUT (t
);
3284 return scalarish_type_p (t
);
3287 /* Nonzero iff type T is a class template implicit specialization. */
3290 class_tmpl_impl_spec_p (const_tree t
)
3292 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
3295 /* Returns 1 iff zero initialization of type T means actually storing
3299 zero_init_p (const_tree t
)
3301 /* This CONST_CAST is okay because strip_array_types returns its
3302 argument unmodified and we assign it to a const_tree. */
3303 t
= strip_array_types (CONST_CAST_TREE(t
));
3305 if (t
== error_mark_node
)
3308 /* NULL pointers to data members are initialized with -1. */
3309 if (TYPE_PTRDATAMEM_P (t
))
3312 /* Classes that contain types that can't be zero-initialized, cannot
3313 be zero-initialized themselves. */
3314 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
3320 /* Table of valid C++ attributes. */
3321 const struct attribute_spec cxx_attribute_table
[] =
3323 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, decl_handler,
3324 type_handler, affects_type_identity } */
3325 { "java_interface", 0, 0, false, false, false,
3326 handle_java_interface_decl_attribute
, handle_java_interface_type_attribute
,
3328 { "com_interface", 0, 0, false, false, false,
3329 handle_com_interface_decl_attribute
, handle_com_interface_type_attribute
,
3331 { "init_priority", 1, 1, true, false, false,
3332 handle_init_priority_attribute
, NULL
, false },
3333 { "abi_tag", 1, -1, false, false, false,
3334 handle_abi_tag_decl_attribute
, handle_abi_tag_type_attribute
, true },
3335 { NULL
, 0, 0, false, false, false, NULL
, NULL
, false }
3340 handle_java_interface_decl_attribute (tree
* /*node*/, tree name
, tree
/*args*/,
3341 int /*flags*/, bool* no_add_attrs
)
3343 error ("%qE attribute can only be applied to Java class definitions", name
);
3344 *no_add_attrs
= true;
3349 handle_com_interface_decl_attribute (tree
* /*node*/, tree name
, tree
/*args*/,
3350 int /*flags*/, bool* no_add_attrs
)
3352 warning (OPT_Wattributes
, "%qE attribute can only be applied "
3353 "to class definitions", name
);
3354 *no_add_attrs
= true;
3358 /* Handle a "java_interface" attribute; arguments as in
3359 struct attribute_spec.handler. */
3361 handle_java_interface_type_attribute (tree
* node
,
3367 if (!CLASS_TYPE_P (*node
) || !TYPE_FOR_JAVA (*node
))
3369 error ("%qE attribute can only be applied to Java class definitions",
3371 *no_add_attrs
= true;
3374 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
3375 *node
= build_variant_type_copy (*node
);
3376 TYPE_JAVA_INTERFACE (*node
) = 1;
3381 /* Handle a "com_interface" attribute; arguments as in
3382 struct attribute_spec.handler. */
3384 handle_com_interface_type_attribute (tree
* node
,
3392 *no_add_attrs
= true;
3394 if (!CLASS_TYPE_P (*node
) || *node
!= TYPE_MAIN_VARIANT (*node
))
3396 warning (OPT_Wattributes
, "%qE attribute can only be applied "
3397 "to class definitions", name
);
3402 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
3408 /* Handle an "init_priority" attribute; arguments as in
3409 struct attribute_spec.handler. */
3411 handle_init_priority_attribute (tree
* node
,
3417 tree initp_expr
= TREE_VALUE (args
);
3419 tree type
= TREE_TYPE (decl
);
3422 STRIP_NOPS (initp_expr
);
3423 initp_expr
= default_conversion (initp_expr
);
3425 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
3427 error ("requested init_priority is not an integer constant");
3428 *no_add_attrs
= true;
3432 pri
= TREE_INT_CST_LOW (initp_expr
);
3434 type
= strip_array_types (type
);
3436 if (decl
== NULL_TREE
3438 || !TREE_STATIC (decl
)
3439 || DECL_EXTERNAL (decl
)
3440 || (TREE_CODE (type
) != RECORD_TYPE
3441 && TREE_CODE (type
) != UNION_TYPE
)
3442 /* Static objects in functions are initialized the
3443 first time control passes through that
3444 function. This is not precise enough to pin down an
3445 init_priority value, so don't allow it. */
3446 || current_function_decl
)
3448 error ("can only use %qE attribute on file-scope definitions "
3449 "of objects of class type", name
);
3450 *no_add_attrs
= true;
3454 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
3456 error ("requested init_priority is out of range");
3457 *no_add_attrs
= true;
3461 /* Check for init_priorities that are reserved for
3462 language and runtime support implementations.*/
3463 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
3466 (0, "requested init_priority is reserved for internal use");
3469 if (SUPPORTS_INIT_PRIORITY
)
3471 SET_DECL_INIT_PRIORITY (decl
, pri
);
3472 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
3477 error ("%qE attribute is not supported on this platform", name
);
3478 *no_add_attrs
= true;
3483 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
3484 and the new one has the tags in NEW_. Give an error if there are tags
3485 in NEW_ that weren't in OLD. */
3488 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
3490 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
3491 old
= TREE_VALUE (old
);
3492 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
3493 new_
= TREE_VALUE (new_
);
3495 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
3497 tree str
= TREE_VALUE (t
);
3498 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
3500 tree ostr
= TREE_VALUE (in
);
3501 if (cp_tree_equal (str
, ostr
))
3504 error ("redeclaration of %qD adds abi tag %E", decl
, str
);
3510 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
3516 /* Handle an "abi_tag" attribute; arguments as in
3517 struct attribute_spec.handler. */
3520 handle_abi_tag_decl_attribute (tree
* node
, tree name
, tree
/*args*/,
3521 int /*flags*/, bool* no_add_attrs
)
3523 if (TREE_CODE (*node
) != FUNCTION_DECL
)
3525 error ("%qE attribute applied to non-function %qD", name
, *node
);
3526 *no_add_attrs
= true;
3528 else if (DECL_LANGUAGE (*node
) == lang_c
)
3530 error ("%qE attribute applied to extern \"C\" function %qD",
3532 *no_add_attrs
= true;
3540 handle_abi_tag_type_attribute (tree
* node
, tree name
, tree args
,
3541 int flags
, bool* no_add_attrs
)
3543 if (!OVERLOAD_TYPE_P (*node
))
3545 error ("%qE attribute applied to non-class, non-enum type %qT",
3547 *no_add_attrs
= true;
3549 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
3551 error ("%qE attribute applied to %qT after its definition",
3553 *no_add_attrs
= true;
3555 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
3557 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3558 "template instantiation %qT", name
, *node
);
3559 *no_add_attrs
= true;
3561 else if (CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
3563 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3564 "template specialization %qT", name
, *node
);
3565 *no_add_attrs
= true;
3569 tree attributes
= TYPE_ATTRIBUTES (*node
);
3570 tree decl
= TYPE_NAME (*node
);
3572 /* Make sure all declarations have the same abi tags. */
3573 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
3575 if (!check_abi_tag_redeclaration (decl
,
3576 lookup_attribute ("abi_tag",
3579 *no_add_attrs
= true;
3586 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
3587 thing pointed to by the constant. */
3590 make_ptrmem_cst (tree type
, tree member
)
3592 tree ptrmem_cst
= make_node (PTRMEM_CST
);
3593 TREE_TYPE (ptrmem_cst
) = type
;
3594 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
3598 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
3599 return an existing type if an appropriate type already exists. */
3602 cp_build_type_attribute_variant (tree type
, tree attributes
)
3606 new_type
= build_type_attribute_variant (type
, attributes
);
3607 if (TREE_CODE (new_type
) == FUNCTION_TYPE
3608 || TREE_CODE (new_type
) == METHOD_TYPE
)
3610 new_type
= build_exception_variant (new_type
,
3611 TYPE_RAISES_EXCEPTIONS (type
));
3612 new_type
= build_ref_qualified_type (new_type
,
3613 type_memfn_rqual (type
));
3616 /* Making a new main variant of a class type is broken. */
3617 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
3622 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3623 Called only after doing all language independent checks. Only
3624 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3625 compared in type_hash_eq. */
3628 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
3630 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
3631 || TREE_CODE (typea
) == METHOD_TYPE
);
3633 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
3634 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
3637 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3638 traversal. Called from walk_tree. */
3641 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
3642 void *data
, hash_set
<tree
> *pset
)
3644 enum tree_code code
= TREE_CODE (*tp
);
3647 #define WALK_SUBTREE(NODE) \
3650 result = cp_walk_tree (&(NODE), func, data, pset); \
3651 if (result) goto out; \
3655 /* Not one of the easy cases. We must explicitly go through the
3661 case TEMPLATE_TEMPLATE_PARM
:
3662 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3663 case UNBOUND_CLASS_TEMPLATE
:
3664 case TEMPLATE_PARM_INDEX
:
3665 case TEMPLATE_TYPE_PARM
:
3668 case UNDERLYING_TYPE
:
3669 /* None of these have subtrees other than those already walked
3671 *walk_subtrees_p
= 0;
3675 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
3676 *walk_subtrees_p
= 0;
3680 WALK_SUBTREE (TREE_TYPE (*tp
));
3681 *walk_subtrees_p
= 0;
3685 WALK_SUBTREE (TREE_PURPOSE (*tp
));
3689 WALK_SUBTREE (OVL_FUNCTION (*tp
));
3690 WALK_SUBTREE (OVL_CHAIN (*tp
));
3691 *walk_subtrees_p
= 0;
3695 WALK_SUBTREE (DECL_NAME (*tp
));
3696 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
3697 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
3698 *walk_subtrees_p
= 0;
3702 if (TYPE_PTRMEMFUNC_P (*tp
))
3703 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
3706 case TYPE_ARGUMENT_PACK
:
3707 case NONTYPE_ARGUMENT_PACK
:
3709 tree args
= ARGUMENT_PACK_ARGS (*tp
);
3710 int i
, len
= TREE_VEC_LENGTH (args
);
3711 for (i
= 0; i
< len
; i
++)
3712 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
3716 case TYPE_PACK_EXPANSION
:
3717 WALK_SUBTREE (TREE_TYPE (*tp
));
3718 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
3719 *walk_subtrees_p
= 0;
3722 case EXPR_PACK_EXPANSION
:
3723 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
3724 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
3725 *walk_subtrees_p
= 0;
3729 case REINTERPRET_CAST_EXPR
:
3730 case STATIC_CAST_EXPR
:
3731 case CONST_CAST_EXPR
:
3732 case DYNAMIC_CAST_EXPR
:
3733 case IMPLICIT_CONV_EXPR
:
3734 if (TREE_TYPE (*tp
))
3735 WALK_SUBTREE (TREE_TYPE (*tp
));
3739 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
3740 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3742 *walk_subtrees_p
= 0;
3746 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
3747 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
3748 *walk_subtrees_p
= 0;
3752 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
3753 *walk_subtrees_p
= 0;
3761 /* We didn't find what we were looking for. */
3768 /* Like save_expr, but for C++. */
3771 cp_save_expr (tree expr
)
3773 /* There is no reason to create a SAVE_EXPR within a template; if
3774 needed, we can create the SAVE_EXPR when instantiating the
3775 template. Furthermore, the middle-end cannot handle C++-specific
3777 if (processing_template_decl
)
3779 return save_expr (expr
);
3782 /* Initialize tree.c. */
3787 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
3790 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3791 is. Note that sfk_none is zero, so this function can be used as a
3792 predicate to test whether or not DECL is a special function. */
3794 special_function_kind
3795 special_function_p (const_tree decl
)
3797 /* Rather than doing all this stuff with magic names, we should
3798 probably have a field of type `special_function_kind' in
3799 DECL_LANG_SPECIFIC. */
3800 if (DECL_INHERITED_CTOR_BASE (decl
))
3801 return sfk_inheriting_constructor
;
3802 if (DECL_COPY_CONSTRUCTOR_P (decl
))
3803 return sfk_copy_constructor
;
3804 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
3805 return sfk_move_constructor
;
3806 if (DECL_CONSTRUCTOR_P (decl
))
3807 return sfk_constructor
;
3808 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
3810 if (copy_fn_p (decl
))
3811 return sfk_copy_assignment
;
3812 if (move_fn_p (decl
))
3813 return sfk_move_assignment
;
3815 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
3816 return sfk_destructor
;
3817 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
3818 return sfk_complete_destructor
;
3819 if (DECL_BASE_DESTRUCTOR_P (decl
))
3820 return sfk_base_destructor
;
3821 if (DECL_DELETING_DESTRUCTOR_P (decl
))
3822 return sfk_deleting_destructor
;
3823 if (DECL_CONV_FN_P (decl
))
3824 return sfk_conversion
;
3829 /* Returns nonzero if TYPE is a character type, including wchar_t. */
3832 char_type_p (tree type
)
3834 return (same_type_p (type
, char_type_node
)
3835 || same_type_p (type
, unsigned_char_type_node
)
3836 || same_type_p (type
, signed_char_type_node
)
3837 || same_type_p (type
, char16_type_node
)
3838 || same_type_p (type
, char32_type_node
)
3839 || same_type_p (type
, wchar_type_node
));
3842 /* Returns the kind of linkage associated with the indicated DECL. Th
3843 value returned is as specified by the language standard; it is
3844 independent of implementation details regarding template
3845 instantiation, etc. For example, it is possible that a declaration
3846 to which this function assigns external linkage would not show up
3847 as a global symbol when you run `nm' on the resulting object file. */
3850 decl_linkage (tree decl
)
3852 /* This function doesn't attempt to calculate the linkage from first
3853 principles as given in [basic.link]. Instead, it makes use of
3854 the fact that we have already set TREE_PUBLIC appropriately, and
3855 then handles a few special cases. Ideally, we would calculate
3856 linkage first, and then transform that into a concrete
3859 /* Things that don't have names have no linkage. */
3860 if (!DECL_NAME (decl
))
3863 /* Fields have no linkage. */
3864 if (TREE_CODE (decl
) == FIELD_DECL
)
3867 /* Things that are TREE_PUBLIC have external linkage. */
3868 if (TREE_PUBLIC (decl
))
3871 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3874 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3876 if (TREE_CODE (decl
) == CONST_DECL
)
3877 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
3879 /* Things in local scope do not have linkage, if they don't have
3881 if (decl_function_context (decl
))
3884 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3885 are considered to have external linkage for language purposes, as do
3886 template instantiations on targets without weak symbols. DECLs really
3887 meant to have internal linkage have DECL_THIS_STATIC set. */
3888 if (TREE_CODE (decl
) == TYPE_DECL
)
3890 if (VAR_OR_FUNCTION_DECL_P (decl
))
3892 if (!DECL_THIS_STATIC (decl
))
3895 /* Static data members and static member functions from classes
3896 in anonymous namespace also don't have TREE_PUBLIC set. */
3897 if (DECL_CLASS_CONTEXT (decl
))
3901 /* Everything else has internal linkage. */
3905 /* Returns the storage duration of the object or reference associated with
3906 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
3909 decl_storage_duration (tree decl
)
3911 if (TREE_CODE (decl
) == PARM_DECL
)
3913 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3915 gcc_assert (VAR_P (decl
));
3916 if (!TREE_STATIC (decl
)
3917 && !DECL_EXTERNAL (decl
))
3919 if (DECL_THREAD_LOCAL_P (decl
))
3924 /* EXP is an expression that we want to pre-evaluate. Returns (in
3925 *INITP) an expression that will perform the pre-evaluation. The
3926 value returned by this function is a side-effect free expression
3927 equivalent to the pre-evaluated expression. Callers must ensure
3928 that *INITP is evaluated before EXP. */
3931 stabilize_expr (tree exp
, tree
* initp
)
3935 if (!TREE_SIDE_EFFECTS (exp
))
3936 init_expr
= NULL_TREE
;
3937 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
3942 /* There are no expressions with REFERENCE_TYPE, but there can be call
3943 arguments with such a type; just treat it as a pointer. */
3944 else if (TREE_CODE (TREE_TYPE (exp
)) == REFERENCE_TYPE
3945 || SCALAR_TYPE_P (TREE_TYPE (exp
))
3946 || !lvalue_or_rvalue_with_address_p (exp
))
3948 init_expr
= get_target_expr (exp
);
3949 exp
= TARGET_EXPR_SLOT (init_expr
);
3950 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
3957 bool xval
= !real_lvalue_p (exp
);
3958 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
3959 init_expr
= get_target_expr (exp
);
3960 exp
= TARGET_EXPR_SLOT (init_expr
);
3961 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
3967 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
3971 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3972 similar expression ORIG. */
3975 add_stmt_to_compound (tree orig
, tree new_expr
)
3977 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
3979 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
3981 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
3984 /* Like stabilize_expr, but for a call whose arguments we want to
3985 pre-evaluate. CALL is modified in place to use the pre-evaluated
3986 arguments, while, upon return, *INITP contains an expression to
3987 compute the arguments. */
3990 stabilize_call (tree call
, tree
*initp
)
3992 tree inits
= NULL_TREE
;
3994 int nargs
= call_expr_nargs (call
);
3996 if (call
== error_mark_node
|| processing_template_decl
)
4002 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
4004 for (i
= 0; i
< nargs
; i
++)
4007 CALL_EXPR_ARG (call
, i
) =
4008 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
4009 inits
= add_stmt_to_compound (inits
, init
);
4015 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
4016 to pre-evaluate. CALL is modified in place to use the pre-evaluated
4017 arguments, while, upon return, *INITP contains an expression to
4018 compute the arguments. */
4021 stabilize_aggr_init (tree call
, tree
*initp
)
4023 tree inits
= NULL_TREE
;
4025 int nargs
= aggr_init_expr_nargs (call
);
4027 if (call
== error_mark_node
)
4030 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
4032 for (i
= 0; i
< nargs
; i
++)
4035 AGGR_INIT_EXPR_ARG (call
, i
) =
4036 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
4037 inits
= add_stmt_to_compound (inits
, init
);
4043 /* Like stabilize_expr, but for an initialization.
4045 If the initialization is for an object of class type, this function
4046 takes care not to introduce additional temporaries.
4048 Returns TRUE iff the expression was successfully pre-evaluated,
4049 i.e., if INIT is now side-effect free, except for, possibly, a
4050 single call to a constructor. */
4053 stabilize_init (tree init
, tree
*initp
)
4059 if (t
== error_mark_node
|| processing_template_decl
)
4062 if (TREE_CODE (t
) == INIT_EXPR
)
4063 t
= TREE_OPERAND (t
, 1);
4064 if (TREE_CODE (t
) == TARGET_EXPR
)
4065 t
= TARGET_EXPR_INITIAL (t
);
4067 /* If the RHS can be stabilized without breaking copy elision, stabilize
4068 it. We specifically don't stabilize class prvalues here because that
4069 would mean an extra copy, but they might be stabilized below. */
4070 if (TREE_CODE (init
) == INIT_EXPR
4071 && TREE_CODE (t
) != CONSTRUCTOR
4072 && TREE_CODE (t
) != AGGR_INIT_EXPR
4073 && (SCALAR_TYPE_P (TREE_TYPE (t
))
4074 || lvalue_or_rvalue_with_address_p (t
)))
4076 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
4080 if (TREE_CODE (t
) == COMPOUND_EXPR
4081 && TREE_CODE (init
) == INIT_EXPR
)
4083 tree last
= expr_last (t
);
4084 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
4085 if (!TREE_SIDE_EFFECTS (last
))
4088 TREE_OPERAND (init
, 1) = last
;
4093 if (TREE_CODE (t
) == CONSTRUCTOR
)
4095 /* Aggregate initialization: stabilize each of the field
4098 constructor_elt
*ce
;
4100 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4101 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4103 tree type
= TREE_TYPE (ce
->value
);
4105 if (TREE_CODE (type
) == REFERENCE_TYPE
4106 || SCALAR_TYPE_P (type
))
4107 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
4108 else if (!stabilize_init (ce
->value
, &subinit
))
4110 *initp
= add_stmt_to_compound (*initp
, subinit
);
4115 if (TREE_CODE (t
) == CALL_EXPR
)
4117 stabilize_call (t
, initp
);
4121 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4123 stabilize_aggr_init (t
, initp
);
4127 /* The initialization is being performed via a bitwise copy -- and
4128 the item copied may have side effects. */
4129 return !TREE_SIDE_EFFECTS (init
);
4132 /* Like "fold", but should be used whenever we might be processing the
4133 body of a template. */
4136 fold_if_not_in_template (tree expr
)
4138 /* In the body of a template, there is never any need to call
4139 "fold". We will call fold later when actually instantiating the
4140 template. Integral constant expressions in templates will be
4141 evaluated via instantiate_non_dependent_expr, as necessary. */
4142 if (processing_template_decl
)
4145 /* Fold C++ front-end specific tree codes. */
4146 if (TREE_CODE (expr
) == UNARY_PLUS_EXPR
)
4147 return fold_convert (TREE_TYPE (expr
), TREE_OPERAND (expr
, 0));
4152 /* Returns true if a cast to TYPE may appear in an integral constant
4156 cast_valid_in_integral_constant_expression_p (tree type
)
4158 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
4159 || cxx_dialect
>= cxx11
4160 || dependent_type_p (type
)
4161 || type
== error_mark_node
);
4164 /* Return true if we need to fix linkage information of DECL. */
4167 cp_fix_function_decl_p (tree decl
)
4169 /* Skip if DECL is not externally visible. */
4170 if (!TREE_PUBLIC (decl
))
4173 /* We need to fix DECL if it a appears to be exported but with no
4174 function body. Thunks do not have CFGs and we may need to
4175 handle them specially later. */
4176 if (!gimple_has_body_p (decl
)
4177 && !DECL_THUNK_P (decl
)
4178 && !DECL_EXTERNAL (decl
))
4180 struct cgraph_node
*node
= cgraph_node::get (decl
);
4182 /* Don't fix same_body aliases. Although they don't have their own
4183 CFG, they share it with what they alias to. */
4184 if (!node
|| !node
->alias
4185 || !vec_safe_length (node
->ref_list
.references
))
4192 /* Clean the C++ specific parts of the tree T. */
4195 cp_free_lang_data (tree t
)
4197 if (TREE_CODE (t
) == METHOD_TYPE
4198 || TREE_CODE (t
) == FUNCTION_TYPE
)
4200 /* Default args are not interesting anymore. */
4201 tree argtypes
= TYPE_ARG_TYPES (t
);
4204 TREE_PURPOSE (argtypes
) = 0;
4205 argtypes
= TREE_CHAIN (argtypes
);
4208 else if (TREE_CODE (t
) == FUNCTION_DECL
4209 && cp_fix_function_decl_p (t
))
4211 /* If T is used in this translation unit at all, the definition
4212 must exist somewhere else since we have decided to not emit it
4213 in this TU. So make it an external reference. */
4214 DECL_EXTERNAL (t
) = 1;
4215 TREE_STATIC (t
) = 0;
4217 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4219 /* The list of users of a namespace isn't useful for the middle-end
4220 or debug generators. */
4221 DECL_NAMESPACE_USERS (t
) = NULL_TREE
;
4222 /* Neither do we need the leftover chaining of namespaces
4223 from the binding level. */
4224 DECL_CHAIN (t
) = NULL_TREE
;
4228 /* Stub for c-common. Please keep in sync with c-decl.c.
4229 FIXME: If address space support is target specific, then this
4230 should be a C target hook. But currently this is not possible,
4231 because this function is called via REGISTER_TARGET_PRAGMAS. */
4233 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
4237 /* Return the number of operands in T that we care about for things like
4241 cp_tree_operand_length (const_tree t
)
4243 enum tree_code code
= TREE_CODE (t
);
4247 case PREINCREMENT_EXPR
:
4248 case PREDECREMENT_EXPR
:
4249 case POSTINCREMENT_EXPR
:
4250 case POSTDECREMENT_EXPR
:
4256 case EXPR_PACK_EXPANSION
:
4260 return TREE_OPERAND_LENGTH (t
);
4264 /* Implement -Wzero_as_null_pointer_constant. Return true if the
4265 conditions for the warning hold, false otherwise. */
4267 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
4269 if (c_inhibit_evaluation_warnings
== 0
4270 && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
4272 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
4273 "zero as null pointer constant");
4279 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4280 /* Complain that some language-specific thing hanging off a tree
4281 node has been accessed improperly. */
4284 lang_check_failed (const char* file
, int line
, const char* function
)
4286 internal_error ("lang_* check: failed in %s, at %s:%d",
4287 function
, trim_filename (file
), line
);
4289 #endif /* ENABLE_TREE_CHECKING */
4291 #include "gt-cp-tree.h"