1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 static tree bot_manip PROTO((tree));
33 static tree build_cplus_array_type_1 PROTO((tree, tree));
34 static void list_hash_add PROTO((int, tree));
35 static int list_hash PROTO((tree, tree, tree));
36 static tree list_hash_lookup PROTO((int, tree, tree, tree));
37 static void propagate_binfo_offsets PROTO((tree, tree));
38 static int avoid_overlap PROTO((tree, tree));
39 static cp_lvalue_kind lvalue_p_1 PROTO((tree, int));
40 static tree no_linkage_helper PROTO((tree));
41 static tree build_srcloc PROTO((char *, int));
42 static void mark_list_hash PROTO ((void *));
44 #define CEIL(x,y) (((x) + (y) - 1) / (y))
46 /* If REF is an lvalue, returns the kind of lvalue that REF is.
47 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
48 non-zero, rvalues of class type are considered lvalues. */
51 lvalue_p_1 (ref, treat_class_rvalues_as_lvalues)
53 int treat_class_rvalues_as_lvalues;
55 cp_lvalue_kind op1_lvalue_kind = clk_none;
56 cp_lvalue_kind op2_lvalue_kind = clk_none;
58 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
61 if (ref == current_class_ptr && flag_this_is_variable <= 0)
64 switch (TREE_CODE (ref))
66 /* preincrements and predecrements are valid lvals, provided
67 what they refer to are valid lvals. */
68 case PREINCREMENT_EXPR:
69 case PREDECREMENT_EXPR:
73 case WITH_CLEANUP_EXPR:
77 return lvalue_p_1 (TREE_OPERAND (ref, 0),
78 treat_class_rvalues_as_lvalues);
81 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
82 treat_class_rvalues_as_lvalues);
84 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
86 && TREE_CODE (TREE_OPERAND (ref, 1)) == FIELD_DECL
87 && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
89 /* Clear the ordinary bit. If this object was a class
90 rvalue we want to preserve that information. */
91 op1_lvalue_kind &= ~clk_ordinary;
92 /* The lvalue is for a btifield. */
93 op1_lvalue_kind |= clk_bitfield;
95 return op1_lvalue_kind;
101 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
102 && DECL_LANG_SPECIFIC (ref)
103 && DECL_IN_AGGR_P (ref))
109 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
113 /* A currently unresolved scope ref. */
115 my_friendly_abort (103);
117 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
122 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
123 treat_class_rvalues_as_lvalues);
124 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
125 treat_class_rvalues_as_lvalues);
129 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
130 treat_class_rvalues_as_lvalues);
131 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
132 treat_class_rvalues_as_lvalues);
139 return lvalue_p_1 (TREE_OPERAND (ref, 1),
140 treat_class_rvalues_as_lvalues);
143 return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
146 return ((treat_class_rvalues_as_lvalues
147 && IS_AGGR_TYPE (TREE_TYPE (ref)))
148 ? clk_class : clk_none);
151 /* All functions (except non-static-member functions) are
153 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
154 ? clk_none : clk_ordinary);
160 /* If one operand is not an lvalue at all, then this expression is
162 if (!op1_lvalue_kind || !op2_lvalue_kind)
165 /* Otherwise, it's an lvalue, and it has all the odd properties
166 contributed by either operand. */
167 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
168 /* It's not an ordinary lvalue if it involves either a bit-field or
170 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
171 op1_lvalue_kind &= ~clk_ordinary;
172 return op1_lvalue_kind;
175 /* If REF is an lvalue, returns the kind of lvalue that REF is.
176 Otherwise, returns clk_none. Lvalues can be assigned, unless they
177 have TREE_READONLY, or unless they are FUNCTION_DECLs. Lvalues can
178 have their address taken, unless they have DECL_REGISTER. */
184 return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/0);
187 /* This differs from real_lvalue_p in that class rvalues are
188 considered lvalues. */
195 (lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/1) != clk_none);
198 /* Return nonzero if REF is an lvalue valid for this language;
199 otherwise, print an error message and return zero. */
202 lvalue_or_else (ref, string)
206 int win = lvalue_p (ref);
208 error ("non-lvalue in %s", string);
212 /* INIT is a CALL_EXPR which needs info about its target.
213 TYPE is the type that this initialization should appear to have.
215 Build an encapsulation of the initialization to perform
216 and return it so that it can be processed by language-independent
217 and language-specific expression expanders. */
220 build_cplus_new (type, init)
228 /* Make sure that we're not trying to create an instance of an
230 abstract_virtuals_error (NULL_TREE, type);
232 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
233 return convert (type, init);
235 slot = build (VAR_DECL, type);
236 DECL_ARTIFICIAL (slot) = 1;
237 layout_decl (slot, 0);
239 /* We split the CALL_EXPR into its function and its arguments here.
240 Then, in expand_expr, we put them back together. The reason for
241 this is that this expression might be a default argument
242 expression. In that case, we need a new temporary every time the
243 expression is used. That's what break_out_target_exprs does; it
244 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
245 temporary slot. Then, expand_expr builds up a call-expression
246 using the new slot. */
247 fn = TREE_OPERAND (init, 0);
248 rval = build (AGGR_INIT_EXPR, type, fn, TREE_OPERAND (init, 1), slot);
249 TREE_SIDE_EFFECTS (rval) = 1;
250 AGGR_INIT_VIA_CTOR_P (rval)
251 = (TREE_CODE (fn) == ADDR_EXPR
252 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
253 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
254 rval = build_target_expr (slot, rval);
259 /* Encapsulate the expression INIT in a TARGET_EXPR. */
262 get_target_expr (init)
268 slot = build (VAR_DECL, TREE_TYPE (init));
269 DECL_ARTIFICIAL (slot) = 1;
270 layout_decl (slot, 0);
271 rval = build_target_expr (slot, init);
276 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
277 these CALL_EXPRs with tree nodes that will perform the cleanups. */
280 break_out_cleanups (exp)
285 if (TREE_CODE (tmp) == CALL_EXPR
286 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
287 return build_cplus_new (TREE_TYPE (tmp), tmp);
289 while (TREE_CODE (tmp) == NOP_EXPR
290 || TREE_CODE (tmp) == CONVERT_EXPR
291 || TREE_CODE (tmp) == NON_LVALUE_EXPR)
293 if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
294 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
296 TREE_OPERAND (tmp, 0)
297 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
298 TREE_OPERAND (tmp, 0));
302 tmp = TREE_OPERAND (tmp, 0);
307 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
308 copies where they are found. Returns a deep copy all nodes transitively
309 containing CALL_EXPRs. */
312 break_out_calls (exp)
315 register tree t1, t2 = NULL_TREE;
316 register enum tree_code code;
317 register int changed = 0;
320 if (exp == NULL_TREE)
323 code = TREE_CODE (exp);
325 if (code == CALL_EXPR)
326 return copy_node (exp);
328 /* Don't try and defeat a save_expr, as it should only be done once. */
329 if (code == SAVE_EXPR)
332 switch (TREE_CODE_CLASS (code))
337 case 'c': /* a constant */
338 case 't': /* a type node */
339 case 'x': /* something random, like an identifier or an ERROR_MARK. */
342 case 'd': /* A decl node */
343 #if 0 /* This is bogus. jason 9/21/94 */
345 t1 = break_out_calls (DECL_INITIAL (exp));
346 if (t1 != DECL_INITIAL (exp))
348 exp = copy_node (exp);
349 DECL_INITIAL (exp) = t1;
354 case 'b': /* A block node */
356 /* Don't know how to handle these correctly yet. Must do a
357 break_out_calls on all DECL_INITIAL values for local variables,
358 and also break_out_calls on all sub-blocks and sub-statements. */
363 case 'e': /* an expression */
364 case 'r': /* a reference */
365 case 's': /* an expression with side effects */
366 for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
368 t1 = break_out_calls (TREE_OPERAND (exp, i));
369 if (t1 != TREE_OPERAND (exp, i))
371 exp = copy_node (exp);
372 TREE_OPERAND (exp, i) = t1;
377 case '<': /* a comparison expression */
378 case '2': /* a binary arithmetic expression */
379 t2 = break_out_calls (TREE_OPERAND (exp, 1));
380 if (t2 != TREE_OPERAND (exp, 1))
382 case '1': /* a unary arithmetic expression */
383 t1 = break_out_calls (TREE_OPERAND (exp, 0));
384 if (t1 != TREE_OPERAND (exp, 0))
388 if (tree_code_length[(int) code] == 1)
389 return build1 (code, TREE_TYPE (exp), t1);
391 return build (code, TREE_TYPE (exp), t1, t2);
398 extern struct obstack *current_obstack;
399 extern struct obstack permanent_obstack, class_obstack;
400 extern struct obstack *saveable_obstack;
401 extern struct obstack *expression_obstack;
403 /* Here is how primitive or already-canonicalized types' hash
404 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
405 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
407 /* Construct, lay out and return the type of methods belonging to class
408 BASETYPE and whose arguments are described by ARGTYPES and whose values
409 are described by RETTYPE. If each type exists already, reuse it. */
412 build_cplus_method_type (basetype, rettype, argtypes)
413 tree basetype, rettype, argtypes;
419 /* Make a node of the sort we want. */
420 t = make_node (METHOD_TYPE);
422 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
423 TREE_TYPE (t) = rettype;
424 ptype = build_pointer_type (basetype);
426 /* The actual arglist for this function includes a "hidden" argument
427 which is "this". Put it into the list of argument types. Make
428 sure that the new argument list is allocated on the same obstack
430 push_obstacks (TYPE_OBSTACK (t), TYPE_OBSTACK (t));
431 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
432 TYPE_ARG_TYPES (t) = argtypes;
433 TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */
436 /* If we already have such a type, use the old one and free this one.
437 Note that it also frees up the above cons cell if found. */
438 hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) +
439 type_hash_list (argtypes);
441 t = type_hash_canon (hashcode, t);
443 if (TYPE_SIZE (t) == 0)
450 build_cplus_array_type_1 (elt_type, index_type)
456 if (elt_type == error_mark_node || index_type == error_mark_node)
457 return error_mark_node;
459 if (processing_template_decl
460 || uses_template_parms (elt_type)
461 || uses_template_parms (index_type))
463 t = make_node (ARRAY_TYPE);
464 TREE_TYPE (t) = elt_type;
465 TYPE_DOMAIN (t) = index_type;
468 t = build_array_type (elt_type, index_type);
470 /* Push these needs up so that initialization takes place
472 TYPE_NEEDS_CONSTRUCTING (t)
473 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
474 TYPE_NEEDS_DESTRUCTOR (t)
475 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
480 build_cplus_array_type (elt_type, index_type)
485 int type_quals = CP_TYPE_QUALS (elt_type);
487 elt_type = TYPE_MAIN_VARIANT (elt_type);
489 t = build_cplus_array_type_1 (elt_type, index_type);
491 if (type_quals != TYPE_UNQUALIFIED)
492 t = cp_build_qualified_type (t, type_quals);
497 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
498 arrays correctly. In particular, if TYPE is an array of T's, and
499 TYPE_QUALS is non-empty, returns an array of qualified T's. If
500 at attempt is made to qualify a type illegally, and COMPLAIN is
501 non-zero, an error is issued. If COMPLAIN is zero, error_mark_node
505 cp_build_qualified_type_real (type, type_quals, complain)
512 if (type == error_mark_node)
515 if (type_quals == TYPE_QUALS (type))
518 /* A restrict-qualified pointer type must be a pointer (or reference)
519 to object or incomplete type. */
520 if ((type_quals & TYPE_QUAL_RESTRICT)
521 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
522 && (!POINTER_TYPE_P (type)
523 || TYPE_PTRMEM_P (type)
524 || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE))
527 cp_error ("`%T' cannot be `restrict'-qualified", type);
529 return error_mark_node;
531 type_quals &= ~TYPE_QUAL_RESTRICT;
534 if (type_quals != TYPE_UNQUALIFIED
535 && TREE_CODE (type) == FUNCTION_TYPE)
538 cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type);
540 return error_mark_node;
541 type_quals = TYPE_UNQUALIFIED;
543 else if (TREE_CODE (type) == ARRAY_TYPE)
545 /* In C++, the qualification really applies to the array element
546 type. Obtain the appropriately qualified element type. */
549 = cp_build_qualified_type_real (TREE_TYPE (type),
553 if (element_type == error_mark_node)
554 return error_mark_node;
556 /* See if we already have an identically qualified type. */
557 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
558 if (CP_TYPE_QUALS (t) == type_quals)
561 /* If we didn't already have it, create it now. */
564 /* Make a new array type, just like the old one, but with the
565 appropriately qualified element type. */
566 t = build_type_copy (type);
567 TREE_TYPE (t) = element_type;
570 /* Even if we already had this variant, we update
571 TYPE_NEEDS_CONSTRUCTING and TYPE_NEEDS_DESTRUCTOR in case
572 they changed since the variant was originally created.
574 This seems hokey; if there is some way to use a previous
575 variant *without* coming through here,
576 TYPE_NEEDS_CONSTRUCTING will never be updated. */
577 TYPE_NEEDS_CONSTRUCTING (t)
578 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
579 TYPE_NEEDS_DESTRUCTOR (t)
580 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
583 else if (TYPE_PTRMEMFUNC_P (type))
585 /* For a pointer-to-member type, we can't just return a
586 cv-qualified version of the RECORD_TYPE. If we do, we
587 haven't change the field that contains the actual pointer to
588 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
591 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
592 t = cp_build_qualified_type_real (t, type_quals, complain);
593 return build_ptrmemfunc_type (t);
596 /* Retrieve (or create) the appropriately qualified variant. */
597 result = build_qualified_type (type, type_quals);
599 /* If this was a pointer-to-method type, and we just made a copy,
600 then we need to clear the cached associated
601 pointer-to-member-function type; it is not valid for the new
604 && TREE_CODE (type) == POINTER_TYPE
605 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
606 TYPE_SET_PTRMEMFUNC_TYPE (result, NULL_TREE);
611 /* Returns the canonical version of TYPE. In other words, if TYPE is
612 a typedef, returns the underlying type. The cv-qualification of
613 the type returned matches the type input; they will always be
617 canonical_type_variant (t)
620 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), CP_TYPE_QUALS (t));
623 /* Add OFFSET to all base types of T.
625 OFFSET, which is a type offset, is number of bytes.
627 Note that we don't have to worry about having two paths to the
628 same base type, since this type owns its association list. */
631 propagate_binfo_offsets (binfo, offset)
635 tree binfos = BINFO_BASETYPES (binfo);
636 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
638 for (i = 0; i < n_baselinks; /* note increment is done in the loop. */)
640 tree base_binfo = TREE_VEC_ELT (binfos, i);
642 if (TREE_VIA_VIRTUAL (base_binfo))
647 tree delta = NULL_TREE;
649 for (j = i+1; j < n_baselinks; j++)
650 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
652 /* The next basetype offset must take into account the space
653 between the classes, not just the size of each class. */
654 delta = size_binop (MINUS_EXPR,
655 BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
656 BINFO_OFFSET (base_binfo));
661 if (BINFO_OFFSET_ZEROP (base_binfo))
662 BINFO_OFFSET (base_binfo) = offset;
664 BINFO_OFFSET (base_binfo)
665 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
667 BINFO_OFFSET (base_binfo) = offset;
670 propagate_binfo_offsets (base_binfo, offset);
672 /* Go to our next class that counts for offset propagation. */
675 offset = size_binop (PLUS_EXPR, offset, delta);
680 /* Makes new binfos for the indirect bases under BINFO, and updates
681 BINFO_OFFSET for them and their bases. */
684 unshare_base_binfos (binfo)
687 tree binfos = BINFO_BASETYPES (binfo);
691 if (binfos == NULL_TREE)
694 /* Now unshare the structure beneath BINFO. */
695 for (j = TREE_VEC_LENGTH (binfos)-1;
698 tree base_binfo = TREE_VEC_ELT (binfos, j);
699 new_binfo = TREE_VEC_ELT (binfos, j)
700 = make_binfo (BINFO_OFFSET (base_binfo),
702 BINFO_VTABLE (base_binfo),
703 BINFO_VIRTUALS (base_binfo));
704 TREE_VIA_PUBLIC (new_binfo) = TREE_VIA_PUBLIC (base_binfo);
705 TREE_VIA_PROTECTED (new_binfo) = TREE_VIA_PROTECTED (base_binfo);
706 TREE_VIA_VIRTUAL (new_binfo) = TREE_VIA_VIRTUAL (base_binfo);
707 BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;
708 unshare_base_binfos (new_binfo);
712 /* Finish the work of layout_record, now taking virtual bases into account.
713 Also compute the actual offsets that our base classes will have.
714 This must be performed after the fields are laid out, since virtual
715 baseclasses must lay down at the end of the record.
717 Returns the maximum number of virtual functions any of the
718 baseclasses provide. */
721 layout_basetypes (rec, max)
725 tree binfos = TYPE_BINFO_BASETYPES (rec);
726 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
730 unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
731 unsigned int desired_align;
733 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
734 register unsigned int const_size = 0;
735 unsigned int nonvirtual_const_size;
737 #ifdef STRUCTURE_SIZE_BOUNDARY
738 /* Packed structures don't need to have minimum size. */
739 if (! TYPE_PACKED (rec))
740 record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
743 /* Get all the virtual base types that this type uses. The
744 TREE_VALUE slot holds the virtual baseclass type. Note that
745 get_vbase_types makes copies of the virtual base BINFOs, so that
746 the vbase_types are unshared. */
747 vbase_types = CLASSTYPE_VBASECLASSES (rec);
749 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
750 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
752 nonvirtual_const_size = const_size;
756 tree basetype = BINFO_TYPE (vbase_types);
759 desired_align = TYPE_ALIGN (basetype);
760 record_align = MAX (record_align, desired_align);
763 offset = integer_zero_node;
766 /* Give each virtual base type the alignment it wants. */
767 const_size = CEIL (const_size, desired_align) * desired_align;
768 offset = size_int (CEIL (const_size, BITS_PER_UNIT));
771 if (CLASSTYPE_VSIZE (basetype) > max)
772 max = CLASSTYPE_VSIZE (basetype);
773 BINFO_OFFSET (vbase_types) = offset;
775 /* Every virtual baseclass takes a least a UNIT, so that we can
776 take it's address and get something different for each base. */
777 const_size += MAX (BITS_PER_UNIT,
778 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype)));
780 vbase_types = TREE_CHAIN (vbase_types);
785 /* Because a virtual base might take a single byte above,
786 we have to re-adjust the total size to make sure it is
787 a multiple of the alignment. */
788 /* Give the whole object the alignment it wants. */
789 const_size = CEIL (const_size, record_align) * record_align;
792 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
793 here, as that is for this class, without any virtual base classes. */
794 TYPE_ALIGN (rec) = record_align;
795 if (const_size != nonvirtual_const_size)
797 TYPE_SIZE (rec) = size_int (const_size);
798 TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec),
799 size_int (BITS_PER_UNIT));
802 /* Now propagate offset information throughout the lattice. */
803 for (i = 0; i < n_baseclasses; i++)
805 register tree base_binfo = TREE_VEC_ELT (binfos, i);
806 register tree basetype = BINFO_TYPE (base_binfo);
807 tree field = TYPE_FIELDS (rec);
809 if (TREE_VIA_VIRTUAL (base_binfo))
812 my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
814 if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
815 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
818 BINFO_OFFSET (base_binfo)
819 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
821 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
822 TYPE_FIELDS (rec) = TREE_CHAIN (field);
825 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
826 vbase_types = TREE_CHAIN (vbase_types))
828 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
829 unshare_base_binfos (vbase_types);
830 propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
834 tree basetype = BINFO_TYPE (vbase_types);
835 if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
836 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
844 /* If the empty base field in DECL overlaps with a base of the same type in
845 NEWDECL, which is either another base field or the first data field of
846 the class, pad the base just before NEWDECL and return 1. Otherwise,
850 avoid_overlap (decl, newdecl)
855 if (newdecl == NULL_TREE
856 || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl)))
859 for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl;
860 field = TREE_CHAIN (field))
863 DECL_SIZE (field) = integer_one_node;
868 /* Returns a list of fields to stand in for the base class subobjects
869 of REC. These fields are later removed by layout_basetypes. */
872 build_base_fields (rec)
875 /* Chain to hold all the new FIELD_DECLs which stand in for base class
877 tree base_decls = NULL_TREE;
878 tree binfos = TYPE_BINFO_BASETYPES (rec);
879 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
881 int i, saw_empty = 0;
882 unsigned int base_align = 0;
884 for (i = 0; i < n_baseclasses; ++i)
886 register tree base_binfo = TREE_VEC_ELT (binfos, i);
887 register tree basetype = BINFO_TYPE (base_binfo);
889 if (TYPE_SIZE (basetype) == 0)
890 /* This error is now reported in xref_tag, thus giving better
891 location information. */
894 if (TREE_VIA_VIRTUAL (base_binfo))
897 decl = build_lang_decl (FIELD_DECL, NULL_TREE, basetype);
898 DECL_ARTIFICIAL (decl) = 1;
899 DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec;
900 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
901 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
902 TREE_CHAIN (decl) = base_decls;
907 /* Brain damage for backwards compatibility. For no good reason,
908 the old layout_basetypes made every base at least as large as
909 the alignment for the bases up to that point, gratuitously
910 wasting space. So we do the same thing here. */
911 base_align = MAX (base_align, DECL_ALIGN (decl));
913 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
916 else if (DECL_SIZE (decl) == integer_zero_node)
920 /* Reverse the list of fields so we allocate the bases in the proper
922 base_decls = nreverse (base_decls);
924 /* In the presence of empty base classes, we run the risk of allocating
925 two objects of the same class on top of one another. Avoid that. */
926 if (flag_new_abi && saw_empty)
927 for (decl = base_decls; decl; decl = TREE_CHAIN (decl))
929 if (DECL_SIZE (decl) == integer_zero_node)
931 /* First step through the following bases until we find
932 an overlap or a non-empty base. */
933 for (nextdecl = TREE_CHAIN (decl); nextdecl;
934 nextdecl = TREE_CHAIN (nextdecl))
936 if (avoid_overlap (decl, nextdecl)
937 || DECL_SIZE (nextdecl) != integer_zero_node)
941 /* If we're still looking, also check against the first
943 for (nextdecl = TYPE_FIELDS (rec);
944 nextdecl && TREE_CODE (nextdecl) != FIELD_DECL;
945 nextdecl = TREE_CHAIN (nextdecl))
947 avoid_overlap (decl, nextdecl);
955 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
958 build_vbase_pointer_fields (rec)
961 /* Chain to hold all the new FIELD_DECLs which point at virtual
963 tree vbase_decls = NULL_TREE;
964 tree binfos = TYPE_BINFO_BASETYPES (rec);
965 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
969 /* Handle basetypes almost like fields, but record their
970 offsets differently. */
972 for (i = 0; i < n_baseclasses; i++)
974 register tree base_binfo = TREE_VEC_ELT (binfos, i);
975 register tree basetype = BINFO_TYPE (base_binfo);
977 if (TYPE_SIZE (basetype) == 0)
978 /* This error is now reported in xref_tag, thus giving better
979 location information. */
982 /* All basetypes are recorded in the association list of the
985 if (TREE_VIA_VIRTUAL (base_binfo))
990 /* The offset for a virtual base class is only used in computing
991 virtual function tables and for initializing virtual base
992 pointers. It is built once `get_vbase_types' is called. */
994 /* If this basetype can come from another vbase pointer
995 without an additional indirection, we will share
996 that pointer. If an indirection is involved, we
997 make our own pointer. */
998 for (j = 0; j < n_baseclasses; j++)
1000 tree other_base_binfo = TREE_VEC_ELT (binfos, j);
1001 if (! TREE_VIA_VIRTUAL (other_base_binfo)
1002 && binfo_member (basetype,
1003 CLASSTYPE_VBASECLASSES (BINFO_TYPE
1008 FORMAT_VBASE_NAME (name, basetype);
1009 decl = build_lang_decl (FIELD_DECL, get_identifier (name),
1010 build_pointer_type (basetype));
1011 /* If you change any of the below, take a look at all the
1012 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
1014 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
1015 DECL_VIRTUAL_P (decl) = 1;
1016 DECL_ARTIFICIAL (decl) = 1;
1017 DECL_FIELD_CONTEXT (decl) = rec;
1018 DECL_CLASS_CONTEXT (decl) = rec;
1019 DECL_FCONTEXT (decl) = basetype;
1020 DECL_SAVED_INSNS (decl) = 0;
1021 DECL_FIELD_SIZE (decl) = 0;
1022 DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
1023 TREE_CHAIN (decl) = vbase_decls;
1024 BINFO_VPTR_FIELD (base_binfo) = decl;
1028 /* The space this decl occupies has already been accounted for. */
1036 /* Hashing of lists so that we don't make duplicates.
1037 The entry point is `list_hash_canon'. */
1039 /* Each hash table slot is a bucket containing a chain
1040 of these structures. */
1044 struct list_hash *next; /* Next structure in the bucket. */
1045 int hashcode; /* Hash code of this list. */
1046 tree list; /* The list recorded here. */
1049 /* Now here is the hash table. When recording a list, it is added
1050 to the slot whose index is the hash code mod the table size.
1051 Note that the hash table is used for several kinds of lists.
1052 While all these live in the same table, they are completely independent,
1053 and the hash code is computed differently for each of these. */
1055 #define TYPE_HASH_SIZE 59
1056 static struct list_hash *list_hash_table[TYPE_HASH_SIZE];
1058 /* Compute a hash code for a list (chain of TREE_LIST nodes
1059 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1060 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1063 list_hash (purpose, value, chain)
1064 tree purpose, value, chain;
1066 register int hashcode = 0;
1069 hashcode += TYPE_HASH (chain);
1072 hashcode += TYPE_HASH (value);
1076 hashcode += TYPE_HASH (purpose);
1082 /* Look in the type hash table for a type isomorphic to TYPE.
1083 If one is found, return it. Otherwise return 0. */
1086 list_hash_lookup (hashcode, purpose, value, chain)
1088 tree purpose, value, chain;
1090 register struct list_hash *h;
1092 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1093 if (h->hashcode == hashcode
1094 && TREE_PURPOSE (h->list) == purpose
1095 && TREE_VALUE (h->list) == value
1096 && TREE_CHAIN (h->list) == chain)
1101 /* Add an entry to the list-hash-table
1102 for a list TYPE whose hash code is HASHCODE. */
1105 list_hash_add (hashcode, list)
1109 register struct list_hash *h;
1111 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
1112 h->hashcode = hashcode;
1114 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1115 list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1118 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1119 object for an identical list if one already exists. Otherwise, build a
1120 new one, and record it as the canonical object. */
1122 /* Set to 1 to debug without canonicalization. Never set by program. */
1124 static int debug_no_list_hash = 0;
1127 hash_tree_cons (purpose, value, chain)
1128 tree purpose, value, chain;
1130 struct obstack *ambient_obstack = current_obstack;
1134 if (! debug_no_list_hash)
1136 hashcode = list_hash (purpose, value, chain);
1137 t = list_hash_lookup (hashcode, purpose, value, chain);
1142 current_obstack = &class_obstack;
1144 t = tree_cons (purpose, value, chain);
1146 /* If this is a new list, record it for later reuse. */
1147 if (! debug_no_list_hash)
1148 list_hash_add (hashcode, t);
1150 current_obstack = ambient_obstack;
1154 /* Constructor for hashed lists. */
1157 hash_tree_chain (value, chain)
1160 return hash_tree_cons (NULL_TREE, value, chain);
1163 /* Similar, but used for concatenating two lists. */
1166 hash_chainon (list1, list2)
1173 if (TREE_CHAIN (list1) == NULL_TREE)
1174 return hash_tree_chain (TREE_VALUE (list1), list2);
1175 return hash_tree_chain (TREE_VALUE (list1),
1176 hash_chainon (TREE_CHAIN (list1), list2));
1179 /* Build an association between TYPE and some parameters:
1181 OFFSET is the offset added to `this' to convert it to a pointer
1184 BINFO is the base binfo to use, if we are deriving from one. This
1185 is necessary, as we want specialized parent binfos from base
1186 classes, so that the VTABLE_NAMEs of bases are for the most derived
1187 type, instead of the simple type.
1189 VTABLE is the virtual function table with which to initialize
1190 sub-objects of type TYPE.
1192 VIRTUALS are the virtual functions sitting in VTABLE. */
1195 make_binfo (offset, binfo, vtable, virtuals)
1197 tree vtable, virtuals;
1199 tree new_binfo = make_tree_vec (7);
1202 if (TREE_CODE (binfo) == TREE_VEC)
1203 type = BINFO_TYPE (binfo);
1207 binfo = CLASS_TYPE_P (type) ? TYPE_BINFO (binfo) : NULL_TREE;
1210 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1211 BINFO_OFFSET (new_binfo) = offset;
1212 BINFO_VTABLE (new_binfo) = vtable;
1213 BINFO_VIRTUALS (new_binfo) = virtuals;
1214 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1216 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1217 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
1221 /* Return the binfo value for ELEM in TYPE. */
1224 binfo_value (elem, type)
1228 if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1229 compiler_error ("base class `%s' ambiguous in binfo_value",
1230 TYPE_NAME_STRING (elem));
1232 return TYPE_BINFO (type);
1233 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1235 return get_binfo (elem, type, 0);
1238 /* Return a reversed copy of the BINFO-chain given by PATH. (If the
1239 BINFO_INHERITANCE_CHAIN points from base classes to derived
1240 classes, it will instead point from derived classes to base
1241 classes.) Returns the first node in the reversed chain. */
1247 register tree prev = NULL_TREE, cur;
1248 push_expression_obstack ();
1249 for (cur = path; cur; cur = BINFO_INHERITANCE_CHAIN (cur))
1251 tree r = copy_node (cur);
1252 BINFO_INHERITANCE_CHAIN (r) = prev;
1263 unsigned HOST_WIDE_INT n;
1266 fprintf (stderr, "type \"%s\"; offset = %ld\n",
1267 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1268 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1269 fprintf (stderr, "vtable type:\n");
1270 debug_tree (BINFO_TYPE (elem));
1271 if (BINFO_VTABLE (elem))
1272 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1274 fprintf (stderr, "no vtable decl yet\n");
1275 fprintf (stderr, "virtuals:\n");
1276 virtuals = BINFO_VIRTUALS (elem);
1278 n = skip_rtti_stuff (&virtuals, BINFO_TYPE (elem));
1282 tree fndecl = TREE_VALUE (virtuals);
1283 fprintf (stderr, "%s [%ld =? %ld]\n",
1284 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1285 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1287 virtuals = TREE_CHAIN (virtuals);
1296 if (TREE_CODE (t) == FUNCTION_DECL)
1298 else if (TREE_CODE (t) == OVERLOAD)
1300 for (i=0; t; t = OVL_CHAIN (t))
1305 my_friendly_abort (359);
1310 is_overloaded_fn (x)
1313 /* A baselink is also considered an overloaded function. */
1314 if (TREE_CODE (x) == OFFSET_REF)
1315 x = TREE_OPERAND (x, 1);
1318 return (TREE_CODE (x) == FUNCTION_DECL
1319 || TREE_CODE (x) == TEMPLATE_ID_EXPR
1320 || DECL_FUNCTION_TEMPLATE_P (x)
1321 || TREE_CODE (x) == OVERLOAD);
1325 really_overloaded_fn (x)
1328 /* A baselink is also considered an overloaded function. */
1329 if (TREE_CODE (x) == OFFSET_REF)
1330 x = TREE_OPERAND (x, 1);
1333 return (TREE_CODE (x) == OVERLOAD
1334 && (TREE_CHAIN (x) != NULL_TREE
1335 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1342 my_friendly_assert (is_overloaded_fn (from), 9);
1343 /* A baselink is also considered an overloaded function. */
1344 if (BASELINK_P (from))
1345 from = TREE_VALUE (from);
1346 return OVL_CURRENT (from);
1349 /* Returns nonzero if T is a ->* or .* expression that refers to a
1356 return (TREE_CODE (t) == OFFSET_REF
1357 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
1360 /* Return a new OVL node, concatenating it with the old one. */
1363 ovl_cons (decl, chain)
1367 tree result = make_node (OVERLOAD);
1368 TREE_TYPE (result) = unknown_type_node;
1369 OVL_FUNCTION (result) = decl;
1370 TREE_CHAIN (result) = chain;
1375 /* Same as ovl_cons, but on the scratch_obstack. */
1378 scratch_ovl_cons (value, chain)
1382 register struct obstack *ambient_obstack = current_obstack;
1383 extern struct obstack *expression_obstack;
1384 current_obstack = expression_obstack;
1385 node = ovl_cons (value, chain);
1386 current_obstack = ambient_obstack;
1390 /* Build a new overloaded function. If this is the first one,
1391 just return it; otherwise, ovl_cons the _DECLs */
1394 build_overload (decl, chain)
1398 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1400 if (chain && TREE_CODE (chain) != OVERLOAD)
1401 chain = ovl_cons (chain, NULL_TREE);
1402 return ovl_cons (decl, chain);
1405 /* True if fn is in ovl. */
1408 ovl_member (fn, ovl)
1412 if (ovl == NULL_TREE)
1414 if (TREE_CODE (ovl) != OVERLOAD)
1416 for (; ovl; ovl = OVL_CHAIN (ovl))
1417 if (OVL_FUNCTION (ovl) == fn)
1423 is_aggr_type_2 (t1, t2)
1426 if (TREE_CODE (t1) != TREE_CODE (t2))
1428 return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1431 #define PRINT_RING_SIZE 4
1434 lang_printable_name (decl, v)
1438 static tree decl_ring[PRINT_RING_SIZE];
1439 static char *print_ring[PRINT_RING_SIZE];
1440 static int ring_counter;
1443 /* Only cache functions. */
1445 || TREE_CODE (decl) != FUNCTION_DECL
1446 || DECL_LANG_SPECIFIC (decl) == 0)
1447 return lang_decl_name (decl, v);
1449 /* See if this print name is lying around. */
1450 for (i = 0; i < PRINT_RING_SIZE; i++)
1451 if (decl_ring[i] == decl)
1452 /* yes, so return it. */
1453 return print_ring[i];
1455 if (++ring_counter == PRINT_RING_SIZE)
1458 if (current_function_decl != NULL_TREE)
1460 if (decl_ring[ring_counter] == current_function_decl)
1462 if (ring_counter == PRINT_RING_SIZE)
1464 if (decl_ring[ring_counter] == current_function_decl)
1465 my_friendly_abort (106);
1468 if (print_ring[ring_counter])
1469 free (print_ring[ring_counter]);
1471 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1472 decl_ring[ring_counter] = decl;
1473 return print_ring[ring_counter];
1476 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1477 listed in RAISES. */
1480 build_exception_variant (type, raises)
1484 tree v = TYPE_MAIN_VARIANT (type);
1485 int type_quals = TYPE_QUALS (type);
1487 for (; v; v = TYPE_NEXT_VARIANT (v))
1488 if (TYPE_QUALS (v) == type_quals
1489 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1492 /* Need to build a new variant. */
1493 v = build_type_copy (type);
1494 TYPE_RAISES_EXCEPTIONS (v) = raises;
1498 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1499 lang_specific field and its corresponding TEMPLATE_DECL node */
1502 copy_template_template_parm (t)
1505 tree template = TYPE_NAME (t);
1508 /* Make sure these end up on the permanent_obstack. */
1509 push_permanent_obstack ();
1511 t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1512 template = copy_node (template);
1513 copy_lang_decl (template);
1517 TREE_TYPE (template) = t2;
1518 TYPE_NAME (t2) = template;
1519 TYPE_STUB_DECL (t2) = template;
1521 /* No need to copy these */
1522 TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1523 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1524 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
1528 /* Walk through the tree structure T, applying func. If func ever returns
1529 non-null, return that value. */
1532 search_tree (t, func)
1534 tree (*func) PROTO((tree));
1536 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1539 enum tree_code code;
1548 /* Handle some common cases up front. */
1549 code = TREE_CODE (t);
1550 if (TREE_CODE_CLASS (code) == '1')
1552 TRY (TREE_OPERAND (t, 0));
1555 else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
1557 TRY (TREE_OPERAND (t, 0));
1558 TRY (TREE_OPERAND (t, 1));
1567 case IDENTIFIER_NODE:
1574 case NAMESPACE_DECL:
1578 TRY (TREE_TYPE (t));
1582 TRY (TREE_TYPE (t));
1583 TRY (TREE_CHAIN (t));
1587 TRY (TREE_PURPOSE (t));
1588 TRY (TREE_VALUE (t));
1589 TRY (TREE_CHAIN (t));
1593 TRY (OVL_FUNCTION (t));
1594 TRY (OVL_CHAIN (t));
1599 int len = TREE_VEC_LENGTH (t);
1603 TRY (TREE_VEC_ELT (t, len));
1614 TRY (TREE_TYPE (t));
1619 case AGGR_INIT_EXPR:
1621 TRY (TREE_OPERAND (t, 0));
1622 TRY (TREE_OPERAND (t, 1));
1623 TRY (TREE_OPERAND (t, 2));
1626 case TRUTH_AND_EXPR:
1628 case TRUTH_XOR_EXPR:
1629 case TRUTH_ANDIF_EXPR:
1630 case TRUTH_ORIF_EXPR:
1631 case PREDECREMENT_EXPR:
1632 case PREINCREMENT_EXPR:
1633 case POSTDECREMENT_EXPR:
1634 case POSTINCREMENT_EXPR:
1637 case TRY_CATCH_EXPR:
1638 case WITH_CLEANUP_EXPR:
1644 TRY (TREE_OPERAND (t, 0));
1645 TRY (TREE_OPERAND (t, 1));
1651 case TRUTH_NOT_EXPR:
1653 case CLEANUP_POINT_EXPR:
1659 TRY (TREE_OPERAND (t, 0));
1666 case PSEUDO_DTOR_EXPR:
1670 TRY (TREE_REALPART (t));
1671 TRY (TREE_IMAGPART (t));
1675 TRY (CONSTRUCTOR_ELTS (t));
1678 case TEMPLATE_TEMPLATE_PARM:
1679 case TEMPLATE_PARM_INDEX:
1680 case TEMPLATE_TYPE_PARM:
1698 case REFERENCE_TYPE:
1699 TRY (TREE_TYPE (t));
1704 TRY (TREE_TYPE (t));
1705 TRY (TYPE_ARG_TYPES (t));
1709 TRY (TREE_TYPE (t));
1710 TRY (TYPE_DOMAIN (t));
1714 TRY (TYPE_MAX_VALUE (t));
1718 TRY (TREE_TYPE (t));
1719 TRY (TYPE_OFFSET_BASETYPE (t));
1723 if (TYPE_PTRMEMFUNC_P (t))
1724 TRY (TYPE_PTRMEMFUNC_FN_TYPE (t));
1728 my_friendly_abort (19990803);
1736 /* Passed to search_tree. Checks for the use of types with no linkage. */
1739 no_linkage_helper (t)
1743 && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1744 && (decl_function_context (TYPE_MAIN_DECL (t))
1745 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
1750 /* Check if the type T depends on a type with no linkage and if so, return
1754 no_linkage_check (t)
1757 /* There's no point in checking linkage on template functions; we
1758 can't know their complete types. */
1759 if (processing_template_decl)
1762 t = search_tree (t, no_linkage_helper);
1763 if (t != error_mark_node)
1769 /* Make copies of all the nodes below T. If FUNC is non-NULL, call it
1775 tree (*func) PROTO((tree));
1778 enum tree_code code;
1790 /* Handle some common cases up front. */
1791 code = TREE_CODE (t);
1792 if (TREE_CODE_CLASS (code) == '1')
1795 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1796 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1799 else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
1802 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1803 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1804 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1808 switch (TREE_CODE (t))
1811 return error_mark_node;
1816 /* Rather than aborting, return error_mark_node. This allows us
1817 to report a sensible error message on code like this:
1819 void g() { int i; f<i>(7); }
1823 void g() { const int i = 7; f<i>(7); }
1825 however, we must actually return the constant initializer. */
1826 if (TREE_READONLY_DECL_P (t))
1828 tmp = decl_constant_value (t);
1830 return mapcar (tmp, func);
1832 return error_mark_node;
1836 tree chain = TREE_CHAIN (t);
1838 TREE_CHAIN (t) = mapcar (chain, func);
1839 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1840 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1841 DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1847 tree chain = TREE_CHAIN (t);
1849 TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1850 TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1851 TREE_CHAIN (t) = mapcar (chain, func);
1857 tree chain = OVL_CHAIN (t);
1859 OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1860 OVL_CHAIN (t) = mapcar (chain, func);
1866 int len = TREE_VEC_LENGTH (t);
1870 TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1877 return copy_node (t);
1881 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1882 PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func);
1887 case AGGR_INIT_EXPR:
1889 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1890 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1891 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1894 case TRUTH_AND_EXPR:
1896 case TRUTH_XOR_EXPR:
1897 case TRUTH_ANDIF_EXPR:
1898 case TRUTH_ORIF_EXPR:
1899 case PREDECREMENT_EXPR:
1900 case PREINCREMENT_EXPR:
1901 case POSTDECREMENT_EXPR:
1902 case POSTINCREMENT_EXPR:
1905 case TRY_CATCH_EXPR:
1906 case WITH_CLEANUP_EXPR:
1912 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1913 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1918 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1919 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1920 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1921 TREE_OPERAND (t, 2) = NULL_TREE;
1927 case TRUTH_NOT_EXPR:
1929 case CLEANUP_POINT_EXPR:
1933 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1934 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1938 tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1939 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1940 case REFERENCE_TYPE:
1941 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1942 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1944 tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1945 mapcar (TYPE_ARG_TYPES (t), func));
1946 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1948 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1949 mapcar (TYPE_DOMAIN (t), func));
1950 return cp_build_qualified_type (tmp, CP_TYPE_QUALS (t));
1952 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1953 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1955 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1956 mapcar (TREE_TYPE (t), func));
1957 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1959 tmp = build_cplus_method_type
1960 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1961 mapcar (TREE_TYPE (t), func),
1962 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1963 return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1967 TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1968 TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1973 CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
1976 case TEMPLATE_TEMPLATE_PARM:
1977 return copy_template_template_parm (t);
1981 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1982 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1983 TREE_OPERAND (t, 2) = NULL_TREE;
1988 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1989 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1990 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1995 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1996 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1997 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1998 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
2005 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2010 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
2014 if (TYPE_PTRMEMFUNC_P (t))
2015 return build_ptrmemfunc_type
2016 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
2017 /* else fall through */
2020 my_friendly_abort (19990815);
2022 my_friendly_abort (107);
2027 #ifdef GATHER_STATISTICS
2028 extern int depth_reached;
2032 print_lang_statistics ()
2034 extern struct obstack decl_obstack;
2035 print_obstack_statistics ("class_obstack", &class_obstack);
2036 print_obstack_statistics ("decl_obstack", &decl_obstack);
2037 print_search_statistics ();
2038 print_class_statistics ();
2039 #ifdef GATHER_STATISTICS
2040 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2045 /* This is used by the `assert' macro. It is provided in libgcc.a,
2046 which `cc' doesn't know how to link. Note that the C++ front-end
2047 no longer actually uses the `assert' macro (instead, it calls
2048 my_friendly_assert). But all of the back-end files still need this. */
2051 __eprintf (string, expression, line, filename)
2053 const char *expression;
2055 const char *filename;
2057 fprintf (stderr, string, expression, line, filename);
2062 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2063 (which is an ARRAY_TYPE). This counts only elements of the top
2067 array_type_nelts_top (type)
2070 return fold (build (PLUS_EXPR, sizetype,
2071 array_type_nelts (type),
2075 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2076 (which is an ARRAY_TYPE). This one is a recursive count of all
2077 ARRAY_TYPEs that are clumped together. */
2080 array_type_nelts_total (type)
2083 tree sz = array_type_nelts_top (type);
2084 type = TREE_TYPE (type);
2085 while (TREE_CODE (type) == ARRAY_TYPE)
2087 tree n = array_type_nelts_top (type);
2088 sz = fold (build (MULT_EXPR, sizetype, sz, n));
2089 type = TREE_TYPE (type);
2099 if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
2101 else if (TREE_CODE (t) == TARGET_EXPR)
2103 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2105 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
2106 return build_cplus_new
2107 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
2110 TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t));
2111 layout_decl (TREE_OPERAND (t, 0), 0);
2114 else if (TREE_CODE (t) == CALL_EXPR)
2115 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2120 /* Actually, we'll just clean out the target exprs for the moment. */
2123 break_out_target_exprs (t)
2126 return mapcar (t, bot_manip);
2129 /* Obstack used for allocating nodes in template function and variable
2132 /* Similar to `build_nt', except we build
2133 on the permanent_obstack, regardless. */
2136 build_min_nt VPROTO((enum tree_code code, ...))
2138 #ifndef ANSI_PROTOTYPES
2139 enum tree_code code;
2141 register struct obstack *ambient_obstack = expression_obstack;
2144 register int length;
2149 #ifndef ANSI_PROTOTYPES
2150 code = va_arg (p, enum tree_code);
2153 expression_obstack = &permanent_obstack;
2155 t = make_node (code);
2156 length = tree_code_length[(int) code];
2157 TREE_COMPLEXITY (t) = lineno;
2159 for (i = 0; i < length; i++)
2161 tree x = va_arg (p, tree);
2162 TREE_OPERAND (t, i) = x;
2166 expression_obstack = ambient_obstack;
2170 /* Similar to `build', except we build
2171 on the permanent_obstack, regardless. */
2174 build_min VPROTO((enum tree_code code, tree tt, ...))
2176 #ifndef ANSI_PROTOTYPES
2177 enum tree_code code;
2180 register struct obstack *ambient_obstack = expression_obstack;
2183 register int length;
2188 #ifndef ANSI_PROTOTYPES
2189 code = va_arg (p, enum tree_code);
2190 tt = va_arg (p, tree);
2193 expression_obstack = &permanent_obstack;
2195 t = make_node (code);
2196 length = tree_code_length[(int) code];
2198 TREE_COMPLEXITY (t) = lineno;
2200 for (i = 0; i < length; i++)
2202 tree x = va_arg (p, tree);
2203 TREE_OPERAND (t, i) = x;
2207 expression_obstack = ambient_obstack;
2211 /* Same as `tree_cons' but make a permanent object. */
2214 min_tree_cons (purpose, value, chain)
2215 tree purpose, value, chain;
2218 register struct obstack *ambient_obstack = current_obstack;
2219 current_obstack = &permanent_obstack;
2221 node = tree_cons (purpose, value, chain);
2223 current_obstack = ambient_obstack;
2231 if (TREE_CODE (t) == TYPE_DECL)
2233 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2234 return TYPE_STUB_DECL (t);
2236 my_friendly_abort (42);
2238 /* Stop compiler from complaining control reaches end of non-void function. */
2243 can_free (obstack, t)
2244 struct obstack *obstack;
2249 if (TREE_CODE (t) == TREE_VEC)
2250 size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2252 my_friendly_abort (42);
2254 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2255 & ~ obstack_alignment_mask (obstack))
2256 if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2263 /* Return first vector element whose BINFO_TYPE is ELEM.
2264 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
2267 vec_binfo_member (elem, vec)
2273 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2274 if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
2275 return TREE_VEC_ELT (vec, i);
2280 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2281 the wrong thing for decl_function_context. Hopefully the uses in the
2282 backend won't matter, since we don't need a static chain for local class
2286 hack_decl_function_context (decl)
2289 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2290 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2291 return decl_function_context (decl);
2294 /* Returns the namespace that contains DECL, whether directly or
2298 decl_namespace_context (decl)
2303 if (TREE_CODE (decl) == NAMESPACE_DECL)
2305 else if (TYPE_P (decl))
2306 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2308 decl = CP_DECL_CONTEXT (decl);
2312 /* Return truthvalue of whether T1 is the same tree structure as T2.
2313 Return 1 if they are the same.
2314 Return 0 if they are understandably different.
2315 Return -1 if either contains tree structure not understood by
2319 cp_tree_equal (t1, t2)
2322 register enum tree_code code1, code2;
2327 if (t1 == 0 || t2 == 0)
2330 code1 = TREE_CODE (t1);
2331 code2 = TREE_CODE (t2);
2333 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2335 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2336 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2338 return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2340 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2341 || code2 == NON_LVALUE_EXPR)
2342 return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2350 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2351 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2354 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2357 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2358 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2359 TREE_STRING_LENGTH (t1));
2362 /* We need to do this when determining whether or not two
2363 non-type pointer to member function template arguments
2365 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2366 /* The first operand is RTL. */
2367 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2369 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2372 cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2375 cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2378 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2381 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2384 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2387 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2390 /* Special case: if either target is an unallocated VAR_DECL,
2391 it means that it's going to be unified with whatever the
2392 TARGET_EXPR is really supposed to initialize, so treat it
2393 as being equivalent to anything. */
2394 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2395 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2396 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2397 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2398 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2399 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2402 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2405 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2407 case WITH_CLEANUP_EXPR:
2408 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2411 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2414 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2415 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2424 case TEMPLATE_PARM_INDEX:
2425 return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2426 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2430 if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2432 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2433 return same_type_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2437 /* Two pointer-to-members are the same if they point to the same
2438 field or function in the same class. */
2439 return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2)
2440 && same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)));
2446 switch (TREE_CODE_CLASS (code1))
2456 for (i=0; i<tree_code_length[(int) code1]; ++i)
2458 cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2468 /* Similar to make_tree_vec, but build on the momentary_obstack.
2469 Thus, these vectors are really and truly temporary. */
2476 push_expression_obstack ();
2477 node = make_tree_vec (len);
2482 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2485 build_ptr_wrapper (ptr)
2488 tree t = make_node (WRAPPER);
2489 WRAPPER_PTR (t) = ptr;
2493 /* Same, but on the expression_obstack. */
2496 build_expr_ptr_wrapper (ptr)
2500 push_expression_obstack ();
2501 t = build_ptr_wrapper (ptr);
2506 /* Build a wrapper around some integer I so we can use it as a tree. */
2509 build_int_wrapper (i)
2512 tree t = make_node (WRAPPER);
2513 WRAPPER_INT (t) = i;
2518 build_srcloc (file, line)
2524 t = make_node (SRCLOC);
2525 SRCLOC_FILE (t) = file;
2526 SRCLOC_LINE (t) = line;
2532 build_srcloc_here ()
2534 return build_srcloc (input_filename, lineno);
2538 push_expression_obstack ()
2540 push_obstacks_nochange ();
2541 current_obstack = expression_obstack;
2544 /* Begin allocating on the permanent obstack. When you're done
2545 allocating there, call pop_obstacks to return to the previous set
2549 push_permanent_obstack ()
2551 push_obstacks_nochange ();
2552 end_temporary_allocation ();
2555 /* The type of ARG when used as an lvalue. */
2561 tree type = TREE_TYPE (arg);
2562 if (TREE_CODE (arg) == OVERLOAD)
2563 type = unknown_type_node;
2567 /* The type of ARG for printing error messages; denote lvalues with
2574 tree type = TREE_TYPE (arg);
2575 if (TREE_CODE (type) == ARRAY_TYPE)
2577 else if (real_lvalue_p (arg))
2578 type = build_reference_type (lvalue_type (arg));
2579 else if (IS_AGGR_TYPE (type))
2580 type = lvalue_type (arg);
2585 /* Does FUNCTION use a variable-length argument list? */
2588 varargs_function_p (function)
2591 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2592 for (; parm; parm = TREE_CHAIN (parm))
2593 if (TREE_VALUE (parm) == void_type_node)
2598 /* Returns 1 if decl is a member of a class. */
2604 tree ctx = DECL_CONTEXT (decl);
2605 return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2608 /* Create a placeholder for member access where we don't actually have an
2609 object that the access is against. */
2612 build_dummy_object (type)
2615 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2616 return build_indirect_ref (decl, NULL_PTR);
2619 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2620 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2621 binfo path from current_class_type to TYPE, or 0. */
2624 maybe_dummy_object (type, binfop)
2630 if (current_class_type
2631 && get_base_distance (type, current_class_type, 0, binfop) != -1)
2632 context = current_class_type;
2635 /* Reference from a nested class member function. */
2638 *binfop = TYPE_BINFO (type);
2641 if (current_class_ref && context == current_class_type)
2642 decl = current_class_ref;
2644 decl = build_dummy_object (context);
2649 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2652 is_dummy_object (ob)
2655 if (TREE_CODE (ob) == INDIRECT_REF)
2656 ob = TREE_OPERAND (ob, 0);
2657 return (TREE_CODE (ob) == NOP_EXPR
2658 && TREE_OPERAND (ob, 0) == void_zero_node);
2661 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2667 while (TREE_CODE (t) == ARRAY_TYPE)
2670 if (INTEGRAL_TYPE_P (t))
2671 return 1; /* integral, character or enumeral type */
2672 if (FLOAT_TYPE_P (t))
2675 return 1; /* pointer to non-member */
2676 if (TYPE_PTRMEM_P (t))
2677 return 1; /* pointer to member object */
2678 if (TYPE_PTRMEMFUNC_P (t))
2679 return 1; /* pointer to member function */
2681 if (! CLASS_TYPE_P (t))
2682 return 0; /* other non-class type (reference or function) */
2683 if (CLASSTYPE_NON_POD_P (t))
2688 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2689 attribute for either declaration DECL or type TYPE and 0 otherwise.
2690 Plugged into valid_lang_attribute. */
2693 cp_valid_lang_attribute (attr_name, attr_args, decl, type)
2695 tree attr_args ATTRIBUTE_UNUSED;
2696 tree decl ATTRIBUTE_UNUSED;
2697 tree type ATTRIBUTE_UNUSED;
2699 if (is_attribute_p ("com_interface", attr_name))
2701 if (! flag_vtable_thunks)
2703 error ("`com_interface' only supported with -fvtable-thunks");
2707 if (attr_args != NULL_TREE
2708 || decl != NULL_TREE
2709 || ! CLASS_TYPE_P (type)
2710 || type != TYPE_MAIN_VARIANT (type))
2712 warning ("`com_interface' attribute can only be applied to class definitions");
2716 CLASSTYPE_COM_INTERFACE (type) = 1;
2719 else if (is_attribute_p ("init_priority", attr_name))
2721 tree initp_expr = (attr_args ? TREE_VALUE (attr_args): NULL_TREE);
2725 STRIP_NOPS (initp_expr);
2727 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2729 error ("requested init_priority is not an integer constant");
2733 pri = TREE_INT_CST_LOW (initp_expr);
2735 while (TREE_CODE (type) == ARRAY_TYPE)
2736 type = TREE_TYPE (type);
2738 if (decl == NULL_TREE
2739 || TREE_CODE (decl) != VAR_DECL
2740 || ! TREE_STATIC (decl)
2741 || DECL_EXTERNAL (decl)
2742 || (TREE_CODE (type) != RECORD_TYPE
2743 && TREE_CODE (type) != UNION_TYPE)
2744 /* Static objects in functions are initialized the
2745 first time control passes through that
2746 function. This is not precise enough to pin down an
2747 init_priority value, so don't allow it. */
2748 || current_function_decl)
2750 error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2754 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2756 error ("requested init_priority is out of range");
2760 /* Check for init_priorities that are reserved for
2761 language and runtime support implementations.*/
2762 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2765 ("requested init_priority is reserved for internal use");
2768 DECL_INIT_PRIORITY (decl) = pri;
2775 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2776 thing pointed to by the constant. */
2779 make_ptrmem_cst (type, member)
2783 tree ptrmem_cst = make_node (PTRMEM_CST);
2784 /* If would seem a great convenience if make_node would set
2785 TREE_CONSTANT for things of class `c', but it does not. */
2786 TREE_CONSTANT (ptrmem_cst) = 1;
2787 TREE_TYPE (ptrmem_cst) = type;
2788 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2792 /* Mark ARG (which is really a list_hash_table **) for GC. */
2795 mark_list_hash (arg)
2798 struct list_hash *lh;
2800 for (lh = * ((struct list_hash **) arg); lh; lh = lh->next)
2801 ggc_mark_tree (lh->list);
2804 /* Initialize tree.c. */
2809 lang_unsave_expr_now = cplus_unsave_expr_now;
2810 ggc_add_root (list_hash_table,
2811 sizeof (list_hash_table) / sizeof (struct list_hash *),
2812 sizeof (struct list_hash *),
2816 /* The C++ version of unsave_expr_now.
2817 See gcc/tree.c:unsave_expr_now for comments. */
2820 cplus_unsave_expr_now (expr)
2826 else if (TREE_CODE (expr) == AGGR_INIT_EXPR)
2828 unsave_expr_now (TREE_OPERAND (expr,0));
2829 if (TREE_OPERAND (expr, 1)
2830 && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
2832 tree exp = TREE_OPERAND (expr, 1);
2835 unsave_expr_now (TREE_VALUE (exp));
2836 exp = TREE_CHAIN (exp);
2839 unsave_expr_now (TREE_OPERAND (expr,2));