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 cp_lvalue_kind lvalue_p_1 (const_tree);
44 static tree build_target_expr (tree, tree);
45 static tree count_trees_r (tree *, int *, void *);
46 static tree verify_stmt_tree_r (tree *, int *, void *);
47 static tree build_local_temp (tree);
49 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
50 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
51 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
53 /* If REF is an lvalue, returns the kind of lvalue that REF is.
54 Otherwise, returns clk_none. */
57 lvalue_p_1 (const_tree ref)
59 cp_lvalue_kind op1_lvalue_kind = clk_none;
60 cp_lvalue_kind op2_lvalue_kind = clk_none;
62 /* Expressions of reference type are sometimes wrapped in
63 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
64 representation, not part of the language, so we have to look
66 if (TREE_CODE (ref) == INDIRECT_REF
67 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0)))
69 return lvalue_p_1 (TREE_OPERAND (ref, 0));
71 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
73 /* unnamed rvalue references are rvalues */
74 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
75 && TREE_CODE (ref) != PARM_DECL
76 && TREE_CODE (ref) != VAR_DECL
77 && TREE_CODE (ref) != COMPONENT_REF)
80 /* lvalue references and named rvalue references are lvalues. */
84 if (ref == current_class_ptr)
87 switch (TREE_CODE (ref))
91 /* preincrements and predecrements are valid lvals, provided
92 what they refer to are valid lvals. */
93 case PREINCREMENT_EXPR:
94 case PREDECREMENT_EXPR:
96 case WITH_CLEANUP_EXPR:
99 return lvalue_p_1 (TREE_OPERAND (ref, 0));
102 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
103 /* Look at the member designator. */
104 if (!op1_lvalue_kind)
106 else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
107 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
108 situations. If we're seeing a COMPONENT_REF, it's a non-static
109 member, so it isn't an lvalue. */
110 op1_lvalue_kind = clk_none;
111 else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
112 /* This can be IDENTIFIER_NODE in a template. */;
113 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
115 /* Clear the ordinary bit. If this object was a class
116 rvalue we want to preserve that information. */
117 op1_lvalue_kind &= ~clk_ordinary;
118 /* The lvalue is for a bitfield. */
119 op1_lvalue_kind |= clk_bitfield;
121 else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
122 op1_lvalue_kind |= clk_packed;
124 return op1_lvalue_kind;
127 case COMPOUND_LITERAL_EXPR:
131 /* CONST_DECL without TREE_STATIC are enumeration values and
132 thus not lvalues. With TREE_STATIC they are used by ObjC++
133 in objc_build_string_object and need to be considered as
135 if (! TREE_STATIC (ref))
138 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
139 && DECL_LANG_SPECIFIC (ref)
140 && DECL_IN_AGGR_P (ref))
146 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
150 /* A currently unresolved scope ref. */
155 /* Disallow <? and >? as lvalues if either argument side-effects. */
156 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
157 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
159 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
160 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1));
164 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1)
165 ? TREE_OPERAND (ref, 1)
166 : TREE_OPERAND (ref, 0));
167 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2));
174 return lvalue_p_1 (TREE_OPERAND (ref, 1));
180 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
183 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
187 /* All functions (except non-static-member functions) are
189 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
190 ? clk_none : clk_ordinary);
193 /* We now represent a reference to a single static member function
195 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
196 its argument unmodified and we assign it to a const_tree. */
197 return lvalue_p_1 (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
199 case NON_DEPENDENT_EXPR:
200 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
201 things like "&E" where "E" is an expression with a
202 non-dependent type work. It is safe to be lenient because an
203 error will be issued when the template is instantiated if "E"
211 /* If one operand is not an lvalue at all, then this expression is
213 if (!op1_lvalue_kind || !op2_lvalue_kind)
216 /* Otherwise, it's an lvalue, and it has all the odd properties
217 contributed by either operand. */
218 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
219 /* It's not an ordinary lvalue if it involves any other kind. */
220 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
221 op1_lvalue_kind &= ~clk_ordinary;
222 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
223 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
224 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
225 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
226 op1_lvalue_kind = clk_none;
227 return op1_lvalue_kind;
230 /* Returns the kind of lvalue that REF is, in the sense of
231 [basic.lval]. This function should really be named lvalue_p; it
232 computes the C++ definition of lvalue. */
235 real_lvalue_p (tree ref)
237 cp_lvalue_kind kind = lvalue_p_1 (ref);
238 if (kind & (clk_rvalueref|clk_class))
244 /* This differs from real_lvalue_p in that class rvalues are considered
248 lvalue_p (const_tree ref)
250 return (lvalue_p_1 (ref) != clk_none);
253 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
254 rvalue references are considered rvalues. */
257 lvalue_or_rvalue_with_address_p (const_tree ref)
259 cp_lvalue_kind kind = lvalue_p_1 (ref);
260 if (kind & clk_class)
263 return (kind != clk_none);
266 /* Test whether DECL is a builtin that may appear in a
267 constant-expression. */
270 builtin_valid_in_constant_expr_p (const_tree decl)
272 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
273 in constant-expressions. We may want to add other builtins later. */
274 return DECL_IS_BUILTIN_CONSTANT_P (decl);
277 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
280 build_target_expr (tree decl, tree value)
284 #ifdef ENABLE_CHECKING
285 gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
286 || TREE_TYPE (decl) == TREE_TYPE (value)
287 || useless_type_conversion_p (TREE_TYPE (decl),
291 t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
292 cxx_maybe_build_cleanup (decl), NULL_TREE);
293 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
294 ignore the TARGET_EXPR. If there really turn out to be no
295 side-effects, then the optimizer should be able to get rid of
296 whatever code is generated anyhow. */
297 TREE_SIDE_EFFECTS (t) = 1;
302 /* Return an undeclared local temporary of type TYPE for use in building a
306 build_local_temp (tree type)
308 tree slot = build_decl (input_location,
309 VAR_DECL, NULL_TREE, type);
310 DECL_ARTIFICIAL (slot) = 1;
311 DECL_IGNORED_P (slot) = 1;
312 DECL_CONTEXT (slot) = current_function_decl;
313 layout_decl (slot, 0);
317 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
320 process_aggr_init_operands (tree t)
324 side_effects = TREE_SIDE_EFFECTS (t);
328 n = TREE_OPERAND_LENGTH (t);
329 for (i = 1; i < n; i++)
331 tree op = TREE_OPERAND (t, i);
332 if (op && TREE_SIDE_EFFECTS (op))
339 TREE_SIDE_EFFECTS (t) = side_effects;
342 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
343 FN, and SLOT. NARGS is the number of call arguments which are specified
344 as a tree array ARGS. */
347 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
353 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
354 TREE_TYPE (t) = return_type;
355 AGGR_INIT_EXPR_FN (t) = fn;
356 AGGR_INIT_EXPR_SLOT (t) = slot;
357 for (i = 0; i < nargs; i++)
358 AGGR_INIT_EXPR_ARG (t, i) = args[i];
359 process_aggr_init_operands (t);
363 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
364 target. TYPE is the type to be initialized.
366 Build an AGGR_INIT_EXPR to represent the initialization. This function
367 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
368 to initialize another object, whereas a TARGET_EXPR can either
369 initialize another object or create its own temporary object, and as a
370 result building up a TARGET_EXPR requires that the type's destructor be
374 build_aggr_init_expr (tree type, tree init)
381 /* Make sure that we're not trying to create an instance of an
383 abstract_virtuals_error (NULL_TREE, type);
385 if (TREE_CODE (init) == CALL_EXPR)
386 fn = CALL_EXPR_FN (init);
387 else if (TREE_CODE (init) == AGGR_INIT_EXPR)
388 fn = AGGR_INIT_EXPR_FN (init);
390 return convert (type, init);
392 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
393 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
394 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
396 /* We split the CALL_EXPR into its function and its arguments here.
397 Then, in expand_expr, we put them back together. The reason for
398 this is that this expression might be a default argument
399 expression. In that case, we need a new temporary every time the
400 expression is used. That's what break_out_target_exprs does; it
401 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
402 temporary slot. Then, expand_expr builds up a call-expression
403 using the new slot. */
405 /* If we don't need to use a constructor to create an object of this
406 type, don't mess with AGGR_INIT_EXPR. */
407 if (is_ctor || TREE_ADDRESSABLE (type))
409 slot = build_local_temp (type);
411 if (TREE_CODE(init) == CALL_EXPR)
412 rval = build_aggr_init_array (void_type_node, fn, slot,
413 call_expr_nargs (init),
414 CALL_EXPR_ARGP (init));
416 rval = build_aggr_init_array (void_type_node, fn, slot,
417 aggr_init_expr_nargs (init),
418 AGGR_INIT_EXPR_ARGP (init));
419 TREE_SIDE_EFFECTS (rval) = 1;
420 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
421 TREE_NOTHROW (rval) = TREE_NOTHROW (init);
429 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
430 target. TYPE is the type that this initialization should appear to
433 Build an encapsulation of the initialization to perform
434 and return it so that it can be processed by language-independent
435 and language-specific expression expanders. */
438 build_cplus_new (tree type, tree init)
440 tree rval = build_aggr_init_expr (type, init);
443 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
444 slot = AGGR_INIT_EXPR_SLOT (rval);
445 else if (TREE_CODE (rval) == CALL_EXPR)
446 slot = build_local_temp (type);
450 rval = build_target_expr (slot, rval);
451 TARGET_EXPR_IMPLICIT_P (rval) = 1;
456 /* Return a TARGET_EXPR which expresses the direct-initialization of one
457 array from another. */
460 build_array_copy (tree init)
462 tree type = TREE_TYPE (init);
463 tree slot = build_local_temp (type);
464 init = build2 (VEC_INIT_EXPR, type, slot, init);
465 SET_EXPR_LOCATION (init, input_location);
466 init = build_target_expr (slot, init);
467 TARGET_EXPR_IMPLICIT_P (init) = 1;
472 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
476 build_target_expr_with_type (tree init, tree type)
478 gcc_assert (!VOID_TYPE_P (type));
480 if (TREE_CODE (init) == TARGET_EXPR
481 || init == error_mark_node)
483 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
484 && !VOID_TYPE_P (TREE_TYPE (init))
485 && TREE_CODE (init) != COND_EXPR
486 && TREE_CODE (init) != CONSTRUCTOR
487 && TREE_CODE (init) != VA_ARG_EXPR)
488 /* We need to build up a copy constructor call. A void initializer
489 means we're being called from bot_manip. COND_EXPR is a special
490 case because we already have copies on the arms and we don't want
491 another one here. A CONSTRUCTOR is aggregate initialization, which
492 is handled separately. A VA_ARG_EXPR is magic creation of an
493 aggregate; there's no additional work to be done. */
494 return force_rvalue (init);
496 return force_target_expr (type, init);
499 /* Like the above function, but without the checking. This function should
500 only be used by code which is deliberately trying to subvert the type
501 system, such as call_builtin_trap. Or build_over_call, to avoid
502 infinite recursion. */
505 force_target_expr (tree type, tree init)
509 gcc_assert (!VOID_TYPE_P (type));
511 slot = build_local_temp (type);
512 return build_target_expr (slot, init);
515 /* Like build_target_expr_with_type, but use the type of INIT. */
518 get_target_expr (tree init)
520 if (TREE_CODE (init) == AGGR_INIT_EXPR)
521 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init);
523 return build_target_expr_with_type (init, TREE_TYPE (init));
526 /* If EXPR is a bitfield reference, convert it to the declared type of
527 the bitfield, and return the resulting expression. Otherwise,
528 return EXPR itself. */
531 convert_bitfield_to_declared_type (tree expr)
535 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
537 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
542 /* EXPR is being used in an rvalue context. Return a version of EXPR
543 that is marked as an rvalue. */
550 if (error_operand_p (expr))
553 expr = mark_rvalue_use (expr);
557 Non-class rvalues always have cv-unqualified types. */
558 type = TREE_TYPE (expr);
559 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
560 type = cv_unqualified (type);
562 /* We need to do this for rvalue refs as well to get the right answer
563 from decltype; see c++/36628. */
564 if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
565 expr = build1 (NON_LVALUE_EXPR, type, expr);
566 else if (type != TREE_TYPE (expr))
567 expr = build_nop (type, expr);
573 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
576 cplus_array_hash (const void* k)
579 const_tree const t = (const_tree) k;
581 hash = TYPE_UID (TREE_TYPE (t));
583 hash ^= TYPE_UID (TYPE_DOMAIN (t));
587 typedef struct cplus_array_info {
592 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
593 of type `cplus_array_info*'. */
596 cplus_array_compare (const void * k1, const void * k2)
598 const_tree const t1 = (const_tree) k1;
599 const cplus_array_info *const t2 = (const cplus_array_info*) k2;
601 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
604 /* Hash table containing dependent array types, which are unsuitable for
605 the language-independent type hash table. */
606 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
608 /* Like build_array_type, but handle special C++ semantics. */
611 build_cplus_array_type (tree elt_type, tree index_type)
615 if (elt_type == error_mark_node || index_type == error_mark_node)
616 return error_mark_node;
618 if (processing_template_decl
619 && (dependent_type_p (elt_type)
620 || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
623 cplus_array_info cai;
626 if (cplus_array_htab == NULL)
627 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
628 &cplus_array_compare, NULL);
630 hash = TYPE_UID (elt_type);
632 hash ^= TYPE_UID (index_type);
634 cai.domain = index_type;
636 e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
638 /* We have found the type: we're done. */
642 /* Build a new array type. */
643 t = cxx_make_type (ARRAY_TYPE);
644 TREE_TYPE (t) = elt_type;
645 TYPE_DOMAIN (t) = index_type;
647 /* Store it in the hash table. */
650 /* Set the canonical type for this new node. */
651 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
652 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
653 SET_TYPE_STRUCTURAL_EQUALITY (t);
654 else if (TYPE_CANONICAL (elt_type) != elt_type
656 && TYPE_CANONICAL (index_type) != index_type))
658 = build_cplus_array_type
659 (TYPE_CANONICAL (elt_type),
660 index_type ? TYPE_CANONICAL (index_type) : index_type);
662 TYPE_CANONICAL (t) = t;
666 t = build_array_type (elt_type, index_type);
668 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
669 element type as well, so fix it up if needed. */
670 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
672 tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
674 if (TYPE_MAIN_VARIANT (t) != m)
676 TYPE_MAIN_VARIANT (t) = m;
677 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
678 TYPE_NEXT_VARIANT (m) = t;
682 /* Push these needs up so that initialization takes place
684 TYPE_NEEDS_CONSTRUCTING (t)
685 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
686 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
687 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
691 /* Return an ARRAY_TYPE with element type ELT and length N. */
694 build_array_of_n_type (tree elt, int n)
696 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
699 /* Return a reference type node referring to TO_TYPE. If RVAL is
700 true, return an rvalue reference type, otherwise return an lvalue
701 reference type. If a type node exists, reuse it, otherwise create
704 cp_build_reference_type (tree to_type, bool rval)
707 lvalue_ref = build_reference_type (to_type);
711 /* This code to create rvalue reference types is based on and tied
712 to the code creating lvalue reference types in the middle-end
713 functions build_reference_type_for_mode and build_reference_type.
715 It works by putting the rvalue reference type nodes after the
716 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
717 they will effectively be ignored by the middle end. */
719 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
720 if (TYPE_REF_IS_RVALUE (t))
723 t = build_distinct_type_copy (lvalue_ref);
725 TYPE_REF_IS_RVALUE (t) = true;
726 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
727 TYPE_NEXT_REF_TO (lvalue_ref) = t;
729 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
730 SET_TYPE_STRUCTURAL_EQUALITY (t);
731 else if (TYPE_CANONICAL (to_type) != to_type)
733 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
735 TYPE_CANONICAL (t) = t;
743 /* Returns EXPR cast to rvalue reference type, like std::move. */
748 tree type = TREE_TYPE (expr);
749 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
750 type = cp_build_reference_type (type, /*rval*/true);
751 return build_static_cast (type, expr, tf_warning_or_error);
754 /* Used by the C++ front end to build qualified array types. However,
755 the C version of this function does not properly maintain canonical
756 types (which are not used in C). */
758 c_build_qualified_type (tree type, int type_quals)
760 return cp_build_qualified_type (type, type_quals);
764 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
765 arrays correctly. In particular, if TYPE is an array of T's, and
766 TYPE_QUALS is non-empty, returns an array of qualified T's.
768 FLAGS determines how to deal with ill-formed qualifications. If
769 tf_ignore_bad_quals is set, then bad qualifications are dropped
770 (this is permitted if TYPE was introduced via a typedef or template
771 type parameter). If bad qualifications are dropped and tf_warning
772 is set, then a warning is issued for non-const qualifications. If
773 tf_ignore_bad_quals is not set and tf_error is not set, we
774 return error_mark_node. Otherwise, we issue an error, and ignore
777 Qualification of a reference type is valid when the reference came
778 via a typedef or template type argument. [dcl.ref] No such
779 dispensation is provided for qualifying a function type. [dcl.fct]
780 DR 295 queries this and the proposed resolution brings it into line
781 with qualifying a reference. We implement the DR. We also behave
782 in a similar manner for restricting non-pointer types. */
785 cp_build_qualified_type_real (tree type,
787 tsubst_flags_t complain)
790 int bad_quals = TYPE_UNQUALIFIED;
792 if (type == error_mark_node)
795 if (type_quals == cp_type_quals (type))
798 if (TREE_CODE (type) == ARRAY_TYPE)
800 /* In C++, the qualification really applies to the array element
801 type. Obtain the appropriately qualified element type. */
804 = cp_build_qualified_type_real (TREE_TYPE (type),
808 if (element_type == error_mark_node)
809 return error_mark_node;
811 /* See if we already have an identically qualified type. Tests
812 should be equivalent to those in check_qualified_type. */
813 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
814 if (cp_type_quals (t) == type_quals
815 && TYPE_NAME (t) == TYPE_NAME (type)
816 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
817 && attribute_list_equal (TYPE_ATTRIBUTES (t),
818 TYPE_ATTRIBUTES (type)))
823 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
825 /* Keep the typedef name. */
826 if (TYPE_NAME (t) != TYPE_NAME (type))
828 t = build_variant_type_copy (t);
829 TYPE_NAME (t) = TYPE_NAME (type);
833 /* Even if we already had this variant, we update
834 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
835 they changed since the variant was originally created.
837 This seems hokey; if there is some way to use a previous
838 variant *without* coming through here,
839 TYPE_NEEDS_CONSTRUCTING will never be updated. */
840 TYPE_NEEDS_CONSTRUCTING (t)
841 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
842 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
843 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
846 else if (TYPE_PTRMEMFUNC_P (type))
848 /* For a pointer-to-member type, we can't just return a
849 cv-qualified version of the RECORD_TYPE. If we do, we
850 haven't changed the field that contains the actual pointer to
851 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
854 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
855 t = cp_build_qualified_type_real (t, type_quals, complain);
856 return build_ptrmemfunc_type (t);
858 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
860 tree t = PACK_EXPANSION_PATTERN (type);
862 t = cp_build_qualified_type_real (t, type_quals, complain);
863 return make_pack_expansion (t);
866 /* A reference or method type shall not be cv-qualified.
867 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
868 (in CD1) we always ignore extra cv-quals on functions. */
869 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
870 && (TREE_CODE (type) == REFERENCE_TYPE
871 || TREE_CODE (type) == FUNCTION_TYPE
872 || TREE_CODE (type) == METHOD_TYPE))
874 if (TREE_CODE (type) == REFERENCE_TYPE)
875 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
876 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
879 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
880 if (TREE_CODE (type) == FUNCTION_TYPE)
881 type_quals |= type_memfn_quals (type);
883 /* A restrict-qualified type must be a pointer (or reference)
884 to object or incomplete type. */
885 if ((type_quals & TYPE_QUAL_RESTRICT)
886 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
887 && TREE_CODE (type) != TYPENAME_TYPE
888 && !POINTER_TYPE_P (type))
890 bad_quals |= TYPE_QUAL_RESTRICT;
891 type_quals &= ~TYPE_QUAL_RESTRICT;
894 if (bad_quals == TYPE_UNQUALIFIED
895 || (complain & tf_ignore_bad_quals))
897 else if (!(complain & tf_error))
898 return error_mark_node;
901 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
902 error ("%qV qualifiers cannot be applied to %qT",
906 /* Retrieve (or create) the appropriately qualified variant. */
907 result = build_qualified_type (type, type_quals);
909 /* If this was a pointer-to-method type, and we just made a copy,
910 then we need to unshare the record that holds the cached
911 pointer-to-member-function type, because these will be distinct
912 between the unqualified and qualified types. */
914 && TREE_CODE (type) == POINTER_TYPE
915 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
916 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
917 TYPE_LANG_SPECIFIC (result) = NULL;
919 /* We may also have ended up building a new copy of the canonical
920 type of a pointer-to-method type, which could have the same
921 sharing problem described above. */
922 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
923 && TREE_CODE (type) == POINTER_TYPE
924 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
925 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
926 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
927 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
932 /* Return TYPE with const and volatile removed. */
935 cv_unqualified (tree type)
939 if (type == error_mark_node)
942 quals = cp_type_quals (type);
943 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
944 return cp_build_qualified_type (type, quals);
947 /* Builds a qualified variant of T that is not a typedef variant.
948 E.g. consider the following declarations:
949 typedef const int ConstInt;
950 typedef ConstInt* PtrConstInt;
951 If T is PtrConstInt, this function returns a type representing
953 In other words, if T is a typedef, the function returns the underlying type.
954 The cv-qualification and attributes of the type returned match the
956 They will always be compatible types.
957 The returned type is built so that all of its subtypes
958 recursively have their typedefs stripped as well.
960 This is different from just returning TYPE_CANONICAL (T)
961 Because of several reasons:
962 * If T is a type that needs structural equality
963 its TYPE_CANONICAL (T) will be NULL.
964 * TYPE_CANONICAL (T) desn't carry type attributes
965 and looses template parameter names. */
968 strip_typedefs (tree t)
970 tree result = NULL, type = NULL, t0 = NULL;
972 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
975 gcc_assert (TYPE_P (t));
977 switch (TREE_CODE (t))
980 type = strip_typedefs (TREE_TYPE (t));
981 result = build_pointer_type (type);
984 type = strip_typedefs (TREE_TYPE (t));
985 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
988 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
989 type = strip_typedefs (TREE_TYPE (t));
990 result = build_offset_type (t0, type);
993 if (TYPE_PTRMEMFUNC_P (t))
995 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
996 result = build_ptrmemfunc_type (t0);
1000 type = strip_typedefs (TREE_TYPE (t));
1001 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1002 result = build_cplus_array_type (type, t0);
1007 tree arg_types = NULL, arg_node, arg_type;
1008 for (arg_node = TYPE_ARG_TYPES (t);
1010 arg_node = TREE_CHAIN (arg_node))
1012 if (arg_node == void_list_node)
1014 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1015 gcc_assert (arg_type);
1018 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1022 arg_types = nreverse (arg_types);
1024 /* A list of parameters not ending with an ellipsis
1025 must end with void_list_node. */
1027 arg_types = chainon (arg_types, void_list_node);
1029 type = strip_typedefs (TREE_TYPE (t));
1030 if (TREE_CODE (t) == METHOD_TYPE)
1032 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1033 gcc_assert (class_type);
1035 build_method_type_directly (class_type, type,
1036 TREE_CHAIN (arg_types));
1040 result = build_function_type (type,
1042 result = apply_memfn_quals (result, type_memfn_quals (t));
1045 if (TYPE_RAISES_EXCEPTIONS (t))
1046 result = build_exception_variant (result,
1047 TYPE_RAISES_EXCEPTIONS (t));
1051 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1052 TYPENAME_TYPE_FULLNAME (t),
1053 typename_type, tf_none);
1060 result = TYPE_MAIN_VARIANT (t);
1061 if (TYPE_ATTRIBUTES (t))
1062 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1063 return cp_build_qualified_type (result, cp_type_quals (t));
1066 /* Setup a TYPE_DECL node as a typedef representation.
1067 See comments of set_underlying_type in c-common.c. */
1070 cp_set_underlying_type (tree t)
1072 set_underlying_type (t);
1073 /* If T is a template type parm, make it require structural equality.
1074 This is useful when comparing two template type parms,
1075 because it forces the comparison of the template parameters of their
1077 if (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1078 SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t));
1082 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1083 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1084 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1085 VIRT indicates whether TYPE is inherited virtually or not.
1086 IGO_PREV points at the previous binfo of the inheritance graph
1087 order chain. The newly copied binfo's TREE_CHAIN forms this
1090 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1091 correct order. That is in the order the bases themselves should be
1094 The BINFO_INHERITANCE of a virtual base class points to the binfo
1095 of the most derived type. ??? We could probably change this so that
1096 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1097 remove a field. They currently can only differ for primary virtual
1101 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1107 /* See if we've already made this virtual base. */
1108 new_binfo = binfo_for_vbase (type, t);
1113 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1114 BINFO_TYPE (new_binfo) = type;
1116 /* Chain it into the inheritance graph. */
1117 TREE_CHAIN (*igo_prev) = new_binfo;
1118 *igo_prev = new_binfo;
1125 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1126 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1128 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1129 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1131 /* We do not need to copy the accesses, as they are read only. */
1132 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1134 /* Recursively copy base binfos of BINFO. */
1135 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1137 tree new_base_binfo;
1139 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1140 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1142 BINFO_VIRTUAL_P (base_binfo));
1144 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1145 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1146 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1150 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1154 /* Push it onto the list after any virtual bases it contains
1155 will have been pushed. */
1156 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1157 BINFO_VIRTUAL_P (new_binfo) = 1;
1158 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1164 /* Hashing of lists so that we don't make duplicates.
1165 The entry point is `list_hash_canon'. */
1167 /* Now here is the hash table. When recording a list, it is added
1168 to the slot whose index is the hash code mod the table size.
1169 Note that the hash table is used for several kinds of lists.
1170 While all these live in the same table, they are completely independent,
1171 and the hash code is computed differently for each of these. */
1173 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1182 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1183 for a node we are thinking about adding). */
1186 list_hash_eq (const void* entry, const void* data)
1188 const_tree const t = (const_tree) entry;
1189 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1191 return (TREE_VALUE (t) == proxy->value
1192 && TREE_PURPOSE (t) == proxy->purpose
1193 && TREE_CHAIN (t) == proxy->chain);
1196 /* Compute a hash code for a list (chain of TREE_LIST nodes
1197 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1198 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1201 list_hash_pieces (tree purpose, tree value, tree chain)
1203 hashval_t hashcode = 0;
1206 hashcode += TREE_HASH (chain);
1209 hashcode += TREE_HASH (value);
1213 hashcode += TREE_HASH (purpose);
1219 /* Hash an already existing TREE_LIST. */
1222 list_hash (const void* p)
1224 const_tree const t = (const_tree) p;
1225 return list_hash_pieces (TREE_PURPOSE (t),
1230 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1231 object for an identical list if one already exists. Otherwise, build a
1232 new one, and record it as the canonical object. */
1235 hash_tree_cons (tree purpose, tree value, tree chain)
1239 struct list_proxy proxy;
1241 /* Hash the list node. */
1242 hashcode = list_hash_pieces (purpose, value, chain);
1243 /* Create a proxy for the TREE_LIST we would like to create. We
1244 don't actually create it so as to avoid creating garbage. */
1245 proxy.purpose = purpose;
1246 proxy.value = value;
1247 proxy.chain = chain;
1248 /* See if it is already in the table. */
1249 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1251 /* If not, create a new node. */
1253 *slot = tree_cons (purpose, value, chain);
1254 return (tree) *slot;
1257 /* Constructor for hashed lists. */
1260 hash_tree_chain (tree value, tree chain)
1262 return hash_tree_cons (NULL_TREE, value, chain);
1266 debug_binfo (tree elem)
1271 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1273 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1274 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1275 debug_tree (BINFO_TYPE (elem));
1276 if (BINFO_VTABLE (elem))
1277 fprintf (stderr, "vtable decl \"%s\"\n",
1278 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1280 fprintf (stderr, "no vtable decl yet\n");
1281 fprintf (stderr, "virtuals:\n");
1282 virtuals = BINFO_VIRTUALS (elem);
1287 tree fndecl = TREE_VALUE (virtuals);
1288 fprintf (stderr, "%s [%ld =? %ld]\n",
1289 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1290 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1292 virtuals = TREE_CHAIN (virtuals);
1296 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1297 the type of the result expression, if known, or NULL_TREE if the
1298 resulting expression is type-dependent. If TEMPLATE_P is true,
1299 NAME is known to be a template because the user explicitly used the
1300 "template" keyword after the "::".
1302 All SCOPE_REFs should be built by use of this function. */
1305 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1308 if (type == error_mark_node
1309 || scope == error_mark_node
1310 || name == error_mark_node)
1311 return error_mark_node;
1312 t = build2 (SCOPE_REF, type, scope, name);
1313 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1315 t = convert_from_reference (t);
1319 /* Returns nonzero if X is an expression for a (possibly overloaded)
1320 function. If "f" is a function or function template, "f", "c->f",
1321 "c.f", "C::f", and "f<int>" will all be considered possibly
1322 overloaded functions. Returns 2 if the function is actually
1323 overloaded, i.e., if it is impossible to know the type of the
1324 function without performing overload resolution. */
1327 is_overloaded_fn (tree x)
1329 /* A baselink is also considered an overloaded function. */
1330 if (TREE_CODE (x) == OFFSET_REF
1331 || TREE_CODE (x) == COMPONENT_REF)
1332 x = TREE_OPERAND (x, 1);
1334 x = BASELINK_FUNCTIONS (x);
1335 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1336 x = TREE_OPERAND (x, 0);
1337 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1338 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1340 return (TREE_CODE (x) == FUNCTION_DECL
1341 || TREE_CODE (x) == OVERLOAD);
1344 /* Returns true iff X is an expression for an overloaded function
1345 whose type cannot be known without performing overload
1349 really_overloaded_fn (tree x)
1351 return is_overloaded_fn (x) == 2;
1357 gcc_assert (is_overloaded_fn (from));
1358 /* A baselink is also considered an overloaded function. */
1359 if (TREE_CODE (from) == OFFSET_REF
1360 || TREE_CODE (from) == COMPONENT_REF)
1361 from = TREE_OPERAND (from, 1);
1362 if (BASELINK_P (from))
1363 from = BASELINK_FUNCTIONS (from);
1364 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1365 from = TREE_OPERAND (from, 0);
1370 get_first_fn (tree from)
1372 return OVL_CURRENT (get_fns (from));
1375 /* Return a new OVL node, concatenating it with the old one. */
1378 ovl_cons (tree decl, tree chain)
1380 tree result = make_node (OVERLOAD);
1381 TREE_TYPE (result) = unknown_type_node;
1382 OVL_FUNCTION (result) = decl;
1383 TREE_CHAIN (result) = chain;
1388 /* Build a new overloaded function. If this is the first one,
1389 just return it; otherwise, ovl_cons the _DECLs */
1392 build_overload (tree decl, tree chain)
1394 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1396 if (chain && TREE_CODE (chain) != OVERLOAD)
1397 chain = ovl_cons (chain, NULL_TREE);
1398 return ovl_cons (decl, chain);
1402 #define PRINT_RING_SIZE 4
1405 cxx_printable_name_internal (tree decl, int v, bool translate)
1407 static unsigned int uid_ring[PRINT_RING_SIZE];
1408 static char *print_ring[PRINT_RING_SIZE];
1409 static bool trans_ring[PRINT_RING_SIZE];
1410 static int ring_counter;
1413 /* Only cache functions. */
1415 || TREE_CODE (decl) != FUNCTION_DECL
1416 || DECL_LANG_SPECIFIC (decl) == 0)
1417 return lang_decl_name (decl, v, translate);
1419 /* See if this print name is lying around. */
1420 for (i = 0; i < PRINT_RING_SIZE; i++)
1421 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1422 /* yes, so return it. */
1423 return print_ring[i];
1425 if (++ring_counter == PRINT_RING_SIZE)
1428 if (current_function_decl != NULL_TREE)
1430 /* There may be both translated and untranslated versions of the
1432 for (i = 0; i < 2; i++)
1434 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1436 if (ring_counter == PRINT_RING_SIZE)
1439 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1442 if (print_ring[ring_counter])
1443 free (print_ring[ring_counter]);
1445 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1446 uid_ring[ring_counter] = DECL_UID (decl);
1447 trans_ring[ring_counter] = translate;
1448 return print_ring[ring_counter];
1452 cxx_printable_name (tree decl, int v)
1454 return cxx_printable_name_internal (decl, v, false);
1458 cxx_printable_name_translate (tree decl, int v)
1460 return cxx_printable_name_internal (decl, v, true);
1463 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1464 listed in RAISES. */
1467 build_exception_variant (tree type, tree raises)
1472 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1475 type_quals = TYPE_QUALS (type);
1476 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1477 if (check_qualified_type (v, type, type_quals)
1478 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1481 /* Need to build a new variant. */
1482 v = build_variant_type_copy (type);
1483 TYPE_RAISES_EXCEPTIONS (v) = raises;
1487 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1488 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1492 bind_template_template_parm (tree t, tree newargs)
1494 tree decl = TYPE_NAME (t);
1497 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1498 decl = build_decl (input_location,
1499 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1501 /* These nodes have to be created to reflect new TYPE_DECL and template
1503 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1504 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1505 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1506 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1508 TREE_TYPE (decl) = t2;
1509 TYPE_NAME (t2) = decl;
1510 TYPE_STUB_DECL (t2) = decl;
1512 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1517 /* Called from count_trees via walk_tree. */
1520 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1530 /* Debugging function for measuring the rough complexity of a tree
1534 count_trees (tree t)
1537 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1541 /* Called from verify_stmt_tree via walk_tree. */
1544 verify_stmt_tree_r (tree* tp,
1545 int* walk_subtrees ATTRIBUTE_UNUSED ,
1549 htab_t *statements = (htab_t *) data;
1552 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1555 /* If this statement is already present in the hash table, then
1556 there is a circularity in the statement tree. */
1557 gcc_assert (!htab_find (*statements, t));
1559 slot = htab_find_slot (*statements, t, INSERT);
1565 /* Debugging function to check that the statement T has not been
1566 corrupted. For now, this function simply checks that T contains no
1570 verify_stmt_tree (tree t)
1573 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1574 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1575 htab_delete (statements);
1578 /* Check if the type T depends on a type with no linkage and if so, return
1579 it. If RELAXED_P then do not consider a class type declared within
1580 a vague-linkage function to have no linkage. */
1583 no_linkage_check (tree t, bool relaxed_p)
1587 /* There's no point in checking linkage on template functions; we
1588 can't know their complete types. */
1589 if (processing_template_decl)
1592 switch (TREE_CODE (t))
1595 if (TYPE_PTRMEMFUNC_P (t))
1597 /* Lambda types that don't have mangling scope have no linkage. We
1598 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1599 when we get here from pushtag none of the lambda information is
1600 set up yet, so we want to assume that the lambda has linkage and
1601 fix it up later if not. */
1602 if (CLASSTYPE_LAMBDA_EXPR (t)
1603 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1607 if (!CLASS_TYPE_P (t))
1611 /* Only treat anonymous types as having no linkage if they're at
1612 namespace scope. This is core issue 966. */
1613 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1616 for (r = CP_TYPE_CONTEXT (t); ; )
1618 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1619 have linkage, or we might just be in an anonymous namespace.
1620 If we're in a TREE_PUBLIC class, we have linkage. */
1621 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1622 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1623 else if (TREE_CODE (r) == FUNCTION_DECL)
1625 if (!relaxed_p || !vague_linkage_p (r))
1628 r = CP_DECL_CONTEXT (r);
1638 case REFERENCE_TYPE:
1639 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1643 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1647 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1650 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1657 for (parm = TYPE_ARG_TYPES (t);
1658 parm && parm != void_list_node;
1659 parm = TREE_CHAIN (parm))
1661 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1665 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1673 #ifdef GATHER_STATISTICS
1674 extern int depth_reached;
1678 cxx_print_statistics (void)
1680 print_search_statistics ();
1681 print_class_statistics ();
1682 print_template_statistics ();
1683 #ifdef GATHER_STATISTICS
1684 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1689 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1690 (which is an ARRAY_TYPE). This counts only elements of the top
1694 array_type_nelts_top (tree type)
1696 return fold_build2_loc (input_location,
1697 PLUS_EXPR, sizetype,
1698 array_type_nelts (type),
1702 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1703 (which is an ARRAY_TYPE). This one is a recursive count of all
1704 ARRAY_TYPEs that are clumped together. */
1707 array_type_nelts_total (tree type)
1709 tree sz = array_type_nelts_top (type);
1710 type = TREE_TYPE (type);
1711 while (TREE_CODE (type) == ARRAY_TYPE)
1713 tree n = array_type_nelts_top (type);
1714 sz = fold_build2_loc (input_location,
1715 MULT_EXPR, sizetype, sz, n);
1716 type = TREE_TYPE (type);
1721 /* Called from break_out_target_exprs via mapcar. */
1724 bot_manip (tree* tp, int* walk_subtrees, void* data)
1726 splay_tree target_remap = ((splay_tree) data);
1729 if (!TYPE_P (t) && TREE_CONSTANT (t))
1731 /* There can't be any TARGET_EXPRs or their slot variables below
1732 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1733 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1737 if (TREE_CODE (t) == TARGET_EXPR)
1741 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1742 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1));
1744 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t));
1746 /* Map the old variable to the new one. */
1747 splay_tree_insert (target_remap,
1748 (splay_tree_key) TREE_OPERAND (t, 0),
1749 (splay_tree_value) TREE_OPERAND (u, 0));
1751 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1753 /* Replace the old expression with the new version. */
1755 /* We don't have to go below this point; the recursive call to
1756 break_out_target_exprs will have handled anything below this
1762 /* Make a copy of this node. */
1763 return copy_tree_r (tp, walk_subtrees, NULL);
1766 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1767 DATA is really a splay-tree mapping old variables to new
1771 bot_replace (tree* t,
1772 int* walk_subtrees ATTRIBUTE_UNUSED ,
1775 splay_tree target_remap = ((splay_tree) data);
1777 if (TREE_CODE (*t) == VAR_DECL)
1779 splay_tree_node n = splay_tree_lookup (target_remap,
1780 (splay_tree_key) *t);
1782 *t = (tree) n->value;
1788 /* When we parse a default argument expression, we may create
1789 temporary variables via TARGET_EXPRs. When we actually use the
1790 default-argument expression, we make a copy of the expression, but
1791 we must replace the temporaries with appropriate local versions. */
1794 break_out_target_exprs (tree t)
1796 static int target_remap_count;
1797 static splay_tree target_remap;
1799 if (!target_remap_count++)
1800 target_remap = splay_tree_new (splay_tree_compare_pointers,
1801 /*splay_tree_delete_key_fn=*/NULL,
1802 /*splay_tree_delete_value_fn=*/NULL);
1803 cp_walk_tree (&t, bot_manip, target_remap, NULL);
1804 cp_walk_tree (&t, bot_replace, target_remap, NULL);
1806 if (!--target_remap_count)
1808 splay_tree_delete (target_remap);
1809 target_remap = NULL;
1815 /* Similar to `build_nt', but for template definitions of dependent
1819 build_min_nt (enum tree_code code, ...)
1826 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1830 t = make_node (code);
1831 length = TREE_CODE_LENGTH (code);
1833 for (i = 0; i < length; i++)
1835 tree x = va_arg (p, tree);
1836 TREE_OPERAND (t, i) = x;
1844 /* Similar to `build', but for template definitions. */
1847 build_min (enum tree_code code, tree tt, ...)
1854 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1858 t = make_node (code);
1859 length = TREE_CODE_LENGTH (code);
1862 for (i = 0; i < length; i++)
1864 tree x = va_arg (p, tree);
1865 TREE_OPERAND (t, i) = x;
1866 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1867 TREE_SIDE_EFFECTS (t) = 1;
1874 /* Similar to `build', but for template definitions of non-dependent
1875 expressions. NON_DEP is the non-dependent expression that has been
1879 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1886 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1888 va_start (p, non_dep);
1890 t = make_node (code);
1891 length = TREE_CODE_LENGTH (code);
1892 TREE_TYPE (t) = TREE_TYPE (non_dep);
1893 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1895 for (i = 0; i < length; i++)
1897 tree x = va_arg (p, tree);
1898 TREE_OPERAND (t, i) = x;
1901 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1902 /* This should not be considered a COMPOUND_EXPR, because it
1903 resolves to an overload. */
1904 COMPOUND_EXPR_OVERLOADED (t) = 1;
1910 /* Similar to `build_nt_call_vec', but for template definitions of
1911 non-dependent expressions. NON_DEP is the non-dependent expression
1912 that has been built. */
1915 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
1917 tree t = build_nt_call_vec (fn, argvec);
1918 TREE_TYPE (t) = TREE_TYPE (non_dep);
1919 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1924 get_type_decl (tree t)
1926 if (TREE_CODE (t) == TYPE_DECL)
1929 return TYPE_STUB_DECL (t);
1930 gcc_assert (t == error_mark_node);
1934 /* Returns the namespace that contains DECL, whether directly or
1938 decl_namespace_context (tree decl)
1942 if (TREE_CODE (decl) == NAMESPACE_DECL)
1944 else if (TYPE_P (decl))
1945 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1947 decl = CP_DECL_CONTEXT (decl);
1951 /* Returns true if decl is within an anonymous namespace, however deeply
1952 nested, or false otherwise. */
1955 decl_anon_ns_mem_p (const_tree decl)
1959 if (decl == NULL_TREE || decl == error_mark_node)
1961 if (TREE_CODE (decl) == NAMESPACE_DECL
1962 && DECL_NAME (decl) == NULL_TREE)
1964 /* Classes and namespaces inside anonymous namespaces have
1965 TREE_PUBLIC == 0, so we can shortcut the search. */
1966 else if (TYPE_P (decl))
1967 return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
1968 else if (TREE_CODE (decl) == NAMESPACE_DECL)
1969 return (TREE_PUBLIC (decl) == 0);
1971 decl = DECL_CONTEXT (decl);
1975 /* Return truthvalue of whether T1 is the same tree structure as T2.
1976 Return 1 if they are the same. Return 0 if they are different. */
1979 cp_tree_equal (tree t1, tree t2)
1981 enum tree_code code1, code2;
1988 for (code1 = TREE_CODE (t1);
1989 CONVERT_EXPR_CODE_P (code1)
1990 || code1 == NON_LVALUE_EXPR;
1991 code1 = TREE_CODE (t1))
1992 t1 = TREE_OPERAND (t1, 0);
1993 for (code2 = TREE_CODE (t2);
1994 CONVERT_EXPR_CODE_P (code2)
1995 || code1 == NON_LVALUE_EXPR;
1996 code2 = TREE_CODE (t2))
1997 t2 = TREE_OPERAND (t2, 0);
1999 /* They might have become equal now. */
2009 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2010 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2013 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2016 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2017 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2018 TREE_STRING_LENGTH (t1));
2021 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2022 TREE_FIXED_CST (t2));
2025 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2026 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2029 /* We need to do this when determining whether or not two
2030 non-type pointer to member function template arguments
2032 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2033 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2038 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2040 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2041 if (!cp_tree_equal (field, elt2->index)
2042 || !cp_tree_equal (value, elt2->value))
2049 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2051 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2053 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2056 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2061 call_expr_arg_iterator iter1, iter2;
2062 if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2064 for (arg1 = first_call_expr_arg (t1, &iter1),
2065 arg2 = first_call_expr_arg (t2, &iter2);
2067 arg1 = next_call_expr_arg (&iter1),
2068 arg2 = next_call_expr_arg (&iter2))
2069 if (!cp_tree_equal (arg1, arg2))
2078 tree o1 = TREE_OPERAND (t1, 0);
2079 tree o2 = TREE_OPERAND (t2, 0);
2081 /* Special case: if either target is an unallocated VAR_DECL,
2082 it means that it's going to be unified with whatever the
2083 TARGET_EXPR is really supposed to initialize, so treat it
2084 as being equivalent to anything. */
2085 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2086 && !DECL_RTL_SET_P (o1))
2088 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2089 && !DECL_RTL_SET_P (o2))
2091 else if (!cp_tree_equal (o1, o2))
2094 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2097 case WITH_CLEANUP_EXPR:
2098 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2100 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2103 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2105 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2108 /* For comparing uses of parameters in late-specified return types
2109 with an out-of-class definition of the function. */
2110 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2111 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
2120 case IDENTIFIER_NODE:
2125 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2126 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2127 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2128 BASELINK_FUNCTIONS (t2)));
2130 case TEMPLATE_PARM_INDEX:
2131 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2132 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2133 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2134 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2135 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2136 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2138 case TEMPLATE_ID_EXPR:
2143 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2145 vec1 = TREE_OPERAND (t1, 1);
2146 vec2 = TREE_OPERAND (t2, 1);
2149 return !vec1 && !vec2;
2151 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2154 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2155 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2156 TREE_VEC_ELT (vec2, ix)))
2165 tree o1 = TREE_OPERAND (t1, 0);
2166 tree o2 = TREE_OPERAND (t2, 0);
2168 if (TREE_CODE (o1) != TREE_CODE (o2))
2171 return same_type_p (o1, o2);
2173 return cp_tree_equal (o1, o2);
2178 tree t1_op1, t2_op1;
2180 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2183 t1_op1 = TREE_OPERAND (t1, 1);
2184 t2_op1 = TREE_OPERAND (t2, 1);
2185 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2188 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2192 /* Two pointer-to-members are the same if they point to the same
2193 field or function in the same class. */
2194 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2197 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2200 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2202 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2205 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2207 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2208 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2211 case STATIC_CAST_EXPR:
2212 case REINTERPRET_CAST_EXPR:
2213 case CONST_CAST_EXPR:
2214 case DYNAMIC_CAST_EXPR:
2216 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2218 /* Now compare operands as usual. */
2225 switch (TREE_CODE_CLASS (code1))
2229 case tcc_comparison:
2230 case tcc_expression:
2237 n = TREE_OPERAND_LENGTH (t1);
2238 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2239 && n != TREE_OPERAND_LENGTH (t2))
2242 for (i = 0; i < n; ++i)
2243 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2250 return same_type_p (t1, t2);
2254 /* We can get here with --disable-checking. */
2258 /* The type of ARG when used as an lvalue. */
2261 lvalue_type (tree arg)
2263 tree type = TREE_TYPE (arg);
2267 /* The type of ARG for printing error messages; denote lvalues with
2271 error_type (tree arg)
2273 tree type = TREE_TYPE (arg);
2275 if (TREE_CODE (type) == ARRAY_TYPE)
2277 else if (TREE_CODE (type) == ERROR_MARK)
2279 else if (real_lvalue_p (arg))
2280 type = build_reference_type (lvalue_type (arg));
2281 else if (MAYBE_CLASS_TYPE_P (type))
2282 type = lvalue_type (arg);
2287 /* Does FUNCTION use a variable-length argument list? */
2290 varargs_function_p (const_tree function)
2292 return stdarg_p (TREE_TYPE (function));
2295 /* Returns 1 if decl is a member of a class. */
2298 member_p (const_tree decl)
2300 const_tree const ctx = DECL_CONTEXT (decl);
2301 return (ctx && TYPE_P (ctx));
2304 /* Create a placeholder for member access where we don't actually have an
2305 object that the access is against. */
2308 build_dummy_object (tree type)
2310 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2311 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2314 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2315 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2316 binfo path from current_class_type to TYPE, or 0. */
2319 maybe_dummy_object (tree type, tree* binfop)
2323 tree current = current_nonlambda_class_type ();
2326 && (binfo = lookup_base (current, type, ba_any, NULL)))
2330 /* Reference from a nested class member function. */
2332 binfo = TYPE_BINFO (type);
2338 if (current_class_ref && context == current_class_type
2339 /* Kludge: Make sure that current_class_type is actually
2340 correct. It might not be if we're in the middle of
2341 tsubst_default_argument. */
2342 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
2343 current_class_type))
2344 decl = current_class_ref;
2345 else if (current != current_class_type
2346 && context == nonlambda_method_basetype ())
2347 /* In a lambda, need to go through 'this' capture. */
2348 decl = (cp_build_indirect_ref
2349 ((lambda_expr_this_capture
2350 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2351 RO_NULL, tf_warning_or_error));
2353 decl = build_dummy_object (context);
2358 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2361 is_dummy_object (const_tree ob)
2363 if (TREE_CODE (ob) == INDIRECT_REF)
2364 ob = TREE_OPERAND (ob, 0);
2365 return (TREE_CODE (ob) == NOP_EXPR
2366 && TREE_OPERAND (ob, 0) == void_zero_node);
2369 /* Returns 1 iff type T is something we want to treat as a scalar type for
2370 the purpose of deciding whether it is trivial/POD/standard-layout. */
2373 scalarish_type_p (const_tree t)
2375 if (t == error_mark_node)
2378 return (SCALAR_TYPE_P (t)
2379 || TREE_CODE (t) == VECTOR_TYPE);
2382 /* Returns true iff T requires non-trivial default initialization. */
2385 type_has_nontrivial_default_init (const_tree t)
2387 t = strip_array_types (CONST_CAST_TREE (t));
2389 if (CLASS_TYPE_P (t))
2390 return TYPE_HAS_COMPLEX_DFLT (t);
2395 /* Returns true iff copying an object of type T (including via move
2396 constructor) is non-trivial. That is, T has no non-trivial copy
2397 constructors and no non-trivial move constructors. */
2400 type_has_nontrivial_copy_init (const_tree t)
2402 t = strip_array_types (CONST_CAST_TREE (t));
2404 if (CLASS_TYPE_P (t))
2406 gcc_assert (COMPLETE_TYPE_P (t));
2407 return ((TYPE_HAS_COPY_CTOR (t)
2408 && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2409 || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2415 /* Returns 1 iff type T is a trivially copyable type, as defined in
2416 [basic.types] and [class]. */
2419 trivially_copyable_p (const_tree t)
2421 t = strip_array_types (CONST_CAST_TREE (t));
2423 if (CLASS_TYPE_P (t))
2424 return ((!TYPE_HAS_COPY_CTOR (t)
2425 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2426 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2427 && (!TYPE_HAS_COPY_ASSIGN (t)
2428 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2429 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2430 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2432 return scalarish_type_p (t);
2435 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2439 trivial_type_p (const_tree t)
2441 t = strip_array_types (CONST_CAST_TREE (t));
2443 if (CLASS_TYPE_P (t))
2444 return (TYPE_HAS_TRIVIAL_DFLT (t)
2445 && trivially_copyable_p (t));
2447 return scalarish_type_p (t);
2450 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2453 pod_type_p (const_tree t)
2455 /* This CONST_CAST is okay because strip_array_types returns its
2456 argument unmodified and we assign it to a const_tree. */
2457 t = strip_array_types (CONST_CAST_TREE(t));
2459 if (!CLASS_TYPE_P (t))
2460 return scalarish_type_p (t);
2461 else if (cxx_dialect > cxx98)
2462 /* [class]/10: A POD struct is a class that is both a trivial class and a
2463 standard-layout class, and has no non-static data members of type
2464 non-POD struct, non-POD union (or array of such types).
2466 We don't need to check individual members because if a member is
2467 non-std-layout or non-trivial, the class will be too. */
2468 return (std_layout_type_p (t) && trivial_type_p (t));
2470 /* The C++98 definition of POD is different. */
2471 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2474 /* Returns true iff T is POD for the purpose of layout, as defined in the
2478 layout_pod_type_p (const_tree t)
2480 t = strip_array_types (CONST_CAST_TREE (t));
2482 if (CLASS_TYPE_P (t))
2483 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2485 return scalarish_type_p (t);
2488 /* Returns true iff T is a standard-layout type, as defined in
2492 std_layout_type_p (const_tree t)
2494 t = strip_array_types (CONST_CAST_TREE (t));
2496 if (CLASS_TYPE_P (t))
2497 return !CLASSTYPE_NON_STD_LAYOUT (t);
2499 return scalarish_type_p (t);
2502 /* Nonzero iff type T is a class template implicit specialization. */
2505 class_tmpl_impl_spec_p (const_tree t)
2507 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2510 /* Returns 1 iff zero initialization of type T means actually storing
2514 zero_init_p (const_tree t)
2516 /* This CONST_CAST is okay because strip_array_types returns its
2517 argument unmodified and we assign it to a const_tree. */
2518 t = strip_array_types (CONST_CAST_TREE(t));
2520 if (t == error_mark_node)
2523 /* NULL pointers to data members are initialized with -1. */
2524 if (TYPE_PTRMEM_P (t))
2527 /* Classes that contain types that can't be zero-initialized, cannot
2528 be zero-initialized themselves. */
2529 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2535 /* Table of valid C++ attributes. */
2536 const struct attribute_spec cxx_attribute_table[] =
2538 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2539 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2540 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
2541 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
2542 { NULL, 0, 0, false, false, false, NULL }
2545 /* Handle a "java_interface" attribute; arguments as in
2546 struct attribute_spec.handler. */
2548 handle_java_interface_attribute (tree* node,
2550 tree args ATTRIBUTE_UNUSED ,
2555 || !CLASS_TYPE_P (*node)
2556 || !TYPE_FOR_JAVA (*node))
2558 error ("%qE attribute can only be applied to Java class definitions",
2560 *no_add_attrs = true;
2563 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2564 *node = build_variant_type_copy (*node);
2565 TYPE_JAVA_INTERFACE (*node) = 1;
2570 /* Handle a "com_interface" attribute; arguments as in
2571 struct attribute_spec.handler. */
2573 handle_com_interface_attribute (tree* node,
2575 tree args ATTRIBUTE_UNUSED ,
2576 int flags ATTRIBUTE_UNUSED ,
2581 *no_add_attrs = true;
2584 || !CLASS_TYPE_P (*node)
2585 || *node != TYPE_MAIN_VARIANT (*node))
2587 warning (OPT_Wattributes, "%qE attribute can only be applied "
2588 "to class definitions", name);
2593 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2599 /* Handle an "init_priority" attribute; arguments as in
2600 struct attribute_spec.handler. */
2602 handle_init_priority_attribute (tree* node,
2605 int flags ATTRIBUTE_UNUSED ,
2608 tree initp_expr = TREE_VALUE (args);
2610 tree type = TREE_TYPE (decl);
2613 STRIP_NOPS (initp_expr);
2615 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2617 error ("requested init_priority is not an integer constant");
2618 *no_add_attrs = true;
2622 pri = TREE_INT_CST_LOW (initp_expr);
2624 type = strip_array_types (type);
2626 if (decl == NULL_TREE
2627 || TREE_CODE (decl) != VAR_DECL
2628 || !TREE_STATIC (decl)
2629 || DECL_EXTERNAL (decl)
2630 || (TREE_CODE (type) != RECORD_TYPE
2631 && TREE_CODE (type) != UNION_TYPE)
2632 /* Static objects in functions are initialized the
2633 first time control passes through that
2634 function. This is not precise enough to pin down an
2635 init_priority value, so don't allow it. */
2636 || current_function_decl)
2638 error ("can only use %qE attribute on file-scope definitions "
2639 "of objects of class type", name);
2640 *no_add_attrs = true;
2644 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2646 error ("requested init_priority is out of range");
2647 *no_add_attrs = true;
2651 /* Check for init_priorities that are reserved for
2652 language and runtime support implementations.*/
2653 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2656 (0, "requested init_priority is reserved for internal use");
2659 if (SUPPORTS_INIT_PRIORITY)
2661 SET_DECL_INIT_PRIORITY (decl, pri);
2662 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2667 error ("%qE attribute is not supported on this platform", name);
2668 *no_add_attrs = true;
2673 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2674 thing pointed to by the constant. */
2677 make_ptrmem_cst (tree type, tree member)
2679 tree ptrmem_cst = make_node (PTRMEM_CST);
2680 TREE_TYPE (ptrmem_cst) = type;
2681 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2685 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2686 return an existing type if an appropriate type already exists. */
2689 cp_build_type_attribute_variant (tree type, tree attributes)
2693 new_type = build_type_attribute_variant (type, attributes);
2694 if (TREE_CODE (new_type) == FUNCTION_TYPE
2695 || TREE_CODE (new_type) == METHOD_TYPE)
2696 new_type = build_exception_variant (new_type,
2697 TYPE_RAISES_EXCEPTIONS (type));
2699 /* Making a new main variant of a class type is broken. */
2700 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2705 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2706 Called only after doing all language independent checks. Only
2707 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2708 compared in type_hash_eq. */
2711 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2713 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE);
2715 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2716 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
2719 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2720 traversal. Called from walk_tree. */
2723 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2724 void *data, struct pointer_set_t *pset)
2726 enum tree_code code = TREE_CODE (*tp);
2729 #define WALK_SUBTREE(NODE) \
2732 result = cp_walk_tree (&(NODE), func, data, pset); \
2733 if (result) goto out; \
2737 /* Not one of the easy cases. We must explicitly go through the
2743 case TEMPLATE_TEMPLATE_PARM:
2744 case BOUND_TEMPLATE_TEMPLATE_PARM:
2745 case UNBOUND_CLASS_TEMPLATE:
2746 case TEMPLATE_PARM_INDEX:
2747 case TEMPLATE_TYPE_PARM:
2750 /* None of these have subtrees other than those already walked
2752 *walk_subtrees_p = 0;
2756 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2757 *walk_subtrees_p = 0;
2761 WALK_SUBTREE (TREE_TYPE (*tp));
2762 *walk_subtrees_p = 0;
2766 WALK_SUBTREE (TREE_PURPOSE (*tp));
2770 WALK_SUBTREE (OVL_FUNCTION (*tp));
2771 WALK_SUBTREE (OVL_CHAIN (*tp));
2772 *walk_subtrees_p = 0;
2776 WALK_SUBTREE (DECL_NAME (*tp));
2777 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2778 WALK_SUBTREE (USING_DECL_DECLS (*tp));
2779 *walk_subtrees_p = 0;
2783 if (TYPE_PTRMEMFUNC_P (*tp))
2784 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2787 case TYPE_ARGUMENT_PACK:
2788 case NONTYPE_ARGUMENT_PACK:
2790 tree args = ARGUMENT_PACK_ARGS (*tp);
2791 int i, len = TREE_VEC_LENGTH (args);
2792 for (i = 0; i < len; i++)
2793 WALK_SUBTREE (TREE_VEC_ELT (args, i));
2797 case TYPE_PACK_EXPANSION:
2798 WALK_SUBTREE (TREE_TYPE (*tp));
2799 *walk_subtrees_p = 0;
2802 case EXPR_PACK_EXPANSION:
2803 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2804 *walk_subtrees_p = 0;
2808 case REINTERPRET_CAST_EXPR:
2809 case STATIC_CAST_EXPR:
2810 case CONST_CAST_EXPR:
2811 case DYNAMIC_CAST_EXPR:
2812 if (TREE_TYPE (*tp))
2813 WALK_SUBTREE (TREE_TYPE (*tp));
2817 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2818 WALK_SUBTREE (TREE_OPERAND (*tp, i));
2820 *walk_subtrees_p = 0;
2824 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2825 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2826 *walk_subtrees_p = 0;
2830 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2831 *walk_subtrees_p = 0;
2839 /* We didn't find what we were looking for. */
2846 /* Like save_expr, but for C++. */
2849 cp_save_expr (tree expr)
2851 /* There is no reason to create a SAVE_EXPR within a template; if
2852 needed, we can create the SAVE_EXPR when instantiating the
2853 template. Furthermore, the middle-end cannot handle C++-specific
2855 if (processing_template_decl)
2857 return save_expr (expr);
2860 /* Initialize tree.c. */
2865 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2868 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2869 is. Note that sfk_none is zero, so this function can be used as a
2870 predicate to test whether or not DECL is a special function. */
2872 special_function_kind
2873 special_function_p (const_tree decl)
2875 /* Rather than doing all this stuff with magic names, we should
2876 probably have a field of type `special_function_kind' in
2877 DECL_LANG_SPECIFIC. */
2878 if (DECL_COPY_CONSTRUCTOR_P (decl))
2879 return sfk_copy_constructor;
2880 if (DECL_MOVE_CONSTRUCTOR_P (decl))
2881 return sfk_move_constructor;
2882 if (DECL_CONSTRUCTOR_P (decl))
2883 return sfk_constructor;
2884 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2886 if (copy_fn_p (decl))
2887 return sfk_copy_assignment;
2888 if (move_fn_p (decl))
2889 return sfk_move_assignment;
2891 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2892 return sfk_destructor;
2893 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2894 return sfk_complete_destructor;
2895 if (DECL_BASE_DESTRUCTOR_P (decl))
2896 return sfk_base_destructor;
2897 if (DECL_DELETING_DESTRUCTOR_P (decl))
2898 return sfk_deleting_destructor;
2899 if (DECL_CONV_FN_P (decl))
2900 return sfk_conversion;
2905 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2908 char_type_p (tree type)
2910 return (same_type_p (type, char_type_node)
2911 || same_type_p (type, unsigned_char_type_node)
2912 || same_type_p (type, signed_char_type_node)
2913 || same_type_p (type, char16_type_node)
2914 || same_type_p (type, char32_type_node)
2915 || same_type_p (type, wchar_type_node));
2918 /* Returns the kind of linkage associated with the indicated DECL. Th
2919 value returned is as specified by the language standard; it is
2920 independent of implementation details regarding template
2921 instantiation, etc. For example, it is possible that a declaration
2922 to which this function assigns external linkage would not show up
2923 as a global symbol when you run `nm' on the resulting object file. */
2926 decl_linkage (tree decl)
2928 /* This function doesn't attempt to calculate the linkage from first
2929 principles as given in [basic.link]. Instead, it makes use of
2930 the fact that we have already set TREE_PUBLIC appropriately, and
2931 then handles a few special cases. Ideally, we would calculate
2932 linkage first, and then transform that into a concrete
2935 /* Things that don't have names have no linkage. */
2936 if (!DECL_NAME (decl))
2939 /* Fields have no linkage. */
2940 if (TREE_CODE (decl) == FIELD_DECL)
2943 /* Things that are TREE_PUBLIC have external linkage. */
2944 if (TREE_PUBLIC (decl))
2947 if (TREE_CODE (decl) == NAMESPACE_DECL)
2950 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2952 if (TREE_CODE (decl) == CONST_DECL)
2953 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2955 /* Some things that are not TREE_PUBLIC have external linkage, too.
2956 For example, on targets that don't have weak symbols, we make all
2957 template instantiations have internal linkage (in the object
2958 file), but the symbols should still be treated as having external
2959 linkage from the point of view of the language. */
2960 if ((TREE_CODE (decl) == FUNCTION_DECL
2961 || TREE_CODE (decl) == VAR_DECL)
2962 && DECL_COMDAT (decl))
2965 /* Things in local scope do not have linkage, if they don't have
2967 if (decl_function_context (decl))
2970 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2971 are considered to have external linkage for language purposes. DECLs
2972 really meant to have internal linkage have DECL_THIS_STATIC set. */
2973 if (TREE_CODE (decl) == TYPE_DECL)
2975 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2977 if (!DECL_THIS_STATIC (decl))
2980 /* Static data members and static member functions from classes
2981 in anonymous namespace also don't have TREE_PUBLIC set. */
2982 if (DECL_CLASS_CONTEXT (decl))
2986 /* Everything else has internal linkage. */
2990 /* EXP is an expression that we want to pre-evaluate. Returns (in
2991 *INITP) an expression that will perform the pre-evaluation. The
2992 value returned by this function is a side-effect free expression
2993 equivalent to the pre-evaluated expression. Callers must ensure
2994 that *INITP is evaluated before EXP. */
2997 stabilize_expr (tree exp, tree* initp)
3001 if (!TREE_SIDE_EFFECTS (exp))
3002 init_expr = NULL_TREE;
3003 else if (!real_lvalue_p (exp)
3004 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
3006 init_expr = get_target_expr (exp);
3007 exp = TARGET_EXPR_SLOT (init_expr);
3011 exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
3012 init_expr = get_target_expr (exp);
3013 exp = TARGET_EXPR_SLOT (init_expr);
3014 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3018 gcc_assert (!TREE_SIDE_EFFECTS (exp));
3022 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3023 similar expression ORIG. */
3026 add_stmt_to_compound (tree orig, tree new_expr)
3028 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3030 if (!orig || !TREE_SIDE_EFFECTS (orig))
3032 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3035 /* Like stabilize_expr, but for a call whose arguments we want to
3036 pre-evaluate. CALL is modified in place to use the pre-evaluated
3037 arguments, while, upon return, *INITP contains an expression to
3038 compute the arguments. */
3041 stabilize_call (tree call, tree *initp)
3043 tree inits = NULL_TREE;
3045 int nargs = call_expr_nargs (call);
3047 if (call == error_mark_node || processing_template_decl)
3053 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3055 for (i = 0; i < nargs; i++)
3058 CALL_EXPR_ARG (call, i) =
3059 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3060 inits = add_stmt_to_compound (inits, init);
3066 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3067 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3068 arguments, while, upon return, *INITP contains an expression to
3069 compute the arguments. */
3072 stabilize_aggr_init (tree call, tree *initp)
3074 tree inits = NULL_TREE;
3076 int nargs = aggr_init_expr_nargs (call);
3078 if (call == error_mark_node)
3081 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3083 for (i = 0; i < nargs; i++)
3086 AGGR_INIT_EXPR_ARG (call, i) =
3087 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3088 inits = add_stmt_to_compound (inits, init);
3094 /* Like stabilize_expr, but for an initialization.
3096 If the initialization is for an object of class type, this function
3097 takes care not to introduce additional temporaries.
3099 Returns TRUE iff the expression was successfully pre-evaluated,
3100 i.e., if INIT is now side-effect free, except for, possible, a
3101 single call to a constructor. */
3104 stabilize_init (tree init, tree *initp)
3110 if (t == error_mark_node || processing_template_decl)
3113 if (TREE_CODE (t) == INIT_EXPR
3114 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3115 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3117 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3121 if (TREE_CODE (t) == INIT_EXPR)
3122 t = TREE_OPERAND (t, 1);
3123 if (TREE_CODE (t) == TARGET_EXPR)
3124 t = TARGET_EXPR_INITIAL (t);
3125 if (TREE_CODE (t) == COMPOUND_EXPR)
3127 if (TREE_CODE (t) == CONSTRUCTOR
3128 && EMPTY_CONSTRUCTOR_P (t))
3129 /* Default-initialization. */
3132 /* If the initializer is a COND_EXPR, we can't preevaluate
3134 if (TREE_CODE (t) == COND_EXPR)
3137 if (TREE_CODE (t) == CALL_EXPR)
3139 stabilize_call (t, initp);
3143 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3145 stabilize_aggr_init (t, initp);
3149 /* The initialization is being performed via a bitwise copy -- and
3150 the item copied may have side effects. */
3151 return TREE_SIDE_EFFECTS (init);
3154 /* Like "fold", but should be used whenever we might be processing the
3155 body of a template. */
3158 fold_if_not_in_template (tree expr)
3160 /* In the body of a template, there is never any need to call
3161 "fold". We will call fold later when actually instantiating the
3162 template. Integral constant expressions in templates will be
3163 evaluated via fold_non_dependent_expr, as necessary. */
3164 if (processing_template_decl)
3167 /* Fold C++ front-end specific tree codes. */
3168 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3169 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3174 /* Returns true if a cast to TYPE may appear in an integral constant
3178 cast_valid_in_integral_constant_expression_p (tree type)
3180 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3181 || dependent_type_p (type)
3182 || type == error_mark_node);
3185 /* Return true if we need to fix linkage information of DECL. */
3188 cp_fix_function_decl_p (tree decl)
3190 /* Skip if DECL is not externally visible. */
3191 if (!TREE_PUBLIC (decl))
3194 /* We need to fix DECL if it a appears to be exported but with no
3195 function body. Thunks do not have CFGs and we may need to
3196 handle them specially later. */
3197 if (!gimple_has_body_p (decl)
3198 && !DECL_THUNK_P (decl)
3199 && !DECL_EXTERNAL (decl))
3201 struct cgraph_node *node = cgraph_get_node (decl);
3203 /* Don't fix same_body aliases. Although they don't have their own
3204 CFG, they share it with what they alias to. */
3206 || node->decl == decl
3207 || !node->same_body)
3214 /* Clean the C++ specific parts of the tree T. */
3217 cp_free_lang_data (tree t)
3219 if (TREE_CODE (t) == METHOD_TYPE
3220 || TREE_CODE (t) == FUNCTION_TYPE)
3222 /* Default args are not interesting anymore. */
3223 tree argtypes = TYPE_ARG_TYPES (t);
3226 TREE_PURPOSE (argtypes) = 0;
3227 argtypes = TREE_CHAIN (argtypes);
3230 else if (TREE_CODE (t) == FUNCTION_DECL
3231 && cp_fix_function_decl_p (t))
3233 /* If T is used in this translation unit at all, the definition
3234 must exist somewhere else since we have decided to not emit it
3235 in this TU. So make it an external reference. */
3236 DECL_EXTERNAL (t) = 1;
3237 TREE_STATIC (t) = 0;
3239 if (CP_AGGREGATE_TYPE_P (t)
3242 tree name = TYPE_NAME (t);
3243 if (TREE_CODE (name) == TYPE_DECL)
3244 name = DECL_NAME (name);
3245 /* Drop anonymous names. */
3246 if (name != NULL_TREE
3247 && ANON_AGGRNAME_P (name))
3248 TYPE_NAME (t) = NULL_TREE;
3252 /* Stub for c-common. Please keep in sync with c-decl.c.
3253 FIXME: If address space support is target specific, then this
3254 should be a C target hook. But currently this is not possible,
3255 because this function is called via REGISTER_TARGET_PRAGMAS. */
3257 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3258 addr_space_t as ATTRIBUTE_UNUSED)
3263 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3264 /* Complain that some language-specific thing hanging off a tree
3265 node has been accessed improperly. */
3268 lang_check_failed (const char* file, int line, const char* function)
3270 internal_error ("lang_* check: failed in %s, at %s:%d",
3271 function, trim_filename (file), line);
3273 #endif /* ENABLE_TREE_CHECKING */
3275 #include "gt-cp-tree.h"