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 (TREE_TYPE (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. We might
823 end up doing this multiple times if t is an array of
825 tree size = TYPE_SIZE (t);
826 tree size_unit = TYPE_SIZE_UNIT (t);
827 unsigned int align = TYPE_ALIGN (t);
828 unsigned int user_align = TYPE_USER_ALIGN (t);
829 enum machine_mode mode = TYPE_MODE (t);
831 for (var = m; var; var = TYPE_NEXT_VARIANT (var))
833 TYPE_SIZE (var) = size;
834 TYPE_SIZE_UNIT (var) = size_unit;
835 TYPE_ALIGN (var) = align;
836 TYPE_USER_ALIGN (var) = user_align;
837 SET_TYPE_MODE (var, mode);
838 TYPE_NEEDS_CONSTRUCTING (var) = needs_ctor;
839 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (var) = needs_dtor;
843 TYPE_MAIN_VARIANT (t) = m;
844 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
845 TYPE_NEXT_VARIANT (m) = t;
852 /* Return an ARRAY_TYPE with element type ELT and length N. */
855 build_array_of_n_type (tree elt, int n)
857 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
860 /* Return a reference type node referring to TO_TYPE. If RVAL is
861 true, return an rvalue reference type, otherwise return an lvalue
862 reference type. If a type node exists, reuse it, otherwise create
865 cp_build_reference_type (tree to_type, bool rval)
868 lvalue_ref = build_reference_type (to_type);
872 /* This code to create rvalue reference types is based on and tied
873 to the code creating lvalue reference types in the middle-end
874 functions build_reference_type_for_mode and build_reference_type.
876 It works by putting the rvalue reference type nodes after the
877 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
878 they will effectively be ignored by the middle end. */
880 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
881 if (TYPE_REF_IS_RVALUE (t))
884 t = build_distinct_type_copy (lvalue_ref);
886 TYPE_REF_IS_RVALUE (t) = true;
887 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
888 TYPE_NEXT_REF_TO (lvalue_ref) = t;
890 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
891 SET_TYPE_STRUCTURAL_EQUALITY (t);
892 else if (TYPE_CANONICAL (to_type) != to_type)
894 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
896 TYPE_CANONICAL (t) = t;
904 /* Returns EXPR cast to rvalue reference type, like std::move. */
909 tree type = TREE_TYPE (expr);
910 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
911 type = cp_build_reference_type (type, /*rval*/true);
912 return build_static_cast (type, expr, tf_warning_or_error);
915 /* Used by the C++ front end to build qualified array types. However,
916 the C version of this function does not properly maintain canonical
917 types (which are not used in C). */
919 c_build_qualified_type (tree type, int type_quals)
921 return cp_build_qualified_type (type, type_quals);
925 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
926 arrays correctly. In particular, if TYPE is an array of T's, and
927 TYPE_QUALS is non-empty, returns an array of qualified T's.
929 FLAGS determines how to deal with ill-formed qualifications. If
930 tf_ignore_bad_quals is set, then bad qualifications are dropped
931 (this is permitted if TYPE was introduced via a typedef or template
932 type parameter). If bad qualifications are dropped and tf_warning
933 is set, then a warning is issued for non-const qualifications. If
934 tf_ignore_bad_quals is not set and tf_error is not set, we
935 return error_mark_node. Otherwise, we issue an error, and ignore
938 Qualification of a reference type is valid when the reference came
939 via a typedef or template type argument. [dcl.ref] No such
940 dispensation is provided for qualifying a function type. [dcl.fct]
941 DR 295 queries this and the proposed resolution brings it into line
942 with qualifying a reference. We implement the DR. We also behave
943 in a similar manner for restricting non-pointer types. */
946 cp_build_qualified_type_real (tree type,
948 tsubst_flags_t complain)
951 int bad_quals = TYPE_UNQUALIFIED;
953 if (type == error_mark_node)
956 if (type_quals == cp_type_quals (type))
959 if (TREE_CODE (type) == ARRAY_TYPE)
961 /* In C++, the qualification really applies to the array element
962 type. Obtain the appropriately qualified element type. */
965 = cp_build_qualified_type_real (TREE_TYPE (type),
969 if (element_type == error_mark_node)
970 return error_mark_node;
972 /* See if we already have an identically qualified type. Tests
973 should be equivalent to those in check_qualified_type. */
974 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
975 if (TREE_TYPE (t) == element_type
976 && TYPE_NAME (t) == TYPE_NAME (type)
977 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
978 && attribute_list_equal (TYPE_ATTRIBUTES (t),
979 TYPE_ATTRIBUTES (type)))
984 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
986 /* Keep the typedef name. */
987 if (TYPE_NAME (t) != TYPE_NAME (type))
989 t = build_variant_type_copy (t);
990 TYPE_NAME (t) = TYPE_NAME (type);
994 /* Even if we already had this variant, we update
995 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
996 they changed since the variant was originally created.
998 This seems hokey; if there is some way to use a previous
999 variant *without* coming through here,
1000 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1001 TYPE_NEEDS_CONSTRUCTING (t)
1002 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
1003 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1004 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
1007 else if (TYPE_PTRMEMFUNC_P (type))
1009 /* For a pointer-to-member type, we can't just return a
1010 cv-qualified version of the RECORD_TYPE. If we do, we
1011 haven't changed the field that contains the actual pointer to
1012 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
1015 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
1016 t = cp_build_qualified_type_real (t, type_quals, complain);
1017 return build_ptrmemfunc_type (t);
1019 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
1021 tree t = PACK_EXPANSION_PATTERN (type);
1023 t = cp_build_qualified_type_real (t, type_quals, complain);
1024 return make_pack_expansion (t);
1027 /* A reference or method type shall not be cv-qualified.
1028 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1029 (in CD1) we always ignore extra cv-quals on functions. */
1030 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1031 && (TREE_CODE (type) == REFERENCE_TYPE
1032 || TREE_CODE (type) == FUNCTION_TYPE
1033 || TREE_CODE (type) == METHOD_TYPE))
1035 if (TREE_CODE (type) == REFERENCE_TYPE)
1036 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1037 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1040 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1041 if (TREE_CODE (type) == FUNCTION_TYPE)
1042 type_quals |= type_memfn_quals (type);
1044 /* A restrict-qualified type must be a pointer (or reference)
1045 to object or incomplete type. */
1046 if ((type_quals & TYPE_QUAL_RESTRICT)
1047 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1048 && TREE_CODE (type) != TYPENAME_TYPE
1049 && !POINTER_TYPE_P (type))
1051 bad_quals |= TYPE_QUAL_RESTRICT;
1052 type_quals &= ~TYPE_QUAL_RESTRICT;
1055 if (bad_quals == TYPE_UNQUALIFIED
1056 || (complain & tf_ignore_bad_quals))
1058 else if (!(complain & tf_error))
1059 return error_mark_node;
1062 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1063 error ("%qV qualifiers cannot be applied to %qT",
1067 /* Retrieve (or create) the appropriately qualified variant. */
1068 result = build_qualified_type (type, type_quals);
1070 /* If this was a pointer-to-method type, and we just made a copy,
1071 then we need to unshare the record that holds the cached
1072 pointer-to-member-function type, because these will be distinct
1073 between the unqualified and qualified types. */
1075 && TREE_CODE (type) == POINTER_TYPE
1076 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1077 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
1078 TYPE_LANG_SPECIFIC (result) = NULL;
1080 /* We may also have ended up building a new copy of the canonical
1081 type of a pointer-to-method type, which could have the same
1082 sharing problem described above. */
1083 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
1084 && TREE_CODE (type) == POINTER_TYPE
1085 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1086 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
1087 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
1088 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
1093 /* Return TYPE with const and volatile removed. */
1096 cv_unqualified (tree type)
1100 if (type == error_mark_node)
1103 quals = cp_type_quals (type);
1104 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1105 return cp_build_qualified_type (type, quals);
1108 /* Builds a qualified variant of T that is not a typedef variant.
1109 E.g. consider the following declarations:
1110 typedef const int ConstInt;
1111 typedef ConstInt* PtrConstInt;
1112 If T is PtrConstInt, this function returns a type representing
1114 In other words, if T is a typedef, the function returns the underlying type.
1115 The cv-qualification and attributes of the type returned match the
1117 They will always be compatible types.
1118 The returned type is built so that all of its subtypes
1119 recursively have their typedefs stripped as well.
1121 This is different from just returning TYPE_CANONICAL (T)
1122 Because of several reasons:
1123 * If T is a type that needs structural equality
1124 its TYPE_CANONICAL (T) will be NULL.
1125 * TYPE_CANONICAL (T) desn't carry type attributes
1126 and loses template parameter names. */
1129 strip_typedefs (tree t)
1131 tree result = NULL, type = NULL, t0 = NULL;
1133 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1136 gcc_assert (TYPE_P (t));
1138 switch (TREE_CODE (t))
1141 type = strip_typedefs (TREE_TYPE (t));
1142 result = build_pointer_type (type);
1144 case REFERENCE_TYPE:
1145 type = strip_typedefs (TREE_TYPE (t));
1146 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1149 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1150 type = strip_typedefs (TREE_TYPE (t));
1151 result = build_offset_type (t0, type);
1154 if (TYPE_PTRMEMFUNC_P (t))
1156 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1157 result = build_ptrmemfunc_type (t0);
1161 type = strip_typedefs (TREE_TYPE (t));
1162 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1163 result = build_cplus_array_type (type, t0);
1168 tree arg_types = NULL, arg_node, arg_type;
1169 for (arg_node = TYPE_ARG_TYPES (t);
1171 arg_node = TREE_CHAIN (arg_node))
1173 if (arg_node == void_list_node)
1175 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1176 gcc_assert (arg_type);
1179 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1183 arg_types = nreverse (arg_types);
1185 /* A list of parameters not ending with an ellipsis
1186 must end with void_list_node. */
1188 arg_types = chainon (arg_types, void_list_node);
1190 type = strip_typedefs (TREE_TYPE (t));
1191 if (TREE_CODE (t) == METHOD_TYPE)
1193 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1194 gcc_assert (class_type);
1196 build_method_type_directly (class_type, type,
1197 TREE_CHAIN (arg_types));
1201 result = build_function_type (type,
1203 result = apply_memfn_quals (result, type_memfn_quals (t));
1206 if (TYPE_RAISES_EXCEPTIONS (t))
1207 result = build_exception_variant (result,
1208 TYPE_RAISES_EXCEPTIONS (t));
1213 tree fullname = TYPENAME_TYPE_FULLNAME (t);
1214 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
1215 && TREE_OPERAND (fullname, 1))
1217 tree args = TREE_OPERAND (fullname, 1);
1218 tree new_args = copy_node (args);
1219 bool changed = false;
1221 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
1223 tree arg = TREE_VEC_ELT (args, i);
1226 strip_arg = strip_typedefs (arg);
1228 strip_arg = strip_typedefs_expr (arg);
1229 TREE_VEC_ELT (new_args, i) = strip_arg;
1230 if (strip_arg != arg)
1235 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)
1236 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
1238 = lookup_template_function (TREE_OPERAND (fullname, 0),
1242 ggc_free (new_args);
1244 result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1245 fullname, typename_type, tf_none);
1249 result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t));
1250 if (result == DECLTYPE_TYPE_EXPR (t))
1253 result = (finish_decltype_type
1255 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
1263 result = TYPE_MAIN_VARIANT (t);
1264 if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1265 || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1267 gcc_assert (TYPE_USER_ALIGN (t));
1268 if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1269 result = build_variant_type_copy (result);
1271 result = build_aligned_type (result, TYPE_ALIGN (t));
1272 TYPE_USER_ALIGN (result) = true;
1274 if (TYPE_ATTRIBUTES (t))
1275 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1276 return cp_build_qualified_type (result, cp_type_quals (t));
1279 /* Like strip_typedefs above, but works on expressions, so that in
1281 template<class T> struct A
1287 sizeof(TT) is replaced by sizeof(T). */
1290 strip_typedefs_expr (tree t)
1294 enum tree_code code;
1296 if (t == NULL_TREE || t == error_mark_node)
1299 if (DECL_P (t) || CONSTANT_CLASS_P (t))
1302 /* Some expressions have type operands, so let's handle types here rather
1303 than check TYPE_P in multiple places below. */
1305 return strip_typedefs (t);
1307 code = TREE_CODE (t);
1310 case IDENTIFIER_NODE:
1311 case TEMPLATE_PARM_INDEX:
1314 case ARGUMENT_PACK_SELECT:
1319 tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t));
1320 tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t));
1321 if (type1 == TRAIT_EXPR_TYPE1 (t)
1322 && type2 == TRAIT_EXPR_TYPE2 (t))
1325 TRAIT_EXPR_TYPE1 (t) = type1;
1326 TRAIT_EXPR_TYPE2 (t) = type2;
1332 VEC(tree,gc) *vec = make_tree_vector ();
1333 bool changed = false;
1335 for (it = t; it; it = TREE_CHAIN (it))
1337 tree val = strip_typedefs_expr (TREE_VALUE (t));
1338 VEC_safe_push (tree, gc, vec, val);
1339 if (val != TREE_VALUE (t))
1341 gcc_assert (TREE_PURPOSE (it) == NULL_TREE);
1346 FOR_EACH_VEC_ELT_REVERSE (tree, vec, i, it)
1347 r = tree_cons (NULL_TREE, it, r);
1351 release_tree_vector (vec);
1357 bool changed = false;
1358 VEC(tree,gc)* vec = make_tree_vector ();
1359 n = TREE_VEC_LENGTH (t);
1360 VEC_reserve (tree, gc, vec, n);
1361 for (i = 0; i < n; ++i)
1363 tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i));
1364 VEC_quick_push (tree, vec, op);
1365 if (op != TREE_VEC_ELT (t, i))
1371 for (i = 0; i < n; ++i)
1372 TREE_VEC_ELT (r, i) = VEC_index (tree, vec, i);
1373 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)
1374 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
1378 release_tree_vector (vec);
1384 bool changed = false;
1385 VEC(constructor_elt,gc) *vec
1386 = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
1387 n = CONSTRUCTOR_NELTS (t);
1388 type = strip_typedefs (TREE_TYPE (t));
1389 for (i = 0; i < n; ++i)
1391 constructor_elt *e = VEC_index (constructor_elt, vec, i);
1392 tree op = strip_typedefs_expr (e->value);
1398 gcc_checking_assert (e->index == strip_typedefs_expr (e->index));
1401 if (!changed && type == TREE_TYPE (t))
1403 VEC_free (constructor_elt, gc, vec);
1409 TREE_TYPE (r) = type;
1410 CONSTRUCTOR_ELTS (r) = vec;
1422 gcc_assert (EXPR_P (t));
1424 n = TREE_OPERAND_LENGTH (t);
1425 ops = XALLOCAVEC (tree, n);
1426 type = TREE_TYPE (t);
1431 case IMPLICIT_CONV_EXPR:
1432 case DYNAMIC_CAST_EXPR:
1433 case STATIC_CAST_EXPR:
1434 case CONST_CAST_EXPR:
1435 case REINTERPRET_CAST_EXPR:
1438 type = strip_typedefs (type);
1442 for (i = 0; i < n; ++i)
1443 ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i));
1447 /* If nothing changed, return t. */
1448 for (i = 0; i < n; ++i)
1449 if (ops[i] != TREE_OPERAND (t, i))
1451 if (i == n && type == TREE_TYPE (t))
1455 TREE_TYPE (r) = type;
1456 for (i = 0; i < n; ++i)
1457 TREE_OPERAND (r, i) = ops[i];
1461 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1462 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1463 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1464 VIRT indicates whether TYPE is inherited virtually or not.
1465 IGO_PREV points at the previous binfo of the inheritance graph
1466 order chain. The newly copied binfo's TREE_CHAIN forms this
1469 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1470 correct order. That is in the order the bases themselves should be
1473 The BINFO_INHERITANCE of a virtual base class points to the binfo
1474 of the most derived type. ??? We could probably change this so that
1475 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1476 remove a field. They currently can only differ for primary virtual
1480 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1486 /* See if we've already made this virtual base. */
1487 new_binfo = binfo_for_vbase (type, t);
1492 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1493 BINFO_TYPE (new_binfo) = type;
1495 /* Chain it into the inheritance graph. */
1496 TREE_CHAIN (*igo_prev) = new_binfo;
1497 *igo_prev = new_binfo;
1499 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
1504 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1506 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1507 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1509 /* We do not need to copy the accesses, as they are read only. */
1510 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1512 /* Recursively copy base binfos of BINFO. */
1513 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1515 tree new_base_binfo;
1516 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1518 BINFO_VIRTUAL_P (base_binfo));
1520 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1521 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1522 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1526 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1530 /* Push it onto the list after any virtual bases it contains
1531 will have been pushed. */
1532 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1533 BINFO_VIRTUAL_P (new_binfo) = 1;
1534 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1540 /* Hashing of lists so that we don't make duplicates.
1541 The entry point is `list_hash_canon'. */
1543 /* Now here is the hash table. When recording a list, it is added
1544 to the slot whose index is the hash code mod the table size.
1545 Note that the hash table is used for several kinds of lists.
1546 While all these live in the same table, they are completely independent,
1547 and the hash code is computed differently for each of these. */
1549 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1558 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1559 for a node we are thinking about adding). */
1562 list_hash_eq (const void* entry, const void* data)
1564 const_tree const t = (const_tree) entry;
1565 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1567 return (TREE_VALUE (t) == proxy->value
1568 && TREE_PURPOSE (t) == proxy->purpose
1569 && TREE_CHAIN (t) == proxy->chain);
1572 /* Compute a hash code for a list (chain of TREE_LIST nodes
1573 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1574 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1577 list_hash_pieces (tree purpose, tree value, tree chain)
1579 hashval_t hashcode = 0;
1582 hashcode += TREE_HASH (chain);
1585 hashcode += TREE_HASH (value);
1589 hashcode += TREE_HASH (purpose);
1595 /* Hash an already existing TREE_LIST. */
1598 list_hash (const void* p)
1600 const_tree const t = (const_tree) p;
1601 return list_hash_pieces (TREE_PURPOSE (t),
1606 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1607 object for an identical list if one already exists. Otherwise, build a
1608 new one, and record it as the canonical object. */
1611 hash_tree_cons (tree purpose, tree value, tree chain)
1615 struct list_proxy proxy;
1617 /* Hash the list node. */
1618 hashcode = list_hash_pieces (purpose, value, chain);
1619 /* Create a proxy for the TREE_LIST we would like to create. We
1620 don't actually create it so as to avoid creating garbage. */
1621 proxy.purpose = purpose;
1622 proxy.value = value;
1623 proxy.chain = chain;
1624 /* See if it is already in the table. */
1625 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1627 /* If not, create a new node. */
1629 *slot = tree_cons (purpose, value, chain);
1630 return (tree) *slot;
1633 /* Constructor for hashed lists. */
1636 hash_tree_chain (tree value, tree chain)
1638 return hash_tree_cons (NULL_TREE, value, chain);
1642 debug_binfo (tree elem)
1647 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1649 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1650 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1651 debug_tree (BINFO_TYPE (elem));
1652 if (BINFO_VTABLE (elem))
1653 fprintf (stderr, "vtable decl \"%s\"\n",
1654 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1656 fprintf (stderr, "no vtable decl yet\n");
1657 fprintf (stderr, "virtuals:\n");
1658 virtuals = BINFO_VIRTUALS (elem);
1663 tree fndecl = TREE_VALUE (virtuals);
1664 fprintf (stderr, "%s [%ld =? %ld]\n",
1665 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1666 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1668 virtuals = TREE_CHAIN (virtuals);
1672 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1673 the type of the result expression, if known, or NULL_TREE if the
1674 resulting expression is type-dependent. If TEMPLATE_P is true,
1675 NAME is known to be a template because the user explicitly used the
1676 "template" keyword after the "::".
1678 All SCOPE_REFs should be built by use of this function. */
1681 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1684 if (type == error_mark_node
1685 || scope == error_mark_node
1686 || name == error_mark_node)
1687 return error_mark_node;
1688 t = build2 (SCOPE_REF, type, scope, name);
1689 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1690 PTRMEM_OK_P (t) = true;
1692 t = convert_from_reference (t);
1696 /* Returns nonzero if X is an expression for a (possibly overloaded)
1697 function. If "f" is a function or function template, "f", "c->f",
1698 "c.f", "C::f", and "f<int>" will all be considered possibly
1699 overloaded functions. Returns 2 if the function is actually
1700 overloaded, i.e., if it is impossible to know the type of the
1701 function without performing overload resolution. */
1704 is_overloaded_fn (tree x)
1706 /* A baselink is also considered an overloaded function. */
1707 if (TREE_CODE (x) == OFFSET_REF
1708 || TREE_CODE (x) == COMPONENT_REF)
1709 x = TREE_OPERAND (x, 1);
1711 x = BASELINK_FUNCTIONS (x);
1712 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1713 x = TREE_OPERAND (x, 0);
1714 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1715 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1717 return (TREE_CODE (x) == FUNCTION_DECL
1718 || TREE_CODE (x) == OVERLOAD);
1721 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
1722 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
1726 dependent_name (tree x)
1728 if (TREE_CODE (x) == IDENTIFIER_NODE)
1730 if (TREE_CODE (x) != COMPONENT_REF
1731 && TREE_CODE (x) != OFFSET_REF
1732 && TREE_CODE (x) != BASELINK
1733 && is_overloaded_fn (x))
1734 return DECL_NAME (get_first_fn (x));
1738 /* Returns true iff X is an expression for an overloaded function
1739 whose type cannot be known without performing overload
1743 really_overloaded_fn (tree x)
1745 return is_overloaded_fn (x) == 2;
1751 gcc_assert (is_overloaded_fn (from));
1752 /* A baselink is also considered an overloaded function. */
1753 if (TREE_CODE (from) == OFFSET_REF
1754 || TREE_CODE (from) == COMPONENT_REF)
1755 from = TREE_OPERAND (from, 1);
1756 if (BASELINK_P (from))
1757 from = BASELINK_FUNCTIONS (from);
1758 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1759 from = TREE_OPERAND (from, 0);
1764 get_first_fn (tree from)
1766 return OVL_CURRENT (get_fns (from));
1769 /* Return a new OVL node, concatenating it with the old one. */
1772 ovl_cons (tree decl, tree chain)
1774 tree result = make_node (OVERLOAD);
1775 TREE_TYPE (result) = unknown_type_node;
1776 OVL_FUNCTION (result) = decl;
1777 TREE_CHAIN (result) = chain;
1782 /* Build a new overloaded function. If this is the first one,
1783 just return it; otherwise, ovl_cons the _DECLs */
1786 build_overload (tree decl, tree chain)
1788 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1790 return ovl_cons (decl, chain);
1793 /* Return the scope where the overloaded functions OVL were found. */
1796 ovl_scope (tree ovl)
1798 if (TREE_CODE (ovl) == OFFSET_REF
1799 || TREE_CODE (ovl) == COMPONENT_REF)
1800 ovl = TREE_OPERAND (ovl, 1);
1801 if (TREE_CODE (ovl) == BASELINK)
1802 return BINFO_TYPE (BASELINK_BINFO (ovl));
1803 if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
1804 ovl = TREE_OPERAND (ovl, 0);
1805 /* Skip using-declarations. */
1806 while (TREE_CODE (ovl) == OVERLOAD && OVL_USED (ovl) && OVL_CHAIN (ovl))
1807 ovl = OVL_CHAIN (ovl);
1808 return CP_DECL_CONTEXT (OVL_CURRENT (ovl));
1811 /* Return TRUE if FN is a non-static member function, FALSE otherwise.
1812 This function looks into BASELINK and OVERLOAD nodes. */
1815 non_static_member_function_p (tree fn)
1817 if (fn == NULL_TREE)
1820 if (is_overloaded_fn (fn))
1821 fn = get_first_fn (fn);
1824 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn));
1828 #define PRINT_RING_SIZE 4
1831 cxx_printable_name_internal (tree decl, int v, bool translate)
1833 static unsigned int uid_ring[PRINT_RING_SIZE];
1834 static char *print_ring[PRINT_RING_SIZE];
1835 static bool trans_ring[PRINT_RING_SIZE];
1836 static int ring_counter;
1839 /* Only cache functions. */
1841 || TREE_CODE (decl) != FUNCTION_DECL
1842 || DECL_LANG_SPECIFIC (decl) == 0)
1843 return lang_decl_name (decl, v, translate);
1845 /* See if this print name is lying around. */
1846 for (i = 0; i < PRINT_RING_SIZE; i++)
1847 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1848 /* yes, so return it. */
1849 return print_ring[i];
1851 if (++ring_counter == PRINT_RING_SIZE)
1854 if (current_function_decl != NULL_TREE)
1856 /* There may be both translated and untranslated versions of the
1858 for (i = 0; i < 2; i++)
1860 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1862 if (ring_counter == PRINT_RING_SIZE)
1865 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1868 free (print_ring[ring_counter]);
1870 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1871 uid_ring[ring_counter] = DECL_UID (decl);
1872 trans_ring[ring_counter] = translate;
1873 return print_ring[ring_counter];
1877 cxx_printable_name (tree decl, int v)
1879 return cxx_printable_name_internal (decl, v, false);
1883 cxx_printable_name_translate (tree decl, int v)
1885 return cxx_printable_name_internal (decl, v, true);
1888 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1889 listed in RAISES. */
1892 build_exception_variant (tree type, tree raises)
1897 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1900 type_quals = TYPE_QUALS (type);
1901 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1902 if (check_qualified_type (v, type, type_quals)
1903 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1906 /* Need to build a new variant. */
1907 v = build_variant_type_copy (type);
1908 TYPE_RAISES_EXCEPTIONS (v) = raises;
1912 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1913 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1917 bind_template_template_parm (tree t, tree newargs)
1919 tree decl = TYPE_NAME (t);
1922 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1923 decl = build_decl (input_location,
1924 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1926 /* These nodes have to be created to reflect new TYPE_DECL and template
1928 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1929 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1930 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1931 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1933 TREE_TYPE (decl) = t2;
1934 TYPE_NAME (t2) = decl;
1935 TYPE_STUB_DECL (t2) = decl;
1937 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1942 /* Called from count_trees via walk_tree. */
1945 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1955 /* Debugging function for measuring the rough complexity of a tree
1959 count_trees (tree t)
1962 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1966 /* Called from verify_stmt_tree via walk_tree. */
1969 verify_stmt_tree_r (tree* tp,
1970 int* walk_subtrees ATTRIBUTE_UNUSED ,
1974 htab_t *statements = (htab_t *) data;
1977 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1980 /* If this statement is already present in the hash table, then
1981 there is a circularity in the statement tree. */
1982 gcc_assert (!htab_find (*statements, t));
1984 slot = htab_find_slot (*statements, t, INSERT);
1990 /* Debugging function to check that the statement T has not been
1991 corrupted. For now, this function simply checks that T contains no
1995 verify_stmt_tree (tree t)
1998 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1999 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
2000 htab_delete (statements);
2003 /* Check if the type T depends on a type with no linkage and if so, return
2004 it. If RELAXED_P then do not consider a class type declared within
2005 a vague-linkage function to have no linkage. */
2008 no_linkage_check (tree t, bool relaxed_p)
2012 /* There's no point in checking linkage on template functions; we
2013 can't know their complete types. */
2014 if (processing_template_decl)
2017 switch (TREE_CODE (t))
2020 if (TYPE_PTRMEMFUNC_P (t))
2022 /* Lambda types that don't have mangling scope have no linkage. We
2023 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
2024 when we get here from pushtag none of the lambda information is
2025 set up yet, so we want to assume that the lambda has linkage and
2026 fix it up later if not. */
2027 if (CLASSTYPE_LAMBDA_EXPR (t)
2028 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
2032 if (!CLASS_TYPE_P (t))
2036 /* Only treat anonymous types as having no linkage if they're at
2037 namespace scope. This is core issue 966. */
2038 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
2041 for (r = CP_TYPE_CONTEXT (t); ; )
2043 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2044 have linkage, or we might just be in an anonymous namespace.
2045 If we're in a TREE_PUBLIC class, we have linkage. */
2046 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
2047 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
2048 else if (TREE_CODE (r) == FUNCTION_DECL)
2050 if (!relaxed_p || !vague_linkage_p (r))
2053 r = CP_DECL_CONTEXT (r);
2063 case REFERENCE_TYPE:
2064 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2068 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
2072 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
2075 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
2082 for (parm = TYPE_ARG_TYPES (t);
2083 parm && parm != void_list_node;
2084 parm = TREE_CHAIN (parm))
2086 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
2090 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2098 #ifdef GATHER_STATISTICS
2099 extern int depth_reached;
2103 cxx_print_statistics (void)
2105 print_search_statistics ();
2106 print_class_statistics ();
2107 print_template_statistics ();
2108 #ifdef GATHER_STATISTICS
2109 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2114 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2115 (which is an ARRAY_TYPE). This counts only elements of the top
2119 array_type_nelts_top (tree type)
2121 return fold_build2_loc (input_location,
2122 PLUS_EXPR, sizetype,
2123 array_type_nelts (type),
2127 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2128 (which is an ARRAY_TYPE). This one is a recursive count of all
2129 ARRAY_TYPEs that are clumped together. */
2132 array_type_nelts_total (tree type)
2134 tree sz = array_type_nelts_top (type);
2135 type = TREE_TYPE (type);
2136 while (TREE_CODE (type) == ARRAY_TYPE)
2138 tree n = array_type_nelts_top (type);
2139 sz = fold_build2_loc (input_location,
2140 MULT_EXPR, sizetype, sz, n);
2141 type = TREE_TYPE (type);
2146 /* Called from break_out_target_exprs via mapcar. */
2149 bot_manip (tree* tp, int* walk_subtrees, void* data)
2151 splay_tree target_remap = ((splay_tree) data);
2154 if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2156 /* There can't be any TARGET_EXPRs or their slot variables below this
2157 point. But we must make a copy, in case subsequent processing
2158 alters any part of it. For example, during gimplification a cast
2159 of the form (T) &X::f (where "f" is a member function) will lead
2160 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2162 *tp = unshare_expr (t);
2165 if (TREE_CODE (t) == TARGET_EXPR)
2169 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2171 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2172 tf_warning_or_error);
2173 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2174 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2177 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2178 tf_warning_or_error);
2180 TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2181 TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2182 TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2184 /* Map the old variable to the new one. */
2185 splay_tree_insert (target_remap,
2186 (splay_tree_key) TREE_OPERAND (t, 0),
2187 (splay_tree_value) TREE_OPERAND (u, 0));
2189 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
2191 /* Replace the old expression with the new version. */
2193 /* We don't have to go below this point; the recursive call to
2194 break_out_target_exprs will have handled anything below this
2200 /* Make a copy of this node. */
2201 t = copy_tree_r (tp, walk_subtrees, NULL);
2202 if (TREE_CODE (*tp) == CALL_EXPR)
2203 set_flags_from_callee (*tp);
2207 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2208 DATA is really a splay-tree mapping old variables to new
2212 bot_replace (tree* t,
2213 int* walk_subtrees ATTRIBUTE_UNUSED ,
2216 splay_tree target_remap = ((splay_tree) data);
2218 if (TREE_CODE (*t) == VAR_DECL)
2220 splay_tree_node n = splay_tree_lookup (target_remap,
2221 (splay_tree_key) *t);
2223 *t = (tree) n->value;
2225 else if (TREE_CODE (*t) == PARM_DECL
2226 && DECL_NAME (*t) == this_identifier)
2228 /* In an NSDMI we need to replace the 'this' parameter we used for
2229 parsing with the real one for this function. */
2230 *t = current_class_ptr;
2232 else if (TREE_CODE (*t) == CONVERT_EXPR
2233 && CONVERT_EXPR_VBASE_PATH (*t))
2235 /* In an NSDMI build_base_path defers building conversions to virtual
2236 bases, and we handle it here. */
2237 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
2238 VEC(tree,gc) *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
2240 FOR_EACH_VEC_ELT (tree, vbases, i, binfo)
2241 if (BINFO_TYPE (binfo) == basetype)
2243 *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
2244 tf_warning_or_error);
2250 /* When we parse a default argument expression, we may create
2251 temporary variables via TARGET_EXPRs. When we actually use the
2252 default-argument expression, we make a copy of the expression
2253 and replace the temporaries with appropriate local versions. */
2256 break_out_target_exprs (tree t)
2258 static int target_remap_count;
2259 static splay_tree target_remap;
2261 if (!target_remap_count++)
2262 target_remap = splay_tree_new (splay_tree_compare_pointers,
2263 /*splay_tree_delete_key_fn=*/NULL,
2264 /*splay_tree_delete_value_fn=*/NULL);
2265 cp_walk_tree (&t, bot_manip, target_remap, NULL);
2266 cp_walk_tree (&t, bot_replace, target_remap, NULL);
2268 if (!--target_remap_count)
2270 splay_tree_delete (target_remap);
2271 target_remap = NULL;
2277 /* Similar to `build_nt', but for template definitions of dependent
2281 build_min_nt (enum tree_code code, ...)
2288 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2292 t = make_node (code);
2293 length = TREE_CODE_LENGTH (code);
2295 for (i = 0; i < length; i++)
2297 tree x = va_arg (p, tree);
2298 TREE_OPERAND (t, i) = x;
2306 /* Similar to `build', but for template definitions. */
2309 build_min (enum tree_code code, tree tt, ...)
2316 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2320 t = make_node (code);
2321 length = TREE_CODE_LENGTH (code);
2324 for (i = 0; i < length; i++)
2326 tree x = va_arg (p, tree);
2327 TREE_OPERAND (t, i) = x;
2328 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2329 TREE_SIDE_EFFECTS (t) = 1;
2336 /* Similar to `build', but for template definitions of non-dependent
2337 expressions. NON_DEP is the non-dependent expression that has been
2341 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2348 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2350 va_start (p, non_dep);
2352 if (REFERENCE_REF_P (non_dep))
2353 non_dep = TREE_OPERAND (non_dep, 0);
2355 t = make_node (code);
2356 length = TREE_CODE_LENGTH (code);
2357 TREE_TYPE (t) = TREE_TYPE (non_dep);
2358 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2360 for (i = 0; i < length; i++)
2362 tree x = va_arg (p, tree);
2363 TREE_OPERAND (t, i) = x;
2366 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2367 /* This should not be considered a COMPOUND_EXPR, because it
2368 resolves to an overload. */
2369 COMPOUND_EXPR_OVERLOADED (t) = 1;
2372 return convert_from_reference (t);
2375 /* Similar to `build_nt_call_vec', but for template definitions of
2376 non-dependent expressions. NON_DEP is the non-dependent expression
2377 that has been built. */
2380 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
2382 tree t = build_nt_call_vec (fn, argvec);
2383 if (REFERENCE_REF_P (non_dep))
2384 non_dep = TREE_OPERAND (non_dep, 0);
2385 TREE_TYPE (t) = TREE_TYPE (non_dep);
2386 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2387 return convert_from_reference (t);
2391 get_type_decl (tree t)
2393 if (TREE_CODE (t) == TYPE_DECL)
2396 return TYPE_STUB_DECL (t);
2397 gcc_assert (t == error_mark_node);
2401 /* Returns the namespace that contains DECL, whether directly or
2405 decl_namespace_context (tree decl)
2409 if (TREE_CODE (decl) == NAMESPACE_DECL)
2411 else if (TYPE_P (decl))
2412 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2414 decl = CP_DECL_CONTEXT (decl);
2418 /* Returns true if decl is within an anonymous namespace, however deeply
2419 nested, or false otherwise. */
2422 decl_anon_ns_mem_p (const_tree decl)
2426 if (decl == NULL_TREE || decl == error_mark_node)
2428 if (TREE_CODE (decl) == NAMESPACE_DECL
2429 && DECL_NAME (decl) == NULL_TREE)
2431 /* Classes and namespaces inside anonymous namespaces have
2432 TREE_PUBLIC == 0, so we can shortcut the search. */
2433 else if (TYPE_P (decl))
2434 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl)) == 0);
2435 else if (TREE_CODE (decl) == NAMESPACE_DECL)
2436 return (TREE_PUBLIC (decl) == 0);
2438 decl = DECL_CONTEXT (decl);
2442 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2443 CALL_EXPRS. Return whether they are equivalent. */
2446 called_fns_equal (tree t1, tree t2)
2448 /* Core 1321: dependent names are equivalent even if the overload sets
2449 are different. But do compare explicit template arguments. */
2450 tree name1 = dependent_name (t1);
2451 tree name2 = dependent_name (t2);
2454 tree targs1 = NULL_TREE, targs2 = NULL_TREE;
2459 if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
2460 targs1 = TREE_OPERAND (t1, 1);
2461 if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
2462 targs2 = TREE_OPERAND (t2, 1);
2463 return cp_tree_equal (targs1, targs2);
2466 return cp_tree_equal (t1, t2);
2469 /* Return truthvalue of whether T1 is the same tree structure as T2.
2470 Return 1 if they are the same. Return 0 if they are different. */
2473 cp_tree_equal (tree t1, tree t2)
2475 enum tree_code code1, code2;
2482 for (code1 = TREE_CODE (t1);
2483 CONVERT_EXPR_CODE_P (code1)
2484 || code1 == NON_LVALUE_EXPR;
2485 code1 = TREE_CODE (t1))
2486 t1 = TREE_OPERAND (t1, 0);
2487 for (code2 = TREE_CODE (t2);
2488 CONVERT_EXPR_CODE_P (code2)
2489 || code1 == NON_LVALUE_EXPR;
2490 code2 = TREE_CODE (t2))
2491 t2 = TREE_OPERAND (t2, 0);
2493 /* They might have become equal now. */
2503 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2504 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2507 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2510 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2511 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2512 TREE_STRING_LENGTH (t1));
2515 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2516 TREE_FIXED_CST (t2));
2519 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2520 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2523 /* We need to do this when determining whether or not two
2524 non-type pointer to member function template arguments
2526 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2527 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2532 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2534 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2535 if (!cp_tree_equal (field, elt2->index)
2536 || !cp_tree_equal (value, elt2->value))
2543 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2545 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2547 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2550 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2555 call_expr_arg_iterator iter1, iter2;
2556 if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2558 for (arg1 = first_call_expr_arg (t1, &iter1),
2559 arg2 = first_call_expr_arg (t2, &iter2);
2561 arg1 = next_call_expr_arg (&iter1),
2562 arg2 = next_call_expr_arg (&iter2))
2563 if (!cp_tree_equal (arg1, arg2))
2572 tree o1 = TREE_OPERAND (t1, 0);
2573 tree o2 = TREE_OPERAND (t2, 0);
2575 /* Special case: if either target is an unallocated VAR_DECL,
2576 it means that it's going to be unified with whatever the
2577 TARGET_EXPR is really supposed to initialize, so treat it
2578 as being equivalent to anything. */
2579 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2580 && !DECL_RTL_SET_P (o1))
2582 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2583 && !DECL_RTL_SET_P (o2))
2585 else if (!cp_tree_equal (o1, o2))
2588 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2591 case WITH_CLEANUP_EXPR:
2592 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2594 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2597 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2599 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2602 /* For comparing uses of parameters in late-specified return types
2603 with an out-of-class definition of the function, but can also come
2604 up for expressions that involve 'this' in a member function
2607 if (comparing_specializations)
2608 /* When comparing hash table entries, only an exact match is
2609 good enough; we don't want to replace 'this' with the
2610 version from another function. */
2613 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2615 if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2617 if (DECL_ARTIFICIAL (t1)
2618 || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2619 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2629 case IDENTIFIER_NODE:
2634 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2635 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2636 && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
2637 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2638 BASELINK_FUNCTIONS (t2)));
2640 case TEMPLATE_PARM_INDEX:
2641 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2642 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2643 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2644 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2645 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2646 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2648 case TEMPLATE_ID_EXPR:
2649 return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2650 && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2655 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2657 for (ix = TREE_VEC_LENGTH (t1); ix--;)
2658 if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
2659 TREE_VEC_ELT (t2, ix)))
2667 tree o1 = TREE_OPERAND (t1, 0);
2668 tree o2 = TREE_OPERAND (t2, 0);
2670 if (TREE_CODE (o1) != TREE_CODE (o2))
2673 return same_type_p (o1, o2);
2675 return cp_tree_equal (o1, o2);
2680 tree t1_op1, t2_op1;
2682 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2685 t1_op1 = TREE_OPERAND (t1, 1);
2686 t2_op1 = TREE_OPERAND (t2, 1);
2687 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2690 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2694 /* Two pointer-to-members are the same if they point to the same
2695 field or function in the same class. */
2696 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2699 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2702 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2704 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2707 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2709 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2710 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2713 case STATIC_CAST_EXPR:
2714 case REINTERPRET_CAST_EXPR:
2715 case CONST_CAST_EXPR:
2716 case DYNAMIC_CAST_EXPR:
2717 case IMPLICIT_CONV_EXPR:
2719 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2721 /* Now compare operands as usual. */
2724 case DEFERRED_NOEXCEPT:
2725 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2726 DEFERRED_NOEXCEPT_PATTERN (t2))
2727 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2728 DEFERRED_NOEXCEPT_ARGS (t2)));
2735 switch (TREE_CODE_CLASS (code1))
2739 case tcc_comparison:
2740 case tcc_expression:
2747 n = cp_tree_operand_length (t1);
2748 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2749 && n != TREE_OPERAND_LENGTH (t2))
2752 for (i = 0; i < n; ++i)
2753 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2760 return same_type_p (t1, t2);
2764 /* We can get here with --disable-checking. */
2768 /* The type of ARG when used as an lvalue. */
2771 lvalue_type (tree arg)
2773 tree type = TREE_TYPE (arg);
2777 /* The type of ARG for printing error messages; denote lvalues with
2781 error_type (tree arg)
2783 tree type = TREE_TYPE (arg);
2785 if (TREE_CODE (type) == ARRAY_TYPE)
2787 else if (TREE_CODE (type) == ERROR_MARK)
2789 else if (real_lvalue_p (arg))
2790 type = build_reference_type (lvalue_type (arg));
2791 else if (MAYBE_CLASS_TYPE_P (type))
2792 type = lvalue_type (arg);
2797 /* Does FUNCTION use a variable-length argument list? */
2800 varargs_function_p (const_tree function)
2802 return stdarg_p (TREE_TYPE (function));
2805 /* Returns 1 if decl is a member of a class. */
2808 member_p (const_tree decl)
2810 const_tree const ctx = DECL_CONTEXT (decl);
2811 return (ctx && TYPE_P (ctx));
2814 /* Create a placeholder for member access where we don't actually have an
2815 object that the access is against. */
2818 build_dummy_object (tree type)
2820 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2821 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2824 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2825 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2826 binfo path from current_class_type to TYPE, or 0. */
2829 maybe_dummy_object (tree type, tree* binfop)
2833 tree current = current_nonlambda_class_type ();
2836 && (binfo = lookup_base (current, type, ba_any, NULL)))
2840 /* Reference from a nested class member function. */
2842 binfo = TYPE_BINFO (type);
2848 if (current_class_ref
2849 /* current_class_ref might not correspond to current_class_type if
2850 we're in tsubst_default_argument or a lambda-declarator; in either
2851 case, we want to use current_class_ref if it matches CONTEXT. */
2852 && (same_type_ignoring_top_level_qualifiers_p
2853 (TREE_TYPE (current_class_ref), context)))
2854 decl = current_class_ref;
2855 else if (current != current_class_type
2856 && context == nonlambda_method_basetype ())
2857 /* In a lambda, need to go through 'this' capture. */
2858 decl = (build_x_indirect_ref
2859 ((lambda_expr_this_capture
2860 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2861 RO_NULL, tf_warning_or_error));
2863 decl = build_dummy_object (context);
2868 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2871 is_dummy_object (const_tree ob)
2873 if (TREE_CODE (ob) == INDIRECT_REF)
2874 ob = TREE_OPERAND (ob, 0);
2875 return (TREE_CODE (ob) == NOP_EXPR
2876 && TREE_OPERAND (ob, 0) == void_zero_node);
2879 /* Returns 1 iff type T is something we want to treat as a scalar type for
2880 the purpose of deciding whether it is trivial/POD/standard-layout. */
2883 scalarish_type_p (const_tree t)
2885 if (t == error_mark_node)
2888 return (SCALAR_TYPE_P (t)
2889 || TREE_CODE (t) == VECTOR_TYPE);
2892 /* Returns true iff T requires non-trivial default initialization. */
2895 type_has_nontrivial_default_init (const_tree t)
2897 t = strip_array_types (CONST_CAST_TREE (t));
2899 if (CLASS_TYPE_P (t))
2900 return TYPE_HAS_COMPLEX_DFLT (t);
2905 /* Returns true iff copying an object of type T (including via move
2906 constructor) is non-trivial. That is, T has no non-trivial copy
2907 constructors and no non-trivial move constructors. */
2910 type_has_nontrivial_copy_init (const_tree t)
2912 t = strip_array_types (CONST_CAST_TREE (t));
2914 if (CLASS_TYPE_P (t))
2916 gcc_assert (COMPLETE_TYPE_P (t));
2917 return ((TYPE_HAS_COPY_CTOR (t)
2918 && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2919 || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2925 /* Returns 1 iff type T is a trivially copyable type, as defined in
2926 [basic.types] and [class]. */
2929 trivially_copyable_p (const_tree t)
2931 t = strip_array_types (CONST_CAST_TREE (t));
2933 if (CLASS_TYPE_P (t))
2934 return ((!TYPE_HAS_COPY_CTOR (t)
2935 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2936 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2937 && (!TYPE_HAS_COPY_ASSIGN (t)
2938 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2939 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2940 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2942 return scalarish_type_p (t);
2945 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2949 trivial_type_p (const_tree t)
2951 t = strip_array_types (CONST_CAST_TREE (t));
2953 if (CLASS_TYPE_P (t))
2954 return (TYPE_HAS_TRIVIAL_DFLT (t)
2955 && trivially_copyable_p (t));
2957 return scalarish_type_p (t);
2960 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2963 pod_type_p (const_tree t)
2965 /* This CONST_CAST is okay because strip_array_types returns its
2966 argument unmodified and we assign it to a const_tree. */
2967 t = strip_array_types (CONST_CAST_TREE(t));
2969 if (!CLASS_TYPE_P (t))
2970 return scalarish_type_p (t);
2971 else if (cxx_dialect > cxx98)
2972 /* [class]/10: A POD struct is a class that is both a trivial class and a
2973 standard-layout class, and has no non-static data members of type
2974 non-POD struct, non-POD union (or array of such types).
2976 We don't need to check individual members because if a member is
2977 non-std-layout or non-trivial, the class will be too. */
2978 return (std_layout_type_p (t) && trivial_type_p (t));
2980 /* The C++98 definition of POD is different. */
2981 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2984 /* Returns true iff T is POD for the purpose of layout, as defined in the
2988 layout_pod_type_p (const_tree t)
2990 t = strip_array_types (CONST_CAST_TREE (t));
2992 if (CLASS_TYPE_P (t))
2993 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2995 return scalarish_type_p (t);
2998 /* Returns true iff T is a standard-layout type, as defined in
3002 std_layout_type_p (const_tree t)
3004 t = strip_array_types (CONST_CAST_TREE (t));
3006 if (CLASS_TYPE_P (t))
3007 return !CLASSTYPE_NON_STD_LAYOUT (t);
3009 return scalarish_type_p (t);
3012 /* Nonzero iff type T is a class template implicit specialization. */
3015 class_tmpl_impl_spec_p (const_tree t)
3017 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
3020 /* Returns 1 iff zero initialization of type T means actually storing
3024 zero_init_p (const_tree t)
3026 /* This CONST_CAST is okay because strip_array_types returns its
3027 argument unmodified and we assign it to a const_tree. */
3028 t = strip_array_types (CONST_CAST_TREE(t));
3030 if (t == error_mark_node)
3033 /* NULL pointers to data members are initialized with -1. */
3034 if (TYPE_PTRMEM_P (t))
3037 /* Classes that contain types that can't be zero-initialized, cannot
3038 be zero-initialized themselves. */
3039 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
3045 /* Table of valid C++ attributes. */
3046 const struct attribute_spec cxx_attribute_table[] =
3048 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3049 affects_type_identity } */
3050 { "java_interface", 0, 0, false, false, false,
3051 handle_java_interface_attribute, false },
3052 { "com_interface", 0, 0, false, false, false,
3053 handle_com_interface_attribute, false },
3054 { "init_priority", 1, 1, true, false, false,
3055 handle_init_priority_attribute, false },
3056 { NULL, 0, 0, false, false, false, NULL, false }
3059 /* Handle a "java_interface" attribute; arguments as in
3060 struct attribute_spec.handler. */
3062 handle_java_interface_attribute (tree* node,
3064 tree args ATTRIBUTE_UNUSED ,
3069 || !CLASS_TYPE_P (*node)
3070 || !TYPE_FOR_JAVA (*node))
3072 error ("%qE attribute can only be applied to Java class definitions",
3074 *no_add_attrs = true;
3077 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3078 *node = build_variant_type_copy (*node);
3079 TYPE_JAVA_INTERFACE (*node) = 1;
3084 /* Handle a "com_interface" attribute; arguments as in
3085 struct attribute_spec.handler. */
3087 handle_com_interface_attribute (tree* node,
3089 tree args ATTRIBUTE_UNUSED ,
3090 int flags ATTRIBUTE_UNUSED ,
3095 *no_add_attrs = true;
3098 || !CLASS_TYPE_P (*node)
3099 || *node != TYPE_MAIN_VARIANT (*node))
3101 warning (OPT_Wattributes, "%qE attribute can only be applied "
3102 "to class definitions", name);
3107 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
3113 /* Handle an "init_priority" attribute; arguments as in
3114 struct attribute_spec.handler. */
3116 handle_init_priority_attribute (tree* node,
3119 int flags ATTRIBUTE_UNUSED ,
3122 tree initp_expr = TREE_VALUE (args);
3124 tree type = TREE_TYPE (decl);
3127 STRIP_NOPS (initp_expr);
3129 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
3131 error ("requested init_priority is not an integer constant");
3132 *no_add_attrs = true;
3136 pri = TREE_INT_CST_LOW (initp_expr);
3138 type = strip_array_types (type);
3140 if (decl == NULL_TREE
3141 || TREE_CODE (decl) != VAR_DECL
3142 || !TREE_STATIC (decl)
3143 || DECL_EXTERNAL (decl)
3144 || (TREE_CODE (type) != RECORD_TYPE
3145 && TREE_CODE (type) != UNION_TYPE)
3146 /* Static objects in functions are initialized the
3147 first time control passes through that
3148 function. This is not precise enough to pin down an
3149 init_priority value, so don't allow it. */
3150 || current_function_decl)
3152 error ("can only use %qE attribute on file-scope definitions "
3153 "of objects of class type", name);
3154 *no_add_attrs = true;
3158 if (pri > MAX_INIT_PRIORITY || pri <= 0)
3160 error ("requested init_priority is out of range");
3161 *no_add_attrs = true;
3165 /* Check for init_priorities that are reserved for
3166 language and runtime support implementations.*/
3167 if (pri <= MAX_RESERVED_INIT_PRIORITY)
3170 (0, "requested init_priority is reserved for internal use");
3173 if (SUPPORTS_INIT_PRIORITY)
3175 SET_DECL_INIT_PRIORITY (decl, pri);
3176 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
3181 error ("%qE attribute is not supported on this platform", name);
3182 *no_add_attrs = true;
3187 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
3188 thing pointed to by the constant. */
3191 make_ptrmem_cst (tree type, tree member)
3193 tree ptrmem_cst = make_node (PTRMEM_CST);
3194 TREE_TYPE (ptrmem_cst) = type;
3195 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
3199 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
3200 return an existing type if an appropriate type already exists. */
3203 cp_build_type_attribute_variant (tree type, tree attributes)
3207 new_type = build_type_attribute_variant (type, attributes);
3208 if (TREE_CODE (new_type) == FUNCTION_TYPE
3209 || TREE_CODE (new_type) == METHOD_TYPE)
3210 new_type = build_exception_variant (new_type,
3211 TYPE_RAISES_EXCEPTIONS (type));
3213 /* Making a new main variant of a class type is broken. */
3214 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
3219 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3220 Called only after doing all language independent checks. Only
3221 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3222 compared in type_hash_eq. */
3225 cxx_type_hash_eq (const_tree typea, const_tree typeb)
3227 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
3228 || TREE_CODE (typea) == METHOD_TYPE);
3230 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
3231 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
3234 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3235 traversal. Called from walk_tree. */
3238 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
3239 void *data, struct pointer_set_t *pset)
3241 enum tree_code code = TREE_CODE (*tp);
3244 #define WALK_SUBTREE(NODE) \
3247 result = cp_walk_tree (&(NODE), func, data, pset); \
3248 if (result) goto out; \
3252 /* Not one of the easy cases. We must explicitly go through the
3258 case TEMPLATE_TEMPLATE_PARM:
3259 case BOUND_TEMPLATE_TEMPLATE_PARM:
3260 case UNBOUND_CLASS_TEMPLATE:
3261 case TEMPLATE_PARM_INDEX:
3262 case TEMPLATE_TYPE_PARM:
3265 case UNDERLYING_TYPE:
3266 /* None of these have subtrees other than those already walked
3268 *walk_subtrees_p = 0;
3272 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
3273 *walk_subtrees_p = 0;
3277 WALK_SUBTREE (TREE_TYPE (*tp));
3278 *walk_subtrees_p = 0;
3282 WALK_SUBTREE (TREE_PURPOSE (*tp));
3286 WALK_SUBTREE (OVL_FUNCTION (*tp));
3287 WALK_SUBTREE (OVL_CHAIN (*tp));
3288 *walk_subtrees_p = 0;
3292 WALK_SUBTREE (DECL_NAME (*tp));
3293 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
3294 WALK_SUBTREE (USING_DECL_DECLS (*tp));
3295 *walk_subtrees_p = 0;
3299 if (TYPE_PTRMEMFUNC_P (*tp))
3300 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
3303 case TYPE_ARGUMENT_PACK:
3304 case NONTYPE_ARGUMENT_PACK:
3306 tree args = ARGUMENT_PACK_ARGS (*tp);
3307 int i, len = TREE_VEC_LENGTH (args);
3308 for (i = 0; i < len; i++)
3309 WALK_SUBTREE (TREE_VEC_ELT (args, i));
3313 case TYPE_PACK_EXPANSION:
3314 WALK_SUBTREE (TREE_TYPE (*tp));
3315 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3316 *walk_subtrees_p = 0;
3319 case EXPR_PACK_EXPANSION:
3320 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
3321 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3322 *walk_subtrees_p = 0;
3326 case REINTERPRET_CAST_EXPR:
3327 case STATIC_CAST_EXPR:
3328 case CONST_CAST_EXPR:
3329 case DYNAMIC_CAST_EXPR:
3330 case IMPLICIT_CONV_EXPR:
3331 if (TREE_TYPE (*tp))
3332 WALK_SUBTREE (TREE_TYPE (*tp));
3336 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
3337 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3339 *walk_subtrees_p = 0;
3343 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3344 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3345 *walk_subtrees_p = 0;
3349 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3350 *walk_subtrees_p = 0;
3358 /* We didn't find what we were looking for. */
3365 /* Like save_expr, but for C++. */
3368 cp_save_expr (tree expr)
3370 /* There is no reason to create a SAVE_EXPR within a template; if
3371 needed, we can create the SAVE_EXPR when instantiating the
3372 template. Furthermore, the middle-end cannot handle C++-specific
3374 if (processing_template_decl)
3376 return save_expr (expr);
3379 /* Initialize tree.c. */
3384 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3387 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3388 is. Note that sfk_none is zero, so this function can be used as a
3389 predicate to test whether or not DECL is a special function. */
3391 special_function_kind
3392 special_function_p (const_tree decl)
3394 /* Rather than doing all this stuff with magic names, we should
3395 probably have a field of type `special_function_kind' in
3396 DECL_LANG_SPECIFIC. */
3397 if (DECL_COPY_CONSTRUCTOR_P (decl))
3398 return sfk_copy_constructor;
3399 if (DECL_MOVE_CONSTRUCTOR_P (decl))
3400 return sfk_move_constructor;
3401 if (DECL_CONSTRUCTOR_P (decl))
3402 return sfk_constructor;
3403 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3405 if (copy_fn_p (decl))
3406 return sfk_copy_assignment;
3407 if (move_fn_p (decl))
3408 return sfk_move_assignment;
3410 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3411 return sfk_destructor;
3412 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3413 return sfk_complete_destructor;
3414 if (DECL_BASE_DESTRUCTOR_P (decl))
3415 return sfk_base_destructor;
3416 if (DECL_DELETING_DESTRUCTOR_P (decl))
3417 return sfk_deleting_destructor;
3418 if (DECL_CONV_FN_P (decl))
3419 return sfk_conversion;
3424 /* Returns nonzero if TYPE is a character type, including wchar_t. */
3427 char_type_p (tree type)
3429 return (same_type_p (type, char_type_node)
3430 || same_type_p (type, unsigned_char_type_node)
3431 || same_type_p (type, signed_char_type_node)
3432 || same_type_p (type, char16_type_node)
3433 || same_type_p (type, char32_type_node)
3434 || same_type_p (type, wchar_type_node));
3437 /* Returns the kind of linkage associated with the indicated DECL. Th
3438 value returned is as specified by the language standard; it is
3439 independent of implementation details regarding template
3440 instantiation, etc. For example, it is possible that a declaration
3441 to which this function assigns external linkage would not show up
3442 as a global symbol when you run `nm' on the resulting object file. */
3445 decl_linkage (tree decl)
3447 /* This function doesn't attempt to calculate the linkage from first
3448 principles as given in [basic.link]. Instead, it makes use of
3449 the fact that we have already set TREE_PUBLIC appropriately, and
3450 then handles a few special cases. Ideally, we would calculate
3451 linkage first, and then transform that into a concrete
3454 /* Things that don't have names have no linkage. */
3455 if (!DECL_NAME (decl))
3458 /* Fields have no linkage. */
3459 if (TREE_CODE (decl) == FIELD_DECL)
3462 /* Things that are TREE_PUBLIC have external linkage. */
3463 if (TREE_PUBLIC (decl))
3466 if (TREE_CODE (decl) == NAMESPACE_DECL)
3469 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3471 if (TREE_CODE (decl) == CONST_DECL)
3472 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
3474 /* Some things that are not TREE_PUBLIC have external linkage, too.
3475 For example, on targets that don't have weak symbols, we make all
3476 template instantiations have internal linkage (in the object
3477 file), but the symbols should still be treated as having external
3478 linkage from the point of view of the language. */
3479 if ((TREE_CODE (decl) == FUNCTION_DECL
3480 || TREE_CODE (decl) == VAR_DECL)
3481 && DECL_COMDAT (decl))
3484 /* Things in local scope do not have linkage, if they don't have
3486 if (decl_function_context (decl))
3489 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3490 are considered to have external linkage for language purposes. DECLs
3491 really meant to have internal linkage have DECL_THIS_STATIC set. */
3492 if (TREE_CODE (decl) == TYPE_DECL)
3494 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3496 if (!DECL_THIS_STATIC (decl))
3499 /* Static data members and static member functions from classes
3500 in anonymous namespace also don't have TREE_PUBLIC set. */
3501 if (DECL_CLASS_CONTEXT (decl))
3505 /* Everything else has internal linkage. */
3509 /* Returns the storage duration of the object or reference associated with
3510 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
3513 decl_storage_duration (tree decl)
3515 if (TREE_CODE (decl) == PARM_DECL)
3517 if (TREE_CODE (decl) == FUNCTION_DECL)
3519 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3520 if (!TREE_STATIC (decl)
3521 && !DECL_EXTERNAL (decl))
3523 if (DECL_THREAD_LOCAL_P (decl))
3528 /* EXP is an expression that we want to pre-evaluate. Returns (in
3529 *INITP) an expression that will perform the pre-evaluation. The
3530 value returned by this function is a side-effect free expression
3531 equivalent to the pre-evaluated expression. Callers must ensure
3532 that *INITP is evaluated before EXP. */
3535 stabilize_expr (tree exp, tree* initp)
3539 if (!TREE_SIDE_EFFECTS (exp))
3540 init_expr = NULL_TREE;
3541 else if (VOID_TYPE_P (TREE_TYPE (exp)))
3544 return void_zero_node;
3546 /* There are no expressions with REFERENCE_TYPE, but there can be call
3547 arguments with such a type; just treat it as a pointer. */
3548 else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3549 || SCALAR_TYPE_P (TREE_TYPE (exp))
3550 || !lvalue_or_rvalue_with_address_p (exp))
3552 init_expr = get_target_expr (exp);
3553 exp = TARGET_EXPR_SLOT (init_expr);
3557 bool xval = !real_lvalue_p (exp);
3558 exp = cp_build_addr_expr (exp, tf_warning_or_error);
3559 init_expr = get_target_expr (exp);
3560 exp = TARGET_EXPR_SLOT (init_expr);
3561 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3567 gcc_assert (!TREE_SIDE_EFFECTS (exp));
3571 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3572 similar expression ORIG. */
3575 add_stmt_to_compound (tree orig, tree new_expr)
3577 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3579 if (!orig || !TREE_SIDE_EFFECTS (orig))
3581 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3584 /* Like stabilize_expr, but for a call whose arguments we want to
3585 pre-evaluate. CALL is modified in place to use the pre-evaluated
3586 arguments, while, upon return, *INITP contains an expression to
3587 compute the arguments. */
3590 stabilize_call (tree call, tree *initp)
3592 tree inits = NULL_TREE;
3594 int nargs = call_expr_nargs (call);
3596 if (call == error_mark_node || processing_template_decl)
3602 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3604 for (i = 0; i < nargs; i++)
3607 CALL_EXPR_ARG (call, i) =
3608 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3609 inits = add_stmt_to_compound (inits, init);
3615 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3616 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3617 arguments, while, upon return, *INITP contains an expression to
3618 compute the arguments. */
3621 stabilize_aggr_init (tree call, tree *initp)
3623 tree inits = NULL_TREE;
3625 int nargs = aggr_init_expr_nargs (call);
3627 if (call == error_mark_node)
3630 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3632 for (i = 0; i < nargs; i++)
3635 AGGR_INIT_EXPR_ARG (call, i) =
3636 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3637 inits = add_stmt_to_compound (inits, init);
3643 /* Like stabilize_expr, but for an initialization.
3645 If the initialization is for an object of class type, this function
3646 takes care not to introduce additional temporaries.
3648 Returns TRUE iff the expression was successfully pre-evaluated,
3649 i.e., if INIT is now side-effect free, except for, possible, a
3650 single call to a constructor. */
3653 stabilize_init (tree init, tree *initp)
3659 if (t == error_mark_node || processing_template_decl)
3662 if (TREE_CODE (t) == INIT_EXPR
3663 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3664 && TREE_CODE (TREE_OPERAND (t, 1)) != CONSTRUCTOR
3665 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3667 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3671 if (TREE_CODE (t) == INIT_EXPR)
3672 t = TREE_OPERAND (t, 1);
3673 if (TREE_CODE (t) == TARGET_EXPR)
3674 t = TARGET_EXPR_INITIAL (t);
3675 if (TREE_CODE (t) == COMPOUND_EXPR)
3677 if (TREE_CODE (t) == CONSTRUCTOR)
3679 /* Aggregate initialization: stabilize each of the field
3682 constructor_elt *ce;
3684 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (t);
3685 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
3687 tree type = TREE_TYPE (ce->value);
3689 if (TREE_CODE (type) == REFERENCE_TYPE
3690 || SCALAR_TYPE_P (type))
3691 ce->value = stabilize_expr (ce->value, &subinit);
3692 else if (!stabilize_init (ce->value, &subinit))
3694 *initp = add_stmt_to_compound (*initp, subinit);
3699 /* If the initializer is a COND_EXPR, we can't preevaluate
3701 if (TREE_CODE (t) == COND_EXPR)
3704 if (TREE_CODE (t) == CALL_EXPR)
3706 stabilize_call (t, initp);
3710 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3712 stabilize_aggr_init (t, initp);
3716 /* The initialization is being performed via a bitwise copy -- and
3717 the item copied may have side effects. */
3718 return !TREE_SIDE_EFFECTS (init);
3721 /* Like "fold", but should be used whenever we might be processing the
3722 body of a template. */
3725 fold_if_not_in_template (tree expr)
3727 /* In the body of a template, there is never any need to call
3728 "fold". We will call fold later when actually instantiating the
3729 template. Integral constant expressions in templates will be
3730 evaluated via fold_non_dependent_expr, as necessary. */
3731 if (processing_template_decl)
3734 /* Fold C++ front-end specific tree codes. */
3735 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3736 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3741 /* Returns true if a cast to TYPE may appear in an integral constant
3745 cast_valid_in_integral_constant_expression_p (tree type)
3747 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3748 || cxx_dialect >= cxx0x
3749 || dependent_type_p (type)
3750 || type == error_mark_node);
3753 /* Return true if we need to fix linkage information of DECL. */
3756 cp_fix_function_decl_p (tree decl)
3758 /* Skip if DECL is not externally visible. */
3759 if (!TREE_PUBLIC (decl))
3762 /* We need to fix DECL if it a appears to be exported but with no
3763 function body. Thunks do not have CFGs and we may need to
3764 handle them specially later. */
3765 if (!gimple_has_body_p (decl)
3766 && !DECL_THUNK_P (decl)
3767 && !DECL_EXTERNAL (decl))
3769 struct cgraph_node *node = cgraph_get_node (decl);
3771 /* Don't fix same_body aliases. Although they don't have their own
3772 CFG, they share it with what they alias to. */
3773 if (!node || !node->alias
3774 || !VEC_length (ipa_ref_t, node->ref_list.references))
3781 /* Clean the C++ specific parts of the tree T. */
3784 cp_free_lang_data (tree t)
3786 if (TREE_CODE (t) == METHOD_TYPE
3787 || TREE_CODE (t) == FUNCTION_TYPE)
3789 /* Default args are not interesting anymore. */
3790 tree argtypes = TYPE_ARG_TYPES (t);
3793 TREE_PURPOSE (argtypes) = 0;
3794 argtypes = TREE_CHAIN (argtypes);
3797 else if (TREE_CODE (t) == FUNCTION_DECL
3798 && cp_fix_function_decl_p (t))
3800 /* If T is used in this translation unit at all, the definition
3801 must exist somewhere else since we have decided to not emit it
3802 in this TU. So make it an external reference. */
3803 DECL_EXTERNAL (t) = 1;
3804 TREE_STATIC (t) = 0;
3806 if (TREE_CODE (t) == NAMESPACE_DECL)
3808 /* The list of users of a namespace isn't useful for the middle-end
3809 or debug generators. */
3810 DECL_NAMESPACE_USERS (t) = NULL_TREE;
3811 /* Neither do we need the leftover chaining of namespaces
3812 from the binding level. */
3813 DECL_CHAIN (t) = NULL_TREE;
3817 /* Stub for c-common. Please keep in sync with c-decl.c.
3818 FIXME: If address space support is target specific, then this
3819 should be a C target hook. But currently this is not possible,
3820 because this function is called via REGISTER_TARGET_PRAGMAS. */
3822 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3823 addr_space_t as ATTRIBUTE_UNUSED)
3827 /* Return the number of operands in T that we care about for things like
3831 cp_tree_operand_length (const_tree t)
3833 enum tree_code code = TREE_CODE (t);
3837 case PREINCREMENT_EXPR:
3838 case PREDECREMENT_EXPR:
3839 case POSTINCREMENT_EXPR:
3840 case POSTDECREMENT_EXPR:
3846 case EXPR_PACK_EXPANSION:
3850 return TREE_OPERAND_LENGTH (t);
3854 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3855 /* Complain that some language-specific thing hanging off a tree
3856 node has been accessed improperly. */
3859 lang_check_failed (const char* file, int line, const char* function)
3861 internal_error ("lang_* check: failed in %s, at %s:%d",
3862 function, trim_filename (file), line);
3864 #endif /* ENABLE_TREE_CHECKING */
3866 #include "gt-cp-tree.h"