1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
31 #include "tree-inline.h"
35 #include "splay-tree.h"
36 #include "gimple.h" /* gimple_has_body_p */
38 static tree
bot_manip (tree
*, int *, void *);
39 static tree
bot_replace (tree
*, int *, void *);
40 static int list_hash_eq (const void *, const void *);
41 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
42 static hashval_t
list_hash (const void *);
43 static tree
build_target_expr (tree
, tree
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
46 static tree
build_local_temp (tree
);
48 static tree
handle_java_interface_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_com_interface_attribute (tree
*, tree
, tree
, int, bool *);
50 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
52 /* If REF is an lvalue, returns the kind of lvalue that REF is.
53 Otherwise, returns clk_none. */
56 lvalue_kind (const_tree ref
)
58 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
59 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
61 /* Expressions of reference type are sometimes wrapped in
62 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
63 representation, not part of the language, so we have to look
65 if (TREE_CODE (ref
) == INDIRECT_REF
66 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref
, 0)))
68 return lvalue_kind (TREE_OPERAND (ref
, 0));
70 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
72 /* unnamed rvalue references are rvalues */
73 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
74 && TREE_CODE (ref
) != PARM_DECL
75 && TREE_CODE (ref
) != VAR_DECL
76 && TREE_CODE (ref
) != COMPONENT_REF
)
79 /* lvalue references and named rvalue references are lvalues. */
83 if (ref
== current_class_ptr
)
86 switch (TREE_CODE (ref
))
90 /* preincrements and predecrements are valid lvals, provided
91 what they refer to are valid lvals. */
92 case PREINCREMENT_EXPR
:
93 case PREDECREMENT_EXPR
:
95 case WITH_CLEANUP_EXPR
:
98 return lvalue_kind (TREE_OPERAND (ref
, 0));
101 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
102 /* Look at the member designator. */
103 if (!op1_lvalue_kind
)
105 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
106 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
107 situations. If we're seeing a COMPONENT_REF, it's a non-static
108 member, so it isn't an lvalue. */
109 op1_lvalue_kind
= clk_none
;
110 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
111 /* This can be IDENTIFIER_NODE in a template. */;
112 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
114 /* Clear the ordinary bit. If this object was a class
115 rvalue we want to preserve that information. */
116 op1_lvalue_kind
&= ~clk_ordinary
;
117 /* The lvalue is for a bitfield. */
118 op1_lvalue_kind
|= clk_bitfield
;
120 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
121 op1_lvalue_kind
|= clk_packed
;
123 return op1_lvalue_kind
;
126 case COMPOUND_LITERAL_EXPR
:
130 /* CONST_DECL without TREE_STATIC are enumeration values and
131 thus not lvalues. With TREE_STATIC they are used by ObjC++
132 in objc_build_string_object and need to be considered as
134 if (! TREE_STATIC (ref
))
137 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
138 && DECL_LANG_SPECIFIC (ref
)
139 && DECL_IN_AGGR_P (ref
))
145 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
149 /* A currently unresolved scope ref. */
154 /* Disallow <? and >? as lvalues if either argument side-effects. */
155 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
156 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
158 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
159 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
163 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
164 ? TREE_OPERAND (ref
, 1)
165 : TREE_OPERAND (ref
, 0));
166 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
173 return lvalue_kind (TREE_OPERAND (ref
, 1));
179 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
182 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
186 /* All functions (except non-static-member functions) are
188 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
189 ? clk_none
: clk_ordinary
);
192 /* We now represent a reference to a single static member function
194 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
195 its argument unmodified and we assign it to a const_tree. */
196 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
198 case NON_DEPENDENT_EXPR
:
199 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
200 things like "&E" where "E" is an expression with a
201 non-dependent type work. It is safe to be lenient because an
202 error will be issued when the template is instantiated if "E"
210 /* If one operand is not an lvalue at all, then this expression is
212 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
215 /* Otherwise, it's an lvalue, and it has all the odd properties
216 contributed by either operand. */
217 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
218 /* It's not an ordinary lvalue if it involves any other kind. */
219 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
220 op1_lvalue_kind
&= ~clk_ordinary
;
221 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
222 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
223 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
224 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
225 op1_lvalue_kind
= clk_none
;
226 return op1_lvalue_kind
;
229 /* Returns the kind of lvalue that REF is, in the sense of
230 [basic.lval]. This function should really be named lvalue_p; it
231 computes the C++ definition of lvalue. */
234 real_lvalue_p (const_tree ref
)
236 cp_lvalue_kind kind
= lvalue_kind (ref
);
237 if (kind
& (clk_rvalueref
|clk_class
))
243 /* This differs from real_lvalue_p in that class rvalues are considered
247 lvalue_p (const_tree ref
)
249 return (lvalue_kind (ref
) != clk_none
);
252 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
253 rvalue references are considered rvalues. */
256 lvalue_or_rvalue_with_address_p (const_tree ref
)
258 cp_lvalue_kind kind
= lvalue_kind (ref
);
259 if (kind
& clk_class
)
262 return (kind
!= clk_none
);
265 /* Test whether DECL is a builtin that may appear in a
266 constant-expression. */
269 builtin_valid_in_constant_expr_p (const_tree decl
)
271 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
272 in constant-expressions. We may want to add other builtins later. */
273 return DECL_IS_BUILTIN_CONSTANT_P (decl
);
276 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
279 build_target_expr (tree decl
, tree value
)
283 #ifdef ENABLE_CHECKING
284 gcc_assert (VOID_TYPE_P (TREE_TYPE (value
))
285 || TREE_TYPE (decl
) == TREE_TYPE (value
)
286 || useless_type_conversion_p (TREE_TYPE (decl
),
290 t
= build4 (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
291 cxx_maybe_build_cleanup (decl
), NULL_TREE
);
292 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
293 ignore the TARGET_EXPR. If there really turn out to be no
294 side-effects, then the optimizer should be able to get rid of
295 whatever code is generated anyhow. */
296 TREE_SIDE_EFFECTS (t
) = 1;
301 /* Return an undeclared local temporary of type TYPE for use in building a
305 build_local_temp (tree type
)
307 tree slot
= build_decl (input_location
,
308 VAR_DECL
, NULL_TREE
, type
);
309 DECL_ARTIFICIAL (slot
) = 1;
310 DECL_IGNORED_P (slot
) = 1;
311 DECL_CONTEXT (slot
) = current_function_decl
;
312 layout_decl (slot
, 0);
316 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
319 process_aggr_init_operands (tree t
)
323 side_effects
= TREE_SIDE_EFFECTS (t
);
327 n
= TREE_OPERAND_LENGTH (t
);
328 for (i
= 1; i
< n
; i
++)
330 tree op
= TREE_OPERAND (t
, i
);
331 if (op
&& TREE_SIDE_EFFECTS (op
))
338 TREE_SIDE_EFFECTS (t
) = side_effects
;
341 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
342 FN, and SLOT. NARGS is the number of call arguments which are specified
343 as a tree array ARGS. */
346 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
352 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
353 TREE_TYPE (t
) = return_type
;
354 AGGR_INIT_EXPR_FN (t
) = fn
;
355 AGGR_INIT_EXPR_SLOT (t
) = slot
;
356 for (i
= 0; i
< nargs
; i
++)
357 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
358 process_aggr_init_operands (t
);
362 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
363 target. TYPE is the type to be initialized.
365 Build an AGGR_INIT_EXPR to represent the initialization. This function
366 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
367 to initialize another object, whereas a TARGET_EXPR can either
368 initialize another object or create its own temporary object, and as a
369 result building up a TARGET_EXPR requires that the type's destructor be
373 build_aggr_init_expr (tree type
, tree init
)
380 /* Make sure that we're not trying to create an instance of an
382 abstract_virtuals_error (NULL_TREE
, type
);
384 if (TREE_CODE (init
) == CALL_EXPR
)
385 fn
= CALL_EXPR_FN (init
);
386 else if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
387 fn
= AGGR_INIT_EXPR_FN (init
);
389 return convert (type
, init
);
391 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
392 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
393 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
395 /* We split the CALL_EXPR into its function and its arguments here.
396 Then, in expand_expr, we put them back together. The reason for
397 this is that this expression might be a default argument
398 expression. In that case, we need a new temporary every time the
399 expression is used. That's what break_out_target_exprs does; it
400 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
401 temporary slot. Then, expand_expr builds up a call-expression
402 using the new slot. */
404 /* If we don't need to use a constructor to create an object of this
405 type, don't mess with AGGR_INIT_EXPR. */
406 if (is_ctor
|| TREE_ADDRESSABLE (type
))
408 slot
= build_local_temp (type
);
410 if (TREE_CODE(init
) == CALL_EXPR
)
411 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
412 call_expr_nargs (init
),
413 CALL_EXPR_ARGP (init
));
415 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
416 aggr_init_expr_nargs (init
),
417 AGGR_INIT_EXPR_ARGP (init
));
418 TREE_SIDE_EFFECTS (rval
) = 1;
419 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
420 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
428 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
429 target. TYPE is the type that this initialization should appear to
432 Build an encapsulation of the initialization to perform
433 and return it so that it can be processed by language-independent
434 and language-specific expression expanders. */
437 build_cplus_new (tree type
, tree init
)
439 tree rval
= build_aggr_init_expr (type
, init
);
442 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
443 slot
= AGGR_INIT_EXPR_SLOT (rval
);
444 else if (TREE_CODE (rval
) == CALL_EXPR
)
445 slot
= build_local_temp (type
);
449 rval
= build_target_expr (slot
, rval
);
450 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
455 /* Return a TARGET_EXPR which expresses the direct-initialization of one
456 array from another. */
459 build_array_copy (tree init
)
461 tree type
= TREE_TYPE (init
);
462 tree slot
= build_local_temp (type
);
463 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
464 SET_EXPR_LOCATION (init
, input_location
);
465 init
= build_target_expr (slot
, init
);
466 TARGET_EXPR_IMPLICIT_P (init
) = 1;
471 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
475 build_target_expr_with_type (tree init
, tree type
)
477 gcc_assert (!VOID_TYPE_P (type
));
479 if (TREE_CODE (init
) == TARGET_EXPR
480 || init
== error_mark_node
)
482 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
483 && !VOID_TYPE_P (TREE_TYPE (init
))
484 && TREE_CODE (init
) != COND_EXPR
485 && TREE_CODE (init
) != CONSTRUCTOR
486 && TREE_CODE (init
) != VA_ARG_EXPR
)
487 /* We need to build up a copy constructor call. A void initializer
488 means we're being called from bot_manip. COND_EXPR is a special
489 case because we already have copies on the arms and we don't want
490 another one here. A CONSTRUCTOR is aggregate initialization, which
491 is handled separately. A VA_ARG_EXPR is magic creation of an
492 aggregate; there's no additional work to be done. */
493 return force_rvalue (init
);
495 return force_target_expr (type
, init
);
498 /* Like the above function, but without the checking. This function should
499 only be used by code which is deliberately trying to subvert the type
500 system, such as call_builtin_trap. Or build_over_call, to avoid
501 infinite recursion. */
504 force_target_expr (tree type
, tree init
)
508 gcc_assert (!VOID_TYPE_P (type
));
510 slot
= build_local_temp (type
);
511 return build_target_expr (slot
, init
);
514 /* Like build_target_expr_with_type, but use the type of INIT. */
517 get_target_expr (tree init
)
519 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
520 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
);
522 return build_target_expr_with_type (init
, TREE_TYPE (init
));
525 /* If EXPR is a bitfield reference, convert it to the declared type of
526 the bitfield, and return the resulting expression. Otherwise,
527 return EXPR itself. */
530 convert_bitfield_to_declared_type (tree expr
)
534 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
536 expr
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
),
541 /* EXPR is being used in an rvalue context. Return a version of EXPR
542 that is marked as an rvalue. */
549 if (error_operand_p (expr
))
552 expr
= mark_rvalue_use (expr
);
556 Non-class rvalues always have cv-unqualified types. */
557 type
= TREE_TYPE (expr
);
558 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
559 type
= cv_unqualified (type
);
561 /* We need to do this for rvalue refs as well to get the right answer
562 from decltype; see c++/36628. */
563 if (!processing_template_decl
&& lvalue_or_rvalue_with_address_p (expr
))
564 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
565 else if (type
!= TREE_TYPE (expr
))
566 expr
= build_nop (type
, expr
);
572 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
575 cplus_array_hash (const void* k
)
578 const_tree
const t
= (const_tree
) k
;
580 hash
= TYPE_UID (TREE_TYPE (t
));
582 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
586 typedef struct cplus_array_info
{
591 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
592 of type `cplus_array_info*'. */
595 cplus_array_compare (const void * k1
, const void * k2
)
597 const_tree
const t1
= (const_tree
) k1
;
598 const cplus_array_info
*const t2
= (const cplus_array_info
*) k2
;
600 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
603 /* Hash table containing dependent array types, which are unsuitable for
604 the language-independent type hash table. */
605 static GTY ((param_is (union tree_node
))) htab_t cplus_array_htab
;
607 /* Like build_array_type, but handle special C++ semantics. */
610 build_cplus_array_type (tree elt_type
, tree index_type
)
614 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
615 return error_mark_node
;
617 if (processing_template_decl
618 && (dependent_type_p (elt_type
)
619 || (index_type
&& !TREE_CONSTANT (TYPE_MAX_VALUE (index_type
)))))
622 cplus_array_info cai
;
625 if (cplus_array_htab
== NULL
)
626 cplus_array_htab
= htab_create_ggc (61, &cplus_array_hash
,
627 &cplus_array_compare
, NULL
);
629 hash
= TYPE_UID (elt_type
);
631 hash
^= TYPE_UID (index_type
);
633 cai
.domain
= index_type
;
635 e
= htab_find_slot_with_hash (cplus_array_htab
, &cai
, hash
, INSERT
);
637 /* We have found the type: we're done. */
641 /* Build a new array type. */
642 t
= cxx_make_type (ARRAY_TYPE
);
643 TREE_TYPE (t
) = elt_type
;
644 TYPE_DOMAIN (t
) = index_type
;
646 /* Store it in the hash table. */
649 /* Set the canonical type for this new node. */
650 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
651 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
652 SET_TYPE_STRUCTURAL_EQUALITY (t
);
653 else if (TYPE_CANONICAL (elt_type
) != elt_type
655 && TYPE_CANONICAL (index_type
) != index_type
))
657 = build_cplus_array_type
658 (TYPE_CANONICAL (elt_type
),
659 index_type
? TYPE_CANONICAL (index_type
) : index_type
);
661 TYPE_CANONICAL (t
) = t
;
665 t
= build_array_type (elt_type
, index_type
);
667 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
668 element type as well, so fix it up if needed. */
669 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
671 tree m
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
673 if (TYPE_MAIN_VARIANT (t
) != m
)
675 TYPE_MAIN_VARIANT (t
) = m
;
676 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
677 TYPE_NEXT_VARIANT (m
) = t
;
681 /* Push these needs up so that initialization takes place
683 TYPE_NEEDS_CONSTRUCTING (t
)
684 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
685 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
686 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
690 /* Return an ARRAY_TYPE with element type ELT and length N. */
693 build_array_of_n_type (tree elt
, int n
)
695 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
698 /* Return a reference type node referring to TO_TYPE. If RVAL is
699 true, return an rvalue reference type, otherwise return an lvalue
700 reference type. If a type node exists, reuse it, otherwise create
703 cp_build_reference_type (tree to_type
, bool rval
)
706 lvalue_ref
= build_reference_type (to_type
);
710 /* This code to create rvalue reference types is based on and tied
711 to the code creating lvalue reference types in the middle-end
712 functions build_reference_type_for_mode and build_reference_type.
714 It works by putting the rvalue reference type nodes after the
715 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
716 they will effectively be ignored by the middle end. */
718 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
719 if (TYPE_REF_IS_RVALUE (t
))
722 t
= build_distinct_type_copy (lvalue_ref
);
724 TYPE_REF_IS_RVALUE (t
) = true;
725 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
726 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
728 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
729 SET_TYPE_STRUCTURAL_EQUALITY (t
);
730 else if (TYPE_CANONICAL (to_type
) != to_type
)
732 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
734 TYPE_CANONICAL (t
) = t
;
742 /* Returns EXPR cast to rvalue reference type, like std::move. */
747 tree type
= TREE_TYPE (expr
);
748 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
749 type
= cp_build_reference_type (type
, /*rval*/true);
750 return build_static_cast (type
, expr
, tf_warning_or_error
);
753 /* Used by the C++ front end to build qualified array types. However,
754 the C version of this function does not properly maintain canonical
755 types (which are not used in C). */
757 c_build_qualified_type (tree type
, int type_quals
)
759 return cp_build_qualified_type (type
, type_quals
);
763 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
764 arrays correctly. In particular, if TYPE is an array of T's, and
765 TYPE_QUALS is non-empty, returns an array of qualified T's.
767 FLAGS determines how to deal with ill-formed qualifications. If
768 tf_ignore_bad_quals is set, then bad qualifications are dropped
769 (this is permitted if TYPE was introduced via a typedef or template
770 type parameter). If bad qualifications are dropped and tf_warning
771 is set, then a warning is issued for non-const qualifications. If
772 tf_ignore_bad_quals is not set and tf_error is not set, we
773 return error_mark_node. Otherwise, we issue an error, and ignore
776 Qualification of a reference type is valid when the reference came
777 via a typedef or template type argument. [dcl.ref] No such
778 dispensation is provided for qualifying a function type. [dcl.fct]
779 DR 295 queries this and the proposed resolution brings it into line
780 with qualifying a reference. We implement the DR. We also behave
781 in a similar manner for restricting non-pointer types. */
784 cp_build_qualified_type_real (tree type
,
786 tsubst_flags_t complain
)
789 int bad_quals
= TYPE_UNQUALIFIED
;
791 if (type
== error_mark_node
)
794 if (type_quals
== cp_type_quals (type
))
797 if (TREE_CODE (type
) == ARRAY_TYPE
)
799 /* In C++, the qualification really applies to the array element
800 type. Obtain the appropriately qualified element type. */
803 = cp_build_qualified_type_real (TREE_TYPE (type
),
807 if (element_type
== error_mark_node
)
808 return error_mark_node
;
810 /* See if we already have an identically qualified type. Tests
811 should be equivalent to those in check_qualified_type. */
812 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
813 if (TREE_TYPE (t
) == element_type
814 && TYPE_NAME (t
) == TYPE_NAME (type
)
815 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
816 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
817 TYPE_ATTRIBUTES (type
)))
822 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
824 /* Keep the typedef name. */
825 if (TYPE_NAME (t
) != TYPE_NAME (type
))
827 t
= build_variant_type_copy (t
);
828 TYPE_NAME (t
) = TYPE_NAME (type
);
832 /* Even if we already had this variant, we update
833 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
834 they changed since the variant was originally created.
836 This seems hokey; if there is some way to use a previous
837 variant *without* coming through here,
838 TYPE_NEEDS_CONSTRUCTING will never be updated. */
839 TYPE_NEEDS_CONSTRUCTING (t
)
840 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
841 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
842 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
845 else if (TYPE_PTRMEMFUNC_P (type
))
847 /* For a pointer-to-member type, we can't just return a
848 cv-qualified version of the RECORD_TYPE. If we do, we
849 haven't changed the field that contains the actual pointer to
850 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
853 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
854 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
855 return build_ptrmemfunc_type (t
);
857 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
859 tree t
= PACK_EXPANSION_PATTERN (type
);
861 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
862 return make_pack_expansion (t
);
865 /* A reference or method type shall not be cv-qualified.
866 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
867 (in CD1) we always ignore extra cv-quals on functions. */
868 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
869 && (TREE_CODE (type
) == REFERENCE_TYPE
870 || TREE_CODE (type
) == FUNCTION_TYPE
871 || TREE_CODE (type
) == METHOD_TYPE
))
873 if (TREE_CODE (type
) == REFERENCE_TYPE
)
874 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
875 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
878 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
879 if (TREE_CODE (type
) == FUNCTION_TYPE
)
880 type_quals
|= type_memfn_quals (type
);
882 /* A restrict-qualified type must be a pointer (or reference)
883 to object or incomplete type. */
884 if ((type_quals
& TYPE_QUAL_RESTRICT
)
885 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
886 && TREE_CODE (type
) != TYPENAME_TYPE
887 && !POINTER_TYPE_P (type
))
889 bad_quals
|= TYPE_QUAL_RESTRICT
;
890 type_quals
&= ~TYPE_QUAL_RESTRICT
;
893 if (bad_quals
== TYPE_UNQUALIFIED
894 || (complain
& tf_ignore_bad_quals
))
896 else if (!(complain
& tf_error
))
897 return error_mark_node
;
900 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
901 error ("%qV qualifiers cannot be applied to %qT",
905 /* Retrieve (or create) the appropriately qualified variant. */
906 result
= build_qualified_type (type
, type_quals
);
908 /* If this was a pointer-to-method type, and we just made a copy,
909 then we need to unshare the record that holds the cached
910 pointer-to-member-function type, because these will be distinct
911 between the unqualified and qualified types. */
913 && TREE_CODE (type
) == POINTER_TYPE
914 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
915 && TYPE_LANG_SPECIFIC (result
) == TYPE_LANG_SPECIFIC (type
))
916 TYPE_LANG_SPECIFIC (result
) = NULL
;
918 /* We may also have ended up building a new copy of the canonical
919 type of a pointer-to-method type, which could have the same
920 sharing problem described above. */
921 if (TYPE_CANONICAL (result
) != TYPE_CANONICAL (type
)
922 && TREE_CODE (type
) == POINTER_TYPE
923 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
924 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result
))
925 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type
))))
926 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result
)) = NULL
;
931 /* Return TYPE with const and volatile removed. */
934 cv_unqualified (tree type
)
938 if (type
== error_mark_node
)
941 quals
= cp_type_quals (type
);
942 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
943 return cp_build_qualified_type (type
, quals
);
946 /* Builds a qualified variant of T that is not a typedef variant.
947 E.g. consider the following declarations:
948 typedef const int ConstInt;
949 typedef ConstInt* PtrConstInt;
950 If T is PtrConstInt, this function returns a type representing
952 In other words, if T is a typedef, the function returns the underlying type.
953 The cv-qualification and attributes of the type returned match the
955 They will always be compatible types.
956 The returned type is built so that all of its subtypes
957 recursively have their typedefs stripped as well.
959 This is different from just returning TYPE_CANONICAL (T)
960 Because of several reasons:
961 * If T is a type that needs structural equality
962 its TYPE_CANONICAL (T) will be NULL.
963 * TYPE_CANONICAL (T) desn't carry type attributes
964 and looses template parameter names. */
967 strip_typedefs (tree t
)
969 tree result
= NULL
, type
= NULL
, t0
= NULL
;
971 if (!t
|| t
== error_mark_node
|| t
== TYPE_CANONICAL (t
))
974 gcc_assert (TYPE_P (t
));
976 switch (TREE_CODE (t
))
979 type
= strip_typedefs (TREE_TYPE (t
));
980 result
= build_pointer_type (type
);
983 type
= strip_typedefs (TREE_TYPE (t
));
984 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
987 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
));
988 type
= strip_typedefs (TREE_TYPE (t
));
989 result
= build_offset_type (t0
, type
);
992 if (TYPE_PTRMEMFUNC_P (t
))
994 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
));
995 result
= build_ptrmemfunc_type (t0
);
999 type
= strip_typedefs (TREE_TYPE (t
));
1000 t0
= strip_typedefs (TYPE_DOMAIN (t
));;
1001 result
= build_cplus_array_type (type
, t0
);
1006 tree arg_types
= NULL
, arg_node
, arg_type
;
1007 for (arg_node
= TYPE_ARG_TYPES (t
);
1009 arg_node
= TREE_CHAIN (arg_node
))
1011 if (arg_node
== void_list_node
)
1013 arg_type
= strip_typedefs (TREE_VALUE (arg_node
));
1014 gcc_assert (arg_type
);
1017 tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1021 arg_types
= nreverse (arg_types
);
1023 /* A list of parameters not ending with an ellipsis
1024 must end with void_list_node. */
1026 arg_types
= chainon (arg_types
, void_list_node
);
1028 type
= strip_typedefs (TREE_TYPE (t
));
1029 if (TREE_CODE (t
) == METHOD_TYPE
)
1031 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1032 gcc_assert (class_type
);
1034 build_method_type_directly (class_type
, type
,
1035 TREE_CHAIN (arg_types
));
1039 result
= build_function_type (type
,
1041 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1044 if (TYPE_RAISES_EXCEPTIONS (t
))
1045 result
= build_exception_variant (result
,
1046 TYPE_RAISES_EXCEPTIONS (t
));
1050 result
= make_typename_type (strip_typedefs (TYPE_CONTEXT (t
)),
1051 TYPENAME_TYPE_FULLNAME (t
),
1052 typename_type
, tf_none
);
1059 result
= TYPE_MAIN_VARIANT (t
);
1060 if (TYPE_ATTRIBUTES (t
))
1061 result
= cp_build_type_attribute_variant (result
, TYPE_ATTRIBUTES (t
));
1062 return cp_build_qualified_type (result
, cp_type_quals (t
));
1065 /* Setup a TYPE_DECL node as a typedef representation.
1066 See comments of set_underlying_type in c-common.c. */
1069 cp_set_underlying_type (tree t
)
1071 set_underlying_type (t
);
1072 /* If T is a template type parm, make it require structural equality.
1073 This is useful when comparing two template type parms,
1074 because it forces the comparison of the template parameters of their
1076 if (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1077 SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t
));
1081 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1082 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1083 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1084 VIRT indicates whether TYPE is inherited virtually or not.
1085 IGO_PREV points at the previous binfo of the inheritance graph
1086 order chain. The newly copied binfo's TREE_CHAIN forms this
1089 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1090 correct order. That is in the order the bases themselves should be
1093 The BINFO_INHERITANCE of a virtual base class points to the binfo
1094 of the most derived type. ??? We could probably change this so that
1095 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1096 remove a field. They currently can only differ for primary virtual
1100 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1106 /* See if we've already made this virtual base. */
1107 new_binfo
= binfo_for_vbase (type
, t
);
1112 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1113 BINFO_TYPE (new_binfo
) = type
;
1115 /* Chain it into the inheritance graph. */
1116 TREE_CHAIN (*igo_prev
) = new_binfo
;
1117 *igo_prev
= new_binfo
;
1124 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo
));
1125 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1127 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1128 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1130 /* We do not need to copy the accesses, as they are read only. */
1131 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1133 /* Recursively copy base binfos of BINFO. */
1134 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1136 tree new_base_binfo
;
1138 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo
));
1139 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1141 BINFO_VIRTUAL_P (base_binfo
));
1143 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1144 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1145 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1149 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1153 /* Push it onto the list after any virtual bases it contains
1154 will have been pushed. */
1155 VEC_quick_push (tree
, CLASSTYPE_VBASECLASSES (t
), new_binfo
);
1156 BINFO_VIRTUAL_P (new_binfo
) = 1;
1157 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1163 /* Hashing of lists so that we don't make duplicates.
1164 The entry point is `list_hash_canon'. */
1166 /* Now here is the hash table. When recording a list, it is added
1167 to the slot whose index is the hash code mod the table size.
1168 Note that the hash table is used for several kinds of lists.
1169 While all these live in the same table, they are completely independent,
1170 and the hash code is computed differently for each of these. */
1172 static GTY ((param_is (union tree_node
))) htab_t list_hash_table
;
1181 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1182 for a node we are thinking about adding). */
1185 list_hash_eq (const void* entry
, const void* data
)
1187 const_tree
const t
= (const_tree
) entry
;
1188 const struct list_proxy
*const proxy
= (const struct list_proxy
*) data
;
1190 return (TREE_VALUE (t
) == proxy
->value
1191 && TREE_PURPOSE (t
) == proxy
->purpose
1192 && TREE_CHAIN (t
) == proxy
->chain
);
1195 /* Compute a hash code for a list (chain of TREE_LIST nodes
1196 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1197 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1200 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1202 hashval_t hashcode
= 0;
1205 hashcode
+= TREE_HASH (chain
);
1208 hashcode
+= TREE_HASH (value
);
1212 hashcode
+= TREE_HASH (purpose
);
1218 /* Hash an already existing TREE_LIST. */
1221 list_hash (const void* p
)
1223 const_tree
const t
= (const_tree
) p
;
1224 return list_hash_pieces (TREE_PURPOSE (t
),
1229 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1230 object for an identical list if one already exists. Otherwise, build a
1231 new one, and record it as the canonical object. */
1234 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1238 struct list_proxy proxy
;
1240 /* Hash the list node. */
1241 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1242 /* Create a proxy for the TREE_LIST we would like to create. We
1243 don't actually create it so as to avoid creating garbage. */
1244 proxy
.purpose
= purpose
;
1245 proxy
.value
= value
;
1246 proxy
.chain
= chain
;
1247 /* See if it is already in the table. */
1248 slot
= htab_find_slot_with_hash (list_hash_table
, &proxy
, hashcode
,
1250 /* If not, create a new node. */
1252 *slot
= tree_cons (purpose
, value
, chain
);
1253 return (tree
) *slot
;
1256 /* Constructor for hashed lists. */
1259 hash_tree_chain (tree value
, tree chain
)
1261 return hash_tree_cons (NULL_TREE
, value
, chain
);
1265 debug_binfo (tree elem
)
1270 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1272 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1273 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1274 debug_tree (BINFO_TYPE (elem
));
1275 if (BINFO_VTABLE (elem
))
1276 fprintf (stderr
, "vtable decl \"%s\"\n",
1277 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
1279 fprintf (stderr
, "no vtable decl yet\n");
1280 fprintf (stderr
, "virtuals:\n");
1281 virtuals
= BINFO_VIRTUALS (elem
);
1286 tree fndecl
= TREE_VALUE (virtuals
);
1287 fprintf (stderr
, "%s [%ld =? %ld]\n",
1288 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1289 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1291 virtuals
= TREE_CHAIN (virtuals
);
1295 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1296 the type of the result expression, if known, or NULL_TREE if the
1297 resulting expression is type-dependent. If TEMPLATE_P is true,
1298 NAME is known to be a template because the user explicitly used the
1299 "template" keyword after the "::".
1301 All SCOPE_REFs should be built by use of this function. */
1304 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
1307 if (type
== error_mark_node
1308 || scope
== error_mark_node
1309 || name
== error_mark_node
)
1310 return error_mark_node
;
1311 t
= build2 (SCOPE_REF
, type
, scope
, name
);
1312 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
1314 t
= convert_from_reference (t
);
1318 /* Returns nonzero if X is an expression for a (possibly overloaded)
1319 function. If "f" is a function or function template, "f", "c->f",
1320 "c.f", "C::f", and "f<int>" will all be considered possibly
1321 overloaded functions. Returns 2 if the function is actually
1322 overloaded, i.e., if it is impossible to know the type of the
1323 function without performing overload resolution. */
1326 is_overloaded_fn (tree x
)
1328 /* A baselink is also considered an overloaded function. */
1329 if (TREE_CODE (x
) == OFFSET_REF
1330 || TREE_CODE (x
) == COMPONENT_REF
)
1331 x
= TREE_OPERAND (x
, 1);
1333 x
= BASELINK_FUNCTIONS (x
);
1334 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1335 x
= TREE_OPERAND (x
, 0);
1336 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x
))
1337 || (TREE_CODE (x
) == OVERLOAD
&& OVL_CHAIN (x
)))
1339 return (TREE_CODE (x
) == FUNCTION_DECL
1340 || TREE_CODE (x
) == OVERLOAD
);
1343 /* Returns true iff X is an expression for an overloaded function
1344 whose type cannot be known without performing overload
1348 really_overloaded_fn (tree x
)
1350 return is_overloaded_fn (x
) == 2;
1356 gcc_assert (is_overloaded_fn (from
));
1357 /* A baselink is also considered an overloaded function. */
1358 if (TREE_CODE (from
) == OFFSET_REF
1359 || TREE_CODE (from
) == COMPONENT_REF
)
1360 from
= TREE_OPERAND (from
, 1);
1361 if (BASELINK_P (from
))
1362 from
= BASELINK_FUNCTIONS (from
);
1363 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
1364 from
= TREE_OPERAND (from
, 0);
1369 get_first_fn (tree from
)
1371 return OVL_CURRENT (get_fns (from
));
1374 /* Return a new OVL node, concatenating it with the old one. */
1377 ovl_cons (tree decl
, tree chain
)
1379 tree result
= make_node (OVERLOAD
);
1380 TREE_TYPE (result
) = unknown_type_node
;
1381 OVL_FUNCTION (result
) = decl
;
1382 TREE_CHAIN (result
) = chain
;
1387 /* Build a new overloaded function. If this is the first one,
1388 just return it; otherwise, ovl_cons the _DECLs */
1391 build_overload (tree decl
, tree chain
)
1393 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1395 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1396 chain
= ovl_cons (chain
, NULL_TREE
);
1397 return ovl_cons (decl
, chain
);
1401 #define PRINT_RING_SIZE 4
1404 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
1406 static unsigned int uid_ring
[PRINT_RING_SIZE
];
1407 static char *print_ring
[PRINT_RING_SIZE
];
1408 static bool trans_ring
[PRINT_RING_SIZE
];
1409 static int ring_counter
;
1412 /* Only cache functions. */
1414 || TREE_CODE (decl
) != FUNCTION_DECL
1415 || DECL_LANG_SPECIFIC (decl
) == 0)
1416 return lang_decl_name (decl
, v
, translate
);
1418 /* See if this print name is lying around. */
1419 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1420 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
1421 /* yes, so return it. */
1422 return print_ring
[i
];
1424 if (++ring_counter
== PRINT_RING_SIZE
)
1427 if (current_function_decl
!= NULL_TREE
)
1429 /* There may be both translated and untranslated versions of the
1431 for (i
= 0; i
< 2; i
++)
1433 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
1435 if (ring_counter
== PRINT_RING_SIZE
)
1438 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
1441 if (print_ring
[ring_counter
])
1442 free (print_ring
[ring_counter
]);
1444 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
1445 uid_ring
[ring_counter
] = DECL_UID (decl
);
1446 trans_ring
[ring_counter
] = translate
;
1447 return print_ring
[ring_counter
];
1451 cxx_printable_name (tree decl
, int v
)
1453 return cxx_printable_name_internal (decl
, v
, false);
1457 cxx_printable_name_translate (tree decl
, int v
)
1459 return cxx_printable_name_internal (decl
, v
, true);
1462 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1463 listed in RAISES. */
1466 build_exception_variant (tree type
, tree raises
)
1471 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
1474 type_quals
= TYPE_QUALS (type
);
1475 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
1476 if (check_qualified_type (v
, type
, type_quals
)
1477 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), ce_exact
))
1480 /* Need to build a new variant. */
1481 v
= build_variant_type_copy (type
);
1482 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1486 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1487 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1491 bind_template_template_parm (tree t
, tree newargs
)
1493 tree decl
= TYPE_NAME (t
);
1496 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
1497 decl
= build_decl (input_location
,
1498 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1500 /* These nodes have to be created to reflect new TYPE_DECL and template
1502 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
1503 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
1504 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1505 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
1507 TREE_TYPE (decl
) = t2
;
1508 TYPE_NAME (t2
) = decl
;
1509 TYPE_STUB_DECL (t2
) = decl
;
1511 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
1516 /* Called from count_trees via walk_tree. */
1519 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
1529 /* Debugging function for measuring the rough complexity of a tree
1533 count_trees (tree t
)
1536 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
1540 /* Called from verify_stmt_tree via walk_tree. */
1543 verify_stmt_tree_r (tree
* tp
,
1544 int* walk_subtrees ATTRIBUTE_UNUSED
,
1548 htab_t
*statements
= (htab_t
*) data
;
1551 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
1554 /* If this statement is already present in the hash table, then
1555 there is a circularity in the statement tree. */
1556 gcc_assert (!htab_find (*statements
, t
));
1558 slot
= htab_find_slot (*statements
, t
, INSERT
);
1564 /* Debugging function to check that the statement T has not been
1565 corrupted. For now, this function simply checks that T contains no
1569 verify_stmt_tree (tree t
)
1572 statements
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1573 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
1574 htab_delete (statements
);
1577 /* Check if the type T depends on a type with no linkage and if so, return
1578 it. If RELAXED_P then do not consider a class type declared within
1579 a vague-linkage function to have no linkage. */
1582 no_linkage_check (tree t
, bool relaxed_p
)
1586 /* There's no point in checking linkage on template functions; we
1587 can't know their complete types. */
1588 if (processing_template_decl
)
1591 switch (TREE_CODE (t
))
1594 if (TYPE_PTRMEMFUNC_P (t
))
1596 /* Lambda types that don't have mangling scope have no linkage. We
1597 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1598 when we get here from pushtag none of the lambda information is
1599 set up yet, so we want to assume that the lambda has linkage and
1600 fix it up later if not. */
1601 if (CLASSTYPE_LAMBDA_EXPR (t
)
1602 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
1606 if (!CLASS_TYPE_P (t
))
1610 /* Only treat anonymous types as having no linkage if they're at
1611 namespace scope. This is core issue 966. */
1612 if (TYPE_ANONYMOUS_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
1615 for (r
= CP_TYPE_CONTEXT (t
); ; )
1617 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1618 have linkage, or we might just be in an anonymous namespace.
1619 If we're in a TREE_PUBLIC class, we have linkage. */
1620 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
1621 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
1622 else if (TREE_CODE (r
) == FUNCTION_DECL
)
1624 if (!relaxed_p
|| !vague_linkage_p (r
))
1627 r
= CP_DECL_CONTEXT (r
);
1637 case REFERENCE_TYPE
:
1638 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
1642 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
1646 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
1649 r
= no_linkage_check (TYPE_METHOD_BASETYPE (t
), relaxed_p
);
1656 for (parm
= TYPE_ARG_TYPES (t
);
1657 parm
&& parm
!= void_list_node
;
1658 parm
= TREE_CHAIN (parm
))
1660 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
1664 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
1672 #ifdef GATHER_STATISTICS
1673 extern int depth_reached
;
1677 cxx_print_statistics (void)
1679 print_search_statistics ();
1680 print_class_statistics ();
1681 print_template_statistics ();
1682 #ifdef GATHER_STATISTICS
1683 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1688 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1689 (which is an ARRAY_TYPE). This counts only elements of the top
1693 array_type_nelts_top (tree type
)
1695 return fold_build2_loc (input_location
,
1696 PLUS_EXPR
, sizetype
,
1697 array_type_nelts (type
),
1701 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1702 (which is an ARRAY_TYPE). This one is a recursive count of all
1703 ARRAY_TYPEs that are clumped together. */
1706 array_type_nelts_total (tree type
)
1708 tree sz
= array_type_nelts_top (type
);
1709 type
= TREE_TYPE (type
);
1710 while (TREE_CODE (type
) == ARRAY_TYPE
)
1712 tree n
= array_type_nelts_top (type
);
1713 sz
= fold_build2_loc (input_location
,
1714 MULT_EXPR
, sizetype
, sz
, n
);
1715 type
= TREE_TYPE (type
);
1720 /* Called from break_out_target_exprs via mapcar. */
1723 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
1725 splay_tree target_remap
= ((splay_tree
) data
);
1728 if (!TYPE_P (t
) && TREE_CONSTANT (t
))
1730 /* There can't be any TARGET_EXPRs or their slot variables below
1731 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1732 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1736 if (TREE_CODE (t
) == TARGET_EXPR
)
1740 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1741 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1));
1743 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
));
1745 /* Map the old variable to the new one. */
1746 splay_tree_insert (target_remap
,
1747 (splay_tree_key
) TREE_OPERAND (t
, 0),
1748 (splay_tree_value
) TREE_OPERAND (u
, 0));
1750 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
1752 /* Replace the old expression with the new version. */
1754 /* We don't have to go below this point; the recursive call to
1755 break_out_target_exprs will have handled anything below this
1761 /* Make a copy of this node. */
1762 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1765 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1766 DATA is really a splay-tree mapping old variables to new
1770 bot_replace (tree
* t
,
1771 int* walk_subtrees ATTRIBUTE_UNUSED
,
1774 splay_tree target_remap
= ((splay_tree
) data
);
1776 if (TREE_CODE (*t
) == VAR_DECL
)
1778 splay_tree_node n
= splay_tree_lookup (target_remap
,
1779 (splay_tree_key
) *t
);
1781 *t
= (tree
) n
->value
;
1787 /* When we parse a default argument expression, we may create
1788 temporary variables via TARGET_EXPRs. When we actually use the
1789 default-argument expression, we make a copy of the expression, but
1790 we must replace the temporaries with appropriate local versions. */
1793 break_out_target_exprs (tree t
)
1795 static int target_remap_count
;
1796 static splay_tree target_remap
;
1798 if (!target_remap_count
++)
1799 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
1800 /*splay_tree_delete_key_fn=*/NULL
,
1801 /*splay_tree_delete_value_fn=*/NULL
);
1802 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
1803 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
1805 if (!--target_remap_count
)
1807 splay_tree_delete (target_remap
);
1808 target_remap
= NULL
;
1814 /* Similar to `build_nt', but for template definitions of dependent
1818 build_min_nt (enum tree_code code
, ...)
1825 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
1829 t
= make_node (code
);
1830 length
= TREE_CODE_LENGTH (code
);
1832 for (i
= 0; i
< length
; i
++)
1834 tree x
= va_arg (p
, tree
);
1835 TREE_OPERAND (t
, i
) = x
;
1843 /* Similar to `build', but for template definitions. */
1846 build_min (enum tree_code code
, tree tt
, ...)
1853 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
1857 t
= make_node (code
);
1858 length
= TREE_CODE_LENGTH (code
);
1861 for (i
= 0; i
< length
; i
++)
1863 tree x
= va_arg (p
, tree
);
1864 TREE_OPERAND (t
, i
) = x
;
1865 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
1866 TREE_SIDE_EFFECTS (t
) = 1;
1873 /* Similar to `build', but for template definitions of non-dependent
1874 expressions. NON_DEP is the non-dependent expression that has been
1878 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
1885 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
1887 va_start (p
, non_dep
);
1889 t
= make_node (code
);
1890 length
= TREE_CODE_LENGTH (code
);
1891 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
1892 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
1894 for (i
= 0; i
< length
; i
++)
1896 tree x
= va_arg (p
, tree
);
1897 TREE_OPERAND (t
, i
) = x
;
1900 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
1901 /* This should not be considered a COMPOUND_EXPR, because it
1902 resolves to an overload. */
1903 COMPOUND_EXPR_OVERLOADED (t
) = 1;
1909 /* Similar to `build_nt_call_vec', but for template definitions of
1910 non-dependent expressions. NON_DEP is the non-dependent expression
1911 that has been built. */
1914 build_min_non_dep_call_vec (tree non_dep
, tree fn
, VEC(tree
,gc
) *argvec
)
1916 tree t
= build_nt_call_vec (fn
, argvec
);
1917 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
1918 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
1923 get_type_decl (tree t
)
1925 if (TREE_CODE (t
) == TYPE_DECL
)
1928 return TYPE_STUB_DECL (t
);
1929 gcc_assert (t
== error_mark_node
);
1933 /* Returns the namespace that contains DECL, whether directly or
1937 decl_namespace_context (tree decl
)
1941 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1943 else if (TYPE_P (decl
))
1944 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
1946 decl
= CP_DECL_CONTEXT (decl
);
1950 /* Returns true if decl is within an anonymous namespace, however deeply
1951 nested, or false otherwise. */
1954 decl_anon_ns_mem_p (const_tree decl
)
1958 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
1960 if (TREE_CODE (decl
) == NAMESPACE_DECL
1961 && DECL_NAME (decl
) == NULL_TREE
)
1963 /* Classes and namespaces inside anonymous namespaces have
1964 TREE_PUBLIC == 0, so we can shortcut the search. */
1965 else if (TYPE_P (decl
))
1966 return (TREE_PUBLIC (TYPE_NAME (decl
)) == 0);
1967 else if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1968 return (TREE_PUBLIC (decl
) == 0);
1970 decl
= DECL_CONTEXT (decl
);
1974 /* Return truthvalue of whether T1 is the same tree structure as T2.
1975 Return 1 if they are the same. Return 0 if they are different. */
1978 cp_tree_equal (tree t1
, tree t2
)
1980 enum tree_code code1
, code2
;
1987 for (code1
= TREE_CODE (t1
);
1988 CONVERT_EXPR_CODE_P (code1
)
1989 || code1
== NON_LVALUE_EXPR
;
1990 code1
= TREE_CODE (t1
))
1991 t1
= TREE_OPERAND (t1
, 0);
1992 for (code2
= TREE_CODE (t2
);
1993 CONVERT_EXPR_CODE_P (code2
)
1994 || code1
== NON_LVALUE_EXPR
;
1995 code2
= TREE_CODE (t2
))
1996 t2
= TREE_OPERAND (t2
, 0);
1998 /* They might have become equal now. */
2008 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
2009 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
2012 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2015 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2016 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2017 TREE_STRING_LENGTH (t1
));
2020 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
2021 TREE_FIXED_CST (t2
));
2024 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
2025 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
2028 /* We need to do this when determining whether or not two
2029 non-type pointer to member function template arguments
2031 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2032 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
2037 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
2039 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
2040 if (!cp_tree_equal (field
, elt2
->index
)
2041 || !cp_tree_equal (value
, elt2
->value
))
2048 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
2050 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
2052 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
2055 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2060 call_expr_arg_iterator iter1
, iter2
;
2061 if (!cp_tree_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
2063 for (arg1
= first_call_expr_arg (t1
, &iter1
),
2064 arg2
= first_call_expr_arg (t2
, &iter2
);
2066 arg1
= next_call_expr_arg (&iter1
),
2067 arg2
= next_call_expr_arg (&iter2
))
2068 if (!cp_tree_equal (arg1
, arg2
))
2077 tree o1
= TREE_OPERAND (t1
, 0);
2078 tree o2
= TREE_OPERAND (t2
, 0);
2080 /* Special case: if either target is an unallocated VAR_DECL,
2081 it means that it's going to be unified with whatever the
2082 TARGET_EXPR is really supposed to initialize, so treat it
2083 as being equivalent to anything. */
2084 if (TREE_CODE (o1
) == VAR_DECL
&& DECL_NAME (o1
) == NULL_TREE
2085 && !DECL_RTL_SET_P (o1
))
2087 else if (TREE_CODE (o2
) == VAR_DECL
&& DECL_NAME (o2
) == NULL_TREE
2088 && !DECL_RTL_SET_P (o2
))
2090 else if (!cp_tree_equal (o1
, o2
))
2093 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2096 case WITH_CLEANUP_EXPR
:
2097 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
2099 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
2102 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
2104 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2107 /* For comparing uses of parameters in late-specified return types
2108 with an out-of-class definition of the function. */
2109 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2110 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
))
2119 case IDENTIFIER_NODE
:
2124 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
2125 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
2126 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
2127 BASELINK_FUNCTIONS (t2
)));
2129 case TEMPLATE_PARM_INDEX
:
2130 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2131 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
2132 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
2133 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
2134 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
2135 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
2137 case TEMPLATE_ID_EXPR
:
2142 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
2144 vec1
= TREE_OPERAND (t1
, 1);
2145 vec2
= TREE_OPERAND (t2
, 1);
2148 return !vec1
&& !vec2
;
2150 if (TREE_VEC_LENGTH (vec1
) != TREE_VEC_LENGTH (vec2
))
2153 for (ix
= TREE_VEC_LENGTH (vec1
); ix
--;)
2154 if (!cp_tree_equal (TREE_VEC_ELT (vec1
, ix
),
2155 TREE_VEC_ELT (vec2
, ix
)))
2164 tree o1
= TREE_OPERAND (t1
, 0);
2165 tree o2
= TREE_OPERAND (t2
, 0);
2167 if (TREE_CODE (o1
) != TREE_CODE (o2
))
2170 return same_type_p (o1
, o2
);
2172 return cp_tree_equal (o1
, o2
);
2177 tree t1_op1
, t2_op1
;
2179 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
2182 t1_op1
= TREE_OPERAND (t1
, 1);
2183 t2_op1
= TREE_OPERAND (t2
, 1);
2184 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
2187 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
2191 /* Two pointer-to-members are the same if they point to the same
2192 field or function in the same class. */
2193 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
2196 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
2199 if (OVL_FUNCTION (t1
) != OVL_FUNCTION (t2
))
2201 return cp_tree_equal (OVL_CHAIN (t1
), OVL_CHAIN (t2
));
2204 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
2206 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
2207 && same_type_p (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
2210 case STATIC_CAST_EXPR
:
2211 case REINTERPRET_CAST_EXPR
:
2212 case CONST_CAST_EXPR
:
2213 case DYNAMIC_CAST_EXPR
:
2215 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
2217 /* Now compare operands as usual. */
2224 switch (TREE_CODE_CLASS (code1
))
2228 case tcc_comparison
:
2229 case tcc_expression
:
2236 n
= TREE_OPERAND_LENGTH (t1
);
2237 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
2238 && n
!= TREE_OPERAND_LENGTH (t2
))
2241 for (i
= 0; i
< n
; ++i
)
2242 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
2249 return same_type_p (t1
, t2
);
2253 /* We can get here with --disable-checking. */
2257 /* The type of ARG when used as an lvalue. */
2260 lvalue_type (tree arg
)
2262 tree type
= TREE_TYPE (arg
);
2266 /* The type of ARG for printing error messages; denote lvalues with
2270 error_type (tree arg
)
2272 tree type
= TREE_TYPE (arg
);
2274 if (TREE_CODE (type
) == ARRAY_TYPE
)
2276 else if (TREE_CODE (type
) == ERROR_MARK
)
2278 else if (real_lvalue_p (arg
))
2279 type
= build_reference_type (lvalue_type (arg
));
2280 else if (MAYBE_CLASS_TYPE_P (type
))
2281 type
= lvalue_type (arg
);
2286 /* Does FUNCTION use a variable-length argument list? */
2289 varargs_function_p (const_tree function
)
2291 return stdarg_p (TREE_TYPE (function
));
2294 /* Returns 1 if decl is a member of a class. */
2297 member_p (const_tree decl
)
2299 const_tree
const ctx
= DECL_CONTEXT (decl
);
2300 return (ctx
&& TYPE_P (ctx
));
2303 /* Create a placeholder for member access where we don't actually have an
2304 object that the access is against. */
2307 build_dummy_object (tree type
)
2309 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
2310 return cp_build_indirect_ref (decl
, RO_NULL
, tf_warning_or_error
);
2313 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2314 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2315 binfo path from current_class_type to TYPE, or 0. */
2318 maybe_dummy_object (tree type
, tree
* binfop
)
2322 tree current
= current_nonlambda_class_type ();
2325 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
)))
2329 /* Reference from a nested class member function. */
2331 binfo
= TYPE_BINFO (type
);
2337 if (current_class_ref
&& context
== current_class_type
2338 /* Kludge: Make sure that current_class_type is actually
2339 correct. It might not be if we're in the middle of
2340 tsubst_default_argument. */
2341 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)),
2342 current_class_type
))
2343 decl
= current_class_ref
;
2344 else if (current
!= current_class_type
2345 && context
== nonlambda_method_basetype ())
2346 /* In a lambda, need to go through 'this' capture. */
2347 decl
= (cp_build_indirect_ref
2348 ((lambda_expr_this_capture
2349 (CLASSTYPE_LAMBDA_EXPR (current_class_type
))),
2350 RO_NULL
, tf_warning_or_error
));
2352 decl
= build_dummy_object (context
);
2357 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2360 is_dummy_object (const_tree ob
)
2362 if (TREE_CODE (ob
) == INDIRECT_REF
)
2363 ob
= TREE_OPERAND (ob
, 0);
2364 return (TREE_CODE (ob
) == NOP_EXPR
2365 && TREE_OPERAND (ob
, 0) == void_zero_node
);
2368 /* Returns 1 iff type T is something we want to treat as a scalar type for
2369 the purpose of deciding whether it is trivial/POD/standard-layout. */
2372 scalarish_type_p (const_tree t
)
2374 if (t
== error_mark_node
)
2377 return (SCALAR_TYPE_P (t
)
2378 || TREE_CODE (t
) == VECTOR_TYPE
);
2381 /* Returns true iff T requires non-trivial default initialization. */
2384 type_has_nontrivial_default_init (const_tree t
)
2386 t
= strip_array_types (CONST_CAST_TREE (t
));
2388 if (CLASS_TYPE_P (t
))
2389 return TYPE_HAS_COMPLEX_DFLT (t
);
2394 /* Returns true iff copying an object of type T (including via move
2395 constructor) is non-trivial. That is, T has no non-trivial copy
2396 constructors and no non-trivial move constructors. */
2399 type_has_nontrivial_copy_init (const_tree t
)
2401 t
= strip_array_types (CONST_CAST_TREE (t
));
2403 if (CLASS_TYPE_P (t
))
2405 gcc_assert (COMPLETE_TYPE_P (t
));
2406 return ((TYPE_HAS_COPY_CTOR (t
)
2407 && TYPE_HAS_COMPLEX_COPY_CTOR (t
))
2408 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
));
2414 /* Returns 1 iff type T is a trivially copyable type, as defined in
2415 [basic.types] and [class]. */
2418 trivially_copyable_p (const_tree t
)
2420 t
= strip_array_types (CONST_CAST_TREE (t
));
2422 if (CLASS_TYPE_P (t
))
2423 return ((!TYPE_HAS_COPY_CTOR (t
)
2424 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
2425 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
2426 && (!TYPE_HAS_COPY_ASSIGN (t
)
2427 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
2428 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
2429 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
2431 return scalarish_type_p (t
);
2434 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2438 trivial_type_p (const_tree t
)
2440 t
= strip_array_types (CONST_CAST_TREE (t
));
2442 if (CLASS_TYPE_P (t
))
2443 return (TYPE_HAS_TRIVIAL_DFLT (t
)
2444 && trivially_copyable_p (t
));
2446 return scalarish_type_p (t
);
2449 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2452 pod_type_p (const_tree t
)
2454 /* This CONST_CAST is okay because strip_array_types returns its
2455 argument unmodified and we assign it to a const_tree. */
2456 t
= strip_array_types (CONST_CAST_TREE(t
));
2458 if (!CLASS_TYPE_P (t
))
2459 return scalarish_type_p (t
);
2460 else if (cxx_dialect
> cxx98
)
2461 /* [class]/10: A POD struct is a class that is both a trivial class and a
2462 standard-layout class, and has no non-static data members of type
2463 non-POD struct, non-POD union (or array of such types).
2465 We don't need to check individual members because if a member is
2466 non-std-layout or non-trivial, the class will be too. */
2467 return (std_layout_type_p (t
) && trivial_type_p (t
));
2469 /* The C++98 definition of POD is different. */
2470 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
2473 /* Returns true iff T is POD for the purpose of layout, as defined in the
2477 layout_pod_type_p (const_tree t
)
2479 t
= strip_array_types (CONST_CAST_TREE (t
));
2481 if (CLASS_TYPE_P (t
))
2482 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
2484 return scalarish_type_p (t
);
2487 /* Returns true iff T is a standard-layout type, as defined in
2491 std_layout_type_p (const_tree t
)
2493 t
= strip_array_types (CONST_CAST_TREE (t
));
2495 if (CLASS_TYPE_P (t
))
2496 return !CLASSTYPE_NON_STD_LAYOUT (t
);
2498 return scalarish_type_p (t
);
2501 /* Nonzero iff type T is a class template implicit specialization. */
2504 class_tmpl_impl_spec_p (const_tree t
)
2506 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
2509 /* Returns 1 iff zero initialization of type T means actually storing
2513 zero_init_p (const_tree t
)
2515 /* This CONST_CAST is okay because strip_array_types returns its
2516 argument unmodified and we assign it to a const_tree. */
2517 t
= strip_array_types (CONST_CAST_TREE(t
));
2519 if (t
== error_mark_node
)
2522 /* NULL pointers to data members are initialized with -1. */
2523 if (TYPE_PTRMEM_P (t
))
2526 /* Classes that contain types that can't be zero-initialized, cannot
2527 be zero-initialized themselves. */
2528 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
2534 /* Table of valid C++ attributes. */
2535 const struct attribute_spec cxx_attribute_table
[] =
2537 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2538 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute
},
2539 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute
},
2540 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute
},
2541 { NULL
, 0, 0, false, false, false, NULL
}
2544 /* Handle a "java_interface" attribute; arguments as in
2545 struct attribute_spec.handler. */
2547 handle_java_interface_attribute (tree
* node
,
2549 tree args ATTRIBUTE_UNUSED
,
2554 || !CLASS_TYPE_P (*node
)
2555 || !TYPE_FOR_JAVA (*node
))
2557 error ("%qE attribute can only be applied to Java class definitions",
2559 *no_add_attrs
= true;
2562 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
2563 *node
= build_variant_type_copy (*node
);
2564 TYPE_JAVA_INTERFACE (*node
) = 1;
2569 /* Handle a "com_interface" attribute; arguments as in
2570 struct attribute_spec.handler. */
2572 handle_com_interface_attribute (tree
* node
,
2574 tree args ATTRIBUTE_UNUSED
,
2575 int flags ATTRIBUTE_UNUSED
,
2580 *no_add_attrs
= true;
2583 || !CLASS_TYPE_P (*node
)
2584 || *node
!= TYPE_MAIN_VARIANT (*node
))
2586 warning (OPT_Wattributes
, "%qE attribute can only be applied "
2587 "to class definitions", name
);
2592 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2598 /* Handle an "init_priority" attribute; arguments as in
2599 struct attribute_spec.handler. */
2601 handle_init_priority_attribute (tree
* node
,
2604 int flags ATTRIBUTE_UNUSED
,
2607 tree initp_expr
= TREE_VALUE (args
);
2609 tree type
= TREE_TYPE (decl
);
2612 STRIP_NOPS (initp_expr
);
2614 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
2616 error ("requested init_priority is not an integer constant");
2617 *no_add_attrs
= true;
2621 pri
= TREE_INT_CST_LOW (initp_expr
);
2623 type
= strip_array_types (type
);
2625 if (decl
== NULL_TREE
2626 || TREE_CODE (decl
) != VAR_DECL
2627 || !TREE_STATIC (decl
)
2628 || DECL_EXTERNAL (decl
)
2629 || (TREE_CODE (type
) != RECORD_TYPE
2630 && TREE_CODE (type
) != UNION_TYPE
)
2631 /* Static objects in functions are initialized the
2632 first time control passes through that
2633 function. This is not precise enough to pin down an
2634 init_priority value, so don't allow it. */
2635 || current_function_decl
)
2637 error ("can only use %qE attribute on file-scope definitions "
2638 "of objects of class type", name
);
2639 *no_add_attrs
= true;
2643 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
2645 error ("requested init_priority is out of range");
2646 *no_add_attrs
= true;
2650 /* Check for init_priorities that are reserved for
2651 language and runtime support implementations.*/
2652 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
2655 (0, "requested init_priority is reserved for internal use");
2658 if (SUPPORTS_INIT_PRIORITY
)
2660 SET_DECL_INIT_PRIORITY (decl
, pri
);
2661 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
2666 error ("%qE attribute is not supported on this platform", name
);
2667 *no_add_attrs
= true;
2672 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2673 thing pointed to by the constant. */
2676 make_ptrmem_cst (tree type
, tree member
)
2678 tree ptrmem_cst
= make_node (PTRMEM_CST
);
2679 TREE_TYPE (ptrmem_cst
) = type
;
2680 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
2684 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2685 return an existing type if an appropriate type already exists. */
2688 cp_build_type_attribute_variant (tree type
, tree attributes
)
2692 new_type
= build_type_attribute_variant (type
, attributes
);
2693 if (TREE_CODE (new_type
) == FUNCTION_TYPE
2694 || TREE_CODE (new_type
) == METHOD_TYPE
)
2695 new_type
= build_exception_variant (new_type
,
2696 TYPE_RAISES_EXCEPTIONS (type
));
2698 /* Making a new main variant of a class type is broken. */
2699 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
2704 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2705 Called only after doing all language independent checks. Only
2706 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2707 compared in type_hash_eq. */
2710 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
2712 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
);
2714 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
2715 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
2718 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2719 traversal. Called from walk_tree. */
2722 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
2723 void *data
, struct pointer_set_t
*pset
)
2725 enum tree_code code
= TREE_CODE (*tp
);
2728 #define WALK_SUBTREE(NODE) \
2731 result = cp_walk_tree (&(NODE), func, data, pset); \
2732 if (result) goto out; \
2736 /* Not one of the easy cases. We must explicitly go through the
2742 case TEMPLATE_TEMPLATE_PARM
:
2743 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2744 case UNBOUND_CLASS_TEMPLATE
:
2745 case TEMPLATE_PARM_INDEX
:
2746 case TEMPLATE_TYPE_PARM
:
2749 /* None of these have subtrees other than those already walked
2751 *walk_subtrees_p
= 0;
2755 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
2756 *walk_subtrees_p
= 0;
2760 WALK_SUBTREE (TREE_TYPE (*tp
));
2761 *walk_subtrees_p
= 0;
2765 WALK_SUBTREE (TREE_PURPOSE (*tp
));
2769 WALK_SUBTREE (OVL_FUNCTION (*tp
));
2770 WALK_SUBTREE (OVL_CHAIN (*tp
));
2771 *walk_subtrees_p
= 0;
2775 WALK_SUBTREE (DECL_NAME (*tp
));
2776 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
2777 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
2778 *walk_subtrees_p
= 0;
2782 if (TYPE_PTRMEMFUNC_P (*tp
))
2783 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
2786 case TYPE_ARGUMENT_PACK
:
2787 case NONTYPE_ARGUMENT_PACK
:
2789 tree args
= ARGUMENT_PACK_ARGS (*tp
);
2790 int i
, len
= TREE_VEC_LENGTH (args
);
2791 for (i
= 0; i
< len
; i
++)
2792 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
2796 case TYPE_PACK_EXPANSION
:
2797 WALK_SUBTREE (TREE_TYPE (*tp
));
2798 *walk_subtrees_p
= 0;
2801 case EXPR_PACK_EXPANSION
:
2802 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
2803 *walk_subtrees_p
= 0;
2807 case REINTERPRET_CAST_EXPR
:
2808 case STATIC_CAST_EXPR
:
2809 case CONST_CAST_EXPR
:
2810 case DYNAMIC_CAST_EXPR
:
2811 if (TREE_TYPE (*tp
))
2812 WALK_SUBTREE (TREE_TYPE (*tp
));
2816 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
2817 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2819 *walk_subtrees_p
= 0;
2823 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
2824 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
2825 *walk_subtrees_p
= 0;
2829 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
2830 *walk_subtrees_p
= 0;
2838 /* We didn't find what we were looking for. */
2845 /* Like save_expr, but for C++. */
2848 cp_save_expr (tree expr
)
2850 /* There is no reason to create a SAVE_EXPR within a template; if
2851 needed, we can create the SAVE_EXPR when instantiating the
2852 template. Furthermore, the middle-end cannot handle C++-specific
2854 if (processing_template_decl
)
2856 return save_expr (expr
);
2859 /* Initialize tree.c. */
2864 list_hash_table
= htab_create_ggc (31, list_hash
, list_hash_eq
, NULL
);
2867 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2868 is. Note that sfk_none is zero, so this function can be used as a
2869 predicate to test whether or not DECL is a special function. */
2871 special_function_kind
2872 special_function_p (const_tree decl
)
2874 /* Rather than doing all this stuff with magic names, we should
2875 probably have a field of type `special_function_kind' in
2876 DECL_LANG_SPECIFIC. */
2877 if (DECL_COPY_CONSTRUCTOR_P (decl
))
2878 return sfk_copy_constructor
;
2879 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
2880 return sfk_move_constructor
;
2881 if (DECL_CONSTRUCTOR_P (decl
))
2882 return sfk_constructor
;
2883 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
2885 if (copy_fn_p (decl
))
2886 return sfk_copy_assignment
;
2887 if (move_fn_p (decl
))
2888 return sfk_move_assignment
;
2890 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2891 return sfk_destructor
;
2892 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
2893 return sfk_complete_destructor
;
2894 if (DECL_BASE_DESTRUCTOR_P (decl
))
2895 return sfk_base_destructor
;
2896 if (DECL_DELETING_DESTRUCTOR_P (decl
))
2897 return sfk_deleting_destructor
;
2898 if (DECL_CONV_FN_P (decl
))
2899 return sfk_conversion
;
2904 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2907 char_type_p (tree type
)
2909 return (same_type_p (type
, char_type_node
)
2910 || same_type_p (type
, unsigned_char_type_node
)
2911 || same_type_p (type
, signed_char_type_node
)
2912 || same_type_p (type
, char16_type_node
)
2913 || same_type_p (type
, char32_type_node
)
2914 || same_type_p (type
, wchar_type_node
));
2917 /* Returns the kind of linkage associated with the indicated DECL. Th
2918 value returned is as specified by the language standard; it is
2919 independent of implementation details regarding template
2920 instantiation, etc. For example, it is possible that a declaration
2921 to which this function assigns external linkage would not show up
2922 as a global symbol when you run `nm' on the resulting object file. */
2925 decl_linkage (tree decl
)
2927 /* This function doesn't attempt to calculate the linkage from first
2928 principles as given in [basic.link]. Instead, it makes use of
2929 the fact that we have already set TREE_PUBLIC appropriately, and
2930 then handles a few special cases. Ideally, we would calculate
2931 linkage first, and then transform that into a concrete
2934 /* Things that don't have names have no linkage. */
2935 if (!DECL_NAME (decl
))
2938 /* Fields have no linkage. */
2939 if (TREE_CODE (decl
) == FIELD_DECL
)
2942 /* Things that are TREE_PUBLIC have external linkage. */
2943 if (TREE_PUBLIC (decl
))
2946 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2949 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2951 if (TREE_CODE (decl
) == CONST_DECL
)
2952 return decl_linkage (TYPE_NAME (TREE_TYPE (decl
)));
2954 /* Some things that are not TREE_PUBLIC have external linkage, too.
2955 For example, on targets that don't have weak symbols, we make all
2956 template instantiations have internal linkage (in the object
2957 file), but the symbols should still be treated as having external
2958 linkage from the point of view of the language. */
2959 if ((TREE_CODE (decl
) == FUNCTION_DECL
2960 || TREE_CODE (decl
) == VAR_DECL
)
2961 && DECL_COMDAT (decl
))
2964 /* Things in local scope do not have linkage, if they don't have
2966 if (decl_function_context (decl
))
2969 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2970 are considered to have external linkage for language purposes. DECLs
2971 really meant to have internal linkage have DECL_THIS_STATIC set. */
2972 if (TREE_CODE (decl
) == TYPE_DECL
)
2974 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
2976 if (!DECL_THIS_STATIC (decl
))
2979 /* Static data members and static member functions from classes
2980 in anonymous namespace also don't have TREE_PUBLIC set. */
2981 if (DECL_CLASS_CONTEXT (decl
))
2985 /* Everything else has internal linkage. */
2989 /* Returns the storage duration of the object or reference associated with
2990 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
2993 decl_storage_duration (tree decl
)
2995 if (TREE_CODE (decl
) == PARM_DECL
)
2997 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2999 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
3000 if (!TREE_STATIC (decl
)
3001 && !DECL_EXTERNAL (decl
))
3003 if (DECL_THREAD_LOCAL_P (decl
))
3008 /* EXP is an expression that we want to pre-evaluate. Returns (in
3009 *INITP) an expression that will perform the pre-evaluation. The
3010 value returned by this function is a side-effect free expression
3011 equivalent to the pre-evaluated expression. Callers must ensure
3012 that *INITP is evaluated before EXP. */
3015 stabilize_expr (tree exp
, tree
* initp
)
3019 if (!TREE_SIDE_EFFECTS (exp
))
3020 init_expr
= NULL_TREE
;
3021 else if (!real_lvalue_p (exp
)
3022 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp
)))
3024 init_expr
= get_target_expr (exp
);
3025 exp
= TARGET_EXPR_SLOT (init_expr
);
3029 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
3030 init_expr
= get_target_expr (exp
);
3031 exp
= TARGET_EXPR_SLOT (init_expr
);
3032 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
3036 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
3040 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3041 similar expression ORIG. */
3044 add_stmt_to_compound (tree orig
, tree new_expr
)
3046 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
3048 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
3050 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
3053 /* Like stabilize_expr, but for a call whose arguments we want to
3054 pre-evaluate. CALL is modified in place to use the pre-evaluated
3055 arguments, while, upon return, *INITP contains an expression to
3056 compute the arguments. */
3059 stabilize_call (tree call
, tree
*initp
)
3061 tree inits
= NULL_TREE
;
3063 int nargs
= call_expr_nargs (call
);
3065 if (call
== error_mark_node
|| processing_template_decl
)
3071 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
3073 for (i
= 0; i
< nargs
; i
++)
3076 CALL_EXPR_ARG (call
, i
) =
3077 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
3078 inits
= add_stmt_to_compound (inits
, init
);
3084 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3085 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3086 arguments, while, upon return, *INITP contains an expression to
3087 compute the arguments. */
3090 stabilize_aggr_init (tree call
, tree
*initp
)
3092 tree inits
= NULL_TREE
;
3094 int nargs
= aggr_init_expr_nargs (call
);
3096 if (call
== error_mark_node
)
3099 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
3101 for (i
= 0; i
< nargs
; i
++)
3104 AGGR_INIT_EXPR_ARG (call
, i
) =
3105 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
3106 inits
= add_stmt_to_compound (inits
, init
);
3112 /* Like stabilize_expr, but for an initialization.
3114 If the initialization is for an object of class type, this function
3115 takes care not to introduce additional temporaries.
3117 Returns TRUE iff the expression was successfully pre-evaluated,
3118 i.e., if INIT is now side-effect free, except for, possible, a
3119 single call to a constructor. */
3122 stabilize_init (tree init
, tree
*initp
)
3128 if (t
== error_mark_node
|| processing_template_decl
)
3131 if (TREE_CODE (t
) == INIT_EXPR
3132 && TREE_CODE (TREE_OPERAND (t
, 1)) != TARGET_EXPR
3133 && TREE_CODE (TREE_OPERAND (t
, 1)) != AGGR_INIT_EXPR
)
3135 TREE_OPERAND (t
, 1) = stabilize_expr (TREE_OPERAND (t
, 1), initp
);
3139 if (TREE_CODE (t
) == INIT_EXPR
)
3140 t
= TREE_OPERAND (t
, 1);
3141 if (TREE_CODE (t
) == TARGET_EXPR
)
3142 t
= TARGET_EXPR_INITIAL (t
);
3143 if (TREE_CODE (t
) == COMPOUND_EXPR
)
3145 if (TREE_CODE (t
) == CONSTRUCTOR
3146 && EMPTY_CONSTRUCTOR_P (t
))
3147 /* Default-initialization. */
3150 /* If the initializer is a COND_EXPR, we can't preevaluate
3152 if (TREE_CODE (t
) == COND_EXPR
)
3155 if (TREE_CODE (t
) == CALL_EXPR
)
3157 stabilize_call (t
, initp
);
3161 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
3163 stabilize_aggr_init (t
, initp
);
3167 /* The initialization is being performed via a bitwise copy -- and
3168 the item copied may have side effects. */
3169 return TREE_SIDE_EFFECTS (init
);
3172 /* Like "fold", but should be used whenever we might be processing the
3173 body of a template. */
3176 fold_if_not_in_template (tree expr
)
3178 /* In the body of a template, there is never any need to call
3179 "fold". We will call fold later when actually instantiating the
3180 template. Integral constant expressions in templates will be
3181 evaluated via fold_non_dependent_expr, as necessary. */
3182 if (processing_template_decl
)
3185 /* Fold C++ front-end specific tree codes. */
3186 if (TREE_CODE (expr
) == UNARY_PLUS_EXPR
)
3187 return fold_convert (TREE_TYPE (expr
), TREE_OPERAND (expr
, 0));
3192 /* Returns true if a cast to TYPE may appear in an integral constant
3196 cast_valid_in_integral_constant_expression_p (tree type
)
3198 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
3199 || dependent_type_p (type
)
3200 || type
== error_mark_node
);
3203 /* Return true if we need to fix linkage information of DECL. */
3206 cp_fix_function_decl_p (tree decl
)
3208 /* Skip if DECL is not externally visible. */
3209 if (!TREE_PUBLIC (decl
))
3212 /* We need to fix DECL if it a appears to be exported but with no
3213 function body. Thunks do not have CFGs and we may need to
3214 handle them specially later. */
3215 if (!gimple_has_body_p (decl
)
3216 && !DECL_THUNK_P (decl
)
3217 && !DECL_EXTERNAL (decl
))
3219 struct cgraph_node
*node
= cgraph_get_node (decl
);
3221 /* Don't fix same_body aliases. Although they don't have their own
3222 CFG, they share it with what they alias to. */
3224 || node
->decl
== decl
3225 || !node
->same_body
)
3232 /* Clean the C++ specific parts of the tree T. */
3235 cp_free_lang_data (tree t
)
3237 if (TREE_CODE (t
) == METHOD_TYPE
3238 || TREE_CODE (t
) == FUNCTION_TYPE
)
3240 /* Default args are not interesting anymore. */
3241 tree argtypes
= TYPE_ARG_TYPES (t
);
3244 TREE_PURPOSE (argtypes
) = 0;
3245 argtypes
= TREE_CHAIN (argtypes
);
3248 else if (TREE_CODE (t
) == FUNCTION_DECL
3249 && cp_fix_function_decl_p (t
))
3251 /* If T is used in this translation unit at all, the definition
3252 must exist somewhere else since we have decided to not emit it
3253 in this TU. So make it an external reference. */
3254 DECL_EXTERNAL (t
) = 1;
3255 TREE_STATIC (t
) = 0;
3257 if (CP_AGGREGATE_TYPE_P (t
)
3260 tree name
= TYPE_NAME (t
);
3261 if (TREE_CODE (name
) == TYPE_DECL
)
3262 name
= DECL_NAME (name
);
3263 /* Drop anonymous names. */
3264 if (name
!= NULL_TREE
3265 && ANON_AGGRNAME_P (name
))
3266 TYPE_NAME (t
) = NULL_TREE
;
3268 if (TREE_CODE (t
) == NAMESPACE_DECL
)
3270 /* The list of users of a namespace isn't useful for the middle-end
3271 or debug generators. */
3272 DECL_NAMESPACE_USERS (t
) = NULL_TREE
;
3273 /* Neither do we need the leftover chaining of namespaces
3274 from the binding level. */
3275 DECL_CHAIN (t
) = NULL_TREE
;
3279 /* Stub for c-common. Please keep in sync with c-decl.c.
3280 FIXME: If address space support is target specific, then this
3281 should be a C target hook. But currently this is not possible,
3282 because this function is called via REGISTER_TARGET_PRAGMAS. */
3284 c_register_addr_space (const char *word ATTRIBUTE_UNUSED
,
3285 addr_space_t as ATTRIBUTE_UNUSED
)
3290 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3291 /* Complain that some language-specific thing hanging off a tree
3292 node has been accessed improperly. */
3295 lang_check_failed (const char* file
, int line
, const char* function
)
3297 internal_error ("lang_* check: failed in %s, at %s:%d",
3298 function
, trim_filename (file
), line
);
3300 #endif /* ENABLE_TREE_CHECKING */
3302 #include "gt-cp-tree.h"