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, 2011,
4 2012 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, tsubst_flags_t);
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 (REFERENCE_REF_P (ref))
65 return lvalue_kind (TREE_OPERAND (ref, 0));
68 && TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
72 && TREE_CODE (ref) != PARM_DECL
73 && TREE_CODE (ref) != VAR_DECL
74 && TREE_CODE (ref) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
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))
148 /* A scope ref in a template, left as SCOPE_REF to support later
152 tree op = TREE_OPERAND (ref, 1);
153 /* The member must be an lvalue; assume it isn't a bit-field. */
154 if (TREE_CODE (op) == IDENTIFIER_NODE)
156 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
157 return lvalue_kind (op);
162 /* Disallow <? and >? as lvalues if either argument side-effects. */
163 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
164 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
166 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
167 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
171 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)
172 ? TREE_OPERAND (ref, 1)
173 : TREE_OPERAND (ref, 0));
174 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2));
182 return lvalue_kind (TREE_OPERAND (ref, 1));
188 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
191 /* We can see calls outside of TARGET_EXPR in templates. */
192 if (CLASS_TYPE_P (TREE_TYPE (ref)))
197 /* All functions (except non-static-member functions) are
199 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
200 ? clk_none : clk_ordinary);
203 /* We now represent a reference to a single static member function
205 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
206 its argument unmodified and we assign it to a const_tree. */
207 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
209 case NON_DEPENDENT_EXPR:
210 /* We just return clk_ordinary for NON_DEPENDENT_EXPR in C++98, but
211 in C++11 lvalues don't bind to rvalue references, so we need to
212 work harder to avoid bogus errors (c++/44870). */
213 if (cxx_dialect < cxx0x)
216 return lvalue_kind (TREE_OPERAND (ref, 0));
219 if (!TREE_TYPE (ref))
221 if (CLASS_TYPE_P (TREE_TYPE (ref)))
226 /* If one operand is not an lvalue at all, then this expression is
228 if (!op1_lvalue_kind || !op2_lvalue_kind)
231 /* Otherwise, it's an lvalue, and it has all the odd properties
232 contributed by either operand. */
233 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
234 /* It's not an ordinary lvalue if it involves any other kind. */
235 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
236 op1_lvalue_kind &= ~clk_ordinary;
237 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
238 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
239 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
240 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
241 op1_lvalue_kind = clk_none;
242 return op1_lvalue_kind;
245 /* Returns the kind of lvalue that REF is, in the sense of
246 [basic.lval]. This function should really be named lvalue_p; it
247 computes the C++ definition of lvalue. */
250 real_lvalue_p (const_tree ref)
252 cp_lvalue_kind kind = lvalue_kind (ref);
253 if (kind & (clk_rvalueref|clk_class))
259 /* This differs from real_lvalue_p in that class rvalues are considered
263 lvalue_p (const_tree ref)
265 return (lvalue_kind (ref) != clk_none);
268 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
269 rvalue references are considered rvalues. */
272 lvalue_or_rvalue_with_address_p (const_tree ref)
274 cp_lvalue_kind kind = lvalue_kind (ref);
275 if (kind & clk_class)
278 return (kind != clk_none);
281 /* Test whether DECL is a builtin that may appear in a
282 constant-expression. */
285 builtin_valid_in_constant_expr_p (const_tree decl)
287 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
288 in constant-expressions. We may want to add other builtins later. */
289 return DECL_IS_BUILTIN_CONSTANT_P (decl);
292 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
295 build_target_expr (tree decl, tree value, tsubst_flags_t complain)
298 tree type = TREE_TYPE (decl);
300 #ifdef ENABLE_CHECKING
301 gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
302 || TREE_TYPE (decl) == TREE_TYPE (value)
303 /* On ARM ctors return 'this'. */
304 || (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
305 && TREE_CODE (value) == CALL_EXPR)
306 || useless_type_conversion_p (TREE_TYPE (decl),
310 t = cxx_maybe_build_cleanup (decl, complain);
311 if (t == error_mark_node)
312 return error_mark_node;
313 t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
314 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
315 ignore the TARGET_EXPR. If there really turn out to be no
316 side-effects, then the optimizer should be able to get rid of
317 whatever code is generated anyhow. */
318 TREE_SIDE_EFFECTS (t) = 1;
323 /* Return an undeclared local temporary of type TYPE for use in building a
327 build_local_temp (tree type)
329 tree slot = build_decl (input_location,
330 VAR_DECL, NULL_TREE, type);
331 DECL_ARTIFICIAL (slot) = 1;
332 DECL_IGNORED_P (slot) = 1;
333 DECL_CONTEXT (slot) = current_function_decl;
334 layout_decl (slot, 0);
338 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
341 process_aggr_init_operands (tree t)
345 side_effects = TREE_SIDE_EFFECTS (t);
349 n = TREE_OPERAND_LENGTH (t);
350 for (i = 1; i < n; i++)
352 tree op = TREE_OPERAND (t, i);
353 if (op && TREE_SIDE_EFFECTS (op))
360 TREE_SIDE_EFFECTS (t) = side_effects;
363 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
364 FN, and SLOT. NARGS is the number of call arguments which are specified
365 as a tree array ARGS. */
368 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
374 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
375 TREE_TYPE (t) = return_type;
376 AGGR_INIT_EXPR_FN (t) = fn;
377 AGGR_INIT_EXPR_SLOT (t) = slot;
378 for (i = 0; i < nargs; i++)
379 AGGR_INIT_EXPR_ARG (t, i) = args[i];
380 process_aggr_init_operands (t);
384 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
385 target. TYPE is the type to be initialized.
387 Build an AGGR_INIT_EXPR to represent the initialization. This function
388 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
389 to initialize another object, whereas a TARGET_EXPR can either
390 initialize another object or create its own temporary object, and as a
391 result building up a TARGET_EXPR requires that the type's destructor be
395 build_aggr_init_expr (tree type, tree init,
396 tsubst_flags_t complain ATTRIBUTE_UNUSED)
403 if (TREE_CODE (init) == CALL_EXPR)
404 fn = CALL_EXPR_FN (init);
405 else if (TREE_CODE (init) == AGGR_INIT_EXPR)
406 fn = AGGR_INIT_EXPR_FN (init);
408 return convert (type, init);
410 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
411 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
412 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
414 /* We split the CALL_EXPR into its function and its arguments here.
415 Then, in expand_expr, we put them back together. The reason for
416 this is that this expression might be a default argument
417 expression. In that case, we need a new temporary every time the
418 expression is used. That's what break_out_target_exprs does; it
419 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
420 temporary slot. Then, expand_expr builds up a call-expression
421 using the new slot. */
423 /* If we don't need to use a constructor to create an object of this
424 type, don't mess with AGGR_INIT_EXPR. */
425 if (is_ctor || TREE_ADDRESSABLE (type))
427 slot = build_local_temp (type);
429 if (TREE_CODE(init) == CALL_EXPR)
430 rval = build_aggr_init_array (void_type_node, fn, slot,
431 call_expr_nargs (init),
432 CALL_EXPR_ARGP (init));
434 rval = build_aggr_init_array (void_type_node, fn, slot,
435 aggr_init_expr_nargs (init),
436 AGGR_INIT_EXPR_ARGP (init));
437 TREE_SIDE_EFFECTS (rval) = 1;
438 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
439 TREE_NOTHROW (rval) = TREE_NOTHROW (init);
447 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
448 target. TYPE is the type that this initialization should appear to
451 Build an encapsulation of the initialization to perform
452 and return it so that it can be processed by language-independent
453 and language-specific expression expanders. */
456 build_cplus_new (tree type, tree init, tsubst_flags_t complain)
458 tree rval = build_aggr_init_expr (type, init, complain);
461 /* Make sure that we're not trying to create an instance of an
463 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
464 return error_mark_node;
466 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
467 slot = AGGR_INIT_EXPR_SLOT (rval);
468 else if (TREE_CODE (rval) == CALL_EXPR
469 || TREE_CODE (rval) == CONSTRUCTOR)
470 slot = build_local_temp (type);
474 rval = build_target_expr (slot, rval, complain);
476 if (rval != error_mark_node)
477 TARGET_EXPR_IMPLICIT_P (rval) = 1;
482 /* Subroutine of build_vec_init_expr: Build up a single element
483 intialization as a proxy for the full array initialization to get things
484 marked as used and any appropriate diagnostics.
486 Since we're deferring building the actual constructor calls until
487 gimplification time, we need to build one now and throw it away so
488 that the relevant constructor gets mark_used before cgraph decides
489 what functions are needed. Here we assume that init is either
490 NULL_TREE, void_type_node (indicating value-initialization), or
491 another array to copy. */
494 build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
496 tree inner_type = strip_array_types (type);
497 VEC(tree,gc) *argvec;
499 if (integer_zerop (array_type_nelts_total (type))
500 || !CLASS_TYPE_P (inner_type))
501 /* No interesting initialization to do. */
502 return integer_zero_node;
503 else if (init == void_type_node)
504 return build_value_init (inner_type, complain);
506 gcc_assert (init == NULL_TREE
507 || (same_type_ignoring_top_level_qualifiers_p
508 (type, TREE_TYPE (init))));
510 argvec = make_tree_vector ();
513 tree init_type = strip_array_types (TREE_TYPE (init));
514 tree dummy = build_dummy_object (init_type);
515 if (!real_lvalue_p (init))
516 dummy = move (dummy);
517 VEC_quick_push (tree, argvec, dummy);
519 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
520 &argvec, inner_type, LOOKUP_NORMAL,
522 release_tree_vector (argvec);
524 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
525 we don't want one here because we aren't creating a temporary. */
526 if (TREE_CODE (init) == TARGET_EXPR)
527 init = TARGET_EXPR_INITIAL (init);
532 /* Return a TARGET_EXPR which expresses the initialization of an array to
533 be named later, either default-initialization or copy-initialization
534 from another array of the same type. */
537 build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
540 bool value_init = false;
541 tree elt_init = build_vec_init_elt (type, init, complain);
543 if (init == void_type_node)
549 slot = build_local_temp (type);
550 init = build2 (VEC_INIT_EXPR, type, slot, init);
551 TREE_SIDE_EFFECTS (init) = true;
552 SET_EXPR_LOCATION (init, input_location);
554 if (cxx_dialect >= cxx0x
555 && potential_constant_expression (elt_init))
556 VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
557 VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
562 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
563 that requires a constant expression. */
566 diagnose_non_constexpr_vec_init (tree expr)
568 tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
570 if (VEC_INIT_EXPR_VALUE_INIT (expr))
571 init = void_type_node;
573 init = VEC_INIT_EXPR_INIT (expr);
575 elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
576 require_potential_constant_expression (elt_init);
580 build_array_copy (tree init)
582 return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error);
585 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
589 build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
591 gcc_assert (!VOID_TYPE_P (type));
593 if (TREE_CODE (init) == TARGET_EXPR
594 || init == error_mark_node)
596 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
597 && !VOID_TYPE_P (TREE_TYPE (init))
598 && TREE_CODE (init) != COND_EXPR
599 && TREE_CODE (init) != CONSTRUCTOR
600 && TREE_CODE (init) != VA_ARG_EXPR)
601 /* We need to build up a copy constructor call. A void initializer
602 means we're being called from bot_manip. COND_EXPR is a special
603 case because we already have copies on the arms and we don't want
604 another one here. A CONSTRUCTOR is aggregate initialization, which
605 is handled separately. A VA_ARG_EXPR is magic creation of an
606 aggregate; there's no additional work to be done. */
607 return force_rvalue (init, complain);
609 return force_target_expr (type, init, complain);
612 /* Like the above function, but without the checking. This function should
613 only be used by code which is deliberately trying to subvert the type
614 system, such as call_builtin_trap. Or build_over_call, to avoid
615 infinite recursion. */
618 force_target_expr (tree type, tree init, tsubst_flags_t complain)
622 gcc_assert (!VOID_TYPE_P (type));
624 slot = build_local_temp (type);
625 return build_target_expr (slot, init, complain);
628 /* Like build_target_expr_with_type, but use the type of INIT. */
631 get_target_expr_sfinae (tree init, tsubst_flags_t complain)
633 if (TREE_CODE (init) == AGGR_INIT_EXPR)
634 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
635 else if (TREE_CODE (init) == VEC_INIT_EXPR)
636 return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
638 return build_target_expr_with_type (init, TREE_TYPE (init), complain);
642 get_target_expr (tree init)
644 return get_target_expr_sfinae (init, tf_warning_or_error);
647 /* If EXPR is a bitfield reference, convert it to the declared type of
648 the bitfield, and return the resulting expression. Otherwise,
649 return EXPR itself. */
652 convert_bitfield_to_declared_type (tree expr)
656 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
658 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
663 /* EXPR is being used in an rvalue context. Return a version of EXPR
664 that is marked as an rvalue. */
671 if (error_operand_p (expr))
674 expr = mark_rvalue_use (expr);
678 Non-class rvalues always have cv-unqualified types. */
679 type = TREE_TYPE (expr);
680 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
681 type = cv_unqualified (type);
683 /* We need to do this for rvalue refs as well to get the right answer
684 from decltype; see c++/36628. */
685 if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
686 expr = build1 (NON_LVALUE_EXPR, type, expr);
687 else if (type != TREE_TYPE (expr))
688 expr = build_nop (type, expr);
694 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
697 cplus_array_hash (const void* k)
700 const_tree const t = (const_tree) k;
702 hash = TYPE_UID (TREE_TYPE (t));
704 hash ^= TYPE_UID (TYPE_DOMAIN (t));
708 typedef struct cplus_array_info {
713 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
714 of type `cplus_array_info*'. */
717 cplus_array_compare (const void * k1, const void * k2)
719 const_tree const t1 = (const_tree) k1;
720 const cplus_array_info *const t2 = (const cplus_array_info*) k2;
722 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
725 /* Hash table containing dependent array types, which are unsuitable for
726 the language-independent type hash table. */
727 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
729 /* Like build_array_type, but handle special C++ semantics. */
732 build_cplus_array_type (tree elt_type, tree index_type)
735 bool needs_ctor, needs_dtor;
737 if (elt_type == error_mark_node || index_type == error_mark_node)
738 return error_mark_node;
740 if (processing_template_decl
741 && (dependent_type_p (elt_type)
742 || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
745 cplus_array_info cai;
748 if (cplus_array_htab == NULL)
749 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
750 &cplus_array_compare, NULL);
752 hash = TYPE_UID (elt_type);
754 hash ^= TYPE_UID (index_type);
756 cai.domain = index_type;
758 e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
760 /* We have found the type: we're done. */
764 /* Build a new array type. */
765 t = cxx_make_type (ARRAY_TYPE);
766 TREE_TYPE (t) = elt_type;
767 TYPE_DOMAIN (t) = index_type;
769 /* Store it in the hash table. */
772 /* Set the canonical type for this new node. */
773 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
774 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
775 SET_TYPE_STRUCTURAL_EQUALITY (t);
776 else if (TYPE_CANONICAL (elt_type) != elt_type
778 && TYPE_CANONICAL (index_type) != index_type))
780 = build_cplus_array_type
781 (TYPE_CANONICAL (elt_type),
782 index_type ? TYPE_CANONICAL (index_type) : index_type);
784 TYPE_CANONICAL (t) = t;
789 if (!TYPE_STRUCTURAL_EQUALITY_P (elt_type)
790 && !(index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
791 && (TYPE_CANONICAL (elt_type) != elt_type
792 || (index_type && TYPE_CANONICAL (index_type) != index_type)))
793 /* Make sure that the canonical type is on the appropriate
795 build_cplus_array_type
796 (TYPE_CANONICAL (elt_type),
797 index_type ? TYPE_CANONICAL (index_type) : index_type);
798 t = build_array_type (elt_type, index_type);
801 /* Push these needs up so that initialization takes place
804 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
805 TYPE_NEEDS_CONSTRUCTING (t) = needs_ctor;
807 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
808 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = needs_dtor;
810 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
811 element type as well, so fix it up if needed. */
812 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
814 tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
817 if (TYPE_MAIN_VARIANT (t) != m)
819 if (COMPLETE_TYPE_P (t) && !COMPLETE_TYPE_P (m))
821 /* m was built before the element type was complete, so we
822 also need to copy the layout info from t. */
823 tree size = TYPE_SIZE (t);
824 tree size_unit = TYPE_SIZE_UNIT (t);
825 unsigned int align = TYPE_ALIGN (t);
826 unsigned int user_align = TYPE_USER_ALIGN (t);
827 enum machine_mode mode = TYPE_MODE (t);
829 for (var = m; var; var = TYPE_NEXT_VARIANT (var))
831 TYPE_SIZE (var) = size;
832 TYPE_SIZE_UNIT (var) = size_unit;
833 TYPE_ALIGN (var) = align;
834 TYPE_USER_ALIGN (var) = user_align;
835 SET_TYPE_MODE (var, mode);
836 TYPE_NEEDS_CONSTRUCTING (var) = needs_ctor;
837 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (var) = needs_dtor;
841 TYPE_MAIN_VARIANT (t) = m;
842 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
843 TYPE_NEXT_VARIANT (m) = t;
850 /* Return an ARRAY_TYPE with element type ELT and length N. */
853 build_array_of_n_type (tree elt, int n)
855 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
858 /* Return a reference type node referring to TO_TYPE. If RVAL is
859 true, return an rvalue reference type, otherwise return an lvalue
860 reference type. If a type node exists, reuse it, otherwise create
863 cp_build_reference_type (tree to_type, bool rval)
866 lvalue_ref = build_reference_type (to_type);
870 /* This code to create rvalue reference types is based on and tied
871 to the code creating lvalue reference types in the middle-end
872 functions build_reference_type_for_mode and build_reference_type.
874 It works by putting the rvalue reference type nodes after the
875 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
876 they will effectively be ignored by the middle end. */
878 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
879 if (TYPE_REF_IS_RVALUE (t))
882 t = build_distinct_type_copy (lvalue_ref);
884 TYPE_REF_IS_RVALUE (t) = true;
885 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
886 TYPE_NEXT_REF_TO (lvalue_ref) = t;
888 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
889 SET_TYPE_STRUCTURAL_EQUALITY (t);
890 else if (TYPE_CANONICAL (to_type) != to_type)
892 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
894 TYPE_CANONICAL (t) = t;
902 /* Returns EXPR cast to rvalue reference type, like std::move. */
907 tree type = TREE_TYPE (expr);
908 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
909 type = cp_build_reference_type (type, /*rval*/true);
910 return build_static_cast (type, expr, tf_warning_or_error);
913 /* Used by the C++ front end to build qualified array types. However,
914 the C version of this function does not properly maintain canonical
915 types (which are not used in C). */
917 c_build_qualified_type (tree type, int type_quals)
919 return cp_build_qualified_type (type, type_quals);
923 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
924 arrays correctly. In particular, if TYPE is an array of T's, and
925 TYPE_QUALS is non-empty, returns an array of qualified T's.
927 FLAGS determines how to deal with ill-formed qualifications. If
928 tf_ignore_bad_quals is set, then bad qualifications are dropped
929 (this is permitted if TYPE was introduced via a typedef or template
930 type parameter). If bad qualifications are dropped and tf_warning
931 is set, then a warning is issued for non-const qualifications. If
932 tf_ignore_bad_quals is not set and tf_error is not set, we
933 return error_mark_node. Otherwise, we issue an error, and ignore
936 Qualification of a reference type is valid when the reference came
937 via a typedef or template type argument. [dcl.ref] No such
938 dispensation is provided for qualifying a function type. [dcl.fct]
939 DR 295 queries this and the proposed resolution brings it into line
940 with qualifying a reference. We implement the DR. We also behave
941 in a similar manner for restricting non-pointer types. */
944 cp_build_qualified_type_real (tree type,
946 tsubst_flags_t complain)
949 int bad_quals = TYPE_UNQUALIFIED;
951 if (type == error_mark_node)
954 if (type_quals == cp_type_quals (type))
957 if (TREE_CODE (type) == ARRAY_TYPE)
959 /* In C++, the qualification really applies to the array element
960 type. Obtain the appropriately qualified element type. */
963 = cp_build_qualified_type_real (TREE_TYPE (type),
967 if (element_type == error_mark_node)
968 return error_mark_node;
970 /* See if we already have an identically qualified type. Tests
971 should be equivalent to those in check_qualified_type. */
972 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
973 if (TREE_TYPE (t) == element_type
974 && TYPE_NAME (t) == TYPE_NAME (type)
975 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
976 && attribute_list_equal (TYPE_ATTRIBUTES (t),
977 TYPE_ATTRIBUTES (type)))
982 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
984 /* Keep the typedef name. */
985 if (TYPE_NAME (t) != TYPE_NAME (type))
987 t = build_variant_type_copy (t);
988 TYPE_NAME (t) = TYPE_NAME (type);
992 /* Even if we already had this variant, we update
993 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
994 they changed since the variant was originally created.
996 This seems hokey; if there is some way to use a previous
997 variant *without* coming through here,
998 TYPE_NEEDS_CONSTRUCTING will never be updated. */
999 TYPE_NEEDS_CONSTRUCTING (t)
1000 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
1001 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1002 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
1005 else if (TYPE_PTRMEMFUNC_P (type))
1007 /* For a pointer-to-member type, we can't just return a
1008 cv-qualified version of the RECORD_TYPE. If we do, we
1009 haven't changed the field that contains the actual pointer to
1010 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
1013 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
1014 t = cp_build_qualified_type_real (t, type_quals, complain);
1015 return build_ptrmemfunc_type (t);
1017 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
1019 tree t = PACK_EXPANSION_PATTERN (type);
1021 t = cp_build_qualified_type_real (t, type_quals, complain);
1022 return make_pack_expansion (t);
1025 /* A reference or method type shall not be cv-qualified.
1026 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1027 (in CD1) we always ignore extra cv-quals on functions. */
1028 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1029 && (TREE_CODE (type) == REFERENCE_TYPE
1030 || TREE_CODE (type) == FUNCTION_TYPE
1031 || TREE_CODE (type) == METHOD_TYPE))
1033 if (TREE_CODE (type) == REFERENCE_TYPE)
1034 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1035 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1038 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1039 if (TREE_CODE (type) == FUNCTION_TYPE)
1040 type_quals |= type_memfn_quals (type);
1042 /* A restrict-qualified type must be a pointer (or reference)
1043 to object or incomplete type. */
1044 if ((type_quals & TYPE_QUAL_RESTRICT)
1045 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1046 && TREE_CODE (type) != TYPENAME_TYPE
1047 && !POINTER_TYPE_P (type))
1049 bad_quals |= TYPE_QUAL_RESTRICT;
1050 type_quals &= ~TYPE_QUAL_RESTRICT;
1053 if (bad_quals == TYPE_UNQUALIFIED
1054 || (complain & tf_ignore_bad_quals))
1056 else if (!(complain & tf_error))
1057 return error_mark_node;
1060 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1061 error ("%qV qualifiers cannot be applied to %qT",
1065 /* Retrieve (or create) the appropriately qualified variant. */
1066 result = build_qualified_type (type, type_quals);
1068 /* If this was a pointer-to-method type, and we just made a copy,
1069 then we need to unshare the record that holds the cached
1070 pointer-to-member-function type, because these will be distinct
1071 between the unqualified and qualified types. */
1073 && TREE_CODE (type) == POINTER_TYPE
1074 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1075 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
1076 TYPE_LANG_SPECIFIC (result) = NULL;
1078 /* We may also have ended up building a new copy of the canonical
1079 type of a pointer-to-method type, which could have the same
1080 sharing problem described above. */
1081 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
1082 && TREE_CODE (type) == POINTER_TYPE
1083 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1084 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
1085 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
1086 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
1091 /* Return TYPE with const and volatile removed. */
1094 cv_unqualified (tree type)
1098 if (type == error_mark_node)
1101 quals = cp_type_quals (type);
1102 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1103 return cp_build_qualified_type (type, quals);
1106 /* Builds a qualified variant of T that is not a typedef variant.
1107 E.g. consider the following declarations:
1108 typedef const int ConstInt;
1109 typedef ConstInt* PtrConstInt;
1110 If T is PtrConstInt, this function returns a type representing
1112 In other words, if T is a typedef, the function returns the underlying type.
1113 The cv-qualification and attributes of the type returned match the
1115 They will always be compatible types.
1116 The returned type is built so that all of its subtypes
1117 recursively have their typedefs stripped as well.
1119 This is different from just returning TYPE_CANONICAL (T)
1120 Because of several reasons:
1121 * If T is a type that needs structural equality
1122 its TYPE_CANONICAL (T) will be NULL.
1123 * TYPE_CANONICAL (T) desn't carry type attributes
1124 and loses template parameter names. */
1127 strip_typedefs (tree t)
1129 tree result = NULL, type = NULL, t0 = NULL;
1131 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1134 gcc_assert (TYPE_P (t));
1136 switch (TREE_CODE (t))
1139 type = strip_typedefs (TREE_TYPE (t));
1140 result = build_pointer_type (type);
1142 case REFERENCE_TYPE:
1143 type = strip_typedefs (TREE_TYPE (t));
1144 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1147 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1148 type = strip_typedefs (TREE_TYPE (t));
1149 result = build_offset_type (t0, type);
1152 if (TYPE_PTRMEMFUNC_P (t))
1154 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1155 result = build_ptrmemfunc_type (t0);
1159 type = strip_typedefs (TREE_TYPE (t));
1160 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1161 result = build_cplus_array_type (type, t0);
1166 tree arg_types = NULL, arg_node, arg_type;
1167 for (arg_node = TYPE_ARG_TYPES (t);
1169 arg_node = TREE_CHAIN (arg_node))
1171 if (arg_node == void_list_node)
1173 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1174 gcc_assert (arg_type);
1177 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1181 arg_types = nreverse (arg_types);
1183 /* A list of parameters not ending with an ellipsis
1184 must end with void_list_node. */
1186 arg_types = chainon (arg_types, void_list_node);
1188 type = strip_typedefs (TREE_TYPE (t));
1189 if (TREE_CODE (t) == METHOD_TYPE)
1191 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1192 gcc_assert (class_type);
1194 build_method_type_directly (class_type, type,
1195 TREE_CHAIN (arg_types));
1199 result = build_function_type (type,
1201 result = apply_memfn_quals (result, type_memfn_quals (t));
1204 if (TYPE_RAISES_EXCEPTIONS (t))
1205 result = build_exception_variant (result,
1206 TYPE_RAISES_EXCEPTIONS (t));
1211 tree fullname = TYPENAME_TYPE_FULLNAME (t);
1212 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
1213 && TREE_OPERAND (fullname, 1))
1215 tree args = TREE_OPERAND (fullname, 1);
1216 tree new_args = copy_node (args);
1217 bool changed = false;
1219 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
1221 tree arg = TREE_VEC_ELT (args, i);
1224 strip_arg = strip_typedefs (arg);
1226 strip_arg = strip_typedefs_expr (arg);
1227 TREE_VEC_ELT (new_args, i) = strip_arg;
1228 if (strip_arg != arg)
1233 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)
1234 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
1236 = lookup_template_function (TREE_OPERAND (fullname, 0),
1240 ggc_free (new_args);
1242 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1243 fullname, typename_type, tf_none);
1247 result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t));
1248 if (result == DECLTYPE_TYPE_EXPR (t))
1251 result = (finish_decltype_type
1253 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
1261 result = TYPE_MAIN_VARIANT (t);
1262 if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1263 || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1265 gcc_assert (TYPE_USER_ALIGN (t));
1266 if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1267 result = build_variant_type_copy (result);
1269 result = build_aligned_type (result, TYPE_ALIGN (t));
1270 TYPE_USER_ALIGN (result) = true;
1272 if (TYPE_ATTRIBUTES (t))
1273 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1274 return cp_build_qualified_type (result, cp_type_quals (t));
1277 /* Like strip_typedefs above, but works on expressions, so that in
1279 template<class T> struct A
1285 sizeof(TT) is replaced by sizeof(T). */
1288 strip_typedefs_expr (tree t)
1292 enum tree_code code;
1294 if (t == NULL_TREE || t == error_mark_node)
1297 if (DECL_P (t) || CONSTANT_CLASS_P (t))
1300 /* Some expressions have type operands, so let's handle types here rather
1301 than check TYPE_P in multiple places below. */
1303 return strip_typedefs (t);
1305 code = TREE_CODE (t);
1308 case IDENTIFIER_NODE:
1309 case TEMPLATE_PARM_INDEX:
1312 case ARGUMENT_PACK_SELECT:
1317 tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t));
1318 tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t));
1319 if (type1 == TRAIT_EXPR_TYPE1 (t)
1320 && type2 == TRAIT_EXPR_TYPE2 (t))
1323 TRAIT_EXPR_TYPE1 (t) = type1;
1324 TRAIT_EXPR_TYPE2 (t) = type2;
1330 VEC(tree,gc) *vec = make_tree_vector ();
1331 bool changed = false;
1333 for (it = t; it; it = TREE_CHAIN (it))
1335 tree val = strip_typedefs_expr (TREE_VALUE (t));
1336 VEC_safe_push (tree, gc, vec, val);
1337 if (val != TREE_VALUE (t))
1339 gcc_assert (TREE_PURPOSE (it) == NULL_TREE);
1344 FOR_EACH_VEC_ELT_REVERSE (tree, vec, i, it)
1345 r = tree_cons (NULL_TREE, it, r);
1349 release_tree_vector (vec);
1355 bool changed = false;
1356 VEC(tree,gc)* vec = make_tree_vector ();
1357 n = TREE_VEC_LENGTH (t);
1358 VEC_reserve (tree, gc, vec, n);
1359 for (i = 0; i < n; ++i)
1361 tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i));
1362 VEC_quick_push (tree, vec, op);
1363 if (op != TREE_VEC_ELT (t, i))
1369 for (i = 0; i < n; ++i)
1370 TREE_VEC_ELT (r, i) = VEC_index (tree, vec, i);
1371 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)
1372 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
1376 release_tree_vector (vec);
1382 bool changed = false;
1383 VEC(constructor_elt,gc) *vec
1384 = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
1385 n = CONSTRUCTOR_NELTS (t);
1386 type = strip_typedefs (TREE_TYPE (t));
1387 for (i = 0; i < n; ++i)
1389 constructor_elt *e = VEC_index (constructor_elt, vec, i);
1390 tree op = strip_typedefs_expr (e->value);
1396 gcc_checking_assert (e->index == strip_typedefs_expr (e->index));
1399 if (!changed && type == TREE_TYPE (t))
1401 VEC_free (constructor_elt, gc, vec);
1407 TREE_TYPE (r) = type;
1408 CONSTRUCTOR_ELTS (r) = vec;
1420 gcc_assert (EXPR_P (t));
1422 n = TREE_OPERAND_LENGTH (t);
1423 ops = XALLOCAVEC (tree, n);
1424 type = TREE_TYPE (t);
1429 case IMPLICIT_CONV_EXPR:
1430 case DYNAMIC_CAST_EXPR:
1431 case STATIC_CAST_EXPR:
1432 case CONST_CAST_EXPR:
1433 case REINTERPRET_CAST_EXPR:
1436 type = strip_typedefs (type);
1440 for (i = 0; i < n; ++i)
1441 ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i));
1445 /* If nothing changed, return t. */
1446 for (i = 0; i < n; ++i)
1447 if (ops[i] != TREE_OPERAND (t, i))
1449 if (i == n && type == TREE_TYPE (t))
1453 TREE_TYPE (r) = type;
1454 for (i = 0; i < n; ++i)
1455 TREE_OPERAND (r, i) = ops[i];
1459 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1460 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1461 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1462 VIRT indicates whether TYPE is inherited virtually or not.
1463 IGO_PREV points at the previous binfo of the inheritance graph
1464 order chain. The newly copied binfo's TREE_CHAIN forms this
1467 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1468 correct order. That is in the order the bases themselves should be
1471 The BINFO_INHERITANCE of a virtual base class points to the binfo
1472 of the most derived type. ??? We could probably change this so that
1473 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1474 remove a field. They currently can only differ for primary virtual
1478 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1484 /* See if we've already made this virtual base. */
1485 new_binfo = binfo_for_vbase (type, t);
1490 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1491 BINFO_TYPE (new_binfo) = type;
1493 /* Chain it into the inheritance graph. */
1494 TREE_CHAIN (*igo_prev) = new_binfo;
1495 *igo_prev = new_binfo;
1497 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
1502 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1504 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1505 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1507 /* We do not need to copy the accesses, as they are read only. */
1508 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1510 /* Recursively copy base binfos of BINFO. */
1511 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1513 tree new_base_binfo;
1514 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1516 BINFO_VIRTUAL_P (base_binfo));
1518 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1519 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1520 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1524 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1528 /* Push it onto the list after any virtual bases it contains
1529 will have been pushed. */
1530 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1531 BINFO_VIRTUAL_P (new_binfo) = 1;
1532 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1538 /* Hashing of lists so that we don't make duplicates.
1539 The entry point is `list_hash_canon'. */
1541 /* Now here is the hash table. When recording a list, it is added
1542 to the slot whose index is the hash code mod the table size.
1543 Note that the hash table is used for several kinds of lists.
1544 While all these live in the same table, they are completely independent,
1545 and the hash code is computed differently for each of these. */
1547 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1556 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1557 for a node we are thinking about adding). */
1560 list_hash_eq (const void* entry, const void* data)
1562 const_tree const t = (const_tree) entry;
1563 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1565 return (TREE_VALUE (t) == proxy->value
1566 && TREE_PURPOSE (t) == proxy->purpose
1567 && TREE_CHAIN (t) == proxy->chain);
1570 /* Compute a hash code for a list (chain of TREE_LIST nodes
1571 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1572 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1575 list_hash_pieces (tree purpose, tree value, tree chain)
1577 hashval_t hashcode = 0;
1580 hashcode += TREE_HASH (chain);
1583 hashcode += TREE_HASH (value);
1587 hashcode += TREE_HASH (purpose);
1593 /* Hash an already existing TREE_LIST. */
1596 list_hash (const void* p)
1598 const_tree const t = (const_tree) p;
1599 return list_hash_pieces (TREE_PURPOSE (t),
1604 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1605 object for an identical list if one already exists. Otherwise, build a
1606 new one, and record it as the canonical object. */
1609 hash_tree_cons (tree purpose, tree value, tree chain)
1613 struct list_proxy proxy;
1615 /* Hash the list node. */
1616 hashcode = list_hash_pieces (purpose, value, chain);
1617 /* Create a proxy for the TREE_LIST we would like to create. We
1618 don't actually create it so as to avoid creating garbage. */
1619 proxy.purpose = purpose;
1620 proxy.value = value;
1621 proxy.chain = chain;
1622 /* See if it is already in the table. */
1623 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1625 /* If not, create a new node. */
1627 *slot = tree_cons (purpose, value, chain);
1628 return (tree) *slot;
1631 /* Constructor for hashed lists. */
1634 hash_tree_chain (tree value, tree chain)
1636 return hash_tree_cons (NULL_TREE, value, chain);
1640 debug_binfo (tree elem)
1645 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1647 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1648 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1649 debug_tree (BINFO_TYPE (elem));
1650 if (BINFO_VTABLE (elem))
1651 fprintf (stderr, "vtable decl \"%s\"\n",
1652 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1654 fprintf (stderr, "no vtable decl yet\n");
1655 fprintf (stderr, "virtuals:\n");
1656 virtuals = BINFO_VIRTUALS (elem);
1661 tree fndecl = TREE_VALUE (virtuals);
1662 fprintf (stderr, "%s [%ld =? %ld]\n",
1663 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1664 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1666 virtuals = TREE_CHAIN (virtuals);
1670 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1671 the type of the result expression, if known, or NULL_TREE if the
1672 resulting expression is type-dependent. If TEMPLATE_P is true,
1673 NAME is known to be a template because the user explicitly used the
1674 "template" keyword after the "::".
1676 All SCOPE_REFs should be built by use of this function. */
1679 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1682 if (type == error_mark_node
1683 || scope == error_mark_node
1684 || name == error_mark_node)
1685 return error_mark_node;
1686 t = build2 (SCOPE_REF, type, scope, name);
1687 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1688 PTRMEM_OK_P (t) = true;
1690 t = convert_from_reference (t);
1694 /* Returns nonzero if X is an expression for a (possibly overloaded)
1695 function. If "f" is a function or function template, "f", "c->f",
1696 "c.f", "C::f", and "f<int>" will all be considered possibly
1697 overloaded functions. Returns 2 if the function is actually
1698 overloaded, i.e., if it is impossible to know the type of the
1699 function without performing overload resolution. */
1702 is_overloaded_fn (tree x)
1704 /* A baselink is also considered an overloaded function. */
1705 if (TREE_CODE (x) == OFFSET_REF
1706 || TREE_CODE (x) == COMPONENT_REF)
1707 x = TREE_OPERAND (x, 1);
1709 x = BASELINK_FUNCTIONS (x);
1710 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1711 x = TREE_OPERAND (x, 0);
1712 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1713 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1715 return (TREE_CODE (x) == FUNCTION_DECL
1716 || TREE_CODE (x) == OVERLOAD);
1719 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
1720 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
1724 dependent_name (tree x)
1726 if (TREE_CODE (x) == IDENTIFIER_NODE)
1728 if (TREE_CODE (x) != COMPONENT_REF
1729 && TREE_CODE (x) != OFFSET_REF
1730 && TREE_CODE (x) != BASELINK
1731 && is_overloaded_fn (x))
1732 return DECL_NAME (get_first_fn (x));
1736 /* Returns true iff X is an expression for an overloaded function
1737 whose type cannot be known without performing overload
1741 really_overloaded_fn (tree x)
1743 return is_overloaded_fn (x) == 2;
1749 gcc_assert (is_overloaded_fn (from));
1750 /* A baselink is also considered an overloaded function. */
1751 if (TREE_CODE (from) == OFFSET_REF
1752 || TREE_CODE (from) == COMPONENT_REF)
1753 from = TREE_OPERAND (from, 1);
1754 if (BASELINK_P (from))
1755 from = BASELINK_FUNCTIONS (from);
1756 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1757 from = TREE_OPERAND (from, 0);
1762 get_first_fn (tree from)
1764 return OVL_CURRENT (get_fns (from));
1767 /* Return a new OVL node, concatenating it with the old one. */
1770 ovl_cons (tree decl, tree chain)
1772 tree result = make_node (OVERLOAD);
1773 TREE_TYPE (result) = unknown_type_node;
1774 OVL_FUNCTION (result) = decl;
1775 TREE_CHAIN (result) = chain;
1780 /* Build a new overloaded function. If this is the first one,
1781 just return it; otherwise, ovl_cons the _DECLs */
1784 build_overload (tree decl, tree chain)
1786 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1788 return ovl_cons (decl, chain);
1791 /* Return the scope where the overloaded functions OVL were found. */
1794 ovl_scope (tree ovl)
1796 if (TREE_CODE (ovl) == OFFSET_REF
1797 || TREE_CODE (ovl) == COMPONENT_REF)
1798 ovl = TREE_OPERAND (ovl, 1);
1799 if (TREE_CODE (ovl) == BASELINK)
1800 return BINFO_TYPE (BASELINK_BINFO (ovl));
1801 if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
1802 ovl = TREE_OPERAND (ovl, 0);
1803 /* Skip using-declarations. */
1804 while (TREE_CODE (ovl) == OVERLOAD && OVL_USED (ovl) && OVL_CHAIN (ovl))
1805 ovl = OVL_CHAIN (ovl);
1806 return CP_DECL_CONTEXT (OVL_CURRENT (ovl));
1809 /* Return TRUE if FN is a non-static member function, FALSE otherwise.
1810 This function looks into BASELINK and OVERLOAD nodes. */
1813 non_static_member_function_p (tree fn)
1815 if (fn == NULL_TREE)
1818 if (is_overloaded_fn (fn))
1819 fn = get_first_fn (fn);
1822 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn));
1826 #define PRINT_RING_SIZE 4
1829 cxx_printable_name_internal (tree decl, int v, bool translate)
1831 static unsigned int uid_ring[PRINT_RING_SIZE];
1832 static char *print_ring[PRINT_RING_SIZE];
1833 static bool trans_ring[PRINT_RING_SIZE];
1834 static int ring_counter;
1837 /* Only cache functions. */
1839 || TREE_CODE (decl) != FUNCTION_DECL
1840 || DECL_LANG_SPECIFIC (decl) == 0)
1841 return lang_decl_name (decl, v, translate);
1843 /* See if this print name is lying around. */
1844 for (i = 0; i < PRINT_RING_SIZE; i++)
1845 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1846 /* yes, so return it. */
1847 return print_ring[i];
1849 if (++ring_counter == PRINT_RING_SIZE)
1852 if (current_function_decl != NULL_TREE)
1854 /* There may be both translated and untranslated versions of the
1856 for (i = 0; i < 2; i++)
1858 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1860 if (ring_counter == PRINT_RING_SIZE)
1863 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1866 free (print_ring[ring_counter]);
1868 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1869 uid_ring[ring_counter] = DECL_UID (decl);
1870 trans_ring[ring_counter] = translate;
1871 return print_ring[ring_counter];
1875 cxx_printable_name (tree decl, int v)
1877 return cxx_printable_name_internal (decl, v, false);
1881 cxx_printable_name_translate (tree decl, int v)
1883 return cxx_printable_name_internal (decl, v, true);
1886 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1887 listed in RAISES. */
1890 build_exception_variant (tree type, tree raises)
1895 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1898 type_quals = TYPE_QUALS (type);
1899 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1900 if (check_qualified_type (v, type, type_quals)
1901 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1904 /* Need to build a new variant. */
1905 v = build_variant_type_copy (type);
1906 TYPE_RAISES_EXCEPTIONS (v) = raises;
1910 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1911 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1915 bind_template_template_parm (tree t, tree newargs)
1917 tree decl = TYPE_NAME (t);
1920 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1921 decl = build_decl (input_location,
1922 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1924 /* These nodes have to be created to reflect new TYPE_DECL and template
1926 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1927 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1928 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1929 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1931 TREE_TYPE (decl) = t2;
1932 TYPE_NAME (t2) = decl;
1933 TYPE_STUB_DECL (t2) = decl;
1935 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1940 /* Called from count_trees via walk_tree. */
1943 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1953 /* Debugging function for measuring the rough complexity of a tree
1957 count_trees (tree t)
1960 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1964 /* Called from verify_stmt_tree via walk_tree. */
1967 verify_stmt_tree_r (tree* tp,
1968 int* walk_subtrees ATTRIBUTE_UNUSED ,
1972 htab_t *statements = (htab_t *) data;
1975 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1978 /* If this statement is already present in the hash table, then
1979 there is a circularity in the statement tree. */
1980 gcc_assert (!htab_find (*statements, t));
1982 slot = htab_find_slot (*statements, t, INSERT);
1988 /* Debugging function to check that the statement T has not been
1989 corrupted. For now, this function simply checks that T contains no
1993 verify_stmt_tree (tree t)
1996 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1997 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1998 htab_delete (statements);
2001 /* Check if the type T depends on a type with no linkage and if so, return
2002 it. If RELAXED_P then do not consider a class type declared within
2003 a vague-linkage function to have no linkage. */
2006 no_linkage_check (tree t, bool relaxed_p)
2010 /* There's no point in checking linkage on template functions; we
2011 can't know their complete types. */
2012 if (processing_template_decl)
2015 switch (TREE_CODE (t))
2018 if (TYPE_PTRMEMFUNC_P (t))
2020 /* Lambda types that don't have mangling scope have no linkage. We
2021 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
2022 when we get here from pushtag none of the lambda information is
2023 set up yet, so we want to assume that the lambda has linkage and
2024 fix it up later if not. */
2025 if (CLASSTYPE_LAMBDA_EXPR (t)
2026 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
2030 if (!CLASS_TYPE_P (t))
2034 /* Only treat anonymous types as having no linkage if they're at
2035 namespace scope. This is core issue 966. */
2036 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
2039 for (r = CP_TYPE_CONTEXT (t); ; )
2041 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2042 have linkage, or we might just be in an anonymous namespace.
2043 If we're in a TREE_PUBLIC class, we have linkage. */
2044 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
2045 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
2046 else if (TREE_CODE (r) == FUNCTION_DECL)
2048 if (!relaxed_p || !vague_linkage_p (r))
2051 r = CP_DECL_CONTEXT (r);
2061 case REFERENCE_TYPE:
2062 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2066 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
2070 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
2073 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
2080 for (parm = TYPE_ARG_TYPES (t);
2081 parm && parm != void_list_node;
2082 parm = TREE_CHAIN (parm))
2084 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
2088 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2096 #ifdef GATHER_STATISTICS
2097 extern int depth_reached;
2101 cxx_print_statistics (void)
2103 print_search_statistics ();
2104 print_class_statistics ();
2105 print_template_statistics ();
2106 #ifdef GATHER_STATISTICS
2107 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2112 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2113 (which is an ARRAY_TYPE). This counts only elements of the top
2117 array_type_nelts_top (tree type)
2119 return fold_build2_loc (input_location,
2120 PLUS_EXPR, sizetype,
2121 array_type_nelts (type),
2125 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2126 (which is an ARRAY_TYPE). This one is a recursive count of all
2127 ARRAY_TYPEs that are clumped together. */
2130 array_type_nelts_total (tree type)
2132 tree sz = array_type_nelts_top (type);
2133 type = TREE_TYPE (type);
2134 while (TREE_CODE (type) == ARRAY_TYPE)
2136 tree n = array_type_nelts_top (type);
2137 sz = fold_build2_loc (input_location,
2138 MULT_EXPR, sizetype, sz, n);
2139 type = TREE_TYPE (type);
2144 /* Called from break_out_target_exprs via mapcar. */
2147 bot_manip (tree* tp, int* walk_subtrees, void* data)
2149 splay_tree target_remap = ((splay_tree) data);
2152 if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2154 /* There can't be any TARGET_EXPRs or their slot variables below this
2155 point. But we must make a copy, in case subsequent processing
2156 alters any part of it. For example, during gimplification a cast
2157 of the form (T) &X::f (where "f" is a member function) will lead
2158 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2160 *tp = unshare_expr (t);
2163 if (TREE_CODE (t) == TARGET_EXPR)
2167 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2169 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2170 tf_warning_or_error);
2171 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2172 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2175 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2176 tf_warning_or_error);
2178 TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2179 TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2180 TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2182 /* Map the old variable to the new one. */
2183 splay_tree_insert (target_remap,
2184 (splay_tree_key) TREE_OPERAND (t, 0),
2185 (splay_tree_value) TREE_OPERAND (u, 0));
2187 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
2189 /* Replace the old expression with the new version. */
2191 /* We don't have to go below this point; the recursive call to
2192 break_out_target_exprs will have handled anything below this
2198 /* Make a copy of this node. */
2199 t = copy_tree_r (tp, walk_subtrees, NULL);
2200 if (TREE_CODE (*tp) == CALL_EXPR)
2201 set_flags_from_callee (*tp);
2205 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2206 DATA is really a splay-tree mapping old variables to new
2210 bot_replace (tree* t,
2211 int* walk_subtrees ATTRIBUTE_UNUSED ,
2214 splay_tree target_remap = ((splay_tree) data);
2216 if (TREE_CODE (*t) == VAR_DECL)
2218 splay_tree_node n = splay_tree_lookup (target_remap,
2219 (splay_tree_key) *t);
2221 *t = (tree) n->value;
2223 else if (TREE_CODE (*t) == PARM_DECL
2224 && DECL_NAME (*t) == this_identifier)
2226 /* In an NSDMI we need to replace the 'this' parameter we used for
2227 parsing with the real one for this function. */
2228 *t = current_class_ptr;
2230 else if (TREE_CODE (*t) == CONVERT_EXPR
2231 && CONVERT_EXPR_VBASE_PATH (*t))
2233 /* In an NSDMI build_base_path defers building conversions to virtual
2234 bases, and we handle it here. */
2235 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
2236 VEC(tree,gc) *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
2238 FOR_EACH_VEC_ELT (tree, vbases, i, binfo)
2239 if (BINFO_TYPE (binfo) == basetype)
2241 *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
2242 tf_warning_or_error);
2248 /* When we parse a default argument expression, we may create
2249 temporary variables via TARGET_EXPRs. When we actually use the
2250 default-argument expression, we make a copy of the expression
2251 and replace the temporaries with appropriate local versions. */
2254 break_out_target_exprs (tree t)
2256 static int target_remap_count;
2257 static splay_tree target_remap;
2259 if (!target_remap_count++)
2260 target_remap = splay_tree_new (splay_tree_compare_pointers,
2261 /*splay_tree_delete_key_fn=*/NULL,
2262 /*splay_tree_delete_value_fn=*/NULL);
2263 cp_walk_tree (&t, bot_manip, target_remap, NULL);
2264 cp_walk_tree (&t, bot_replace, target_remap, NULL);
2266 if (!--target_remap_count)
2268 splay_tree_delete (target_remap);
2269 target_remap = NULL;
2275 /* Similar to `build_nt', but for template definitions of dependent
2279 build_min_nt (enum tree_code code, ...)
2286 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2290 t = make_node (code);
2291 length = TREE_CODE_LENGTH (code);
2293 for (i = 0; i < length; i++)
2295 tree x = va_arg (p, tree);
2296 TREE_OPERAND (t, i) = x;
2304 /* Similar to `build', but for template definitions. */
2307 build_min (enum tree_code code, tree tt, ...)
2314 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2318 t = make_node (code);
2319 length = TREE_CODE_LENGTH (code);
2322 for (i = 0; i < length; i++)
2324 tree x = va_arg (p, tree);
2325 TREE_OPERAND (t, i) = x;
2326 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2327 TREE_SIDE_EFFECTS (t) = 1;
2334 /* Similar to `build', but for template definitions of non-dependent
2335 expressions. NON_DEP is the non-dependent expression that has been
2339 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2346 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2348 va_start (p, non_dep);
2350 if (REFERENCE_REF_P (non_dep))
2351 non_dep = TREE_OPERAND (non_dep, 0);
2353 t = make_node (code);
2354 length = TREE_CODE_LENGTH (code);
2355 TREE_TYPE (t) = TREE_TYPE (non_dep);
2356 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2358 for (i = 0; i < length; i++)
2360 tree x = va_arg (p, tree);
2361 TREE_OPERAND (t, i) = x;
2364 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2365 /* This should not be considered a COMPOUND_EXPR, because it
2366 resolves to an overload. */
2367 COMPOUND_EXPR_OVERLOADED (t) = 1;
2370 return convert_from_reference (t);
2373 /* Similar to `build_nt_call_vec', but for template definitions of
2374 non-dependent expressions. NON_DEP is the non-dependent expression
2375 that has been built. */
2378 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
2380 tree t = build_nt_call_vec (fn, argvec);
2381 if (REFERENCE_REF_P (non_dep))
2382 non_dep = TREE_OPERAND (non_dep, 0);
2383 TREE_TYPE (t) = TREE_TYPE (non_dep);
2384 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2385 return convert_from_reference (t);
2389 get_type_decl (tree t)
2391 if (TREE_CODE (t) == TYPE_DECL)
2394 return TYPE_STUB_DECL (t);
2395 gcc_assert (t == error_mark_node);
2399 /* Returns the namespace that contains DECL, whether directly or
2403 decl_namespace_context (tree decl)
2407 if (TREE_CODE (decl) == NAMESPACE_DECL)
2409 else if (TYPE_P (decl))
2410 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2412 decl = CP_DECL_CONTEXT (decl);
2416 /* Returns true if decl is within an anonymous namespace, however deeply
2417 nested, or false otherwise. */
2420 decl_anon_ns_mem_p (const_tree decl)
2424 if (decl == NULL_TREE || decl == error_mark_node)
2426 if (TREE_CODE (decl) == NAMESPACE_DECL
2427 && DECL_NAME (decl) == NULL_TREE)
2429 /* Classes and namespaces inside anonymous namespaces have
2430 TREE_PUBLIC == 0, so we can shortcut the search. */
2431 else if (TYPE_P (decl))
2432 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl)) == 0);
2433 else if (TREE_CODE (decl) == NAMESPACE_DECL)
2434 return (TREE_PUBLIC (decl) == 0);
2436 decl = DECL_CONTEXT (decl);
2440 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2441 CALL_EXPRS. Return whether they are equivalent. */
2444 called_fns_equal (tree t1, tree t2)
2446 /* Core 1321: dependent names are equivalent even if the overload sets
2447 are different. But do compare explicit template arguments. */
2448 tree name1 = dependent_name (t1);
2449 tree name2 = dependent_name (t2);
2452 tree targs1 = NULL_TREE, targs2 = NULL_TREE;
2457 if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
2458 targs1 = TREE_OPERAND (t1, 1);
2459 if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
2460 targs2 = TREE_OPERAND (t2, 1);
2461 return cp_tree_equal (targs1, targs2);
2464 return cp_tree_equal (t1, t2);
2467 /* Return truthvalue of whether T1 is the same tree structure as T2.
2468 Return 1 if they are the same. Return 0 if they are different. */
2471 cp_tree_equal (tree t1, tree t2)
2473 enum tree_code code1, code2;
2480 for (code1 = TREE_CODE (t1);
2481 CONVERT_EXPR_CODE_P (code1)
2482 || code1 == NON_LVALUE_EXPR;
2483 code1 = TREE_CODE (t1))
2484 t1 = TREE_OPERAND (t1, 0);
2485 for (code2 = TREE_CODE (t2);
2486 CONVERT_EXPR_CODE_P (code2)
2487 || code1 == NON_LVALUE_EXPR;
2488 code2 = TREE_CODE (t2))
2489 t2 = TREE_OPERAND (t2, 0);
2491 /* They might have become equal now. */
2501 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2502 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2505 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2508 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2509 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2510 TREE_STRING_LENGTH (t1));
2513 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2514 TREE_FIXED_CST (t2));
2517 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2518 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2521 /* We need to do this when determining whether or not two
2522 non-type pointer to member function template arguments
2524 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2525 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2530 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2532 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2533 if (!cp_tree_equal (field, elt2->index)
2534 || !cp_tree_equal (value, elt2->value))
2541 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2543 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2545 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2548 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2553 call_expr_arg_iterator iter1, iter2;
2554 if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2556 for (arg1 = first_call_expr_arg (t1, &iter1),
2557 arg2 = first_call_expr_arg (t2, &iter2);
2559 arg1 = next_call_expr_arg (&iter1),
2560 arg2 = next_call_expr_arg (&iter2))
2561 if (!cp_tree_equal (arg1, arg2))
2570 tree o1 = TREE_OPERAND (t1, 0);
2571 tree o2 = TREE_OPERAND (t2, 0);
2573 /* Special case: if either target is an unallocated VAR_DECL,
2574 it means that it's going to be unified with whatever the
2575 TARGET_EXPR is really supposed to initialize, so treat it
2576 as being equivalent to anything. */
2577 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2578 && !DECL_RTL_SET_P (o1))
2580 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2581 && !DECL_RTL_SET_P (o2))
2583 else if (!cp_tree_equal (o1, o2))
2586 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2589 case WITH_CLEANUP_EXPR:
2590 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2592 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2595 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2597 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2600 /* For comparing uses of parameters in late-specified return types
2601 with an out-of-class definition of the function, but can also come
2602 up for expressions that involve 'this' in a member function
2605 if (comparing_specializations)
2606 /* When comparing hash table entries, only an exact match is
2607 good enough; we don't want to replace 'this' with the
2608 version from another function. */
2611 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2613 if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2615 if (DECL_ARTIFICIAL (t1)
2616 || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2617 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2627 case IDENTIFIER_NODE:
2632 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2633 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2634 && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
2635 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2636 BASELINK_FUNCTIONS (t2)));
2638 case TEMPLATE_PARM_INDEX:
2639 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2640 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2641 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2642 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2643 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2644 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2646 case TEMPLATE_ID_EXPR:
2647 return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2648 && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2653 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2655 for (ix = TREE_VEC_LENGTH (t1); ix--;)
2656 if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
2657 TREE_VEC_ELT (t2, ix)))
2665 tree o1 = TREE_OPERAND (t1, 0);
2666 tree o2 = TREE_OPERAND (t2, 0);
2668 if (TREE_CODE (o1) != TREE_CODE (o2))
2671 return same_type_p (o1, o2);
2673 return cp_tree_equal (o1, o2);
2678 tree t1_op1, t2_op1;
2680 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2683 t1_op1 = TREE_OPERAND (t1, 1);
2684 t2_op1 = TREE_OPERAND (t2, 1);
2685 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2688 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2692 /* Two pointer-to-members are the same if they point to the same
2693 field or function in the same class. */
2694 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2697 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2700 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2702 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2705 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2707 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2708 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2711 case STATIC_CAST_EXPR:
2712 case REINTERPRET_CAST_EXPR:
2713 case CONST_CAST_EXPR:
2714 case DYNAMIC_CAST_EXPR:
2715 case IMPLICIT_CONV_EXPR:
2717 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2719 /* Now compare operands as usual. */
2722 case DEFERRED_NOEXCEPT:
2723 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2724 DEFERRED_NOEXCEPT_PATTERN (t2))
2725 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2726 DEFERRED_NOEXCEPT_ARGS (t2)));
2733 switch (TREE_CODE_CLASS (code1))
2737 case tcc_comparison:
2738 case tcc_expression:
2745 n = cp_tree_operand_length (t1);
2746 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2747 && n != TREE_OPERAND_LENGTH (t2))
2750 for (i = 0; i < n; ++i)
2751 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2758 return same_type_p (t1, t2);
2762 /* We can get here with --disable-checking. */
2766 /* The type of ARG when used as an lvalue. */
2769 lvalue_type (tree arg)
2771 tree type = TREE_TYPE (arg);
2775 /* The type of ARG for printing error messages; denote lvalues with
2779 error_type (tree arg)
2781 tree type = TREE_TYPE (arg);
2783 if (TREE_CODE (type) == ARRAY_TYPE)
2785 else if (TREE_CODE (type) == ERROR_MARK)
2787 else if (real_lvalue_p (arg))
2788 type = build_reference_type (lvalue_type (arg));
2789 else if (MAYBE_CLASS_TYPE_P (type))
2790 type = lvalue_type (arg);
2795 /* Does FUNCTION use a variable-length argument list? */
2798 varargs_function_p (const_tree function)
2800 return stdarg_p (TREE_TYPE (function));
2803 /* Returns 1 if decl is a member of a class. */
2806 member_p (const_tree decl)
2808 const_tree const ctx = DECL_CONTEXT (decl);
2809 return (ctx && TYPE_P (ctx));
2812 /* Create a placeholder for member access where we don't actually have an
2813 object that the access is against. */
2816 build_dummy_object (tree type)
2818 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2819 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2822 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2823 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2824 binfo path from current_class_type to TYPE, or 0. */
2827 maybe_dummy_object (tree type, tree* binfop)
2831 tree current = current_nonlambda_class_type ();
2834 && (binfo = lookup_base (current, type, ba_any, NULL)))
2838 /* Reference from a nested class member function. */
2840 binfo = TYPE_BINFO (type);
2846 if (current_class_ref
2847 /* current_class_ref might not correspond to current_class_type if
2848 we're in tsubst_default_argument or a lambda-declarator; in either
2849 case, we want to use current_class_ref if it matches CONTEXT. */
2850 && (same_type_ignoring_top_level_qualifiers_p
2851 (TREE_TYPE (current_class_ref), context)))
2852 decl = current_class_ref;
2853 else if (current != current_class_type
2854 && context == nonlambda_method_basetype ())
2855 /* In a lambda, need to go through 'this' capture. */
2856 decl = (build_x_indirect_ref
2857 ((lambda_expr_this_capture
2858 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2859 RO_NULL, tf_warning_or_error));
2861 decl = build_dummy_object (context);
2866 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2869 is_dummy_object (const_tree ob)
2871 if (TREE_CODE (ob) == INDIRECT_REF)
2872 ob = TREE_OPERAND (ob, 0);
2873 return (TREE_CODE (ob) == NOP_EXPR
2874 && TREE_OPERAND (ob, 0) == void_zero_node);
2877 /* Returns 1 iff type T is something we want to treat as a scalar type for
2878 the purpose of deciding whether it is trivial/POD/standard-layout. */
2881 scalarish_type_p (const_tree t)
2883 if (t == error_mark_node)
2886 return (SCALAR_TYPE_P (t)
2887 || TREE_CODE (t) == VECTOR_TYPE);
2890 /* Returns true iff T requires non-trivial default initialization. */
2893 type_has_nontrivial_default_init (const_tree t)
2895 t = strip_array_types (CONST_CAST_TREE (t));
2897 if (CLASS_TYPE_P (t))
2898 return TYPE_HAS_COMPLEX_DFLT (t);
2903 /* Returns true iff copying an object of type T (including via move
2904 constructor) is non-trivial. That is, T has no non-trivial copy
2905 constructors and no non-trivial move constructors. */
2908 type_has_nontrivial_copy_init (const_tree t)
2910 t = strip_array_types (CONST_CAST_TREE (t));
2912 if (CLASS_TYPE_P (t))
2914 gcc_assert (COMPLETE_TYPE_P (t));
2915 return ((TYPE_HAS_COPY_CTOR (t)
2916 && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2917 || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2923 /* Returns 1 iff type T is a trivially copyable type, as defined in
2924 [basic.types] and [class]. */
2927 trivially_copyable_p (const_tree t)
2929 t = strip_array_types (CONST_CAST_TREE (t));
2931 if (CLASS_TYPE_P (t))
2932 return ((!TYPE_HAS_COPY_CTOR (t)
2933 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2934 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2935 && (!TYPE_HAS_COPY_ASSIGN (t)
2936 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2937 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2938 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2940 return scalarish_type_p (t);
2943 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2947 trivial_type_p (const_tree t)
2949 t = strip_array_types (CONST_CAST_TREE (t));
2951 if (CLASS_TYPE_P (t))
2952 return (TYPE_HAS_TRIVIAL_DFLT (t)
2953 && trivially_copyable_p (t));
2955 return scalarish_type_p (t);
2958 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2961 pod_type_p (const_tree t)
2963 /* This CONST_CAST is okay because strip_array_types returns its
2964 argument unmodified and we assign it to a const_tree. */
2965 t = strip_array_types (CONST_CAST_TREE(t));
2967 if (!CLASS_TYPE_P (t))
2968 return scalarish_type_p (t);
2969 else if (cxx_dialect > cxx98)
2970 /* [class]/10: A POD struct is a class that is both a trivial class and a
2971 standard-layout class, and has no non-static data members of type
2972 non-POD struct, non-POD union (or array of such types).
2974 We don't need to check individual members because if a member is
2975 non-std-layout or non-trivial, the class will be too. */
2976 return (std_layout_type_p (t) && trivial_type_p (t));
2978 /* The C++98 definition of POD is different. */
2979 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2982 /* Returns true iff T is POD for the purpose of layout, as defined in the
2986 layout_pod_type_p (const_tree t)
2988 t = strip_array_types (CONST_CAST_TREE (t));
2990 if (CLASS_TYPE_P (t))
2991 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2993 return scalarish_type_p (t);
2996 /* Returns true iff T is a standard-layout type, as defined in
3000 std_layout_type_p (const_tree t)
3002 t = strip_array_types (CONST_CAST_TREE (t));
3004 if (CLASS_TYPE_P (t))
3005 return !CLASSTYPE_NON_STD_LAYOUT (t);
3007 return scalarish_type_p (t);
3010 /* Nonzero iff type T is a class template implicit specialization. */
3013 class_tmpl_impl_spec_p (const_tree t)
3015 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
3018 /* Returns 1 iff zero initialization of type T means actually storing
3022 zero_init_p (const_tree t)
3024 /* This CONST_CAST is okay because strip_array_types returns its
3025 argument unmodified and we assign it to a const_tree. */
3026 t = strip_array_types (CONST_CAST_TREE(t));
3028 if (t == error_mark_node)
3031 /* NULL pointers to data members are initialized with -1. */
3032 if (TYPE_PTRMEM_P (t))
3035 /* Classes that contain types that can't be zero-initialized, cannot
3036 be zero-initialized themselves. */
3037 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
3043 /* Table of valid C++ attributes. */
3044 const struct attribute_spec cxx_attribute_table[] =
3046 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3047 affects_type_identity } */
3048 { "java_interface", 0, 0, false, false, false,
3049 handle_java_interface_attribute, false },
3050 { "com_interface", 0, 0, false, false, false,
3051 handle_com_interface_attribute, false },
3052 { "init_priority", 1, 1, true, false, false,
3053 handle_init_priority_attribute, false },
3054 { NULL, 0, 0, false, false, false, NULL, false }
3057 /* Handle a "java_interface" attribute; arguments as in
3058 struct attribute_spec.handler. */
3060 handle_java_interface_attribute (tree* node,
3062 tree args ATTRIBUTE_UNUSED ,
3067 || !CLASS_TYPE_P (*node)
3068 || !TYPE_FOR_JAVA (*node))
3070 error ("%qE attribute can only be applied to Java class definitions",
3072 *no_add_attrs = true;
3075 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3076 *node = build_variant_type_copy (*node);
3077 TYPE_JAVA_INTERFACE (*node) = 1;
3082 /* Handle a "com_interface" attribute; arguments as in
3083 struct attribute_spec.handler. */
3085 handle_com_interface_attribute (tree* node,
3087 tree args ATTRIBUTE_UNUSED ,
3088 int flags ATTRIBUTE_UNUSED ,
3093 *no_add_attrs = true;
3096 || !CLASS_TYPE_P (*node)
3097 || *node != TYPE_MAIN_VARIANT (*node))
3099 warning (OPT_Wattributes, "%qE attribute can only be applied "
3100 "to class definitions", name);
3105 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
3111 /* Handle an "init_priority" attribute; arguments as in
3112 struct attribute_spec.handler. */
3114 handle_init_priority_attribute (tree* node,
3117 int flags ATTRIBUTE_UNUSED ,
3120 tree initp_expr = TREE_VALUE (args);
3122 tree type = TREE_TYPE (decl);
3125 STRIP_NOPS (initp_expr);
3127 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
3129 error ("requested init_priority is not an integer constant");
3130 *no_add_attrs = true;
3134 pri = TREE_INT_CST_LOW (initp_expr);
3136 type = strip_array_types (type);
3138 if (decl == NULL_TREE
3139 || TREE_CODE (decl) != VAR_DECL
3140 || !TREE_STATIC (decl)
3141 || DECL_EXTERNAL (decl)
3142 || (TREE_CODE (type) != RECORD_TYPE
3143 && TREE_CODE (type) != UNION_TYPE)
3144 /* Static objects in functions are initialized the
3145 first time control passes through that
3146 function. This is not precise enough to pin down an
3147 init_priority value, so don't allow it. */
3148 || current_function_decl)
3150 error ("can only use %qE attribute on file-scope definitions "
3151 "of objects of class type", name);
3152 *no_add_attrs = true;
3156 if (pri > MAX_INIT_PRIORITY || pri <= 0)
3158 error ("requested init_priority is out of range");
3159 *no_add_attrs = true;
3163 /* Check for init_priorities that are reserved for
3164 language and runtime support implementations.*/
3165 if (pri <= MAX_RESERVED_INIT_PRIORITY)
3168 (0, "requested init_priority is reserved for internal use");
3171 if (SUPPORTS_INIT_PRIORITY)
3173 SET_DECL_INIT_PRIORITY (decl, pri);
3174 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
3179 error ("%qE attribute is not supported on this platform", name);
3180 *no_add_attrs = true;
3185 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
3186 thing pointed to by the constant. */
3189 make_ptrmem_cst (tree type, tree member)
3191 tree ptrmem_cst = make_node (PTRMEM_CST);
3192 TREE_TYPE (ptrmem_cst) = type;
3193 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
3197 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
3198 return an existing type if an appropriate type already exists. */
3201 cp_build_type_attribute_variant (tree type, tree attributes)
3205 new_type = build_type_attribute_variant (type, attributes);
3206 if (TREE_CODE (new_type) == FUNCTION_TYPE
3207 || TREE_CODE (new_type) == METHOD_TYPE)
3208 new_type = build_exception_variant (new_type,
3209 TYPE_RAISES_EXCEPTIONS (type));
3211 /* Making a new main variant of a class type is broken. */
3212 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
3217 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3218 Called only after doing all language independent checks. Only
3219 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3220 compared in type_hash_eq. */
3223 cxx_type_hash_eq (const_tree typea, const_tree typeb)
3225 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
3226 || TREE_CODE (typea) == METHOD_TYPE);
3228 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
3229 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
3232 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3233 traversal. Called from walk_tree. */
3236 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
3237 void *data, struct pointer_set_t *pset)
3239 enum tree_code code = TREE_CODE (*tp);
3242 #define WALK_SUBTREE(NODE) \
3245 result = cp_walk_tree (&(NODE), func, data, pset); \
3246 if (result) goto out; \
3250 /* Not one of the easy cases. We must explicitly go through the
3256 case TEMPLATE_TEMPLATE_PARM:
3257 case BOUND_TEMPLATE_TEMPLATE_PARM:
3258 case UNBOUND_CLASS_TEMPLATE:
3259 case TEMPLATE_PARM_INDEX:
3260 case TEMPLATE_TYPE_PARM:
3263 case UNDERLYING_TYPE:
3264 /* None of these have subtrees other than those already walked
3266 *walk_subtrees_p = 0;
3270 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
3271 *walk_subtrees_p = 0;
3275 WALK_SUBTREE (TREE_TYPE (*tp));
3276 *walk_subtrees_p = 0;
3280 WALK_SUBTREE (TREE_PURPOSE (*tp));
3284 WALK_SUBTREE (OVL_FUNCTION (*tp));
3285 WALK_SUBTREE (OVL_CHAIN (*tp));
3286 *walk_subtrees_p = 0;
3290 WALK_SUBTREE (DECL_NAME (*tp));
3291 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
3292 WALK_SUBTREE (USING_DECL_DECLS (*tp));
3293 *walk_subtrees_p = 0;
3297 if (TYPE_PTRMEMFUNC_P (*tp))
3298 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
3301 case TYPE_ARGUMENT_PACK:
3302 case NONTYPE_ARGUMENT_PACK:
3304 tree args = ARGUMENT_PACK_ARGS (*tp);
3305 int i, len = TREE_VEC_LENGTH (args);
3306 for (i = 0; i < len; i++)
3307 WALK_SUBTREE (TREE_VEC_ELT (args, i));
3311 case TYPE_PACK_EXPANSION:
3312 WALK_SUBTREE (TREE_TYPE (*tp));
3313 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3314 *walk_subtrees_p = 0;
3317 case EXPR_PACK_EXPANSION:
3318 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
3319 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3320 *walk_subtrees_p = 0;
3324 case REINTERPRET_CAST_EXPR:
3325 case STATIC_CAST_EXPR:
3326 case CONST_CAST_EXPR:
3327 case DYNAMIC_CAST_EXPR:
3328 case IMPLICIT_CONV_EXPR:
3329 if (TREE_TYPE (*tp))
3330 WALK_SUBTREE (TREE_TYPE (*tp));
3334 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
3335 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3337 *walk_subtrees_p = 0;
3341 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3342 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3343 *walk_subtrees_p = 0;
3347 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3348 *walk_subtrees_p = 0;
3356 /* We didn't find what we were looking for. */
3363 /* Like save_expr, but for C++. */
3366 cp_save_expr (tree expr)
3368 /* There is no reason to create a SAVE_EXPR within a template; if
3369 needed, we can create the SAVE_EXPR when instantiating the
3370 template. Furthermore, the middle-end cannot handle C++-specific
3372 if (processing_template_decl)
3374 return save_expr (expr);
3377 /* Initialize tree.c. */
3382 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3385 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3386 is. Note that sfk_none is zero, so this function can be used as a
3387 predicate to test whether or not DECL is a special function. */
3389 special_function_kind
3390 special_function_p (const_tree decl)
3392 /* Rather than doing all this stuff with magic names, we should
3393 probably have a field of type `special_function_kind' in
3394 DECL_LANG_SPECIFIC. */
3395 if (DECL_COPY_CONSTRUCTOR_P (decl))
3396 return sfk_copy_constructor;
3397 if (DECL_MOVE_CONSTRUCTOR_P (decl))
3398 return sfk_move_constructor;
3399 if (DECL_CONSTRUCTOR_P (decl))
3400 return sfk_constructor;
3401 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3403 if (copy_fn_p (decl))
3404 return sfk_copy_assignment;
3405 if (move_fn_p (decl))
3406 return sfk_move_assignment;
3408 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3409 return sfk_destructor;
3410 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3411 return sfk_complete_destructor;
3412 if (DECL_BASE_DESTRUCTOR_P (decl))
3413 return sfk_base_destructor;
3414 if (DECL_DELETING_DESTRUCTOR_P (decl))
3415 return sfk_deleting_destructor;
3416 if (DECL_CONV_FN_P (decl))
3417 return sfk_conversion;
3422 /* Returns nonzero if TYPE is a character type, including wchar_t. */
3425 char_type_p (tree type)
3427 return (same_type_p (type, char_type_node)
3428 || same_type_p (type, unsigned_char_type_node)
3429 || same_type_p (type, signed_char_type_node)
3430 || same_type_p (type, char16_type_node)
3431 || same_type_p (type, char32_type_node)
3432 || same_type_p (type, wchar_type_node));
3435 /* Returns the kind of linkage associated with the indicated DECL. Th
3436 value returned is as specified by the language standard; it is
3437 independent of implementation details regarding template
3438 instantiation, etc. For example, it is possible that a declaration
3439 to which this function assigns external linkage would not show up
3440 as a global symbol when you run `nm' on the resulting object file. */
3443 decl_linkage (tree decl)
3445 /* This function doesn't attempt to calculate the linkage from first
3446 principles as given in [basic.link]. Instead, it makes use of
3447 the fact that we have already set TREE_PUBLIC appropriately, and
3448 then handles a few special cases. Ideally, we would calculate
3449 linkage first, and then transform that into a concrete
3452 /* Things that don't have names have no linkage. */
3453 if (!DECL_NAME (decl))
3456 /* Fields have no linkage. */
3457 if (TREE_CODE (decl) == FIELD_DECL)
3460 /* Things that are TREE_PUBLIC have external linkage. */
3461 if (TREE_PUBLIC (decl))
3464 if (TREE_CODE (decl) == NAMESPACE_DECL)
3467 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3469 if (TREE_CODE (decl) == CONST_DECL)
3470 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
3472 /* Some things that are not TREE_PUBLIC have external linkage, too.
3473 For example, on targets that don't have weak symbols, we make all
3474 template instantiations have internal linkage (in the object
3475 file), but the symbols should still be treated as having external
3476 linkage from the point of view of the language. */
3477 if ((TREE_CODE (decl) == FUNCTION_DECL
3478 || TREE_CODE (decl) == VAR_DECL)
3479 && DECL_COMDAT (decl))
3482 /* Things in local scope do not have linkage, if they don't have
3484 if (decl_function_context (decl))
3487 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3488 are considered to have external linkage for language purposes. DECLs
3489 really meant to have internal linkage have DECL_THIS_STATIC set. */
3490 if (TREE_CODE (decl) == TYPE_DECL)
3492 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3494 if (!DECL_THIS_STATIC (decl))
3497 /* Static data members and static member functions from classes
3498 in anonymous namespace also don't have TREE_PUBLIC set. */
3499 if (DECL_CLASS_CONTEXT (decl))
3503 /* Everything else has internal linkage. */
3507 /* Returns the storage duration of the object or reference associated with
3508 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
3511 decl_storage_duration (tree decl)
3513 if (TREE_CODE (decl) == PARM_DECL)
3515 if (TREE_CODE (decl) == FUNCTION_DECL)
3517 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3518 if (!TREE_STATIC (decl)
3519 && !DECL_EXTERNAL (decl))
3521 if (DECL_THREAD_LOCAL_P (decl))
3526 /* EXP is an expression that we want to pre-evaluate. Returns (in
3527 *INITP) an expression that will perform the pre-evaluation. The
3528 value returned by this function is a side-effect free expression
3529 equivalent to the pre-evaluated expression. Callers must ensure
3530 that *INITP is evaluated before EXP. */
3533 stabilize_expr (tree exp, tree* initp)
3537 if (!TREE_SIDE_EFFECTS (exp))
3538 init_expr = NULL_TREE;
3539 else if (VOID_TYPE_P (TREE_TYPE (exp)))
3542 return void_zero_node;
3544 /* There are no expressions with REFERENCE_TYPE, but there can be call
3545 arguments with such a type; just treat it as a pointer. */
3546 else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3547 || SCALAR_TYPE_P (TREE_TYPE (exp))
3548 || !lvalue_or_rvalue_with_address_p (exp))
3550 init_expr = get_target_expr (exp);
3551 exp = TARGET_EXPR_SLOT (init_expr);
3555 bool xval = !real_lvalue_p (exp);
3556 exp = cp_build_addr_expr (exp, tf_warning_or_error);
3557 init_expr = get_target_expr (exp);
3558 exp = TARGET_EXPR_SLOT (init_expr);
3559 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3565 gcc_assert (!TREE_SIDE_EFFECTS (exp));
3569 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3570 similar expression ORIG. */
3573 add_stmt_to_compound (tree orig, tree new_expr)
3575 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3577 if (!orig || !TREE_SIDE_EFFECTS (orig))
3579 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3582 /* Like stabilize_expr, but for a call whose arguments we want to
3583 pre-evaluate. CALL is modified in place to use the pre-evaluated
3584 arguments, while, upon return, *INITP contains an expression to
3585 compute the arguments. */
3588 stabilize_call (tree call, tree *initp)
3590 tree inits = NULL_TREE;
3592 int nargs = call_expr_nargs (call);
3594 if (call == error_mark_node || processing_template_decl)
3600 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3602 for (i = 0; i < nargs; i++)
3605 CALL_EXPR_ARG (call, i) =
3606 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3607 inits = add_stmt_to_compound (inits, init);
3613 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3614 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3615 arguments, while, upon return, *INITP contains an expression to
3616 compute the arguments. */
3619 stabilize_aggr_init (tree call, tree *initp)
3621 tree inits = NULL_TREE;
3623 int nargs = aggr_init_expr_nargs (call);
3625 if (call == error_mark_node)
3628 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3630 for (i = 0; i < nargs; i++)
3633 AGGR_INIT_EXPR_ARG (call, i) =
3634 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3635 inits = add_stmt_to_compound (inits, init);
3641 /* Like stabilize_expr, but for an initialization.
3643 If the initialization is for an object of class type, this function
3644 takes care not to introduce additional temporaries.
3646 Returns TRUE iff the expression was successfully pre-evaluated,
3647 i.e., if INIT is now side-effect free, except for, possible, a
3648 single call to a constructor. */
3651 stabilize_init (tree init, tree *initp)
3657 if (t == error_mark_node || processing_template_decl)
3660 if (TREE_CODE (t) == INIT_EXPR
3661 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3662 && TREE_CODE (TREE_OPERAND (t, 1)) != CONSTRUCTOR
3663 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3665 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3669 if (TREE_CODE (t) == INIT_EXPR)
3670 t = TREE_OPERAND (t, 1);
3671 if (TREE_CODE (t) == TARGET_EXPR)
3672 t = TARGET_EXPR_INITIAL (t);
3673 if (TREE_CODE (t) == COMPOUND_EXPR)
3675 if (TREE_CODE (t) == CONSTRUCTOR)
3677 /* Aggregate initialization: stabilize each of the field
3680 constructor_elt *ce;
3682 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (t);
3683 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
3685 tree type = TREE_TYPE (ce->value);
3687 if (TREE_CODE (type) == REFERENCE_TYPE
3688 || SCALAR_TYPE_P (type))
3689 ce->value = stabilize_expr (ce->value, &subinit);
3690 else if (!stabilize_init (ce->value, &subinit))
3692 *initp = add_stmt_to_compound (*initp, subinit);
3697 /* If the initializer is a COND_EXPR, we can't preevaluate
3699 if (TREE_CODE (t) == COND_EXPR)
3702 if (TREE_CODE (t) == CALL_EXPR)
3704 stabilize_call (t, initp);
3708 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3710 stabilize_aggr_init (t, initp);
3714 /* The initialization is being performed via a bitwise copy -- and
3715 the item copied may have side effects. */
3716 return !TREE_SIDE_EFFECTS (init);
3719 /* Like "fold", but should be used whenever we might be processing the
3720 body of a template. */
3723 fold_if_not_in_template (tree expr)
3725 /* In the body of a template, there is never any need to call
3726 "fold". We will call fold later when actually instantiating the
3727 template. Integral constant expressions in templates will be
3728 evaluated via fold_non_dependent_expr, as necessary. */
3729 if (processing_template_decl)
3732 /* Fold C++ front-end specific tree codes. */
3733 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3734 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3739 /* Returns true if a cast to TYPE may appear in an integral constant
3743 cast_valid_in_integral_constant_expression_p (tree type)
3745 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3746 || cxx_dialect >= cxx0x
3747 || dependent_type_p (type)
3748 || type == error_mark_node);
3751 /* Return true if we need to fix linkage information of DECL. */
3754 cp_fix_function_decl_p (tree decl)
3756 /* Skip if DECL is not externally visible. */
3757 if (!TREE_PUBLIC (decl))
3760 /* We need to fix DECL if it a appears to be exported but with no
3761 function body. Thunks do not have CFGs and we may need to
3762 handle them specially later. */
3763 if (!gimple_has_body_p (decl)
3764 && !DECL_THUNK_P (decl)
3765 && !DECL_EXTERNAL (decl))
3767 struct cgraph_node *node = cgraph_get_node (decl);
3769 /* Don't fix same_body aliases. Although they don't have their own
3770 CFG, they share it with what they alias to. */
3771 if (!node || !node->alias
3772 || !VEC_length (ipa_ref_t, node->ref_list.references))
3779 /* Clean the C++ specific parts of the tree T. */
3782 cp_free_lang_data (tree t)
3784 if (TREE_CODE (t) == METHOD_TYPE
3785 || TREE_CODE (t) == FUNCTION_TYPE)
3787 /* Default args are not interesting anymore. */
3788 tree argtypes = TYPE_ARG_TYPES (t);
3791 TREE_PURPOSE (argtypes) = 0;
3792 argtypes = TREE_CHAIN (argtypes);
3795 else if (TREE_CODE (t) == FUNCTION_DECL
3796 && cp_fix_function_decl_p (t))
3798 /* If T is used in this translation unit at all, the definition
3799 must exist somewhere else since we have decided to not emit it
3800 in this TU. So make it an external reference. */
3801 DECL_EXTERNAL (t) = 1;
3802 TREE_STATIC (t) = 0;
3804 if (TREE_CODE (t) == NAMESPACE_DECL)
3806 /* The list of users of a namespace isn't useful for the middle-end
3807 or debug generators. */
3808 DECL_NAMESPACE_USERS (t) = NULL_TREE;
3809 /* Neither do we need the leftover chaining of namespaces
3810 from the binding level. */
3811 DECL_CHAIN (t) = NULL_TREE;
3815 /* Stub for c-common. Please keep in sync with c-decl.c.
3816 FIXME: If address space support is target specific, then this
3817 should be a C target hook. But currently this is not possible,
3818 because this function is called via REGISTER_TARGET_PRAGMAS. */
3820 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3821 addr_space_t as ATTRIBUTE_UNUSED)
3825 /* Return the number of operands in T that we care about for things like
3829 cp_tree_operand_length (const_tree t)
3831 enum tree_code code = TREE_CODE (t);
3835 case PREINCREMENT_EXPR:
3836 case PREDECREMENT_EXPR:
3837 case POSTINCREMENT_EXPR:
3838 case POSTDECREMENT_EXPR:
3844 case EXPR_PACK_EXPANSION:
3848 return TREE_OPERAND_LENGTH (t);
3852 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3853 /* Complain that some language-specific thing hanging off a tree
3854 node has been accessed improperly. */
3857 lang_check_failed (const char* file, int line, const char* function)
3859 internal_error ("lang_* check: failed in %s, at %s:%d",
3860 function, trim_filename (file), line);
3862 #endif /* ENABLE_TREE_CHECKING */
3864 #include "gt-cp-tree.h"