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, 2010
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"
30 #include "tree-inline.h"
34 #include "splay-tree.h"
35 #include "gimple.h" /* gimple_has_body_p */
37 static tree bot_manip (tree *, int *, void *);
38 static tree bot_replace (tree *, int *, void *);
39 static int list_hash_eq (const void *, const void *);
40 static hashval_t list_hash_pieces (tree, tree, tree);
41 static hashval_t list_hash (const void *);
42 static tree build_target_expr (tree, tree);
43 static tree count_trees_r (tree *, int *, void *);
44 static tree verify_stmt_tree_r (tree *, int *, void *);
45 static tree build_local_temp (tree);
47 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
55 lvalue_kind (const_tree ref)
57 cp_lvalue_kind op1_lvalue_kind = clk_none;
58 cp_lvalue_kind op2_lvalue_kind = clk_none;
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
64 if (TREE_CODE (ref) == INDIRECT_REF
65 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0)))
67 return lvalue_kind (TREE_OPERAND (ref, 0));
70 && 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 scope ref in a template, left as SCOPE_REF to support later
152 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE(ref)));
153 return lvalue_kind (TREE_OPERAND (ref, 1));
157 /* Disallow <? and >? as lvalues if either argument side-effects. */
158 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
159 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
161 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
162 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
166 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)
167 ? TREE_OPERAND (ref, 1)
168 : TREE_OPERAND (ref, 0));
169 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2));
176 return lvalue_kind (TREE_OPERAND (ref, 1));
182 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
185 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
189 /* All functions (except non-static-member functions) are
191 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
192 ? clk_none : clk_ordinary);
195 /* We now represent a reference to a single static member function
197 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
198 its argument unmodified and we assign it to a const_tree. */
199 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
201 case NON_DEPENDENT_EXPR:
202 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
203 things like "&E" where "E" is an expression with a
204 non-dependent type work. It is safe to be lenient because an
205 error will be issued when the template is instantiated if "E"
213 /* If one operand is not an lvalue at all, then this expression is
215 if (!op1_lvalue_kind || !op2_lvalue_kind)
218 /* Otherwise, it's an lvalue, and it has all the odd properties
219 contributed by either operand. */
220 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
221 /* It's not an ordinary lvalue if it involves any other kind. */
222 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
223 op1_lvalue_kind &= ~clk_ordinary;
224 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
225 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
226 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
227 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
228 op1_lvalue_kind = clk_none;
229 return op1_lvalue_kind;
232 /* Returns the kind of lvalue that REF is, in the sense of
233 [basic.lval]. This function should really be named lvalue_p; it
234 computes the C++ definition of lvalue. */
237 real_lvalue_p (const_tree ref)
239 cp_lvalue_kind kind = lvalue_kind (ref);
240 if (kind & (clk_rvalueref|clk_class))
246 /* This differs from real_lvalue_p in that class rvalues are considered
250 lvalue_p (const_tree ref)
252 return (lvalue_kind (ref) != clk_none);
255 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
256 rvalue references are considered rvalues. */
259 lvalue_or_rvalue_with_address_p (const_tree ref)
261 cp_lvalue_kind kind = lvalue_kind (ref);
262 if (kind & clk_class)
265 return (kind != clk_none);
268 /* Test whether DECL is a builtin that may appear in a
269 constant-expression. */
272 builtin_valid_in_constant_expr_p (const_tree decl)
274 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
275 in constant-expressions. We may want to add other builtins later. */
276 return DECL_IS_BUILTIN_CONSTANT_P (decl);
279 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
282 build_target_expr (tree decl, tree value)
286 #ifdef ENABLE_CHECKING
287 gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
288 || TREE_TYPE (decl) == TREE_TYPE (value)
289 || useless_type_conversion_p (TREE_TYPE (decl),
293 t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
294 cxx_maybe_build_cleanup (decl), NULL_TREE);
295 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
296 ignore the TARGET_EXPR. If there really turn out to be no
297 side-effects, then the optimizer should be able to get rid of
298 whatever code is generated anyhow. */
299 TREE_SIDE_EFFECTS (t) = 1;
304 /* Return an undeclared local temporary of type TYPE for use in building a
308 build_local_temp (tree type)
310 tree slot = build_decl (input_location,
311 VAR_DECL, NULL_TREE, type);
312 DECL_ARTIFICIAL (slot) = 1;
313 DECL_IGNORED_P (slot) = 1;
314 DECL_CONTEXT (slot) = current_function_decl;
315 layout_decl (slot, 0);
319 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
322 process_aggr_init_operands (tree t)
326 side_effects = TREE_SIDE_EFFECTS (t);
330 n = TREE_OPERAND_LENGTH (t);
331 for (i = 1; i < n; i++)
333 tree op = TREE_OPERAND (t, i);
334 if (op && TREE_SIDE_EFFECTS (op))
341 TREE_SIDE_EFFECTS (t) = side_effects;
344 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
345 FN, and SLOT. NARGS is the number of call arguments which are specified
346 as a tree array ARGS. */
349 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
355 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
356 TREE_TYPE (t) = return_type;
357 AGGR_INIT_EXPR_FN (t) = fn;
358 AGGR_INIT_EXPR_SLOT (t) = slot;
359 for (i = 0; i < nargs; i++)
360 AGGR_INIT_EXPR_ARG (t, i) = args[i];
361 process_aggr_init_operands (t);
365 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
366 target. TYPE is the type to be initialized.
368 Build an AGGR_INIT_EXPR to represent the initialization. This function
369 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
370 to initialize another object, whereas a TARGET_EXPR can either
371 initialize another object or create its own temporary object, and as a
372 result building up a TARGET_EXPR requires that the type's destructor be
376 build_aggr_init_expr (tree type, tree init)
383 /* Make sure that we're not trying to create an instance of an
385 abstract_virtuals_error (NULL_TREE, type);
387 if (TREE_CODE (init) == CALL_EXPR)
388 fn = CALL_EXPR_FN (init);
389 else if (TREE_CODE (init) == AGGR_INIT_EXPR)
390 fn = AGGR_INIT_EXPR_FN (init);
392 return convert (type, init);
394 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
395 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
396 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
398 /* We split the CALL_EXPR into its function and its arguments here.
399 Then, in expand_expr, we put them back together. The reason for
400 this is that this expression might be a default argument
401 expression. In that case, we need a new temporary every time the
402 expression is used. That's what break_out_target_exprs does; it
403 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
404 temporary slot. Then, expand_expr builds up a call-expression
405 using the new slot. */
407 /* If we don't need to use a constructor to create an object of this
408 type, don't mess with AGGR_INIT_EXPR. */
409 if (is_ctor || TREE_ADDRESSABLE (type))
411 slot = build_local_temp (type);
413 if (TREE_CODE(init) == CALL_EXPR)
414 rval = build_aggr_init_array (void_type_node, fn, slot,
415 call_expr_nargs (init),
416 CALL_EXPR_ARGP (init));
418 rval = build_aggr_init_array (void_type_node, fn, slot,
419 aggr_init_expr_nargs (init),
420 AGGR_INIT_EXPR_ARGP (init));
421 TREE_SIDE_EFFECTS (rval) = 1;
422 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
423 TREE_NOTHROW (rval) = TREE_NOTHROW (init);
431 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
432 target. TYPE is the type that this initialization should appear to
435 Build an encapsulation of the initialization to perform
436 and return it so that it can be processed by language-independent
437 and language-specific expression expanders. */
440 build_cplus_new (tree type, tree init)
442 tree rval = build_aggr_init_expr (type, init);
445 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
446 slot = AGGR_INIT_EXPR_SLOT (rval);
447 else if (TREE_CODE (rval) == CALL_EXPR
448 || TREE_CODE (rval) == CONSTRUCTOR)
449 slot = build_local_temp (type);
453 rval = build_target_expr (slot, rval);
454 TARGET_EXPR_IMPLICIT_P (rval) = 1;
459 /* Return a TARGET_EXPR which expresses the initialization of an array to
460 be named later, either default-initialization or copy-initialization
461 from another array of the same type. */
464 build_vec_init_expr (tree type, tree init)
467 tree inner_type = strip_array_types (type);
468 tree elt_init = integer_zero_node;
469 bool value_init = false;
471 /* Since we're deferring building the actual constructor calls until
472 gimplification time, we need to build one now and throw it away so
473 that the relevant constructor gets mark_used before cgraph decides
474 what functions are needed. Here we assume that init is either
475 NULL_TREE, void_type_node (indicating value-initialization), or
476 another array to copy. */
477 if (integer_zerop (array_type_nelts_total (type)))
479 /* No actual initialization to do. */;
482 else if (init == void_type_node)
484 elt_init = build_value_init (inner_type, tf_warning_or_error);
490 gcc_assert (init == NULL_TREE
491 || (same_type_ignoring_top_level_qualifiers_p
492 (type, TREE_TYPE (init))));
494 if (CLASS_TYPE_P (inner_type))
496 VEC(tree,gc) *argvec = make_tree_vector ();
499 tree dummy = build_dummy_object (inner_type);
500 if (!real_lvalue_p (init))
501 dummy = move (dummy);
502 VEC_quick_push (tree, argvec, dummy);
505 = build_special_member_call (NULL_TREE, complete_ctor_identifier,
506 &argvec, inner_type, LOOKUP_NORMAL,
507 tf_warning_or_error);
511 slot = build_local_temp (type);
512 init = build2 (VEC_INIT_EXPR, type, slot, init);
513 SET_EXPR_LOCATION (init, input_location);
515 if (current_function_decl
516 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
518 if (potential_constant_expression (elt_init))
519 VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
520 else if (!processing_template_decl)
521 require_potential_constant_expression (elt_init);
523 VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
525 init = build_target_expr (slot, init);
526 TARGET_EXPR_IMPLICIT_P (init) = 1;
532 build_array_copy (tree init)
534 return build_vec_init_expr (TREE_TYPE (init), init);
537 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
541 build_target_expr_with_type (tree init, tree type)
543 gcc_assert (!VOID_TYPE_P (type));
545 if (TREE_CODE (init) == TARGET_EXPR
546 || init == error_mark_node)
548 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
549 && !VOID_TYPE_P (TREE_TYPE (init))
550 && TREE_CODE (init) != COND_EXPR
551 && TREE_CODE (init) != CONSTRUCTOR
552 && TREE_CODE (init) != VA_ARG_EXPR)
553 /* We need to build up a copy constructor call. A void initializer
554 means we're being called from bot_manip. COND_EXPR is a special
555 case because we already have copies on the arms and we don't want
556 another one here. A CONSTRUCTOR is aggregate initialization, which
557 is handled separately. A VA_ARG_EXPR is magic creation of an
558 aggregate; there's no additional work to be done. */
559 return force_rvalue (init);
561 return force_target_expr (type, init);
564 /* Like the above function, but without the checking. This function should
565 only be used by code which is deliberately trying to subvert the type
566 system, such as call_builtin_trap. Or build_over_call, to avoid
567 infinite recursion. */
570 force_target_expr (tree type, tree init)
574 gcc_assert (!VOID_TYPE_P (type));
576 slot = build_local_temp (type);
577 return build_target_expr (slot, init);
580 /* Like build_target_expr_with_type, but use the type of INIT. */
583 get_target_expr (tree init)
585 if (TREE_CODE (init) == AGGR_INIT_EXPR)
586 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init);
588 return build_target_expr_with_type (init, TREE_TYPE (init));
591 /* If EXPR is a bitfield reference, convert it to the declared type of
592 the bitfield, and return the resulting expression. Otherwise,
593 return EXPR itself. */
596 convert_bitfield_to_declared_type (tree expr)
600 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
602 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
607 /* EXPR is being used in an rvalue context. Return a version of EXPR
608 that is marked as an rvalue. */
615 if (error_operand_p (expr))
618 expr = mark_rvalue_use (expr);
622 Non-class rvalues always have cv-unqualified types. */
623 type = TREE_TYPE (expr);
624 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
625 type = cv_unqualified (type);
627 /* We need to do this for rvalue refs as well to get the right answer
628 from decltype; see c++/36628. */
629 if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
630 expr = build1 (NON_LVALUE_EXPR, type, expr);
631 else if (type != TREE_TYPE (expr))
632 expr = build_nop (type, expr);
638 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
641 cplus_array_hash (const void* k)
644 const_tree const t = (const_tree) k;
646 hash = TYPE_UID (TREE_TYPE (t));
648 hash ^= TYPE_UID (TYPE_DOMAIN (t));
652 typedef struct cplus_array_info {
657 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
658 of type `cplus_array_info*'. */
661 cplus_array_compare (const void * k1, const void * k2)
663 const_tree const t1 = (const_tree) k1;
664 const cplus_array_info *const t2 = (const cplus_array_info*) k2;
666 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
669 /* Hash table containing dependent array types, which are unsuitable for
670 the language-independent type hash table. */
671 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
673 /* Like build_array_type, but handle special C++ semantics. */
676 build_cplus_array_type (tree elt_type, tree index_type)
680 if (elt_type == error_mark_node || index_type == error_mark_node)
681 return error_mark_node;
683 if (processing_template_decl
684 && (dependent_type_p (elt_type)
685 || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
688 cplus_array_info cai;
691 if (cplus_array_htab == NULL)
692 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
693 &cplus_array_compare, NULL);
695 hash = TYPE_UID (elt_type);
697 hash ^= TYPE_UID (index_type);
699 cai.domain = index_type;
701 e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
703 /* We have found the type: we're done. */
707 /* Build a new array type. */
708 t = cxx_make_type (ARRAY_TYPE);
709 TREE_TYPE (t) = elt_type;
710 TYPE_DOMAIN (t) = index_type;
712 /* Store it in the hash table. */
715 /* Set the canonical type for this new node. */
716 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
717 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
718 SET_TYPE_STRUCTURAL_EQUALITY (t);
719 else if (TYPE_CANONICAL (elt_type) != elt_type
721 && TYPE_CANONICAL (index_type) != index_type))
723 = build_cplus_array_type
724 (TYPE_CANONICAL (elt_type),
725 index_type ? TYPE_CANONICAL (index_type) : index_type);
727 TYPE_CANONICAL (t) = t;
731 t = build_array_type (elt_type, index_type);
733 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
734 element type as well, so fix it up if needed. */
735 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
737 tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
739 if (TYPE_MAIN_VARIANT (t) != m)
741 TYPE_MAIN_VARIANT (t) = m;
742 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
743 TYPE_NEXT_VARIANT (m) = t;
747 /* Push these needs up so that initialization takes place
749 TYPE_NEEDS_CONSTRUCTING (t)
750 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
751 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
752 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
756 /* Return an ARRAY_TYPE with element type ELT and length N. */
759 build_array_of_n_type (tree elt, int n)
761 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
764 /* Return a reference type node referring to TO_TYPE. If RVAL is
765 true, return an rvalue reference type, otherwise return an lvalue
766 reference type. If a type node exists, reuse it, otherwise create
769 cp_build_reference_type (tree to_type, bool rval)
772 lvalue_ref = build_reference_type (to_type);
776 /* This code to create rvalue reference types is based on and tied
777 to the code creating lvalue reference types in the middle-end
778 functions build_reference_type_for_mode and build_reference_type.
780 It works by putting the rvalue reference type nodes after the
781 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
782 they will effectively be ignored by the middle end. */
784 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
785 if (TYPE_REF_IS_RVALUE (t))
788 t = build_distinct_type_copy (lvalue_ref);
790 TYPE_REF_IS_RVALUE (t) = true;
791 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
792 TYPE_NEXT_REF_TO (lvalue_ref) = t;
794 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
795 SET_TYPE_STRUCTURAL_EQUALITY (t);
796 else if (TYPE_CANONICAL (to_type) != to_type)
798 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
800 TYPE_CANONICAL (t) = t;
808 /* Returns EXPR cast to rvalue reference type, like std::move. */
813 tree type = TREE_TYPE (expr);
814 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
815 type = cp_build_reference_type (type, /*rval*/true);
816 return build_static_cast (type, expr, tf_warning_or_error);
819 /* Used by the C++ front end to build qualified array types. However,
820 the C version of this function does not properly maintain canonical
821 types (which are not used in C). */
823 c_build_qualified_type (tree type, int type_quals)
825 return cp_build_qualified_type (type, type_quals);
829 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
830 arrays correctly. In particular, if TYPE is an array of T's, and
831 TYPE_QUALS is non-empty, returns an array of qualified T's.
833 FLAGS determines how to deal with ill-formed qualifications. If
834 tf_ignore_bad_quals is set, then bad qualifications are dropped
835 (this is permitted if TYPE was introduced via a typedef or template
836 type parameter). If bad qualifications are dropped and tf_warning
837 is set, then a warning is issued for non-const qualifications. If
838 tf_ignore_bad_quals is not set and tf_error is not set, we
839 return error_mark_node. Otherwise, we issue an error, and ignore
842 Qualification of a reference type is valid when the reference came
843 via a typedef or template type argument. [dcl.ref] No such
844 dispensation is provided for qualifying a function type. [dcl.fct]
845 DR 295 queries this and the proposed resolution brings it into line
846 with qualifying a reference. We implement the DR. We also behave
847 in a similar manner for restricting non-pointer types. */
850 cp_build_qualified_type_real (tree type,
852 tsubst_flags_t complain)
855 int bad_quals = TYPE_UNQUALIFIED;
857 if (type == error_mark_node)
860 if (type_quals == cp_type_quals (type))
863 if (TREE_CODE (type) == ARRAY_TYPE)
865 /* In C++, the qualification really applies to the array element
866 type. Obtain the appropriately qualified element type. */
869 = cp_build_qualified_type_real (TREE_TYPE (type),
873 if (element_type == error_mark_node)
874 return error_mark_node;
876 /* See if we already have an identically qualified type. Tests
877 should be equivalent to those in check_qualified_type. */
878 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
879 if (TREE_TYPE (t) == element_type
880 && TYPE_NAME (t) == TYPE_NAME (type)
881 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
882 && attribute_list_equal (TYPE_ATTRIBUTES (t),
883 TYPE_ATTRIBUTES (type)))
888 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
890 /* Keep the typedef name. */
891 if (TYPE_NAME (t) != TYPE_NAME (type))
893 t = build_variant_type_copy (t);
894 TYPE_NAME (t) = TYPE_NAME (type);
898 /* Even if we already had this variant, we update
899 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
900 they changed since the variant was originally created.
902 This seems hokey; if there is some way to use a previous
903 variant *without* coming through here,
904 TYPE_NEEDS_CONSTRUCTING will never be updated. */
905 TYPE_NEEDS_CONSTRUCTING (t)
906 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
907 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
908 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
911 else if (TYPE_PTRMEMFUNC_P (type))
913 /* For a pointer-to-member type, we can't just return a
914 cv-qualified version of the RECORD_TYPE. If we do, we
915 haven't changed the field that contains the actual pointer to
916 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
919 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
920 t = cp_build_qualified_type_real (t, type_quals, complain);
921 return build_ptrmemfunc_type (t);
923 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
925 tree t = PACK_EXPANSION_PATTERN (type);
927 t = cp_build_qualified_type_real (t, type_quals, complain);
928 return make_pack_expansion (t);
931 /* A reference or method type shall not be cv-qualified.
932 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
933 (in CD1) we always ignore extra cv-quals on functions. */
934 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
935 && (TREE_CODE (type) == REFERENCE_TYPE
936 || TREE_CODE (type) == FUNCTION_TYPE
937 || TREE_CODE (type) == METHOD_TYPE))
939 if (TREE_CODE (type) == REFERENCE_TYPE)
940 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
941 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
944 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
945 if (TREE_CODE (type) == FUNCTION_TYPE)
946 type_quals |= type_memfn_quals (type);
948 /* A restrict-qualified type must be a pointer (or reference)
949 to object or incomplete type. */
950 if ((type_quals & TYPE_QUAL_RESTRICT)
951 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
952 && TREE_CODE (type) != TYPENAME_TYPE
953 && !POINTER_TYPE_P (type))
955 bad_quals |= TYPE_QUAL_RESTRICT;
956 type_quals &= ~TYPE_QUAL_RESTRICT;
959 if (bad_quals == TYPE_UNQUALIFIED
960 || (complain & tf_ignore_bad_quals))
962 else if (!(complain & tf_error))
963 return error_mark_node;
966 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
967 error ("%qV qualifiers cannot be applied to %qT",
971 /* Retrieve (or create) the appropriately qualified variant. */
972 result = build_qualified_type (type, type_quals);
974 /* If this was a pointer-to-method type, and we just made a copy,
975 then we need to unshare the record that holds the cached
976 pointer-to-member-function type, because these will be distinct
977 between the unqualified and qualified types. */
979 && TREE_CODE (type) == POINTER_TYPE
980 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
981 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
982 TYPE_LANG_SPECIFIC (result) = NULL;
984 /* We may also have ended up building a new copy of the canonical
985 type of a pointer-to-method type, which could have the same
986 sharing problem described above. */
987 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
988 && TREE_CODE (type) == POINTER_TYPE
989 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
990 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
991 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
992 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
997 /* Return TYPE with const and volatile removed. */
1000 cv_unqualified (tree type)
1004 if (type == error_mark_node)
1007 quals = cp_type_quals (type);
1008 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1009 return cp_build_qualified_type (type, quals);
1012 /* Builds a qualified variant of T that is not a typedef variant.
1013 E.g. consider the following declarations:
1014 typedef const int ConstInt;
1015 typedef ConstInt* PtrConstInt;
1016 If T is PtrConstInt, this function returns a type representing
1018 In other words, if T is a typedef, the function returns the underlying type.
1019 The cv-qualification and attributes of the type returned match the
1021 They will always be compatible types.
1022 The returned type is built so that all of its subtypes
1023 recursively have their typedefs stripped as well.
1025 This is different from just returning TYPE_CANONICAL (T)
1026 Because of several reasons:
1027 * If T is a type that needs structural equality
1028 its TYPE_CANONICAL (T) will be NULL.
1029 * TYPE_CANONICAL (T) desn't carry type attributes
1030 and looses template parameter names. */
1033 strip_typedefs (tree t)
1035 tree result = NULL, type = NULL, t0 = NULL;
1037 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1040 gcc_assert (TYPE_P (t));
1042 switch (TREE_CODE (t))
1045 type = strip_typedefs (TREE_TYPE (t));
1046 result = build_pointer_type (type);
1048 case REFERENCE_TYPE:
1049 type = strip_typedefs (TREE_TYPE (t));
1050 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1053 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1054 type = strip_typedefs (TREE_TYPE (t));
1055 result = build_offset_type (t0, type);
1058 if (TYPE_PTRMEMFUNC_P (t))
1060 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1061 result = build_ptrmemfunc_type (t0);
1065 type = strip_typedefs (TREE_TYPE (t));
1066 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1067 result = build_cplus_array_type (type, t0);
1072 tree arg_types = NULL, arg_node, arg_type;
1073 for (arg_node = TYPE_ARG_TYPES (t);
1075 arg_node = TREE_CHAIN (arg_node))
1077 if (arg_node == void_list_node)
1079 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1080 gcc_assert (arg_type);
1083 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1087 arg_types = nreverse (arg_types);
1089 /* A list of parameters not ending with an ellipsis
1090 must end with void_list_node. */
1092 arg_types = chainon (arg_types, void_list_node);
1094 type = strip_typedefs (TREE_TYPE (t));
1095 if (TREE_CODE (t) == METHOD_TYPE)
1097 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1098 gcc_assert (class_type);
1100 build_method_type_directly (class_type, type,
1101 TREE_CHAIN (arg_types));
1105 result = build_function_type (type,
1107 result = apply_memfn_quals (result, type_memfn_quals (t));
1110 if (TYPE_RAISES_EXCEPTIONS (t))
1111 result = build_exception_variant (result,
1112 TYPE_RAISES_EXCEPTIONS (t));
1116 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1117 TYPENAME_TYPE_FULLNAME (t),
1118 typename_type, tf_none);
1125 result = TYPE_MAIN_VARIANT (t);
1126 if (TYPE_ATTRIBUTES (t))
1127 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1128 return cp_build_qualified_type (result, cp_type_quals (t));
1131 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1132 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1133 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1134 VIRT indicates whether TYPE is inherited virtually or not.
1135 IGO_PREV points at the previous binfo of the inheritance graph
1136 order chain. The newly copied binfo's TREE_CHAIN forms this
1139 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1140 correct order. That is in the order the bases themselves should be
1143 The BINFO_INHERITANCE of a virtual base class points to the binfo
1144 of the most derived type. ??? We could probably change this so that
1145 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1146 remove a field. They currently can only differ for primary virtual
1150 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1156 /* See if we've already made this virtual base. */
1157 new_binfo = binfo_for_vbase (type, t);
1162 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1163 BINFO_TYPE (new_binfo) = type;
1165 /* Chain it into the inheritance graph. */
1166 TREE_CHAIN (*igo_prev) = new_binfo;
1167 *igo_prev = new_binfo;
1174 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1175 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1177 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1178 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1180 /* We do not need to copy the accesses, as they are read only. */
1181 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1183 /* Recursively copy base binfos of BINFO. */
1184 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1186 tree new_base_binfo;
1188 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1189 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1191 BINFO_VIRTUAL_P (base_binfo));
1193 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1194 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1195 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1199 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1203 /* Push it onto the list after any virtual bases it contains
1204 will have been pushed. */
1205 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1206 BINFO_VIRTUAL_P (new_binfo) = 1;
1207 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1213 /* Hashing of lists so that we don't make duplicates.
1214 The entry point is `list_hash_canon'. */
1216 /* Now here is the hash table. When recording a list, it is added
1217 to the slot whose index is the hash code mod the table size.
1218 Note that the hash table is used for several kinds of lists.
1219 While all these live in the same table, they are completely independent,
1220 and the hash code is computed differently for each of these. */
1222 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1231 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1232 for a node we are thinking about adding). */
1235 list_hash_eq (const void* entry, const void* data)
1237 const_tree const t = (const_tree) entry;
1238 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1240 return (TREE_VALUE (t) == proxy->value
1241 && TREE_PURPOSE (t) == proxy->purpose
1242 && TREE_CHAIN (t) == proxy->chain);
1245 /* Compute a hash code for a list (chain of TREE_LIST nodes
1246 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1247 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1250 list_hash_pieces (tree purpose, tree value, tree chain)
1252 hashval_t hashcode = 0;
1255 hashcode += TREE_HASH (chain);
1258 hashcode += TREE_HASH (value);
1262 hashcode += TREE_HASH (purpose);
1268 /* Hash an already existing TREE_LIST. */
1271 list_hash (const void* p)
1273 const_tree const t = (const_tree) p;
1274 return list_hash_pieces (TREE_PURPOSE (t),
1279 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1280 object for an identical list if one already exists. Otherwise, build a
1281 new one, and record it as the canonical object. */
1284 hash_tree_cons (tree purpose, tree value, tree chain)
1288 struct list_proxy proxy;
1290 /* Hash the list node. */
1291 hashcode = list_hash_pieces (purpose, value, chain);
1292 /* Create a proxy for the TREE_LIST we would like to create. We
1293 don't actually create it so as to avoid creating garbage. */
1294 proxy.purpose = purpose;
1295 proxy.value = value;
1296 proxy.chain = chain;
1297 /* See if it is already in the table. */
1298 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1300 /* If not, create a new node. */
1302 *slot = tree_cons (purpose, value, chain);
1303 return (tree) *slot;
1306 /* Constructor for hashed lists. */
1309 hash_tree_chain (tree value, tree chain)
1311 return hash_tree_cons (NULL_TREE, value, chain);
1315 debug_binfo (tree elem)
1320 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1322 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1323 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1324 debug_tree (BINFO_TYPE (elem));
1325 if (BINFO_VTABLE (elem))
1326 fprintf (stderr, "vtable decl \"%s\"\n",
1327 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1329 fprintf (stderr, "no vtable decl yet\n");
1330 fprintf (stderr, "virtuals:\n");
1331 virtuals = BINFO_VIRTUALS (elem);
1336 tree fndecl = TREE_VALUE (virtuals);
1337 fprintf (stderr, "%s [%ld =? %ld]\n",
1338 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1339 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1341 virtuals = TREE_CHAIN (virtuals);
1345 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1346 the type of the result expression, if known, or NULL_TREE if the
1347 resulting expression is type-dependent. If TEMPLATE_P is true,
1348 NAME is known to be a template because the user explicitly used the
1349 "template" keyword after the "::".
1351 All SCOPE_REFs should be built by use of this function. */
1354 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1357 if (type == error_mark_node
1358 || scope == error_mark_node
1359 || name == error_mark_node)
1360 return error_mark_node;
1361 t = build2 (SCOPE_REF, type, scope, name);
1362 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1364 t = convert_from_reference (t);
1368 /* Returns nonzero if X is an expression for a (possibly overloaded)
1369 function. If "f" is a function or function template, "f", "c->f",
1370 "c.f", "C::f", and "f<int>" will all be considered possibly
1371 overloaded functions. Returns 2 if the function is actually
1372 overloaded, i.e., if it is impossible to know the type of the
1373 function without performing overload resolution. */
1376 is_overloaded_fn (tree x)
1378 /* A baselink is also considered an overloaded function. */
1379 if (TREE_CODE (x) == OFFSET_REF
1380 || TREE_CODE (x) == COMPONENT_REF)
1381 x = TREE_OPERAND (x, 1);
1383 x = BASELINK_FUNCTIONS (x);
1384 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1385 x = TREE_OPERAND (x, 0);
1386 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1387 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1389 return (TREE_CODE (x) == FUNCTION_DECL
1390 || TREE_CODE (x) == OVERLOAD);
1393 /* Returns true iff X is an expression for an overloaded function
1394 whose type cannot be known without performing overload
1398 really_overloaded_fn (tree x)
1400 return is_overloaded_fn (x) == 2;
1406 gcc_assert (is_overloaded_fn (from));
1407 /* A baselink is also considered an overloaded function. */
1408 if (TREE_CODE (from) == OFFSET_REF
1409 || TREE_CODE (from) == COMPONENT_REF)
1410 from = TREE_OPERAND (from, 1);
1411 if (BASELINK_P (from))
1412 from = BASELINK_FUNCTIONS (from);
1413 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1414 from = TREE_OPERAND (from, 0);
1419 get_first_fn (tree from)
1421 return OVL_CURRENT (get_fns (from));
1424 /* Return a new OVL node, concatenating it with the old one. */
1427 ovl_cons (tree decl, tree chain)
1429 tree result = make_node (OVERLOAD);
1430 TREE_TYPE (result) = unknown_type_node;
1431 OVL_FUNCTION (result) = decl;
1432 TREE_CHAIN (result) = chain;
1437 /* Build a new overloaded function. If this is the first one,
1438 just return it; otherwise, ovl_cons the _DECLs */
1441 build_overload (tree decl, tree chain)
1443 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1445 if (chain && TREE_CODE (chain) != OVERLOAD)
1446 chain = ovl_cons (chain, NULL_TREE);
1447 return ovl_cons (decl, chain);
1451 #define PRINT_RING_SIZE 4
1454 cxx_printable_name_internal (tree decl, int v, bool translate)
1456 static unsigned int uid_ring[PRINT_RING_SIZE];
1457 static char *print_ring[PRINT_RING_SIZE];
1458 static bool trans_ring[PRINT_RING_SIZE];
1459 static int ring_counter;
1462 /* Only cache functions. */
1464 || TREE_CODE (decl) != FUNCTION_DECL
1465 || DECL_LANG_SPECIFIC (decl) == 0)
1466 return lang_decl_name (decl, v, translate);
1468 /* See if this print name is lying around. */
1469 for (i = 0; i < PRINT_RING_SIZE; i++)
1470 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1471 /* yes, so return it. */
1472 return print_ring[i];
1474 if (++ring_counter == PRINT_RING_SIZE)
1477 if (current_function_decl != NULL_TREE)
1479 /* There may be both translated and untranslated versions of the
1481 for (i = 0; i < 2; i++)
1483 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1485 if (ring_counter == PRINT_RING_SIZE)
1488 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1491 if (print_ring[ring_counter])
1492 free (print_ring[ring_counter]);
1494 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1495 uid_ring[ring_counter] = DECL_UID (decl);
1496 trans_ring[ring_counter] = translate;
1497 return print_ring[ring_counter];
1501 cxx_printable_name (tree decl, int v)
1503 return cxx_printable_name_internal (decl, v, false);
1507 cxx_printable_name_translate (tree decl, int v)
1509 return cxx_printable_name_internal (decl, v, true);
1512 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1513 listed in RAISES. */
1516 build_exception_variant (tree type, tree raises)
1521 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1524 type_quals = TYPE_QUALS (type);
1525 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1526 if (check_qualified_type (v, type, type_quals)
1527 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1530 /* Need to build a new variant. */
1531 v = build_variant_type_copy (type);
1532 TYPE_RAISES_EXCEPTIONS (v) = raises;
1536 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1537 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1541 bind_template_template_parm (tree t, tree newargs)
1543 tree decl = TYPE_NAME (t);
1546 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1547 decl = build_decl (input_location,
1548 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1550 /* These nodes have to be created to reflect new TYPE_DECL and template
1552 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1553 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1554 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1555 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1557 TREE_TYPE (decl) = t2;
1558 TYPE_NAME (t2) = decl;
1559 TYPE_STUB_DECL (t2) = decl;
1561 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1566 /* Called from count_trees via walk_tree. */
1569 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1579 /* Debugging function for measuring the rough complexity of a tree
1583 count_trees (tree t)
1586 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1590 /* Called from verify_stmt_tree via walk_tree. */
1593 verify_stmt_tree_r (tree* tp,
1594 int* walk_subtrees ATTRIBUTE_UNUSED ,
1598 htab_t *statements = (htab_t *) data;
1601 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1604 /* If this statement is already present in the hash table, then
1605 there is a circularity in the statement tree. */
1606 gcc_assert (!htab_find (*statements, t));
1608 slot = htab_find_slot (*statements, t, INSERT);
1614 /* Debugging function to check that the statement T has not been
1615 corrupted. For now, this function simply checks that T contains no
1619 verify_stmt_tree (tree t)
1622 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1623 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1624 htab_delete (statements);
1627 /* Check if the type T depends on a type with no linkage and if so, return
1628 it. If RELAXED_P then do not consider a class type declared within
1629 a vague-linkage function to have no linkage. */
1632 no_linkage_check (tree t, bool relaxed_p)
1636 /* There's no point in checking linkage on template functions; we
1637 can't know their complete types. */
1638 if (processing_template_decl)
1641 switch (TREE_CODE (t))
1644 if (TYPE_PTRMEMFUNC_P (t))
1646 /* Lambda types that don't have mangling scope have no linkage. We
1647 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1648 when we get here from pushtag none of the lambda information is
1649 set up yet, so we want to assume that the lambda has linkage and
1650 fix it up later if not. */
1651 if (CLASSTYPE_LAMBDA_EXPR (t)
1652 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1656 if (!CLASS_TYPE_P (t))
1660 /* Only treat anonymous types as having no linkage if they're at
1661 namespace scope. This is core issue 966. */
1662 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1665 for (r = CP_TYPE_CONTEXT (t); ; )
1667 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1668 have linkage, or we might just be in an anonymous namespace.
1669 If we're in a TREE_PUBLIC class, we have linkage. */
1670 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1671 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1672 else if (TREE_CODE (r) == FUNCTION_DECL)
1674 if (!relaxed_p || !vague_linkage_p (r))
1677 r = CP_DECL_CONTEXT (r);
1687 case REFERENCE_TYPE:
1688 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1692 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1696 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1699 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1706 for (parm = TYPE_ARG_TYPES (t);
1707 parm && parm != void_list_node;
1708 parm = TREE_CHAIN (parm))
1710 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1714 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1722 #ifdef GATHER_STATISTICS
1723 extern int depth_reached;
1727 cxx_print_statistics (void)
1729 print_search_statistics ();
1730 print_class_statistics ();
1731 print_template_statistics ();
1732 #ifdef GATHER_STATISTICS
1733 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1738 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1739 (which is an ARRAY_TYPE). This counts only elements of the top
1743 array_type_nelts_top (tree type)
1745 return fold_build2_loc (input_location,
1746 PLUS_EXPR, sizetype,
1747 array_type_nelts (type),
1751 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1752 (which is an ARRAY_TYPE). This one is a recursive count of all
1753 ARRAY_TYPEs that are clumped together. */
1756 array_type_nelts_total (tree type)
1758 tree sz = array_type_nelts_top (type);
1759 type = TREE_TYPE (type);
1760 while (TREE_CODE (type) == ARRAY_TYPE)
1762 tree n = array_type_nelts_top (type);
1763 sz = fold_build2_loc (input_location,
1764 MULT_EXPR, sizetype, sz, n);
1765 type = TREE_TYPE (type);
1770 /* Called from break_out_target_exprs via mapcar. */
1773 bot_manip (tree* tp, int* walk_subtrees, void* data)
1775 splay_tree target_remap = ((splay_tree) data);
1778 if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
1780 /* There can't be any TARGET_EXPRs or their slot variables below
1785 if (TREE_CODE (t) == TARGET_EXPR)
1789 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1790 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1));
1792 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t));
1794 /* Map the old variable to the new one. */
1795 splay_tree_insert (target_remap,
1796 (splay_tree_key) TREE_OPERAND (t, 0),
1797 (splay_tree_value) TREE_OPERAND (u, 0));
1799 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1801 /* Replace the old expression with the new version. */
1803 /* We don't have to go below this point; the recursive call to
1804 break_out_target_exprs will have handled anything below this
1810 /* Make a copy of this node. */
1811 return copy_tree_r (tp, walk_subtrees, NULL);
1814 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1815 DATA is really a splay-tree mapping old variables to new
1819 bot_replace (tree* t,
1820 int* walk_subtrees ATTRIBUTE_UNUSED ,
1823 splay_tree target_remap = ((splay_tree) data);
1825 if (TREE_CODE (*t) == VAR_DECL)
1827 splay_tree_node n = splay_tree_lookup (target_remap,
1828 (splay_tree_key) *t);
1830 *t = (tree) n->value;
1836 /* When we parse a default argument expression, we may create
1837 temporary variables via TARGET_EXPRs. When we actually use the
1838 default-argument expression, we make a copy of the expression, but
1839 we must replace the temporaries with appropriate local versions. */
1842 break_out_target_exprs (tree t)
1844 static int target_remap_count;
1845 static splay_tree target_remap;
1847 if (!target_remap_count++)
1848 target_remap = splay_tree_new (splay_tree_compare_pointers,
1849 /*splay_tree_delete_key_fn=*/NULL,
1850 /*splay_tree_delete_value_fn=*/NULL);
1851 cp_walk_tree (&t, bot_manip, target_remap, NULL);
1852 cp_walk_tree (&t, bot_replace, target_remap, NULL);
1854 if (!--target_remap_count)
1856 splay_tree_delete (target_remap);
1857 target_remap = NULL;
1863 /* Similar to `build_nt', but for template definitions of dependent
1867 build_min_nt (enum tree_code code, ...)
1874 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1878 t = make_node (code);
1879 length = TREE_CODE_LENGTH (code);
1881 for (i = 0; i < length; i++)
1883 tree x = va_arg (p, tree);
1884 TREE_OPERAND (t, i) = x;
1892 /* Similar to `build', but for template definitions. */
1895 build_min (enum tree_code code, tree tt, ...)
1902 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1906 t = make_node (code);
1907 length = TREE_CODE_LENGTH (code);
1910 for (i = 0; i < length; i++)
1912 tree x = va_arg (p, tree);
1913 TREE_OPERAND (t, i) = x;
1914 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1915 TREE_SIDE_EFFECTS (t) = 1;
1922 /* Similar to `build', but for template definitions of non-dependent
1923 expressions. NON_DEP is the non-dependent expression that has been
1927 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1934 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1936 va_start (p, non_dep);
1938 t = make_node (code);
1939 length = TREE_CODE_LENGTH (code);
1940 TREE_TYPE (t) = TREE_TYPE (non_dep);
1941 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1943 for (i = 0; i < length; i++)
1945 tree x = va_arg (p, tree);
1946 TREE_OPERAND (t, i) = x;
1949 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1950 /* This should not be considered a COMPOUND_EXPR, because it
1951 resolves to an overload. */
1952 COMPOUND_EXPR_OVERLOADED (t) = 1;
1958 /* Similar to `build_nt_call_vec', but for template definitions of
1959 non-dependent expressions. NON_DEP is the non-dependent expression
1960 that has been built. */
1963 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
1965 tree t = build_nt_call_vec (fn, argvec);
1966 TREE_TYPE (t) = TREE_TYPE (non_dep);
1967 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1972 get_type_decl (tree t)
1974 if (TREE_CODE (t) == TYPE_DECL)
1977 return TYPE_STUB_DECL (t);
1978 gcc_assert (t == error_mark_node);
1982 /* Returns the namespace that contains DECL, whether directly or
1986 decl_namespace_context (tree decl)
1990 if (TREE_CODE (decl) == NAMESPACE_DECL)
1992 else if (TYPE_P (decl))
1993 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1995 decl = CP_DECL_CONTEXT (decl);
1999 /* Returns true if decl is within an anonymous namespace, however deeply
2000 nested, or false otherwise. */
2003 decl_anon_ns_mem_p (const_tree decl)
2007 if (decl == NULL_TREE || decl == error_mark_node)
2009 if (TREE_CODE (decl) == NAMESPACE_DECL
2010 && DECL_NAME (decl) == NULL_TREE)
2012 /* Classes and namespaces inside anonymous namespaces have
2013 TREE_PUBLIC == 0, so we can shortcut the search. */
2014 else if (TYPE_P (decl))
2015 return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
2016 else if (TREE_CODE (decl) == NAMESPACE_DECL)
2017 return (TREE_PUBLIC (decl) == 0);
2019 decl = DECL_CONTEXT (decl);
2023 /* Return truthvalue of whether T1 is the same tree structure as T2.
2024 Return 1 if they are the same. Return 0 if they are different. */
2027 cp_tree_equal (tree t1, tree t2)
2029 enum tree_code code1, code2;
2036 for (code1 = TREE_CODE (t1);
2037 CONVERT_EXPR_CODE_P (code1)
2038 || code1 == NON_LVALUE_EXPR;
2039 code1 = TREE_CODE (t1))
2040 t1 = TREE_OPERAND (t1, 0);
2041 for (code2 = TREE_CODE (t2);
2042 CONVERT_EXPR_CODE_P (code2)
2043 || code1 == NON_LVALUE_EXPR;
2044 code2 = TREE_CODE (t2))
2045 t2 = TREE_OPERAND (t2, 0);
2047 /* They might have become equal now. */
2057 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2058 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2061 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2064 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2065 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2066 TREE_STRING_LENGTH (t1));
2069 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2070 TREE_FIXED_CST (t2));
2073 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2074 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2077 /* We need to do this when determining whether or not two
2078 non-type pointer to member function template arguments
2080 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2081 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2086 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2088 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2089 if (!cp_tree_equal (field, elt2->index)
2090 || !cp_tree_equal (value, elt2->value))
2097 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2099 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2101 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2104 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2109 call_expr_arg_iterator iter1, iter2;
2110 if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2112 for (arg1 = first_call_expr_arg (t1, &iter1),
2113 arg2 = first_call_expr_arg (t2, &iter2);
2115 arg1 = next_call_expr_arg (&iter1),
2116 arg2 = next_call_expr_arg (&iter2))
2117 if (!cp_tree_equal (arg1, arg2))
2126 tree o1 = TREE_OPERAND (t1, 0);
2127 tree o2 = TREE_OPERAND (t2, 0);
2129 /* Special case: if either target is an unallocated VAR_DECL,
2130 it means that it's going to be unified with whatever the
2131 TARGET_EXPR is really supposed to initialize, so treat it
2132 as being equivalent to anything. */
2133 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2134 && !DECL_RTL_SET_P (o1))
2136 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2137 && !DECL_RTL_SET_P (o2))
2139 else if (!cp_tree_equal (o1, o2))
2142 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2145 case WITH_CLEANUP_EXPR:
2146 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2148 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2151 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2153 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2156 /* For comparing uses of parameters in late-specified return types
2157 with an out-of-class definition of the function. */
2158 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2159 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
2168 case IDENTIFIER_NODE:
2173 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2174 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2175 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2176 BASELINK_FUNCTIONS (t2)));
2178 case TEMPLATE_PARM_INDEX:
2179 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2180 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2181 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2182 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2183 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2184 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2186 case TEMPLATE_ID_EXPR:
2191 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2193 vec1 = TREE_OPERAND (t1, 1);
2194 vec2 = TREE_OPERAND (t2, 1);
2197 return !vec1 && !vec2;
2199 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2202 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2203 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2204 TREE_VEC_ELT (vec2, ix)))
2213 tree o1 = TREE_OPERAND (t1, 0);
2214 tree o2 = TREE_OPERAND (t2, 0);
2216 if (TREE_CODE (o1) != TREE_CODE (o2))
2219 return same_type_p (o1, o2);
2221 return cp_tree_equal (o1, o2);
2226 tree t1_op1, t2_op1;
2228 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2231 t1_op1 = TREE_OPERAND (t1, 1);
2232 t2_op1 = TREE_OPERAND (t2, 1);
2233 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2236 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2240 /* Two pointer-to-members are the same if they point to the same
2241 field or function in the same class. */
2242 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2245 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2248 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2250 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2253 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2255 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2256 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2259 case STATIC_CAST_EXPR:
2260 case REINTERPRET_CAST_EXPR:
2261 case CONST_CAST_EXPR:
2262 case DYNAMIC_CAST_EXPR:
2264 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2266 /* Now compare operands as usual. */
2273 switch (TREE_CODE_CLASS (code1))
2277 case tcc_comparison:
2278 case tcc_expression:
2285 n = TREE_OPERAND_LENGTH (t1);
2286 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2287 && n != TREE_OPERAND_LENGTH (t2))
2290 for (i = 0; i < n; ++i)
2291 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2298 return same_type_p (t1, t2);
2302 /* We can get here with --disable-checking. */
2306 /* The type of ARG when used as an lvalue. */
2309 lvalue_type (tree arg)
2311 tree type = TREE_TYPE (arg);
2315 /* The type of ARG for printing error messages; denote lvalues with
2319 error_type (tree arg)
2321 tree type = TREE_TYPE (arg);
2323 if (TREE_CODE (type) == ARRAY_TYPE)
2325 else if (TREE_CODE (type) == ERROR_MARK)
2327 else if (real_lvalue_p (arg))
2328 type = build_reference_type (lvalue_type (arg));
2329 else if (MAYBE_CLASS_TYPE_P (type))
2330 type = lvalue_type (arg);
2335 /* Does FUNCTION use a variable-length argument list? */
2338 varargs_function_p (const_tree function)
2340 return stdarg_p (TREE_TYPE (function));
2343 /* Returns 1 if decl is a member of a class. */
2346 member_p (const_tree decl)
2348 const_tree const ctx = DECL_CONTEXT (decl);
2349 return (ctx && TYPE_P (ctx));
2352 /* Create a placeholder for member access where we don't actually have an
2353 object that the access is against. */
2356 build_dummy_object (tree type)
2358 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2359 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2362 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2363 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2364 binfo path from current_class_type to TYPE, or 0. */
2367 maybe_dummy_object (tree type, tree* binfop)
2371 tree current = current_nonlambda_class_type ();
2374 && (binfo = lookup_base (current, type, ba_any, NULL)))
2378 /* Reference from a nested class member function. */
2380 binfo = TYPE_BINFO (type);
2386 if (current_class_ref
2387 /* current_class_ref might not correspond to current_class_type if
2388 we're in tsubst_default_argument or a lambda-declarator; in either
2389 case, we want to use current_class_ref if it matches CONTEXT. */
2390 && (same_type_ignoring_top_level_qualifiers_p
2391 (TREE_TYPE (current_class_ref), context)))
2392 decl = current_class_ref;
2393 else if (current != current_class_type
2394 && context == nonlambda_method_basetype ())
2395 /* In a lambda, need to go through 'this' capture. */
2396 decl = (cp_build_indirect_ref
2397 ((lambda_expr_this_capture
2398 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2399 RO_NULL, tf_warning_or_error));
2401 decl = build_dummy_object (context);
2406 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2409 is_dummy_object (const_tree ob)
2411 if (TREE_CODE (ob) == INDIRECT_REF)
2412 ob = TREE_OPERAND (ob, 0);
2413 return (TREE_CODE (ob) == NOP_EXPR
2414 && TREE_OPERAND (ob, 0) == void_zero_node);
2417 /* Returns 1 iff type T is something we want to treat as a scalar type for
2418 the purpose of deciding whether it is trivial/POD/standard-layout. */
2421 scalarish_type_p (const_tree t)
2423 if (t == error_mark_node)
2426 return (SCALAR_TYPE_P (t)
2427 || TREE_CODE (t) == VECTOR_TYPE);
2430 /* Returns true iff T requires non-trivial default initialization. */
2433 type_has_nontrivial_default_init (const_tree t)
2435 t = strip_array_types (CONST_CAST_TREE (t));
2437 if (CLASS_TYPE_P (t))
2438 return TYPE_HAS_COMPLEX_DFLT (t);
2443 /* Returns true iff copying an object of type T (including via move
2444 constructor) is non-trivial. That is, T has no non-trivial copy
2445 constructors and no non-trivial move constructors. */
2448 type_has_nontrivial_copy_init (const_tree t)
2450 t = strip_array_types (CONST_CAST_TREE (t));
2452 if (CLASS_TYPE_P (t))
2454 gcc_assert (COMPLETE_TYPE_P (t));
2455 return ((TYPE_HAS_COPY_CTOR (t)
2456 && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2457 || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2463 /* Returns 1 iff type T is a trivially copyable type, as defined in
2464 [basic.types] and [class]. */
2467 trivially_copyable_p (const_tree t)
2469 t = strip_array_types (CONST_CAST_TREE (t));
2471 if (CLASS_TYPE_P (t))
2472 return ((!TYPE_HAS_COPY_CTOR (t)
2473 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2474 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2475 && (!TYPE_HAS_COPY_ASSIGN (t)
2476 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2477 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2478 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2480 return scalarish_type_p (t);
2483 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2487 trivial_type_p (const_tree t)
2489 t = strip_array_types (CONST_CAST_TREE (t));
2491 if (CLASS_TYPE_P (t))
2492 return (TYPE_HAS_TRIVIAL_DFLT (t)
2493 && trivially_copyable_p (t));
2495 return scalarish_type_p (t);
2498 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2501 pod_type_p (const_tree t)
2503 /* This CONST_CAST is okay because strip_array_types returns its
2504 argument unmodified and we assign it to a const_tree. */
2505 t = strip_array_types (CONST_CAST_TREE(t));
2507 if (!CLASS_TYPE_P (t))
2508 return scalarish_type_p (t);
2509 else if (cxx_dialect > cxx98)
2510 /* [class]/10: A POD struct is a class that is both a trivial class and a
2511 standard-layout class, and has no non-static data members of type
2512 non-POD struct, non-POD union (or array of such types).
2514 We don't need to check individual members because if a member is
2515 non-std-layout or non-trivial, the class will be too. */
2516 return (std_layout_type_p (t) && trivial_type_p (t));
2518 /* The C++98 definition of POD is different. */
2519 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2522 /* Returns true iff T is POD for the purpose of layout, as defined in the
2526 layout_pod_type_p (const_tree t)
2528 t = strip_array_types (CONST_CAST_TREE (t));
2530 if (CLASS_TYPE_P (t))
2531 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2533 return scalarish_type_p (t);
2536 /* Returns true iff T is a standard-layout type, as defined in
2540 std_layout_type_p (const_tree t)
2542 t = strip_array_types (CONST_CAST_TREE (t));
2544 if (CLASS_TYPE_P (t))
2545 return !CLASSTYPE_NON_STD_LAYOUT (t);
2547 return scalarish_type_p (t);
2550 /* Nonzero iff type T is a class template implicit specialization. */
2553 class_tmpl_impl_spec_p (const_tree t)
2555 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2558 /* Returns 1 iff zero initialization of type T means actually storing
2562 zero_init_p (const_tree t)
2564 /* This CONST_CAST is okay because strip_array_types returns its
2565 argument unmodified and we assign it to a const_tree. */
2566 t = strip_array_types (CONST_CAST_TREE(t));
2568 if (t == error_mark_node)
2571 /* NULL pointers to data members are initialized with -1. */
2572 if (TYPE_PTRMEM_P (t))
2575 /* Classes that contain types that can't be zero-initialized, cannot
2576 be zero-initialized themselves. */
2577 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2583 /* Table of valid C++ attributes. */
2584 const struct attribute_spec cxx_attribute_table[] =
2586 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2587 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2588 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
2589 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
2590 { NULL, 0, 0, false, false, false, NULL }
2593 /* Handle a "java_interface" attribute; arguments as in
2594 struct attribute_spec.handler. */
2596 handle_java_interface_attribute (tree* node,
2598 tree args ATTRIBUTE_UNUSED ,
2603 || !CLASS_TYPE_P (*node)
2604 || !TYPE_FOR_JAVA (*node))
2606 error ("%qE attribute can only be applied to Java class definitions",
2608 *no_add_attrs = true;
2611 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2612 *node = build_variant_type_copy (*node);
2613 TYPE_JAVA_INTERFACE (*node) = 1;
2618 /* Handle a "com_interface" attribute; arguments as in
2619 struct attribute_spec.handler. */
2621 handle_com_interface_attribute (tree* node,
2623 tree args ATTRIBUTE_UNUSED ,
2624 int flags ATTRIBUTE_UNUSED ,
2629 *no_add_attrs = true;
2632 || !CLASS_TYPE_P (*node)
2633 || *node != TYPE_MAIN_VARIANT (*node))
2635 warning (OPT_Wattributes, "%qE attribute can only be applied "
2636 "to class definitions", name);
2641 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2647 /* Handle an "init_priority" attribute; arguments as in
2648 struct attribute_spec.handler. */
2650 handle_init_priority_attribute (tree* node,
2653 int flags ATTRIBUTE_UNUSED ,
2656 tree initp_expr = TREE_VALUE (args);
2658 tree type = TREE_TYPE (decl);
2661 STRIP_NOPS (initp_expr);
2663 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2665 error ("requested init_priority is not an integer constant");
2666 *no_add_attrs = true;
2670 pri = TREE_INT_CST_LOW (initp_expr);
2672 type = strip_array_types (type);
2674 if (decl == NULL_TREE
2675 || TREE_CODE (decl) != VAR_DECL
2676 || !TREE_STATIC (decl)
2677 || DECL_EXTERNAL (decl)
2678 || (TREE_CODE (type) != RECORD_TYPE
2679 && TREE_CODE (type) != UNION_TYPE)
2680 /* Static objects in functions are initialized the
2681 first time control passes through that
2682 function. This is not precise enough to pin down an
2683 init_priority value, so don't allow it. */
2684 || current_function_decl)
2686 error ("can only use %qE attribute on file-scope definitions "
2687 "of objects of class type", name);
2688 *no_add_attrs = true;
2692 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2694 error ("requested init_priority is out of range");
2695 *no_add_attrs = true;
2699 /* Check for init_priorities that are reserved for
2700 language and runtime support implementations.*/
2701 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2704 (0, "requested init_priority is reserved for internal use");
2707 if (SUPPORTS_INIT_PRIORITY)
2709 SET_DECL_INIT_PRIORITY (decl, pri);
2710 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2715 error ("%qE attribute is not supported on this platform", name);
2716 *no_add_attrs = true;
2721 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2722 thing pointed to by the constant. */
2725 make_ptrmem_cst (tree type, tree member)
2727 tree ptrmem_cst = make_node (PTRMEM_CST);
2728 TREE_TYPE (ptrmem_cst) = type;
2729 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2733 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2734 return an existing type if an appropriate type already exists. */
2737 cp_build_type_attribute_variant (tree type, tree attributes)
2741 new_type = build_type_attribute_variant (type, attributes);
2742 if (TREE_CODE (new_type) == FUNCTION_TYPE
2743 || TREE_CODE (new_type) == METHOD_TYPE)
2744 new_type = build_exception_variant (new_type,
2745 TYPE_RAISES_EXCEPTIONS (type));
2747 /* Making a new main variant of a class type is broken. */
2748 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2753 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2754 Called only after doing all language independent checks. Only
2755 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2756 compared in type_hash_eq. */
2759 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2761 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
2762 || TREE_CODE (typea) == METHOD_TYPE);
2764 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2765 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
2768 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2769 traversal. Called from walk_tree. */
2772 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2773 void *data, struct pointer_set_t *pset)
2775 enum tree_code code = TREE_CODE (*tp);
2778 #define WALK_SUBTREE(NODE) \
2781 result = cp_walk_tree (&(NODE), func, data, pset); \
2782 if (result) goto out; \
2786 /* Not one of the easy cases. We must explicitly go through the
2792 case TEMPLATE_TEMPLATE_PARM:
2793 case BOUND_TEMPLATE_TEMPLATE_PARM:
2794 case UNBOUND_CLASS_TEMPLATE:
2795 case TEMPLATE_PARM_INDEX:
2796 case TEMPLATE_TYPE_PARM:
2799 /* None of these have subtrees other than those already walked
2801 *walk_subtrees_p = 0;
2805 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2806 *walk_subtrees_p = 0;
2810 WALK_SUBTREE (TREE_TYPE (*tp));
2811 *walk_subtrees_p = 0;
2815 WALK_SUBTREE (TREE_PURPOSE (*tp));
2819 WALK_SUBTREE (OVL_FUNCTION (*tp));
2820 WALK_SUBTREE (OVL_CHAIN (*tp));
2821 *walk_subtrees_p = 0;
2825 WALK_SUBTREE (DECL_NAME (*tp));
2826 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2827 WALK_SUBTREE (USING_DECL_DECLS (*tp));
2828 *walk_subtrees_p = 0;
2832 if (TYPE_PTRMEMFUNC_P (*tp))
2833 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2836 case TYPE_ARGUMENT_PACK:
2837 case NONTYPE_ARGUMENT_PACK:
2839 tree args = ARGUMENT_PACK_ARGS (*tp);
2840 int i, len = TREE_VEC_LENGTH (args);
2841 for (i = 0; i < len; i++)
2842 WALK_SUBTREE (TREE_VEC_ELT (args, i));
2846 case TYPE_PACK_EXPANSION:
2847 WALK_SUBTREE (TREE_TYPE (*tp));
2848 *walk_subtrees_p = 0;
2851 case EXPR_PACK_EXPANSION:
2852 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2853 *walk_subtrees_p = 0;
2857 case REINTERPRET_CAST_EXPR:
2858 case STATIC_CAST_EXPR:
2859 case CONST_CAST_EXPR:
2860 case DYNAMIC_CAST_EXPR:
2861 if (TREE_TYPE (*tp))
2862 WALK_SUBTREE (TREE_TYPE (*tp));
2866 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2867 WALK_SUBTREE (TREE_OPERAND (*tp, i));
2869 *walk_subtrees_p = 0;
2873 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2874 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2875 *walk_subtrees_p = 0;
2879 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2880 *walk_subtrees_p = 0;
2888 /* We didn't find what we were looking for. */
2895 /* Like save_expr, but for C++. */
2898 cp_save_expr (tree expr)
2900 /* There is no reason to create a SAVE_EXPR within a template; if
2901 needed, we can create the SAVE_EXPR when instantiating the
2902 template. Furthermore, the middle-end cannot handle C++-specific
2904 if (processing_template_decl)
2906 return save_expr (expr);
2909 /* Initialize tree.c. */
2914 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2917 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2918 is. Note that sfk_none is zero, so this function can be used as a
2919 predicate to test whether or not DECL is a special function. */
2921 special_function_kind
2922 special_function_p (const_tree decl)
2924 /* Rather than doing all this stuff with magic names, we should
2925 probably have a field of type `special_function_kind' in
2926 DECL_LANG_SPECIFIC. */
2927 if (DECL_COPY_CONSTRUCTOR_P (decl))
2928 return sfk_copy_constructor;
2929 if (DECL_MOVE_CONSTRUCTOR_P (decl))
2930 return sfk_move_constructor;
2931 if (DECL_CONSTRUCTOR_P (decl))
2932 return sfk_constructor;
2933 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2935 if (copy_fn_p (decl))
2936 return sfk_copy_assignment;
2937 if (move_fn_p (decl))
2938 return sfk_move_assignment;
2940 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2941 return sfk_destructor;
2942 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2943 return sfk_complete_destructor;
2944 if (DECL_BASE_DESTRUCTOR_P (decl))
2945 return sfk_base_destructor;
2946 if (DECL_DELETING_DESTRUCTOR_P (decl))
2947 return sfk_deleting_destructor;
2948 if (DECL_CONV_FN_P (decl))
2949 return sfk_conversion;
2954 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2957 char_type_p (tree type)
2959 return (same_type_p (type, char_type_node)
2960 || same_type_p (type, unsigned_char_type_node)
2961 || same_type_p (type, signed_char_type_node)
2962 || same_type_p (type, char16_type_node)
2963 || same_type_p (type, char32_type_node)
2964 || same_type_p (type, wchar_type_node));
2967 /* Returns the kind of linkage associated with the indicated DECL. Th
2968 value returned is as specified by the language standard; it is
2969 independent of implementation details regarding template
2970 instantiation, etc. For example, it is possible that a declaration
2971 to which this function assigns external linkage would not show up
2972 as a global symbol when you run `nm' on the resulting object file. */
2975 decl_linkage (tree decl)
2977 /* This function doesn't attempt to calculate the linkage from first
2978 principles as given in [basic.link]. Instead, it makes use of
2979 the fact that we have already set TREE_PUBLIC appropriately, and
2980 then handles a few special cases. Ideally, we would calculate
2981 linkage first, and then transform that into a concrete
2984 /* Things that don't have names have no linkage. */
2985 if (!DECL_NAME (decl))
2988 /* Fields have no linkage. */
2989 if (TREE_CODE (decl) == FIELD_DECL)
2992 /* Things that are TREE_PUBLIC have external linkage. */
2993 if (TREE_PUBLIC (decl))
2996 if (TREE_CODE (decl) == NAMESPACE_DECL)
2999 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3001 if (TREE_CODE (decl) == CONST_DECL)
3002 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
3004 /* Some things that are not TREE_PUBLIC have external linkage, too.
3005 For example, on targets that don't have weak symbols, we make all
3006 template instantiations have internal linkage (in the object
3007 file), but the symbols should still be treated as having external
3008 linkage from the point of view of the language. */
3009 if ((TREE_CODE (decl) == FUNCTION_DECL
3010 || TREE_CODE (decl) == VAR_DECL)
3011 && DECL_COMDAT (decl))
3014 /* Things in local scope do not have linkage, if they don't have
3016 if (decl_function_context (decl))
3019 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3020 are considered to have external linkage for language purposes. DECLs
3021 really meant to have internal linkage have DECL_THIS_STATIC set. */
3022 if (TREE_CODE (decl) == TYPE_DECL)
3024 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3026 if (!DECL_THIS_STATIC (decl))
3029 /* Static data members and static member functions from classes
3030 in anonymous namespace also don't have TREE_PUBLIC set. */
3031 if (DECL_CLASS_CONTEXT (decl))
3035 /* Everything else has internal linkage. */
3039 /* Returns the storage duration of the object or reference associated with
3040 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
3043 decl_storage_duration (tree decl)
3045 if (TREE_CODE (decl) == PARM_DECL)
3047 if (TREE_CODE (decl) == FUNCTION_DECL)
3049 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3050 if (!TREE_STATIC (decl)
3051 && !DECL_EXTERNAL (decl))
3053 if (DECL_THREAD_LOCAL_P (decl))
3058 /* EXP is an expression that we want to pre-evaluate. Returns (in
3059 *INITP) an expression that will perform the pre-evaluation. The
3060 value returned by this function is a side-effect free expression
3061 equivalent to the pre-evaluated expression. Callers must ensure
3062 that *INITP is evaluated before EXP. */
3065 stabilize_expr (tree exp, tree* initp)
3069 if (!TREE_SIDE_EFFECTS (exp))
3070 init_expr = NULL_TREE;
3071 else if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp))
3072 || !lvalue_or_rvalue_with_address_p (exp))
3074 init_expr = get_target_expr (exp);
3075 exp = TARGET_EXPR_SLOT (init_expr);
3079 bool xval = !real_lvalue_p (exp);
3080 exp = cp_build_addr_expr (exp, tf_warning_or_error);
3081 init_expr = get_target_expr (exp);
3082 exp = TARGET_EXPR_SLOT (init_expr);
3083 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3089 gcc_assert (!TREE_SIDE_EFFECTS (exp));
3093 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3094 similar expression ORIG. */
3097 add_stmt_to_compound (tree orig, tree new_expr)
3099 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3101 if (!orig || !TREE_SIDE_EFFECTS (orig))
3103 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3106 /* Like stabilize_expr, but for a call whose arguments we want to
3107 pre-evaluate. CALL is modified in place to use the pre-evaluated
3108 arguments, while, upon return, *INITP contains an expression to
3109 compute the arguments. */
3112 stabilize_call (tree call, tree *initp)
3114 tree inits = NULL_TREE;
3116 int nargs = call_expr_nargs (call);
3118 if (call == error_mark_node || processing_template_decl)
3124 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3126 for (i = 0; i < nargs; i++)
3129 CALL_EXPR_ARG (call, i) =
3130 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3131 inits = add_stmt_to_compound (inits, init);
3137 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3138 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3139 arguments, while, upon return, *INITP contains an expression to
3140 compute the arguments. */
3143 stabilize_aggr_init (tree call, tree *initp)
3145 tree inits = NULL_TREE;
3147 int nargs = aggr_init_expr_nargs (call);
3149 if (call == error_mark_node)
3152 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3154 for (i = 0; i < nargs; i++)
3157 AGGR_INIT_EXPR_ARG (call, i) =
3158 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3159 inits = add_stmt_to_compound (inits, init);
3165 /* Like stabilize_expr, but for an initialization.
3167 If the initialization is for an object of class type, this function
3168 takes care not to introduce additional temporaries.
3170 Returns TRUE iff the expression was successfully pre-evaluated,
3171 i.e., if INIT is now side-effect free, except for, possible, a
3172 single call to a constructor. */
3175 stabilize_init (tree init, tree *initp)
3181 if (t == error_mark_node || processing_template_decl)
3184 if (TREE_CODE (t) == INIT_EXPR
3185 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3186 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3188 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3192 if (TREE_CODE (t) == INIT_EXPR)
3193 t = TREE_OPERAND (t, 1);
3194 if (TREE_CODE (t) == TARGET_EXPR)
3195 t = TARGET_EXPR_INITIAL (t);
3196 if (TREE_CODE (t) == COMPOUND_EXPR)
3198 if (TREE_CODE (t) == CONSTRUCTOR
3199 && EMPTY_CONSTRUCTOR_P (t))
3200 /* Default-initialization. */
3203 /* If the initializer is a COND_EXPR, we can't preevaluate
3205 if (TREE_CODE (t) == COND_EXPR)
3208 if (TREE_CODE (t) == CALL_EXPR)
3210 stabilize_call (t, initp);
3214 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3216 stabilize_aggr_init (t, initp);
3220 /* The initialization is being performed via a bitwise copy -- and
3221 the item copied may have side effects. */
3222 return TREE_SIDE_EFFECTS (init);
3225 /* Like "fold", but should be used whenever we might be processing the
3226 body of a template. */
3229 fold_if_not_in_template (tree expr)
3231 /* In the body of a template, there is never any need to call
3232 "fold". We will call fold later when actually instantiating the
3233 template. Integral constant expressions in templates will be
3234 evaluated via fold_non_dependent_expr, as necessary. */
3235 if (processing_template_decl)
3238 /* Fold C++ front-end specific tree codes. */
3239 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3240 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3245 /* Returns true if a cast to TYPE may appear in an integral constant
3249 cast_valid_in_integral_constant_expression_p (tree type)
3251 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3252 || cxx_dialect >= cxx0x
3253 || dependent_type_p (type)
3254 || type == error_mark_node);
3257 /* Return true if we need to fix linkage information of DECL. */
3260 cp_fix_function_decl_p (tree decl)
3262 /* Skip if DECL is not externally visible. */
3263 if (!TREE_PUBLIC (decl))
3266 /* We need to fix DECL if it a appears to be exported but with no
3267 function body. Thunks do not have CFGs and we may need to
3268 handle them specially later. */
3269 if (!gimple_has_body_p (decl)
3270 && !DECL_THUNK_P (decl)
3271 && !DECL_EXTERNAL (decl))
3273 struct cgraph_node *node = cgraph_get_node (decl);
3275 /* Don't fix same_body aliases. Although they don't have their own
3276 CFG, they share it with what they alias to. */
3278 || node->decl == decl
3279 || !node->same_body)
3286 /* Clean the C++ specific parts of the tree T. */
3289 cp_free_lang_data (tree t)
3291 if (TREE_CODE (t) == METHOD_TYPE
3292 || TREE_CODE (t) == FUNCTION_TYPE)
3294 /* Default args are not interesting anymore. */
3295 tree argtypes = TYPE_ARG_TYPES (t);
3298 TREE_PURPOSE (argtypes) = 0;
3299 argtypes = TREE_CHAIN (argtypes);
3302 else if (TREE_CODE (t) == FUNCTION_DECL
3303 && cp_fix_function_decl_p (t))
3305 /* If T is used in this translation unit at all, the definition
3306 must exist somewhere else since we have decided to not emit it
3307 in this TU. So make it an external reference. */
3308 DECL_EXTERNAL (t) = 1;
3309 TREE_STATIC (t) = 0;
3311 if (CP_AGGREGATE_TYPE_P (t)
3314 tree name = TYPE_NAME (t);
3315 if (TREE_CODE (name) == TYPE_DECL)
3316 name = DECL_NAME (name);
3317 /* Drop anonymous names. */
3318 if (name != NULL_TREE
3319 && ANON_AGGRNAME_P (name))
3320 TYPE_NAME (t) = NULL_TREE;
3322 if (TREE_CODE (t) == NAMESPACE_DECL)
3324 /* The list of users of a namespace isn't useful for the middle-end
3325 or debug generators. */
3326 DECL_NAMESPACE_USERS (t) = NULL_TREE;
3327 /* Neither do we need the leftover chaining of namespaces
3328 from the binding level. */
3329 DECL_CHAIN (t) = NULL_TREE;
3333 /* Stub for c-common. Please keep in sync with c-decl.c.
3334 FIXME: If address space support is target specific, then this
3335 should be a C target hook. But currently this is not possible,
3336 because this function is called via REGISTER_TARGET_PRAGMAS. */
3338 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3339 addr_space_t as ATTRIBUTE_UNUSED)
3344 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3345 /* Complain that some language-specific thing hanging off a tree
3346 node has been accessed improperly. */
3349 lang_check_failed (const char* file, int line, const char* function)
3351 internal_error ("lang_* check: failed in %s, at %s:%d",
3352 function, trim_filename (file), line);
3354 #endif /* ENABLE_TREE_CHECKING */
3356 #include "gt-cp-tree.h"