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 initialization of an array to
456 be named later, either default-initialization or copy-initialization
457 from another array of the same type. */
460 build_vec_init_expr (tree type, tree init)
463 tree inner_type = strip_array_types (type);
465 gcc_assert (init == NULL_TREE
466 || (same_type_ignoring_top_level_qualifiers_p
467 (type, TREE_TYPE (init))));
469 /* Since we're deferring building the actual constructor calls until
470 gimplification time, we need to build one now and throw it away so
471 that the relevant constructor gets mark_used before cgraph decides
472 what functions are needed. Here we assume that init is either
473 NULL_TREE or another array to copy. */
474 if (CLASS_TYPE_P (inner_type))
476 VEC(tree,gc) *argvec = make_tree_vector ();
479 tree dummy = build_dummy_object (inner_type);
480 if (!real_lvalue_p (init))
481 dummy = move (dummy);
482 VEC_quick_push (tree, argvec, dummy);
484 build_special_member_call (NULL_TREE, complete_ctor_identifier,
485 &argvec, inner_type, LOOKUP_NORMAL,
486 tf_warning_or_error);
489 slot = build_local_temp (type);
490 init = build2 (VEC_INIT_EXPR, type, slot, init);
491 SET_EXPR_LOCATION (init, input_location);
492 init = build_target_expr (slot, init);
493 TARGET_EXPR_IMPLICIT_P (init) = 1;
499 build_array_copy (tree init)
501 return build_vec_init_expr (TREE_TYPE (init), init);
504 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
508 build_target_expr_with_type (tree init, tree type)
510 gcc_assert (!VOID_TYPE_P (type));
512 if (TREE_CODE (init) == TARGET_EXPR
513 || init == error_mark_node)
515 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
516 && !VOID_TYPE_P (TREE_TYPE (init))
517 && TREE_CODE (init) != COND_EXPR
518 && TREE_CODE (init) != CONSTRUCTOR
519 && TREE_CODE (init) != VA_ARG_EXPR)
520 /* We need to build up a copy constructor call. A void initializer
521 means we're being called from bot_manip. COND_EXPR is a special
522 case because we already have copies on the arms and we don't want
523 another one here. A CONSTRUCTOR is aggregate initialization, which
524 is handled separately. A VA_ARG_EXPR is magic creation of an
525 aggregate; there's no additional work to be done. */
526 return force_rvalue (init);
528 return force_target_expr (type, init);
531 /* Like the above function, but without the checking. This function should
532 only be used by code which is deliberately trying to subvert the type
533 system, such as call_builtin_trap. Or build_over_call, to avoid
534 infinite recursion. */
537 force_target_expr (tree type, tree init)
541 gcc_assert (!VOID_TYPE_P (type));
543 slot = build_local_temp (type);
544 return build_target_expr (slot, init);
547 /* Like build_target_expr_with_type, but use the type of INIT. */
550 get_target_expr (tree init)
552 if (TREE_CODE (init) == AGGR_INIT_EXPR)
553 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init);
555 return build_target_expr_with_type (init, TREE_TYPE (init));
558 /* If EXPR is a bitfield reference, convert it to the declared type of
559 the bitfield, and return the resulting expression. Otherwise,
560 return EXPR itself. */
563 convert_bitfield_to_declared_type (tree expr)
567 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
569 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
574 /* EXPR is being used in an rvalue context. Return a version of EXPR
575 that is marked as an rvalue. */
582 if (error_operand_p (expr))
585 expr = mark_rvalue_use (expr);
589 Non-class rvalues always have cv-unqualified types. */
590 type = TREE_TYPE (expr);
591 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
592 type = cv_unqualified (type);
594 /* We need to do this for rvalue refs as well to get the right answer
595 from decltype; see c++/36628. */
596 if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
597 expr = build1 (NON_LVALUE_EXPR, type, expr);
598 else if (type != TREE_TYPE (expr))
599 expr = build_nop (type, expr);
605 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
608 cplus_array_hash (const void* k)
611 const_tree const t = (const_tree) k;
613 hash = TYPE_UID (TREE_TYPE (t));
615 hash ^= TYPE_UID (TYPE_DOMAIN (t));
619 typedef struct cplus_array_info {
624 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
625 of type `cplus_array_info*'. */
628 cplus_array_compare (const void * k1, const void * k2)
630 const_tree const t1 = (const_tree) k1;
631 const cplus_array_info *const t2 = (const cplus_array_info*) k2;
633 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
636 /* Hash table containing dependent array types, which are unsuitable for
637 the language-independent type hash table. */
638 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
640 /* Like build_array_type, but handle special C++ semantics. */
643 build_cplus_array_type (tree elt_type, tree index_type)
647 if (elt_type == error_mark_node || index_type == error_mark_node)
648 return error_mark_node;
650 if (processing_template_decl
651 && (dependent_type_p (elt_type)
652 || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
655 cplus_array_info cai;
658 if (cplus_array_htab == NULL)
659 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
660 &cplus_array_compare, NULL);
662 hash = TYPE_UID (elt_type);
664 hash ^= TYPE_UID (index_type);
666 cai.domain = index_type;
668 e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
670 /* We have found the type: we're done. */
674 /* Build a new array type. */
675 t = cxx_make_type (ARRAY_TYPE);
676 TREE_TYPE (t) = elt_type;
677 TYPE_DOMAIN (t) = index_type;
679 /* Store it in the hash table. */
682 /* Set the canonical type for this new node. */
683 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
684 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
685 SET_TYPE_STRUCTURAL_EQUALITY (t);
686 else if (TYPE_CANONICAL (elt_type) != elt_type
688 && TYPE_CANONICAL (index_type) != index_type))
690 = build_cplus_array_type
691 (TYPE_CANONICAL (elt_type),
692 index_type ? TYPE_CANONICAL (index_type) : index_type);
694 TYPE_CANONICAL (t) = t;
698 t = build_array_type (elt_type, index_type);
700 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
701 element type as well, so fix it up if needed. */
702 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
704 tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
706 if (TYPE_MAIN_VARIANT (t) != m)
708 TYPE_MAIN_VARIANT (t) = m;
709 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
710 TYPE_NEXT_VARIANT (m) = t;
714 /* Push these needs up so that initialization takes place
716 TYPE_NEEDS_CONSTRUCTING (t)
717 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
718 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
719 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
723 /* Return an ARRAY_TYPE with element type ELT and length N. */
726 build_array_of_n_type (tree elt, int n)
728 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
731 /* Return a reference type node referring to TO_TYPE. If RVAL is
732 true, return an rvalue reference type, otherwise return an lvalue
733 reference type. If a type node exists, reuse it, otherwise create
736 cp_build_reference_type (tree to_type, bool rval)
739 lvalue_ref = build_reference_type (to_type);
743 /* This code to create rvalue reference types is based on and tied
744 to the code creating lvalue reference types in the middle-end
745 functions build_reference_type_for_mode and build_reference_type.
747 It works by putting the rvalue reference type nodes after the
748 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
749 they will effectively be ignored by the middle end. */
751 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
752 if (TYPE_REF_IS_RVALUE (t))
755 t = build_distinct_type_copy (lvalue_ref);
757 TYPE_REF_IS_RVALUE (t) = true;
758 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
759 TYPE_NEXT_REF_TO (lvalue_ref) = t;
761 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
762 SET_TYPE_STRUCTURAL_EQUALITY (t);
763 else if (TYPE_CANONICAL (to_type) != to_type)
765 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
767 TYPE_CANONICAL (t) = t;
775 /* Returns EXPR cast to rvalue reference type, like std::move. */
780 tree type = TREE_TYPE (expr);
781 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
782 type = cp_build_reference_type (type, /*rval*/true);
783 return build_static_cast (type, expr, tf_warning_or_error);
786 /* Used by the C++ front end to build qualified array types. However,
787 the C version of this function does not properly maintain canonical
788 types (which are not used in C). */
790 c_build_qualified_type (tree type, int type_quals)
792 return cp_build_qualified_type (type, type_quals);
796 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
797 arrays correctly. In particular, if TYPE is an array of T's, and
798 TYPE_QUALS is non-empty, returns an array of qualified T's.
800 FLAGS determines how to deal with ill-formed qualifications. If
801 tf_ignore_bad_quals is set, then bad qualifications are dropped
802 (this is permitted if TYPE was introduced via a typedef or template
803 type parameter). If bad qualifications are dropped and tf_warning
804 is set, then a warning is issued for non-const qualifications. If
805 tf_ignore_bad_quals is not set and tf_error is not set, we
806 return error_mark_node. Otherwise, we issue an error, and ignore
809 Qualification of a reference type is valid when the reference came
810 via a typedef or template type argument. [dcl.ref] No such
811 dispensation is provided for qualifying a function type. [dcl.fct]
812 DR 295 queries this and the proposed resolution brings it into line
813 with qualifying a reference. We implement the DR. We also behave
814 in a similar manner for restricting non-pointer types. */
817 cp_build_qualified_type_real (tree type,
819 tsubst_flags_t complain)
822 int bad_quals = TYPE_UNQUALIFIED;
824 if (type == error_mark_node)
827 if (type_quals == cp_type_quals (type))
830 if (TREE_CODE (type) == ARRAY_TYPE)
832 /* In C++, the qualification really applies to the array element
833 type. Obtain the appropriately qualified element type. */
836 = cp_build_qualified_type_real (TREE_TYPE (type),
840 if (element_type == error_mark_node)
841 return error_mark_node;
843 /* See if we already have an identically qualified type. Tests
844 should be equivalent to those in check_qualified_type. */
845 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
846 if (TREE_TYPE (t) == element_type
847 && TYPE_NAME (t) == TYPE_NAME (type)
848 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
849 && attribute_list_equal (TYPE_ATTRIBUTES (t),
850 TYPE_ATTRIBUTES (type)))
855 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
857 /* Keep the typedef name. */
858 if (TYPE_NAME (t) != TYPE_NAME (type))
860 t = build_variant_type_copy (t);
861 TYPE_NAME (t) = TYPE_NAME (type);
865 /* Even if we already had this variant, we update
866 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
867 they changed since the variant was originally created.
869 This seems hokey; if there is some way to use a previous
870 variant *without* coming through here,
871 TYPE_NEEDS_CONSTRUCTING will never be updated. */
872 TYPE_NEEDS_CONSTRUCTING (t)
873 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
874 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
875 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
878 else if (TYPE_PTRMEMFUNC_P (type))
880 /* For a pointer-to-member type, we can't just return a
881 cv-qualified version of the RECORD_TYPE. If we do, we
882 haven't changed the field that contains the actual pointer to
883 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
886 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
887 t = cp_build_qualified_type_real (t, type_quals, complain);
888 return build_ptrmemfunc_type (t);
890 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
892 tree t = PACK_EXPANSION_PATTERN (type);
894 t = cp_build_qualified_type_real (t, type_quals, complain);
895 return make_pack_expansion (t);
898 /* A reference or method type shall not be cv-qualified.
899 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
900 (in CD1) we always ignore extra cv-quals on functions. */
901 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
902 && (TREE_CODE (type) == REFERENCE_TYPE
903 || TREE_CODE (type) == FUNCTION_TYPE
904 || TREE_CODE (type) == METHOD_TYPE))
906 if (TREE_CODE (type) == REFERENCE_TYPE)
907 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
908 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
911 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
912 if (TREE_CODE (type) == FUNCTION_TYPE)
913 type_quals |= type_memfn_quals (type);
915 /* A restrict-qualified type must be a pointer (or reference)
916 to object or incomplete type. */
917 if ((type_quals & TYPE_QUAL_RESTRICT)
918 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
919 && TREE_CODE (type) != TYPENAME_TYPE
920 && !POINTER_TYPE_P (type))
922 bad_quals |= TYPE_QUAL_RESTRICT;
923 type_quals &= ~TYPE_QUAL_RESTRICT;
926 if (bad_quals == TYPE_UNQUALIFIED
927 || (complain & tf_ignore_bad_quals))
929 else if (!(complain & tf_error))
930 return error_mark_node;
933 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
934 error ("%qV qualifiers cannot be applied to %qT",
938 /* Retrieve (or create) the appropriately qualified variant. */
939 result = build_qualified_type (type, type_quals);
941 /* If this was a pointer-to-method type, and we just made a copy,
942 then we need to unshare the record that holds the cached
943 pointer-to-member-function type, because these will be distinct
944 between the unqualified and qualified types. */
946 && TREE_CODE (type) == POINTER_TYPE
947 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
948 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
949 TYPE_LANG_SPECIFIC (result) = NULL;
951 /* We may also have ended up building a new copy of the canonical
952 type of a pointer-to-method type, which could have the same
953 sharing problem described above. */
954 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
955 && TREE_CODE (type) == POINTER_TYPE
956 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
957 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
958 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
959 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
964 /* Return TYPE with const and volatile removed. */
967 cv_unqualified (tree type)
971 if (type == error_mark_node)
974 quals = cp_type_quals (type);
975 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
976 return cp_build_qualified_type (type, quals);
979 /* Builds a qualified variant of T that is not a typedef variant.
980 E.g. consider the following declarations:
981 typedef const int ConstInt;
982 typedef ConstInt* PtrConstInt;
983 If T is PtrConstInt, this function returns a type representing
985 In other words, if T is a typedef, the function returns the underlying type.
986 The cv-qualification and attributes of the type returned match the
988 They will always be compatible types.
989 The returned type is built so that all of its subtypes
990 recursively have their typedefs stripped as well.
992 This is different from just returning TYPE_CANONICAL (T)
993 Because of several reasons:
994 * If T is a type that needs structural equality
995 its TYPE_CANONICAL (T) will be NULL.
996 * TYPE_CANONICAL (T) desn't carry type attributes
997 and looses template parameter names. */
1000 strip_typedefs (tree t)
1002 tree result = NULL, type = NULL, t0 = NULL;
1004 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1007 gcc_assert (TYPE_P (t));
1009 switch (TREE_CODE (t))
1012 type = strip_typedefs (TREE_TYPE (t));
1013 result = build_pointer_type (type);
1015 case REFERENCE_TYPE:
1016 type = strip_typedefs (TREE_TYPE (t));
1017 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1020 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1021 type = strip_typedefs (TREE_TYPE (t));
1022 result = build_offset_type (t0, type);
1025 if (TYPE_PTRMEMFUNC_P (t))
1027 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1028 result = build_ptrmemfunc_type (t0);
1032 type = strip_typedefs (TREE_TYPE (t));
1033 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1034 result = build_cplus_array_type (type, t0);
1039 tree arg_types = NULL, arg_node, arg_type;
1040 for (arg_node = TYPE_ARG_TYPES (t);
1042 arg_node = TREE_CHAIN (arg_node))
1044 if (arg_node == void_list_node)
1046 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1047 gcc_assert (arg_type);
1050 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1054 arg_types = nreverse (arg_types);
1056 /* A list of parameters not ending with an ellipsis
1057 must end with void_list_node. */
1059 arg_types = chainon (arg_types, void_list_node);
1061 type = strip_typedefs (TREE_TYPE (t));
1062 if (TREE_CODE (t) == METHOD_TYPE)
1064 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1065 gcc_assert (class_type);
1067 build_method_type_directly (class_type, type,
1068 TREE_CHAIN (arg_types));
1072 result = build_function_type (type,
1074 result = apply_memfn_quals (result, type_memfn_quals (t));
1077 if (TYPE_RAISES_EXCEPTIONS (t))
1078 result = build_exception_variant (result,
1079 TYPE_RAISES_EXCEPTIONS (t));
1083 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1084 TYPENAME_TYPE_FULLNAME (t),
1085 typename_type, tf_none);
1092 result = TYPE_MAIN_VARIANT (t);
1093 if (TYPE_ATTRIBUTES (t))
1094 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1095 return cp_build_qualified_type (result, cp_type_quals (t));
1098 /* Setup a TYPE_DECL node as a typedef representation.
1099 See comments of set_underlying_type in c-common.c. */
1102 cp_set_underlying_type (tree t)
1104 set_underlying_type (t);
1105 /* If T is a template type parm, make it require structural equality.
1106 This is useful when comparing two template type parms,
1107 because it forces the comparison of the template parameters of their
1109 if (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1110 SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t));
1114 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1115 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1116 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1117 VIRT indicates whether TYPE is inherited virtually or not.
1118 IGO_PREV points at the previous binfo of the inheritance graph
1119 order chain. The newly copied binfo's TREE_CHAIN forms this
1122 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1123 correct order. That is in the order the bases themselves should be
1126 The BINFO_INHERITANCE of a virtual base class points to the binfo
1127 of the most derived type. ??? We could probably change this so that
1128 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1129 remove a field. They currently can only differ for primary virtual
1133 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1139 /* See if we've already made this virtual base. */
1140 new_binfo = binfo_for_vbase (type, t);
1145 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1146 BINFO_TYPE (new_binfo) = type;
1148 /* Chain it into the inheritance graph. */
1149 TREE_CHAIN (*igo_prev) = new_binfo;
1150 *igo_prev = new_binfo;
1157 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1158 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1160 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1161 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1163 /* We do not need to copy the accesses, as they are read only. */
1164 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1166 /* Recursively copy base binfos of BINFO. */
1167 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1169 tree new_base_binfo;
1171 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1172 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1174 BINFO_VIRTUAL_P (base_binfo));
1176 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1177 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1178 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1182 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1186 /* Push it onto the list after any virtual bases it contains
1187 will have been pushed. */
1188 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1189 BINFO_VIRTUAL_P (new_binfo) = 1;
1190 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1196 /* Hashing of lists so that we don't make duplicates.
1197 The entry point is `list_hash_canon'. */
1199 /* Now here is the hash table. When recording a list, it is added
1200 to the slot whose index is the hash code mod the table size.
1201 Note that the hash table is used for several kinds of lists.
1202 While all these live in the same table, they are completely independent,
1203 and the hash code is computed differently for each of these. */
1205 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1214 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1215 for a node we are thinking about adding). */
1218 list_hash_eq (const void* entry, const void* data)
1220 const_tree const t = (const_tree) entry;
1221 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1223 return (TREE_VALUE (t) == proxy->value
1224 && TREE_PURPOSE (t) == proxy->purpose
1225 && TREE_CHAIN (t) == proxy->chain);
1228 /* Compute a hash code for a list (chain of TREE_LIST nodes
1229 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1230 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1233 list_hash_pieces (tree purpose, tree value, tree chain)
1235 hashval_t hashcode = 0;
1238 hashcode += TREE_HASH (chain);
1241 hashcode += TREE_HASH (value);
1245 hashcode += TREE_HASH (purpose);
1251 /* Hash an already existing TREE_LIST. */
1254 list_hash (const void* p)
1256 const_tree const t = (const_tree) p;
1257 return list_hash_pieces (TREE_PURPOSE (t),
1262 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1263 object for an identical list if one already exists. Otherwise, build a
1264 new one, and record it as the canonical object. */
1267 hash_tree_cons (tree purpose, tree value, tree chain)
1271 struct list_proxy proxy;
1273 /* Hash the list node. */
1274 hashcode = list_hash_pieces (purpose, value, chain);
1275 /* Create a proxy for the TREE_LIST we would like to create. We
1276 don't actually create it so as to avoid creating garbage. */
1277 proxy.purpose = purpose;
1278 proxy.value = value;
1279 proxy.chain = chain;
1280 /* See if it is already in the table. */
1281 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1283 /* If not, create a new node. */
1285 *slot = tree_cons (purpose, value, chain);
1286 return (tree) *slot;
1289 /* Constructor for hashed lists. */
1292 hash_tree_chain (tree value, tree chain)
1294 return hash_tree_cons (NULL_TREE, value, chain);
1298 debug_binfo (tree elem)
1303 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1305 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1306 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1307 debug_tree (BINFO_TYPE (elem));
1308 if (BINFO_VTABLE (elem))
1309 fprintf (stderr, "vtable decl \"%s\"\n",
1310 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1312 fprintf (stderr, "no vtable decl yet\n");
1313 fprintf (stderr, "virtuals:\n");
1314 virtuals = BINFO_VIRTUALS (elem);
1319 tree fndecl = TREE_VALUE (virtuals);
1320 fprintf (stderr, "%s [%ld =? %ld]\n",
1321 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1322 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1324 virtuals = TREE_CHAIN (virtuals);
1328 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1329 the type of the result expression, if known, or NULL_TREE if the
1330 resulting expression is type-dependent. If TEMPLATE_P is true,
1331 NAME is known to be a template because the user explicitly used the
1332 "template" keyword after the "::".
1334 All SCOPE_REFs should be built by use of this function. */
1337 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1340 if (type == error_mark_node
1341 || scope == error_mark_node
1342 || name == error_mark_node)
1343 return error_mark_node;
1344 t = build2 (SCOPE_REF, type, scope, name);
1345 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1347 t = convert_from_reference (t);
1351 /* Returns nonzero if X is an expression for a (possibly overloaded)
1352 function. If "f" is a function or function template, "f", "c->f",
1353 "c.f", "C::f", and "f<int>" will all be considered possibly
1354 overloaded functions. Returns 2 if the function is actually
1355 overloaded, i.e., if it is impossible to know the type of the
1356 function without performing overload resolution. */
1359 is_overloaded_fn (tree x)
1361 /* A baselink is also considered an overloaded function. */
1362 if (TREE_CODE (x) == OFFSET_REF
1363 || TREE_CODE (x) == COMPONENT_REF)
1364 x = TREE_OPERAND (x, 1);
1366 x = BASELINK_FUNCTIONS (x);
1367 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1368 x = TREE_OPERAND (x, 0);
1369 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1370 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1372 return (TREE_CODE (x) == FUNCTION_DECL
1373 || TREE_CODE (x) == OVERLOAD);
1376 /* Returns true iff X is an expression for an overloaded function
1377 whose type cannot be known without performing overload
1381 really_overloaded_fn (tree x)
1383 return is_overloaded_fn (x) == 2;
1389 gcc_assert (is_overloaded_fn (from));
1390 /* A baselink is also considered an overloaded function. */
1391 if (TREE_CODE (from) == OFFSET_REF
1392 || TREE_CODE (from) == COMPONENT_REF)
1393 from = TREE_OPERAND (from, 1);
1394 if (BASELINK_P (from))
1395 from = BASELINK_FUNCTIONS (from);
1396 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1397 from = TREE_OPERAND (from, 0);
1402 get_first_fn (tree from)
1404 return OVL_CURRENT (get_fns (from));
1407 /* Return a new OVL node, concatenating it with the old one. */
1410 ovl_cons (tree decl, tree chain)
1412 tree result = make_node (OVERLOAD);
1413 TREE_TYPE (result) = unknown_type_node;
1414 OVL_FUNCTION (result) = decl;
1415 TREE_CHAIN (result) = chain;
1420 /* Build a new overloaded function. If this is the first one,
1421 just return it; otherwise, ovl_cons the _DECLs */
1424 build_overload (tree decl, tree chain)
1426 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1428 if (chain && TREE_CODE (chain) != OVERLOAD)
1429 chain = ovl_cons (chain, NULL_TREE);
1430 return ovl_cons (decl, chain);
1434 #define PRINT_RING_SIZE 4
1437 cxx_printable_name_internal (tree decl, int v, bool translate)
1439 static unsigned int uid_ring[PRINT_RING_SIZE];
1440 static char *print_ring[PRINT_RING_SIZE];
1441 static bool trans_ring[PRINT_RING_SIZE];
1442 static int ring_counter;
1445 /* Only cache functions. */
1447 || TREE_CODE (decl) != FUNCTION_DECL
1448 || DECL_LANG_SPECIFIC (decl) == 0)
1449 return lang_decl_name (decl, v, translate);
1451 /* See if this print name is lying around. */
1452 for (i = 0; i < PRINT_RING_SIZE; i++)
1453 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1454 /* yes, so return it. */
1455 return print_ring[i];
1457 if (++ring_counter == PRINT_RING_SIZE)
1460 if (current_function_decl != NULL_TREE)
1462 /* There may be both translated and untranslated versions of the
1464 for (i = 0; i < 2; i++)
1466 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1468 if (ring_counter == PRINT_RING_SIZE)
1471 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1474 if (print_ring[ring_counter])
1475 free (print_ring[ring_counter]);
1477 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1478 uid_ring[ring_counter] = DECL_UID (decl);
1479 trans_ring[ring_counter] = translate;
1480 return print_ring[ring_counter];
1484 cxx_printable_name (tree decl, int v)
1486 return cxx_printable_name_internal (decl, v, false);
1490 cxx_printable_name_translate (tree decl, int v)
1492 return cxx_printable_name_internal (decl, v, true);
1495 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1496 listed in RAISES. */
1499 build_exception_variant (tree type, tree raises)
1504 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1507 type_quals = TYPE_QUALS (type);
1508 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1509 if (check_qualified_type (v, type, type_quals)
1510 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1513 /* Need to build a new variant. */
1514 v = build_variant_type_copy (type);
1515 TYPE_RAISES_EXCEPTIONS (v) = raises;
1519 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1520 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1524 bind_template_template_parm (tree t, tree newargs)
1526 tree decl = TYPE_NAME (t);
1529 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1530 decl = build_decl (input_location,
1531 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1533 /* These nodes have to be created to reflect new TYPE_DECL and template
1535 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1536 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1537 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1538 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1540 TREE_TYPE (decl) = t2;
1541 TYPE_NAME (t2) = decl;
1542 TYPE_STUB_DECL (t2) = decl;
1544 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1549 /* Called from count_trees via walk_tree. */
1552 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1562 /* Debugging function for measuring the rough complexity of a tree
1566 count_trees (tree t)
1569 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1573 /* Called from verify_stmt_tree via walk_tree. */
1576 verify_stmt_tree_r (tree* tp,
1577 int* walk_subtrees ATTRIBUTE_UNUSED ,
1581 htab_t *statements = (htab_t *) data;
1584 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1587 /* If this statement is already present in the hash table, then
1588 there is a circularity in the statement tree. */
1589 gcc_assert (!htab_find (*statements, t));
1591 slot = htab_find_slot (*statements, t, INSERT);
1597 /* Debugging function to check that the statement T has not been
1598 corrupted. For now, this function simply checks that T contains no
1602 verify_stmt_tree (tree t)
1605 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1606 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1607 htab_delete (statements);
1610 /* Check if the type T depends on a type with no linkage and if so, return
1611 it. If RELAXED_P then do not consider a class type declared within
1612 a vague-linkage function to have no linkage. */
1615 no_linkage_check (tree t, bool relaxed_p)
1619 /* There's no point in checking linkage on template functions; we
1620 can't know their complete types. */
1621 if (processing_template_decl)
1624 switch (TREE_CODE (t))
1627 if (TYPE_PTRMEMFUNC_P (t))
1629 /* Lambda types that don't have mangling scope have no linkage. We
1630 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1631 when we get here from pushtag none of the lambda information is
1632 set up yet, so we want to assume that the lambda has linkage and
1633 fix it up later if not. */
1634 if (CLASSTYPE_LAMBDA_EXPR (t)
1635 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1639 if (!CLASS_TYPE_P (t))
1643 /* Only treat anonymous types as having no linkage if they're at
1644 namespace scope. This is core issue 966. */
1645 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1648 for (r = CP_TYPE_CONTEXT (t); ; )
1650 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1651 have linkage, or we might just be in an anonymous namespace.
1652 If we're in a TREE_PUBLIC class, we have linkage. */
1653 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1654 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1655 else if (TREE_CODE (r) == FUNCTION_DECL)
1657 if (!relaxed_p || !vague_linkage_p (r))
1660 r = CP_DECL_CONTEXT (r);
1670 case REFERENCE_TYPE:
1671 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1675 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1679 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1682 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1689 for (parm = TYPE_ARG_TYPES (t);
1690 parm && parm != void_list_node;
1691 parm = TREE_CHAIN (parm))
1693 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1697 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1705 #ifdef GATHER_STATISTICS
1706 extern int depth_reached;
1710 cxx_print_statistics (void)
1712 print_search_statistics ();
1713 print_class_statistics ();
1714 print_template_statistics ();
1715 #ifdef GATHER_STATISTICS
1716 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1721 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1722 (which is an ARRAY_TYPE). This counts only elements of the top
1726 array_type_nelts_top (tree type)
1728 return fold_build2_loc (input_location,
1729 PLUS_EXPR, sizetype,
1730 array_type_nelts (type),
1734 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1735 (which is an ARRAY_TYPE). This one is a recursive count of all
1736 ARRAY_TYPEs that are clumped together. */
1739 array_type_nelts_total (tree type)
1741 tree sz = array_type_nelts_top (type);
1742 type = TREE_TYPE (type);
1743 while (TREE_CODE (type) == ARRAY_TYPE)
1745 tree n = array_type_nelts_top (type);
1746 sz = fold_build2_loc (input_location,
1747 MULT_EXPR, sizetype, sz, n);
1748 type = TREE_TYPE (type);
1753 /* Called from break_out_target_exprs via mapcar. */
1756 bot_manip (tree* tp, int* walk_subtrees, void* data)
1758 splay_tree target_remap = ((splay_tree) data);
1761 if (!TYPE_P (t) && TREE_CONSTANT (t))
1763 /* There can't be any TARGET_EXPRs or their slot variables below
1764 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1765 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1769 if (TREE_CODE (t) == TARGET_EXPR)
1773 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1774 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1));
1776 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t));
1778 /* Map the old variable to the new one. */
1779 splay_tree_insert (target_remap,
1780 (splay_tree_key) TREE_OPERAND (t, 0),
1781 (splay_tree_value) TREE_OPERAND (u, 0));
1783 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1785 /* Replace the old expression with the new version. */
1787 /* We don't have to go below this point; the recursive call to
1788 break_out_target_exprs will have handled anything below this
1794 /* Make a copy of this node. */
1795 return copy_tree_r (tp, walk_subtrees, NULL);
1798 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1799 DATA is really a splay-tree mapping old variables to new
1803 bot_replace (tree* t,
1804 int* walk_subtrees ATTRIBUTE_UNUSED ,
1807 splay_tree target_remap = ((splay_tree) data);
1809 if (TREE_CODE (*t) == VAR_DECL)
1811 splay_tree_node n = splay_tree_lookup (target_remap,
1812 (splay_tree_key) *t);
1814 *t = (tree) n->value;
1820 /* When we parse a default argument expression, we may create
1821 temporary variables via TARGET_EXPRs. When we actually use the
1822 default-argument expression, we make a copy of the expression, but
1823 we must replace the temporaries with appropriate local versions. */
1826 break_out_target_exprs (tree t)
1828 static int target_remap_count;
1829 static splay_tree target_remap;
1831 if (!target_remap_count++)
1832 target_remap = splay_tree_new (splay_tree_compare_pointers,
1833 /*splay_tree_delete_key_fn=*/NULL,
1834 /*splay_tree_delete_value_fn=*/NULL);
1835 cp_walk_tree (&t, bot_manip, target_remap, NULL);
1836 cp_walk_tree (&t, bot_replace, target_remap, NULL);
1838 if (!--target_remap_count)
1840 splay_tree_delete (target_remap);
1841 target_remap = NULL;
1847 /* Similar to `build_nt', but for template definitions of dependent
1851 build_min_nt (enum tree_code code, ...)
1858 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1862 t = make_node (code);
1863 length = TREE_CODE_LENGTH (code);
1865 for (i = 0; i < length; i++)
1867 tree x = va_arg (p, tree);
1868 TREE_OPERAND (t, i) = x;
1876 /* Similar to `build', but for template definitions. */
1879 build_min (enum tree_code code, tree tt, ...)
1886 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1890 t = make_node (code);
1891 length = TREE_CODE_LENGTH (code);
1894 for (i = 0; i < length; i++)
1896 tree x = va_arg (p, tree);
1897 TREE_OPERAND (t, i) = x;
1898 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1899 TREE_SIDE_EFFECTS (t) = 1;
1906 /* Similar to `build', but for template definitions of non-dependent
1907 expressions. NON_DEP is the non-dependent expression that has been
1911 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1918 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1920 va_start (p, non_dep);
1922 t = make_node (code);
1923 length = TREE_CODE_LENGTH (code);
1924 TREE_TYPE (t) = TREE_TYPE (non_dep);
1925 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1927 for (i = 0; i < length; i++)
1929 tree x = va_arg (p, tree);
1930 TREE_OPERAND (t, i) = x;
1933 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1934 /* This should not be considered a COMPOUND_EXPR, because it
1935 resolves to an overload. */
1936 COMPOUND_EXPR_OVERLOADED (t) = 1;
1942 /* Similar to `build_nt_call_vec', but for template definitions of
1943 non-dependent expressions. NON_DEP is the non-dependent expression
1944 that has been built. */
1947 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
1949 tree t = build_nt_call_vec (fn, argvec);
1950 TREE_TYPE (t) = TREE_TYPE (non_dep);
1951 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1956 get_type_decl (tree t)
1958 if (TREE_CODE (t) == TYPE_DECL)
1961 return TYPE_STUB_DECL (t);
1962 gcc_assert (t == error_mark_node);
1966 /* Returns the namespace that contains DECL, whether directly or
1970 decl_namespace_context (tree decl)
1974 if (TREE_CODE (decl) == NAMESPACE_DECL)
1976 else if (TYPE_P (decl))
1977 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1979 decl = CP_DECL_CONTEXT (decl);
1983 /* Returns true if decl is within an anonymous namespace, however deeply
1984 nested, or false otherwise. */
1987 decl_anon_ns_mem_p (const_tree decl)
1991 if (decl == NULL_TREE || decl == error_mark_node)
1993 if (TREE_CODE (decl) == NAMESPACE_DECL
1994 && DECL_NAME (decl) == NULL_TREE)
1996 /* Classes and namespaces inside anonymous namespaces have
1997 TREE_PUBLIC == 0, so we can shortcut the search. */
1998 else if (TYPE_P (decl))
1999 return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
2000 else if (TREE_CODE (decl) == NAMESPACE_DECL)
2001 return (TREE_PUBLIC (decl) == 0);
2003 decl = DECL_CONTEXT (decl);
2007 /* Return truthvalue of whether T1 is the same tree structure as T2.
2008 Return 1 if they are the same. Return 0 if they are different. */
2011 cp_tree_equal (tree t1, tree t2)
2013 enum tree_code code1, code2;
2020 for (code1 = TREE_CODE (t1);
2021 CONVERT_EXPR_CODE_P (code1)
2022 || code1 == NON_LVALUE_EXPR;
2023 code1 = TREE_CODE (t1))
2024 t1 = TREE_OPERAND (t1, 0);
2025 for (code2 = TREE_CODE (t2);
2026 CONVERT_EXPR_CODE_P (code2)
2027 || code1 == NON_LVALUE_EXPR;
2028 code2 = TREE_CODE (t2))
2029 t2 = TREE_OPERAND (t2, 0);
2031 /* They might have become equal now. */
2041 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2042 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2045 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2048 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2049 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2050 TREE_STRING_LENGTH (t1));
2053 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2054 TREE_FIXED_CST (t2));
2057 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2058 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2061 /* We need to do this when determining whether or not two
2062 non-type pointer to member function template arguments
2064 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2065 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2070 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2072 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2073 if (!cp_tree_equal (field, elt2->index)
2074 || !cp_tree_equal (value, elt2->value))
2081 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2083 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2085 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2088 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2093 call_expr_arg_iterator iter1, iter2;
2094 if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2096 for (arg1 = first_call_expr_arg (t1, &iter1),
2097 arg2 = first_call_expr_arg (t2, &iter2);
2099 arg1 = next_call_expr_arg (&iter1),
2100 arg2 = next_call_expr_arg (&iter2))
2101 if (!cp_tree_equal (arg1, arg2))
2110 tree o1 = TREE_OPERAND (t1, 0);
2111 tree o2 = TREE_OPERAND (t2, 0);
2113 /* Special case: if either target is an unallocated VAR_DECL,
2114 it means that it's going to be unified with whatever the
2115 TARGET_EXPR is really supposed to initialize, so treat it
2116 as being equivalent to anything. */
2117 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2118 && !DECL_RTL_SET_P (o1))
2120 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2121 && !DECL_RTL_SET_P (o2))
2123 else if (!cp_tree_equal (o1, o2))
2126 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2129 case WITH_CLEANUP_EXPR:
2130 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2132 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2135 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2137 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2140 /* For comparing uses of parameters in late-specified return types
2141 with an out-of-class definition of the function. */
2142 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2143 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
2152 case IDENTIFIER_NODE:
2157 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2158 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2159 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2160 BASELINK_FUNCTIONS (t2)));
2162 case TEMPLATE_PARM_INDEX:
2163 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2164 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2165 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2166 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2167 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2168 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2170 case TEMPLATE_ID_EXPR:
2175 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2177 vec1 = TREE_OPERAND (t1, 1);
2178 vec2 = TREE_OPERAND (t2, 1);
2181 return !vec1 && !vec2;
2183 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2186 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2187 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2188 TREE_VEC_ELT (vec2, ix)))
2197 tree o1 = TREE_OPERAND (t1, 0);
2198 tree o2 = TREE_OPERAND (t2, 0);
2200 if (TREE_CODE (o1) != TREE_CODE (o2))
2203 return same_type_p (o1, o2);
2205 return cp_tree_equal (o1, o2);
2210 tree t1_op1, t2_op1;
2212 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2215 t1_op1 = TREE_OPERAND (t1, 1);
2216 t2_op1 = TREE_OPERAND (t2, 1);
2217 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2220 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2224 /* Two pointer-to-members are the same if they point to the same
2225 field or function in the same class. */
2226 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2229 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2232 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2234 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2237 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2239 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2240 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2243 case STATIC_CAST_EXPR:
2244 case REINTERPRET_CAST_EXPR:
2245 case CONST_CAST_EXPR:
2246 case DYNAMIC_CAST_EXPR:
2248 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2250 /* Now compare operands as usual. */
2257 switch (TREE_CODE_CLASS (code1))
2261 case tcc_comparison:
2262 case tcc_expression:
2269 n = TREE_OPERAND_LENGTH (t1);
2270 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2271 && n != TREE_OPERAND_LENGTH (t2))
2274 for (i = 0; i < n; ++i)
2275 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2282 return same_type_p (t1, t2);
2286 /* We can get here with --disable-checking. */
2290 /* The type of ARG when used as an lvalue. */
2293 lvalue_type (tree arg)
2295 tree type = TREE_TYPE (arg);
2299 /* The type of ARG for printing error messages; denote lvalues with
2303 error_type (tree arg)
2305 tree type = TREE_TYPE (arg);
2307 if (TREE_CODE (type) == ARRAY_TYPE)
2309 else if (TREE_CODE (type) == ERROR_MARK)
2311 else if (real_lvalue_p (arg))
2312 type = build_reference_type (lvalue_type (arg));
2313 else if (MAYBE_CLASS_TYPE_P (type))
2314 type = lvalue_type (arg);
2319 /* Does FUNCTION use a variable-length argument list? */
2322 varargs_function_p (const_tree function)
2324 return stdarg_p (TREE_TYPE (function));
2327 /* Returns 1 if decl is a member of a class. */
2330 member_p (const_tree decl)
2332 const_tree const ctx = DECL_CONTEXT (decl);
2333 return (ctx && TYPE_P (ctx));
2336 /* Create a placeholder for member access where we don't actually have an
2337 object that the access is against. */
2340 build_dummy_object (tree type)
2342 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2343 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2346 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2347 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2348 binfo path from current_class_type to TYPE, or 0. */
2351 maybe_dummy_object (tree type, tree* binfop)
2355 tree current = current_nonlambda_class_type ();
2358 && (binfo = lookup_base (current, type, ba_any, NULL)))
2362 /* Reference from a nested class member function. */
2364 binfo = TYPE_BINFO (type);
2370 if (current_class_ref && context == current_class_type
2371 /* Kludge: Make sure that current_class_type is actually
2372 correct. It might not be if we're in the middle of
2373 tsubst_default_argument. */
2374 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
2375 current_class_type))
2376 decl = current_class_ref;
2377 else if (current != current_class_type
2378 && context == nonlambda_method_basetype ())
2379 /* In a lambda, need to go through 'this' capture. */
2380 decl = (cp_build_indirect_ref
2381 ((lambda_expr_this_capture
2382 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2383 RO_NULL, tf_warning_or_error));
2385 decl = build_dummy_object (context);
2390 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2393 is_dummy_object (const_tree ob)
2395 if (TREE_CODE (ob) == INDIRECT_REF)
2396 ob = TREE_OPERAND (ob, 0);
2397 return (TREE_CODE (ob) == NOP_EXPR
2398 && TREE_OPERAND (ob, 0) == void_zero_node);
2401 /* Returns 1 iff type T is something we want to treat as a scalar type for
2402 the purpose of deciding whether it is trivial/POD/standard-layout. */
2405 scalarish_type_p (const_tree t)
2407 if (t == error_mark_node)
2410 return (SCALAR_TYPE_P (t)
2411 || TREE_CODE (t) == VECTOR_TYPE);
2414 /* Returns true iff T requires non-trivial default initialization. */
2417 type_has_nontrivial_default_init (const_tree t)
2419 t = strip_array_types (CONST_CAST_TREE (t));
2421 if (CLASS_TYPE_P (t))
2422 return TYPE_HAS_COMPLEX_DFLT (t);
2427 /* Returns true iff copying an object of type T (including via move
2428 constructor) is non-trivial. That is, T has no non-trivial copy
2429 constructors and no non-trivial move constructors. */
2432 type_has_nontrivial_copy_init (const_tree t)
2434 t = strip_array_types (CONST_CAST_TREE (t));
2436 if (CLASS_TYPE_P (t))
2438 gcc_assert (COMPLETE_TYPE_P (t));
2439 return ((TYPE_HAS_COPY_CTOR (t)
2440 && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2441 || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2447 /* Returns 1 iff type T is a trivially copyable type, as defined in
2448 [basic.types] and [class]. */
2451 trivially_copyable_p (const_tree t)
2453 t = strip_array_types (CONST_CAST_TREE (t));
2455 if (CLASS_TYPE_P (t))
2456 return ((!TYPE_HAS_COPY_CTOR (t)
2457 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2458 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2459 && (!TYPE_HAS_COPY_ASSIGN (t)
2460 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2461 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2462 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2464 return scalarish_type_p (t);
2467 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2471 trivial_type_p (const_tree t)
2473 t = strip_array_types (CONST_CAST_TREE (t));
2475 if (CLASS_TYPE_P (t))
2476 return (TYPE_HAS_TRIVIAL_DFLT (t)
2477 && trivially_copyable_p (t));
2479 return scalarish_type_p (t);
2482 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2485 pod_type_p (const_tree t)
2487 /* This CONST_CAST is okay because strip_array_types returns its
2488 argument unmodified and we assign it to a const_tree. */
2489 t = strip_array_types (CONST_CAST_TREE(t));
2491 if (!CLASS_TYPE_P (t))
2492 return scalarish_type_p (t);
2493 else if (cxx_dialect > cxx98)
2494 /* [class]/10: A POD struct is a class that is both a trivial class and a
2495 standard-layout class, and has no non-static data members of type
2496 non-POD struct, non-POD union (or array of such types).
2498 We don't need to check individual members because if a member is
2499 non-std-layout or non-trivial, the class will be too. */
2500 return (std_layout_type_p (t) && trivial_type_p (t));
2502 /* The C++98 definition of POD is different. */
2503 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2506 /* Returns true iff T is POD for the purpose of layout, as defined in the
2510 layout_pod_type_p (const_tree t)
2512 t = strip_array_types (CONST_CAST_TREE (t));
2514 if (CLASS_TYPE_P (t))
2515 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2517 return scalarish_type_p (t);
2520 /* Returns true iff T is a standard-layout type, as defined in
2524 std_layout_type_p (const_tree t)
2526 t = strip_array_types (CONST_CAST_TREE (t));
2528 if (CLASS_TYPE_P (t))
2529 return !CLASSTYPE_NON_STD_LAYOUT (t);
2531 return scalarish_type_p (t);
2534 /* Nonzero iff type T is a class template implicit specialization. */
2537 class_tmpl_impl_spec_p (const_tree t)
2539 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2542 /* Returns 1 iff zero initialization of type T means actually storing
2546 zero_init_p (const_tree t)
2548 /* This CONST_CAST is okay because strip_array_types returns its
2549 argument unmodified and we assign it to a const_tree. */
2550 t = strip_array_types (CONST_CAST_TREE(t));
2552 if (t == error_mark_node)
2555 /* NULL pointers to data members are initialized with -1. */
2556 if (TYPE_PTRMEM_P (t))
2559 /* Classes that contain types that can't be zero-initialized, cannot
2560 be zero-initialized themselves. */
2561 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2567 /* Table of valid C++ attributes. */
2568 const struct attribute_spec cxx_attribute_table[] =
2570 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2571 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2572 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
2573 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
2574 { NULL, 0, 0, false, false, false, NULL }
2577 /* Handle a "java_interface" attribute; arguments as in
2578 struct attribute_spec.handler. */
2580 handle_java_interface_attribute (tree* node,
2582 tree args ATTRIBUTE_UNUSED ,
2587 || !CLASS_TYPE_P (*node)
2588 || !TYPE_FOR_JAVA (*node))
2590 error ("%qE attribute can only be applied to Java class definitions",
2592 *no_add_attrs = true;
2595 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2596 *node = build_variant_type_copy (*node);
2597 TYPE_JAVA_INTERFACE (*node) = 1;
2602 /* Handle a "com_interface" attribute; arguments as in
2603 struct attribute_spec.handler. */
2605 handle_com_interface_attribute (tree* node,
2607 tree args ATTRIBUTE_UNUSED ,
2608 int flags ATTRIBUTE_UNUSED ,
2613 *no_add_attrs = true;
2616 || !CLASS_TYPE_P (*node)
2617 || *node != TYPE_MAIN_VARIANT (*node))
2619 warning (OPT_Wattributes, "%qE attribute can only be applied "
2620 "to class definitions", name);
2625 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2631 /* Handle an "init_priority" attribute; arguments as in
2632 struct attribute_spec.handler. */
2634 handle_init_priority_attribute (tree* node,
2637 int flags ATTRIBUTE_UNUSED ,
2640 tree initp_expr = TREE_VALUE (args);
2642 tree type = TREE_TYPE (decl);
2645 STRIP_NOPS (initp_expr);
2647 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2649 error ("requested init_priority is not an integer constant");
2650 *no_add_attrs = true;
2654 pri = TREE_INT_CST_LOW (initp_expr);
2656 type = strip_array_types (type);
2658 if (decl == NULL_TREE
2659 || TREE_CODE (decl) != VAR_DECL
2660 || !TREE_STATIC (decl)
2661 || DECL_EXTERNAL (decl)
2662 || (TREE_CODE (type) != RECORD_TYPE
2663 && TREE_CODE (type) != UNION_TYPE)
2664 /* Static objects in functions are initialized the
2665 first time control passes through that
2666 function. This is not precise enough to pin down an
2667 init_priority value, so don't allow it. */
2668 || current_function_decl)
2670 error ("can only use %qE attribute on file-scope definitions "
2671 "of objects of class type", name);
2672 *no_add_attrs = true;
2676 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2678 error ("requested init_priority is out of range");
2679 *no_add_attrs = true;
2683 /* Check for init_priorities that are reserved for
2684 language and runtime support implementations.*/
2685 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2688 (0, "requested init_priority is reserved for internal use");
2691 if (SUPPORTS_INIT_PRIORITY)
2693 SET_DECL_INIT_PRIORITY (decl, pri);
2694 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2699 error ("%qE attribute is not supported on this platform", name);
2700 *no_add_attrs = true;
2705 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2706 thing pointed to by the constant. */
2709 make_ptrmem_cst (tree type, tree member)
2711 tree ptrmem_cst = make_node (PTRMEM_CST);
2712 TREE_TYPE (ptrmem_cst) = type;
2713 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2717 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2718 return an existing type if an appropriate type already exists. */
2721 cp_build_type_attribute_variant (tree type, tree attributes)
2725 new_type = build_type_attribute_variant (type, attributes);
2726 if (TREE_CODE (new_type) == FUNCTION_TYPE
2727 || TREE_CODE (new_type) == METHOD_TYPE)
2728 new_type = build_exception_variant (new_type,
2729 TYPE_RAISES_EXCEPTIONS (type));
2731 /* Making a new main variant of a class type is broken. */
2732 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2737 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2738 Called only after doing all language independent checks. Only
2739 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2740 compared in type_hash_eq. */
2743 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2745 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE);
2747 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2748 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
2751 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2752 traversal. Called from walk_tree. */
2755 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2756 void *data, struct pointer_set_t *pset)
2758 enum tree_code code = TREE_CODE (*tp);
2761 #define WALK_SUBTREE(NODE) \
2764 result = cp_walk_tree (&(NODE), func, data, pset); \
2765 if (result) goto out; \
2769 /* Not one of the easy cases. We must explicitly go through the
2775 case TEMPLATE_TEMPLATE_PARM:
2776 case BOUND_TEMPLATE_TEMPLATE_PARM:
2777 case UNBOUND_CLASS_TEMPLATE:
2778 case TEMPLATE_PARM_INDEX:
2779 case TEMPLATE_TYPE_PARM:
2782 /* None of these have subtrees other than those already walked
2784 *walk_subtrees_p = 0;
2788 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2789 *walk_subtrees_p = 0;
2793 WALK_SUBTREE (TREE_TYPE (*tp));
2794 *walk_subtrees_p = 0;
2798 WALK_SUBTREE (TREE_PURPOSE (*tp));
2802 WALK_SUBTREE (OVL_FUNCTION (*tp));
2803 WALK_SUBTREE (OVL_CHAIN (*tp));
2804 *walk_subtrees_p = 0;
2808 WALK_SUBTREE (DECL_NAME (*tp));
2809 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2810 WALK_SUBTREE (USING_DECL_DECLS (*tp));
2811 *walk_subtrees_p = 0;
2815 if (TYPE_PTRMEMFUNC_P (*tp))
2816 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2819 case TYPE_ARGUMENT_PACK:
2820 case NONTYPE_ARGUMENT_PACK:
2822 tree args = ARGUMENT_PACK_ARGS (*tp);
2823 int i, len = TREE_VEC_LENGTH (args);
2824 for (i = 0; i < len; i++)
2825 WALK_SUBTREE (TREE_VEC_ELT (args, i));
2829 case TYPE_PACK_EXPANSION:
2830 WALK_SUBTREE (TREE_TYPE (*tp));
2831 *walk_subtrees_p = 0;
2834 case EXPR_PACK_EXPANSION:
2835 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2836 *walk_subtrees_p = 0;
2840 case REINTERPRET_CAST_EXPR:
2841 case STATIC_CAST_EXPR:
2842 case CONST_CAST_EXPR:
2843 case DYNAMIC_CAST_EXPR:
2844 if (TREE_TYPE (*tp))
2845 WALK_SUBTREE (TREE_TYPE (*tp));
2849 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2850 WALK_SUBTREE (TREE_OPERAND (*tp, i));
2852 *walk_subtrees_p = 0;
2856 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2857 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2858 *walk_subtrees_p = 0;
2862 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2863 *walk_subtrees_p = 0;
2871 /* We didn't find what we were looking for. */
2878 /* Like save_expr, but for C++. */
2881 cp_save_expr (tree expr)
2883 /* There is no reason to create a SAVE_EXPR within a template; if
2884 needed, we can create the SAVE_EXPR when instantiating the
2885 template. Furthermore, the middle-end cannot handle C++-specific
2887 if (processing_template_decl)
2889 return save_expr (expr);
2892 /* Initialize tree.c. */
2897 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2900 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2901 is. Note that sfk_none is zero, so this function can be used as a
2902 predicate to test whether or not DECL is a special function. */
2904 special_function_kind
2905 special_function_p (const_tree decl)
2907 /* Rather than doing all this stuff with magic names, we should
2908 probably have a field of type `special_function_kind' in
2909 DECL_LANG_SPECIFIC. */
2910 if (DECL_COPY_CONSTRUCTOR_P (decl))
2911 return sfk_copy_constructor;
2912 if (DECL_MOVE_CONSTRUCTOR_P (decl))
2913 return sfk_move_constructor;
2914 if (DECL_CONSTRUCTOR_P (decl))
2915 return sfk_constructor;
2916 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2918 if (copy_fn_p (decl))
2919 return sfk_copy_assignment;
2920 if (move_fn_p (decl))
2921 return sfk_move_assignment;
2923 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2924 return sfk_destructor;
2925 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2926 return sfk_complete_destructor;
2927 if (DECL_BASE_DESTRUCTOR_P (decl))
2928 return sfk_base_destructor;
2929 if (DECL_DELETING_DESTRUCTOR_P (decl))
2930 return sfk_deleting_destructor;
2931 if (DECL_CONV_FN_P (decl))
2932 return sfk_conversion;
2937 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2940 char_type_p (tree type)
2942 return (same_type_p (type, char_type_node)
2943 || same_type_p (type, unsigned_char_type_node)
2944 || same_type_p (type, signed_char_type_node)
2945 || same_type_p (type, char16_type_node)
2946 || same_type_p (type, char32_type_node)
2947 || same_type_p (type, wchar_type_node));
2950 /* Returns the kind of linkage associated with the indicated DECL. Th
2951 value returned is as specified by the language standard; it is
2952 independent of implementation details regarding template
2953 instantiation, etc. For example, it is possible that a declaration
2954 to which this function assigns external linkage would not show up
2955 as a global symbol when you run `nm' on the resulting object file. */
2958 decl_linkage (tree decl)
2960 /* This function doesn't attempt to calculate the linkage from first
2961 principles as given in [basic.link]. Instead, it makes use of
2962 the fact that we have already set TREE_PUBLIC appropriately, and
2963 then handles a few special cases. Ideally, we would calculate
2964 linkage first, and then transform that into a concrete
2967 /* Things that don't have names have no linkage. */
2968 if (!DECL_NAME (decl))
2971 /* Fields have no linkage. */
2972 if (TREE_CODE (decl) == FIELD_DECL)
2975 /* Things that are TREE_PUBLIC have external linkage. */
2976 if (TREE_PUBLIC (decl))
2979 if (TREE_CODE (decl) == NAMESPACE_DECL)
2982 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2984 if (TREE_CODE (decl) == CONST_DECL)
2985 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2987 /* Some things that are not TREE_PUBLIC have external linkage, too.
2988 For example, on targets that don't have weak symbols, we make all
2989 template instantiations have internal linkage (in the object
2990 file), but the symbols should still be treated as having external
2991 linkage from the point of view of the language. */
2992 if ((TREE_CODE (decl) == FUNCTION_DECL
2993 || TREE_CODE (decl) == VAR_DECL)
2994 && DECL_COMDAT (decl))
2997 /* Things in local scope do not have linkage, if they don't have
2999 if (decl_function_context (decl))
3002 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3003 are considered to have external linkage for language purposes. DECLs
3004 really meant to have internal linkage have DECL_THIS_STATIC set. */
3005 if (TREE_CODE (decl) == TYPE_DECL)
3007 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3009 if (!DECL_THIS_STATIC (decl))
3012 /* Static data members and static member functions from classes
3013 in anonymous namespace also don't have TREE_PUBLIC set. */
3014 if (DECL_CLASS_CONTEXT (decl))
3018 /* Everything else has internal linkage. */
3022 /* Returns the storage duration of the object or reference associated with
3023 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
3026 decl_storage_duration (tree decl)
3028 if (TREE_CODE (decl) == PARM_DECL)
3030 if (TREE_CODE (decl) == FUNCTION_DECL)
3032 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3033 if (!TREE_STATIC (decl)
3034 && !DECL_EXTERNAL (decl))
3036 if (DECL_THREAD_LOCAL_P (decl))
3041 /* EXP is an expression that we want to pre-evaluate. Returns (in
3042 *INITP) an expression that will perform the pre-evaluation. The
3043 value returned by this function is a side-effect free expression
3044 equivalent to the pre-evaluated expression. Callers must ensure
3045 that *INITP is evaluated before EXP. */
3048 stabilize_expr (tree exp, tree* initp)
3052 if (!TREE_SIDE_EFFECTS (exp))
3053 init_expr = NULL_TREE;
3054 /* There are no expressions with REFERENCE_TYPE, but there can be call
3055 arguments with such a type; just treat it as a pointer. */
3056 else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3057 || !lvalue_or_rvalue_with_address_p (exp))
3059 init_expr = get_target_expr (exp);
3060 exp = TARGET_EXPR_SLOT (init_expr);
3064 bool xval = !real_lvalue_p (exp);
3065 exp = cp_build_addr_expr (exp, tf_warning_or_error);
3066 init_expr = get_target_expr (exp);
3067 exp = TARGET_EXPR_SLOT (init_expr);
3068 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3074 gcc_assert (!TREE_SIDE_EFFECTS (exp));
3078 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3079 similar expression ORIG. */
3082 add_stmt_to_compound (tree orig, tree new_expr)
3084 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3086 if (!orig || !TREE_SIDE_EFFECTS (orig))
3088 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3091 /* Like stabilize_expr, but for a call whose arguments we want to
3092 pre-evaluate. CALL is modified in place to use the pre-evaluated
3093 arguments, while, upon return, *INITP contains an expression to
3094 compute the arguments. */
3097 stabilize_call (tree call, tree *initp)
3099 tree inits = NULL_TREE;
3101 int nargs = call_expr_nargs (call);
3103 if (call == error_mark_node || processing_template_decl)
3109 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3111 for (i = 0; i < nargs; i++)
3114 CALL_EXPR_ARG (call, i) =
3115 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3116 inits = add_stmt_to_compound (inits, init);
3122 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3123 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3124 arguments, while, upon return, *INITP contains an expression to
3125 compute the arguments. */
3128 stabilize_aggr_init (tree call, tree *initp)
3130 tree inits = NULL_TREE;
3132 int nargs = aggr_init_expr_nargs (call);
3134 if (call == error_mark_node)
3137 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3139 for (i = 0; i < nargs; i++)
3142 AGGR_INIT_EXPR_ARG (call, i) =
3143 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3144 inits = add_stmt_to_compound (inits, init);
3150 /* Like stabilize_expr, but for an initialization.
3152 If the initialization is for an object of class type, this function
3153 takes care not to introduce additional temporaries.
3155 Returns TRUE iff the expression was successfully pre-evaluated,
3156 i.e., if INIT is now side-effect free, except for, possible, a
3157 single call to a constructor. */
3160 stabilize_init (tree init, tree *initp)
3166 if (t == error_mark_node || processing_template_decl)
3169 if (TREE_CODE (t) == INIT_EXPR
3170 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3171 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3173 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3177 if (TREE_CODE (t) == INIT_EXPR)
3178 t = TREE_OPERAND (t, 1);
3179 if (TREE_CODE (t) == TARGET_EXPR)
3180 t = TARGET_EXPR_INITIAL (t);
3181 if (TREE_CODE (t) == COMPOUND_EXPR)
3183 if (TREE_CODE (t) == CONSTRUCTOR
3184 && EMPTY_CONSTRUCTOR_P (t))
3185 /* Default-initialization. */
3188 /* If the initializer is a COND_EXPR, we can't preevaluate
3190 if (TREE_CODE (t) == COND_EXPR)
3193 if (TREE_CODE (t) == CALL_EXPR)
3195 stabilize_call (t, initp);
3199 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3201 stabilize_aggr_init (t, initp);
3205 /* The initialization is being performed via a bitwise copy -- and
3206 the item copied may have side effects. */
3207 return TREE_SIDE_EFFECTS (init);
3210 /* Like "fold", but should be used whenever we might be processing the
3211 body of a template. */
3214 fold_if_not_in_template (tree expr)
3216 /* In the body of a template, there is never any need to call
3217 "fold". We will call fold later when actually instantiating the
3218 template. Integral constant expressions in templates will be
3219 evaluated via fold_non_dependent_expr, as necessary. */
3220 if (processing_template_decl)
3223 /* Fold C++ front-end specific tree codes. */
3224 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3225 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3230 /* Returns true if a cast to TYPE may appear in an integral constant
3234 cast_valid_in_integral_constant_expression_p (tree type)
3236 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3237 || dependent_type_p (type)
3238 || type == error_mark_node);
3241 /* Return true if we need to fix linkage information of DECL. */
3244 cp_fix_function_decl_p (tree decl)
3246 /* Skip if DECL is not externally visible. */
3247 if (!TREE_PUBLIC (decl))
3250 /* We need to fix DECL if it a appears to be exported but with no
3251 function body. Thunks do not have CFGs and we may need to
3252 handle them specially later. */
3253 if (!gimple_has_body_p (decl)
3254 && !DECL_THUNK_P (decl)
3255 && !DECL_EXTERNAL (decl))
3257 struct cgraph_node *node = cgraph_get_node (decl);
3259 /* Don't fix same_body aliases. Although they don't have their own
3260 CFG, they share it with what they alias to. */
3262 || node->decl == decl
3263 || !node->same_body)
3270 /* Clean the C++ specific parts of the tree T. */
3273 cp_free_lang_data (tree t)
3275 if (TREE_CODE (t) == METHOD_TYPE
3276 || TREE_CODE (t) == FUNCTION_TYPE)
3278 /* Default args are not interesting anymore. */
3279 tree argtypes = TYPE_ARG_TYPES (t);
3282 TREE_PURPOSE (argtypes) = 0;
3283 argtypes = TREE_CHAIN (argtypes);
3286 else if (TREE_CODE (t) == FUNCTION_DECL
3287 && cp_fix_function_decl_p (t))
3289 /* If T is used in this translation unit at all, the definition
3290 must exist somewhere else since we have decided to not emit it
3291 in this TU. So make it an external reference. */
3292 DECL_EXTERNAL (t) = 1;
3293 TREE_STATIC (t) = 0;
3295 if (CP_AGGREGATE_TYPE_P (t)
3298 tree name = TYPE_NAME (t);
3299 if (TREE_CODE (name) == TYPE_DECL)
3300 name = DECL_NAME (name);
3301 /* Drop anonymous names. */
3302 if (name != NULL_TREE
3303 && ANON_AGGRNAME_P (name))
3304 TYPE_NAME (t) = NULL_TREE;
3306 if (TREE_CODE (t) == NAMESPACE_DECL)
3308 /* The list of users of a namespace isn't useful for the middle-end
3309 or debug generators. */
3310 DECL_NAMESPACE_USERS (t) = NULL_TREE;
3311 /* Neither do we need the leftover chaining of namespaces
3312 from the binding level. */
3313 DECL_CHAIN (t) = NULL_TREE;
3317 /* Stub for c-common. Please keep in sync with c-decl.c.
3318 FIXME: If address space support is target specific, then this
3319 should be a C target hook. But currently this is not possible,
3320 because this function is called via REGISTER_TARGET_PRAGMAS. */
3322 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3323 addr_space_t as ATTRIBUTE_UNUSED)
3328 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3329 /* Complain that some language-specific thing hanging off a tree
3330 node has been accessed improperly. */
3333 lang_check_failed (const char* file, int line, const char* function)
3335 internal_error ("lang_* check: failed in %s, at %s:%d",
3336 function, trim_filename (file), line);
3338 #endif /* ENABLE_TREE_CHECKING */
3340 #include "gt-cp-tree.h"