1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 1996 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. */
37 extern void compiler_error ();
39 static tree get_identifier_list PROTO((tree));
40 static tree bot_manip PROTO((tree));
41 static tree perm_manip PROTO((tree));
42 static tree build_cplus_array_type_1 PROTO((tree, tree));
43 static void list_hash_add PROTO((int, tree));
44 static int list_hash PROTO((tree, tree, tree));
45 static tree list_hash_lookup PROTO((int, int, int, int, tree, tree,
47 static void propagate_binfo_offsets PROTO((tree, tree));
48 static void unshare_base_binfos PROTO((tree));
49 static int avoid_overlap PROTO((tree, tree));
51 #define CEIL(x,y) (((x) + (y) - 1) / (y))
53 /* Return nonzero if REF is an lvalue valid for this language.
54 Lvalues can be assigned, unless they have TREE_READONLY.
55 Lvalues can have their address taken, unless they have DECL_REGISTER. */
61 if (! language_lvalue_valid (ref))
64 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
67 if (ref == current_class_ptr && flag_this_is_variable <= 0)
70 switch (TREE_CODE (ref))
72 /* preincrements and predecrements are valid lvals, provided
73 what they refer to are valid lvals. */
74 case PREINCREMENT_EXPR:
75 case PREDECREMENT_EXPR:
80 case WITH_CLEANUP_EXPR:
81 return real_lvalue_p (TREE_OPERAND (ref, 0));
87 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
88 && DECL_LANG_SPECIFIC (ref)
89 && DECL_IN_AGGR_P (ref))
96 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
97 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
101 /* A currently unresolved scope ref. */
103 my_friendly_abort (103);
105 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
107 return real_lvalue_p (TREE_OPERAND (ref, 0))
108 && real_lvalue_p (TREE_OPERAND (ref, 1));
112 return (real_lvalue_p (TREE_OPERAND (ref, 1))
113 && real_lvalue_p (TREE_OPERAND (ref, 2)));
119 return real_lvalue_p (TREE_OPERAND (ref, 1));
123 return (real_lvalue_p (TREE_OPERAND (ref, 0))
124 && real_lvalue_p (TREE_OPERAND (ref, 1)));
133 /* This differs from real_lvalue_p in that class rvalues are considered
139 if (! language_lvalue_valid (ref))
142 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
145 if (ref == current_class_ptr && flag_this_is_variable <= 0)
148 switch (TREE_CODE (ref))
150 /* preincrements and predecrements are valid lvals, provided
151 what they refer to are valid lvals. */
152 case PREINCREMENT_EXPR:
153 case PREDECREMENT_EXPR:
160 case WITH_CLEANUP_EXPR:
161 return lvalue_p (TREE_OPERAND (ref, 0));
167 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
168 && DECL_LANG_SPECIFIC (ref)
169 && DECL_IN_AGGR_P (ref))
176 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
177 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
185 if (IS_AGGR_TYPE (TREE_TYPE (ref)))
189 /* A currently unresolved scope ref. */
191 my_friendly_abort (103);
193 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
195 return lvalue_p (TREE_OPERAND (ref, 0))
196 && lvalue_p (TREE_OPERAND (ref, 1));
200 return (lvalue_p (TREE_OPERAND (ref, 1))
201 && lvalue_p (TREE_OPERAND (ref, 2)));
207 return lvalue_p (TREE_OPERAND (ref, 1));
211 return (lvalue_p (TREE_OPERAND (ref, 0))
212 && lvalue_p (TREE_OPERAND (ref, 1)));
221 /* Return nonzero if REF is an lvalue valid for this language;
222 otherwise, print an error message and return zero. */
225 lvalue_or_else (ref, string)
229 int win = lvalue_p (ref);
231 error ("non-lvalue in %s", string);
235 /* INIT is a CALL_EXPR which needs info about its target.
236 TYPE is the type that this initialization should appear to have.
238 Build an encapsulation of the initialization to perform
239 and return it so that it can be processed by language-independent
240 and language-specific expression expanders. */
243 build_cplus_new (type, init)
250 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
253 slot = build (VAR_DECL, type);
254 DECL_ARTIFICIAL (slot) = 1;
255 layout_decl (slot, 0);
256 rval = build (AGGR_INIT_EXPR, type,
257 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
258 TREE_SIDE_EFFECTS (rval) = 1;
259 rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE);
260 TREE_SIDE_EFFECTS (rval) = 1;
265 /* Encapsulate the expression INIT in a TARGET_EXPR. */
268 get_target_expr (init)
274 slot = build (VAR_DECL, TREE_TYPE (init));
275 DECL_ARTIFICIAL (slot) = 1;
276 layout_decl (slot, 0);
277 rval = build (TARGET_EXPR, TREE_TYPE (init), slot, init,
278 NULL_TREE, NULL_TREE);
279 TREE_SIDE_EFFECTS (rval) = 1;
284 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
285 these CALL_EXPRs with tree nodes that will perform the cleanups. */
288 break_out_cleanups (exp)
293 if (TREE_CODE (tmp) == CALL_EXPR
294 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
295 return build_cplus_new (TREE_TYPE (tmp), tmp);
297 while (TREE_CODE (tmp) == NOP_EXPR
298 || TREE_CODE (tmp) == CONVERT_EXPR
299 || TREE_CODE (tmp) == NON_LVALUE_EXPR)
301 if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
302 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
304 TREE_OPERAND (tmp, 0)
305 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
306 TREE_OPERAND (tmp, 0));
310 tmp = TREE_OPERAND (tmp, 0);
315 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
316 copies where they are found. Returns a deep copy all nodes transitively
317 containing CALL_EXPRs. */
320 break_out_calls (exp)
323 register tree t1, t2 = NULL_TREE;
324 register enum tree_code code;
325 register int changed = 0;
328 if (exp == NULL_TREE)
331 code = TREE_CODE (exp);
333 if (code == CALL_EXPR)
334 return copy_node (exp);
336 /* Don't try and defeat a save_expr, as it should only be done once. */
337 if (code == SAVE_EXPR)
340 switch (TREE_CODE_CLASS (code))
345 case 'c': /* a constant */
346 case 't': /* a type node */
347 case 'x': /* something random, like an identifier or an ERROR_MARK. */
350 case 'd': /* A decl node */
351 #if 0 /* This is bogus. jason 9/21/94 */
353 t1 = break_out_calls (DECL_INITIAL (exp));
354 if (t1 != DECL_INITIAL (exp))
356 exp = copy_node (exp);
357 DECL_INITIAL (exp) = t1;
362 case 'b': /* A block node */
364 /* Don't know how to handle these correctly yet. Must do a
365 break_out_calls on all DECL_INITIAL values for local variables,
366 and also break_out_calls on all sub-blocks and sub-statements. */
371 case 'e': /* an expression */
372 case 'r': /* a reference */
373 case 's': /* an expression with side effects */
374 for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
376 t1 = break_out_calls (TREE_OPERAND (exp, i));
377 if (t1 != TREE_OPERAND (exp, i))
379 exp = copy_node (exp);
380 TREE_OPERAND (exp, i) = t1;
385 case '<': /* a comparison expression */
386 case '2': /* a binary arithmetic expression */
387 t2 = break_out_calls (TREE_OPERAND (exp, 1));
388 if (t2 != TREE_OPERAND (exp, 1))
390 case '1': /* a unary arithmetic expression */
391 t1 = break_out_calls (TREE_OPERAND (exp, 0));
392 if (t1 != TREE_OPERAND (exp, 0))
396 if (tree_code_length[(int) code] == 1)
397 return build1 (code, TREE_TYPE (exp), t1);
399 return build (code, TREE_TYPE (exp), t1, t2);
406 extern struct obstack *current_obstack;
407 extern struct obstack permanent_obstack, class_obstack;
408 extern struct obstack *saveable_obstack;
409 extern struct obstack *expression_obstack;
411 /* Here is how primitive or already-canonicalized types' hash
412 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
413 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
415 /* Construct, lay out and return the type of methods belonging to class
416 BASETYPE and whose arguments are described by ARGTYPES and whose values
417 are described by RETTYPE. If each type exists already, reuse it. */
420 build_cplus_method_type (basetype, rettype, argtypes)
421 tree basetype, rettype, argtypes;
427 /* Make a node of the sort we want. */
428 t = make_node (METHOD_TYPE);
430 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
431 TREE_TYPE (t) = rettype;
432 if (IS_SIGNATURE (basetype))
433 ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype),
434 TYPE_READONLY (basetype),
435 TYPE_VOLATILE (basetype));
437 ptype = build_pointer_type (basetype);
439 /* The actual arglist for this function includes a "hidden" argument
440 which is "this". Put it into the list of argument types. */
442 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
443 TYPE_ARG_TYPES (t) = argtypes;
444 TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */
446 /* If we already have such a type, use the old one and free this one.
447 Note that it also frees up the above cons cell if found. */
448 hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
449 t = type_hash_canon (hashcode, t);
451 if (TYPE_SIZE (t) == 0)
458 build_cplus_array_type_1 (elt_type, index_type)
462 register struct obstack *ambient_obstack = current_obstack;
463 register struct obstack *ambient_saveable_obstack = saveable_obstack;
466 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
467 make this permanent too. */
468 if (TREE_PERMANENT (elt_type)
469 && (index_type == 0 || TREE_PERMANENT (index_type)))
471 current_obstack = &permanent_obstack;
472 saveable_obstack = &permanent_obstack;
475 if (processing_template_decl
476 || uses_template_parms (index_type))
478 t = make_node (ARRAY_TYPE);
479 TREE_TYPE (t) = elt_type;
480 TYPE_DOMAIN (t) = index_type;
483 t = build_array_type (elt_type, index_type);
485 /* Push these needs up so that initialization takes place
487 TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
488 TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
489 current_obstack = ambient_obstack;
490 saveable_obstack = ambient_saveable_obstack;
495 build_cplus_array_type (elt_type, index_type)
500 int constp = TYPE_READONLY (elt_type);
501 int volatilep = TYPE_VOLATILE (elt_type);
502 elt_type = TYPE_MAIN_VARIANT (elt_type);
504 t = build_cplus_array_type_1 (elt_type, index_type);
506 if (constp || volatilep)
507 t = cp_build_type_variant (t, constp, volatilep);
512 /* Make a variant type in the proper way for C/C++, propagating qualifiers
513 down to the element type of an array. */
516 cp_build_type_variant (type, constp, volatilep)
518 int constp, volatilep;
520 if (type == error_mark_node)
523 if (TREE_CODE (type) == ARRAY_TYPE)
525 tree real_main_variant = TYPE_MAIN_VARIANT (type);
527 push_obstacks (TYPE_OBSTACK (real_main_variant),
528 TYPE_OBSTACK (real_main_variant));
529 type = build_cplus_array_type_1 (cp_build_type_variant
530 (TREE_TYPE (type), constp, volatilep),
533 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
534 make a copy. (TYPE might have come from the hash table and
535 REAL_MAIN_VARIANT might be in some function's obstack.) */
537 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
539 type = copy_node (type);
540 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
543 TYPE_MAIN_VARIANT (type) = real_main_variant;
547 return build_type_variant (type, constp, volatilep);
550 /* Add OFFSET to all base types of T.
552 OFFSET, which is a type offset, is number of bytes.
554 Note that we don't have to worry about having two paths to the
555 same base type, since this type owns its association list. */
558 propagate_binfo_offsets (binfo, offset)
562 tree binfos = BINFO_BASETYPES (binfo);
563 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
565 for (i = 0; i < n_baselinks; /* note increment is done in the loop. */)
567 tree base_binfo = TREE_VEC_ELT (binfos, i);
569 if (TREE_VIA_VIRTUAL (base_binfo))
574 tree delta = NULL_TREE;
576 for (j = i+1; j < n_baselinks; j++)
577 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
579 /* The next basetype offset must take into account the space
580 between the classes, not just the size of each class. */
581 delta = size_binop (MINUS_EXPR,
582 BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
583 BINFO_OFFSET (base_binfo));
588 if (BINFO_OFFSET_ZEROP (base_binfo))
589 BINFO_OFFSET (base_binfo) = offset;
591 BINFO_OFFSET (base_binfo)
592 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
594 BINFO_OFFSET (base_binfo) = offset;
597 unshare_base_binfos (base_binfo);
599 /* Go to our next class that counts for offset propagation. */
602 offset = size_binop (PLUS_EXPR, offset, delta);
607 /* Makes new binfos for the indirect bases under BASE_BINFO, and updates
608 BINFO_OFFSET for them and their bases. */
611 unshare_base_binfos (base_binfo)
614 if (BINFO_BASETYPES (base_binfo))
616 tree base_binfos = BINFO_BASETYPES (base_binfo);
617 tree chain = NULL_TREE;
620 /* Now unshare the structure beneath BASE_BINFO. */
621 for (j = TREE_VEC_LENGTH (base_binfos)-1;
624 tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
625 if (! TREE_VIA_VIRTUAL (base_base_binfo))
626 TREE_VEC_ELT (base_binfos, j)
627 = make_binfo (BINFO_OFFSET (base_base_binfo),
629 BINFO_VTABLE (base_base_binfo),
630 BINFO_VIRTUALS (base_base_binfo),
632 chain = TREE_VEC_ELT (base_binfos, j);
633 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
634 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
635 BINFO_INHERITANCE_CHAIN (chain) = base_binfo;
638 /* Completely unshare potentially shared data, and
639 update what is ours. */
640 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
644 /* Finish the work of layout_record, now taking virtual bases into account.
645 Also compute the actual offsets that our base classes will have.
646 This must be performed after the fields are laid out, since virtual
647 baseclasses must lay down at the end of the record.
649 Returns the maximum number of virtual functions any of the
650 baseclasses provide. */
653 layout_basetypes (rec, max)
657 tree binfos = TYPE_BINFO_BASETYPES (rec);
658 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
660 /* Get all the virtual base types that this type uses.
661 The TREE_VALUE slot holds the virtual baseclass type. */
662 tree vbase_types = get_vbase_types (rec);
664 unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
665 unsigned int desired_align;
667 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
668 register unsigned int const_size = 0;
669 unsigned int nonvirtual_const_size;
671 #ifdef STRUCTURE_SIZE_BOUNDARY
672 /* Packed structures don't need to have minimum size. */
673 if (! TYPE_PACKED (rec))
674 record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
677 CLASSTYPE_VBASECLASSES (rec) = vbase_types;
679 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
680 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
682 nonvirtual_const_size = const_size;
686 tree basetype = BINFO_TYPE (vbase_types);
689 desired_align = TYPE_ALIGN (basetype);
690 record_align = MAX (record_align, desired_align);
693 offset = integer_zero_node;
696 /* Give each virtual base type the alignment it wants. */
697 const_size = CEIL (const_size, desired_align) * desired_align;
698 offset = size_int (CEIL (const_size, BITS_PER_UNIT));
701 if (CLASSTYPE_VSIZE (basetype) > max)
702 max = CLASSTYPE_VSIZE (basetype);
703 BINFO_OFFSET (vbase_types) = offset;
705 /* Every virtual baseclass takes a least a UNIT, so that we can
706 take it's address and get something different for each base. */
707 const_size += MAX (BITS_PER_UNIT,
708 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype)));
710 vbase_types = TREE_CHAIN (vbase_types);
715 /* Because a virtual base might take a single byte above,
716 we have to re-adjust the total size to make sure it is
717 a multiple of the alignment. */
718 /* Give the whole object the alignment it wants. */
719 const_size = CEIL (const_size, record_align) * record_align;
722 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
723 here, as that is for this class, without any virtual base classes. */
724 TYPE_ALIGN (rec) = record_align;
725 if (const_size != nonvirtual_const_size)
727 TYPE_SIZE (rec) = size_int (const_size);
728 TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec),
729 size_int (BITS_PER_UNIT));
732 /* Now propagate offset information throughout the lattice. */
733 for (i = 0; i < n_baseclasses; i++)
735 register tree base_binfo = TREE_VEC_ELT (binfos, i);
736 register tree basetype = BINFO_TYPE (base_binfo);
737 tree field = TYPE_FIELDS (rec);
739 if (TREE_VIA_VIRTUAL (base_binfo))
742 my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
743 BINFO_OFFSET (base_binfo)
744 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
746 unshare_base_binfos (base_binfo);
747 TYPE_FIELDS (rec) = TREE_CHAIN (field);
750 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
751 vbase_types = TREE_CHAIN (vbase_types))
753 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
754 unshare_base_binfos (vbase_types);
760 /* If the empty base field in DECL overlaps with a base of the same type in
761 NEWDECL, which is either another base field or the first data field of
762 the class, pad the base just before NEWDECL and return 1. Otherwise,
766 avoid_overlap (decl, newdecl)
771 if (newdecl == NULL_TREE
772 || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl)))
775 for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl;
776 field = TREE_CHAIN (field))
779 DECL_SIZE (field) = integer_one_node;
784 /* Returns a list of fields to stand in for the base class subobjects
785 of REC. These fields are later removed by layout_basetypes. */
788 build_base_fields (rec)
791 /* Chain to hold all the new FIELD_DECLs which stand in for base class
793 tree base_decls = NULL_TREE;
794 tree binfos = TYPE_BINFO_BASETYPES (rec);
795 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
797 int i, saw_empty = 0;
798 unsigned int base_align = 0;
800 for (i = 0; i < n_baseclasses; ++i)
802 register tree base_binfo = TREE_VEC_ELT (binfos, i);
803 register tree basetype = BINFO_TYPE (base_binfo);
805 if (TYPE_SIZE (basetype) == 0)
806 /* This error is now reported in xref_tag, thus giving better
807 location information. */
810 if (TREE_VIA_VIRTUAL (base_binfo))
813 decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, basetype);
814 DECL_ARTIFICIAL (decl) = 1;
815 DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec;
816 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
817 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
818 TREE_CHAIN (decl) = base_decls;
823 /* Brain damage for backwards compatibility. For no good reason,
824 the old layout_basetypes made every base at least as large as
825 the alignment for the bases up to that point, gratuitously
826 wasting space. So we do the same thing here. */
827 base_align = MAX (base_align, DECL_ALIGN (decl));
829 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
832 else if (DECL_SIZE (decl) == integer_zero_node)
836 /* Reverse the list of fields so we allocate the bases in the proper
838 base_decls = nreverse (base_decls);
840 /* In the presence of empty base classes, we run the risk of allocating
841 two objects of the same class on top of one another. Avoid that. */
842 if (flag_new_abi && saw_empty)
843 for (decl = base_decls; decl; decl = TREE_CHAIN (decl))
845 if (DECL_SIZE (decl) == integer_zero_node)
847 /* First step through the following bases until we find
848 an overlap or a non-empty base. */
849 for (nextdecl = TREE_CHAIN (decl); nextdecl;
850 nextdecl = TREE_CHAIN (nextdecl))
852 if (avoid_overlap (decl, nextdecl)
853 || DECL_SIZE (nextdecl) != integer_zero_node)
857 /* If we're still looking, also check against the first
859 for (nextdecl = TYPE_FIELDS (rec);
860 nextdecl && TREE_CODE (nextdecl) != FIELD_DECL;
861 nextdecl = TREE_CHAIN (nextdecl))
863 avoid_overlap (decl, nextdecl);
871 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
874 build_vbase_pointer_fields (rec)
877 /* Chain to hold all the new FIELD_DECLs which point at virtual
879 tree vbase_decls = NULL_TREE;
880 tree binfos = TYPE_BINFO_BASETYPES (rec);
881 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
885 /* Handle basetypes almost like fields, but record their
886 offsets differently. */
888 for (i = 0; i < n_baseclasses; i++)
890 register tree base_binfo = TREE_VEC_ELT (binfos, i);
891 register tree basetype = BINFO_TYPE (base_binfo);
893 if (TYPE_SIZE (basetype) == 0)
894 /* This error is now reported in xref_tag, thus giving better
895 location information. */
898 /* All basetypes are recorded in the association list of the
901 if (TREE_VIA_VIRTUAL (base_binfo))
904 char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
905 + sizeof (VBASE_NAME) + 1);
907 /* The offset for a virtual base class is only used in computing
908 virtual function tables and for initializing virtual base
909 pointers. It is built once `get_vbase_types' is called. */
911 /* If this basetype can come from another vbase pointer
912 without an additional indirection, we will share
913 that pointer. If an indirection is involved, we
914 make our own pointer. */
915 for (j = 0; j < n_baseclasses; j++)
917 tree other_base_binfo = TREE_VEC_ELT (binfos, j);
918 if (! TREE_VIA_VIRTUAL (other_base_binfo)
919 && binfo_member (basetype,
920 CLASSTYPE_VBASECLASSES (BINFO_TYPE
925 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
926 decl = build_lang_field_decl (FIELD_DECL, get_identifier (name),
927 build_pointer_type (basetype));
928 /* If you change any of the below, take a look at all the
929 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
931 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
932 DECL_VIRTUAL_P (decl) = 1;
933 DECL_ARTIFICIAL (decl) = 1;
934 DECL_FIELD_CONTEXT (decl) = rec;
935 DECL_CLASS_CONTEXT (decl) = rec;
936 DECL_FCONTEXT (decl) = basetype;
937 DECL_SAVED_INSNS (decl) = NULL_RTX;
938 DECL_FIELD_SIZE (decl) = 0;
939 DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
940 TREE_CHAIN (decl) = vbase_decls;
941 BINFO_VPTR_FIELD (base_binfo) = decl;
945 /* The space this decl occupies has already been accounted for. */
953 /* Hashing of lists so that we don't make duplicates.
954 The entry point is `list_hash_canon'. */
956 /* Each hash table slot is a bucket containing a chain
957 of these structures. */
961 struct list_hash *next; /* Next structure in the bucket. */
962 int hashcode; /* Hash code of this list. */
963 tree list; /* The list recorded here. */
966 /* Now here is the hash table. When recording a list, it is added
967 to the slot whose index is the hash code mod the table size.
968 Note that the hash table is used for several kinds of lists.
969 While all these live in the same table, they are completely independent,
970 and the hash code is computed differently for each of these. */
972 #define TYPE_HASH_SIZE 59
973 static struct list_hash *list_hash_table[TYPE_HASH_SIZE];
975 /* Compute a hash code for a list (chain of TREE_LIST nodes
976 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
977 TREE_COMMON slots), by adding the hash codes of the individual entries. */
980 list_hash (purpose, value, chain)
981 tree purpose, value, chain;
983 register int hashcode = 0;
986 hashcode += TYPE_HASH (chain);
989 hashcode += TYPE_HASH (value);
993 hashcode += TYPE_HASH (purpose);
999 /* Look in the type hash table for a type isomorphic to TYPE.
1000 If one is found, return it. Otherwise return 0. */
1003 list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1004 purpose, value, chain)
1005 int hashcode, via_public, via_virtual, via_protected;
1006 tree purpose, value, chain;
1008 register struct list_hash *h;
1010 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1011 if (h->hashcode == hashcode
1012 && TREE_VIA_VIRTUAL (h->list) == via_virtual
1013 && TREE_VIA_PUBLIC (h->list) == via_public
1014 && TREE_VIA_PROTECTED (h->list) == via_protected
1015 && TREE_PURPOSE (h->list) == purpose
1016 && TREE_VALUE (h->list) == value
1017 && TREE_CHAIN (h->list) == chain)
1022 /* Add an entry to the list-hash-table
1023 for a list TYPE whose hash code is HASHCODE. */
1026 list_hash_add (hashcode, list)
1030 register struct list_hash *h;
1032 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
1033 h->hashcode = hashcode;
1035 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1036 list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1039 /* Given TYPE, and HASHCODE its hash code, return the canonical
1040 object for an identical list if one already exists.
1041 Otherwise, return TYPE, and record it as the canonical object
1042 if it is a permanent object.
1044 To use this function, first create a list of the sort you want.
1045 Then compute its hash code from the fields of the list that
1046 make it different from other similar lists.
1047 Then call this function and use the value.
1048 This function frees the list you pass in if it is a duplicate. */
1050 /* Set to 1 to debug without canonicalization. Never set by program. */
1052 static int debug_no_list_hash = 0;
1055 hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
1056 int via_public, via_virtual, via_protected;
1057 tree purpose, value, chain;
1059 struct obstack *ambient_obstack = current_obstack;
1063 if (! debug_no_list_hash)
1065 hashcode = list_hash (purpose, value, chain);
1066 t = list_hash_lookup (hashcode, via_public, via_protected, via_virtual,
1067 purpose, value, chain);
1072 current_obstack = &class_obstack;
1074 t = tree_cons (purpose, value, chain);
1075 TREE_VIA_PUBLIC (t) = via_public;
1076 TREE_VIA_PROTECTED (t) = via_protected;
1077 TREE_VIA_VIRTUAL (t) = via_virtual;
1079 /* If this is a new list, record it for later reuse. */
1080 if (! debug_no_list_hash)
1081 list_hash_add (hashcode, t);
1083 current_obstack = ambient_obstack;
1087 /* Constructor for hashed lists. */
1090 hash_tree_chain (value, chain)
1093 return hash_tree_cons (0, 0, 0, NULL_TREE, value, chain);
1096 /* Similar, but used for concatenating two lists. */
1099 hash_chainon (list1, list2)
1106 if (TREE_CHAIN (list1) == NULL_TREE)
1107 return hash_tree_chain (TREE_VALUE (list1), list2);
1108 return hash_tree_chain (TREE_VALUE (list1),
1109 hash_chainon (TREE_CHAIN (list1), list2));
1113 get_identifier_list (value)
1116 tree list = IDENTIFIER_AS_LIST (value);
1117 if (list != NULL_TREE
1118 && (TREE_CODE (list) != TREE_LIST
1119 || TREE_VALUE (list) != value))
1121 else if (IDENTIFIER_HAS_TYPE_VALUE (value)
1122 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE
1123 && IDENTIFIER_TYPE_VALUE (value)
1124 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value)))
1126 tree type = IDENTIFIER_TYPE_VALUE (value);
1128 if (TYPE_PTRMEMFUNC_P (type))
1130 else if (type == current_class_type)
1131 /* Don't mess up the constructor name. */
1132 list = tree_cons (NULL_TREE, value, NULL_TREE);
1135 if (! CLASSTYPE_ID_AS_LIST (type))
1136 CLASSTYPE_ID_AS_LIST (type)
1137 = perm_tree_cons (NULL_TREE, TYPE_IDENTIFIER (type), NULL_TREE);
1138 list = CLASSTYPE_ID_AS_LIST (type);
1145 get_decl_list (value)
1148 tree list = NULL_TREE;
1150 if (TREE_CODE (value) == IDENTIFIER_NODE)
1151 list = get_identifier_list (value);
1152 else if (TREE_CODE (value) == RECORD_TYPE
1153 && TYPE_LANG_SPECIFIC (value)
1154 && value == TYPE_MAIN_VARIANT (value))
1155 list = CLASSTYPE_AS_LIST (value);
1157 if (list != NULL_TREE)
1159 my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
1163 return build_decl_list (NULL_TREE, value);
1166 /* Build an association between TYPE and some parameters:
1168 OFFSET is the offset added to `this' to convert it to a pointer
1171 BINFO is the base binfo to use, if we are deriving from one. This
1172 is necessary, as we want specialized parent binfos from base
1173 classes, so that the VTABLE_NAMEs of bases are for the most derived
1174 type, instead of the simple type.
1176 VTABLE is the virtual function table with which to initialize
1177 sub-objects of type TYPE.
1179 VIRTUALS are the virtual functions sitting in VTABLE.
1181 CHAIN are more associations we must retain. */
1184 make_binfo (offset, binfo, vtable, virtuals, chain)
1186 tree vtable, virtuals;
1189 tree new_binfo = make_tree_vec (6);
1192 if (TREE_CODE (binfo) == TREE_VEC)
1193 type = BINFO_TYPE (binfo);
1197 binfo = TYPE_BINFO (binfo);
1200 TREE_CHAIN (new_binfo) = chain;
1202 TREE_USED (new_binfo) = TREE_USED (chain);
1204 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1205 BINFO_OFFSET (new_binfo) = offset;
1206 BINFO_VTABLE (new_binfo) = vtable;
1207 BINFO_VIRTUALS (new_binfo) = virtuals;
1208 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1210 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1211 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
1215 /* Return the binfo value for ELEM in TYPE. */
1218 binfo_value (elem, type)
1222 if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1223 compiler_error ("base class `%s' ambiguous in binfo_value",
1224 TYPE_NAME_STRING (elem));
1226 return TYPE_BINFO (type);
1227 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1229 return get_binfo (elem, type, 0);
1236 register tree prev = 0, tmp, next;
1237 for (tmp = path; tmp; tmp = next)
1239 next = BINFO_INHERITANCE_CHAIN (tmp);
1240 BINFO_INHERITANCE_CHAIN (tmp) = prev;
1250 unsigned HOST_WIDE_INT n;
1253 fprintf (stderr, "type \"%s\"; offset = %ld\n",
1254 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1255 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1256 fprintf (stderr, "vtable type:\n");
1257 debug_tree (BINFO_TYPE (elem));
1258 if (BINFO_VTABLE (elem))
1259 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1261 fprintf (stderr, "no vtable decl yet\n");
1262 fprintf (stderr, "virtuals:\n");
1263 virtuals = BINFO_VIRTUALS (elem);
1265 n = skip_rtti_stuff (&virtuals);
1269 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1270 fprintf (stderr, "%s [%ld =? %ld]\n",
1271 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1272 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1274 virtuals = TREE_CHAIN (virtuals);
1278 /* Initialize an CPLUS_BINDING node that does not live on an obstack. */
1282 struct tree_binding* node;
1284 static struct tree_binding* source;
1287 extern struct obstack permanent_obstack;
1288 push_obstacks (&permanent_obstack, &permanent_obstack);
1289 source = (struct tree_binding*)make_node (CPLUS_BINDING);
1293 TREE_PERMANENT ((tree)node) = 0;
1302 if (TREE_CODE (t) == FUNCTION_DECL)
1304 else if (TREE_CODE (t) == OVERLOAD)
1306 for (i=0; t; t = OVL_CHAIN (t))
1311 my_friendly_abort (359);
1316 is_overloaded_fn (x)
1319 /* XXX A baselink is also considered an overloaded function.
1320 As is a placeholder from push_class_decls. */
1321 if (TREE_CODE (x) == TREE_LIST)
1323 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x)) == TREE_VEC
1324 || TREE_CODE (TREE_PURPOSE (x)) == IDENTIFIER_NODE,
1328 return (TREE_CODE (x) == FUNCTION_DECL
1329 || TREE_CODE (x) == TEMPLATE_ID_EXPR
1330 || DECL_FUNCTION_TEMPLATE_P (x)
1331 || TREE_CODE (x) == OVERLOAD);
1335 really_overloaded_fn (x)
1338 /* A baselink is also considered an overloaded function.
1339 This might also be an ambiguous class member. */
1340 if (TREE_CODE (x) == TREE_LIST)
1342 return (TREE_CODE (x) == OVERLOAD
1343 && (TREE_CHAIN (x) != NULL_TREE
1344 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1351 my_friendly_assert (is_overloaded_fn (from), 9);
1352 /* A baselink is also considered an overloaded function. */
1353 if (TREE_CODE (from) == TREE_LIST)
1354 from = TREE_VALUE (from);
1355 return OVL_CURRENT (from);
1358 /* Return a new OVL node, concatenating it with the old one. */
1361 ovl_cons (decl, chain)
1365 tree result = make_node (OVERLOAD);
1366 TREE_TYPE (result) = unknown_type_node;
1367 OVL_FUNCTION (result) = decl;
1368 TREE_CHAIN (result) = chain;
1373 /* Same as ovl_cons, but on the scratch_obstack. */
1376 scratch_ovl_cons (value, chain)
1380 register struct obstack *ambient_obstack = current_obstack;
1381 extern struct obstack *expression_obstack;
1382 current_obstack = expression_obstack;
1383 node = ovl_cons (value, chain);
1384 current_obstack = ambient_obstack;
1388 /* Build a new overloaded function. If this is the first one,
1389 just return it; otherwise, ovl_cons the _DECLs */
1392 build_overload (decl, chain)
1398 if (TREE_CODE (chain) != OVERLOAD)
1399 chain = ovl_cons (chain, NULL_TREE);
1400 return ovl_cons (decl, chain);
1403 /* True if fn is in ovl. */
1406 ovl_member (fn, ovl)
1412 if (!ovl || TREE_CODE (ovl) != OVERLOAD)
1414 for (; ovl; ovl = OVL_CHAIN (ovl))
1415 if (OVL_FUNCTION (ovl) == fn)
1421 is_aggr_type_2 (t1, t2)
1424 if (TREE_CODE (t1) != TREE_CODE (t2))
1426 return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1429 #define PRINT_RING_SIZE 4
1432 lang_printable_name (decl, v)
1436 static tree decl_ring[PRINT_RING_SIZE];
1437 static char *print_ring[PRINT_RING_SIZE];
1438 static int ring_counter;
1441 /* Only cache functions. */
1443 || TREE_CODE (decl) != FUNCTION_DECL
1444 || DECL_LANG_SPECIFIC (decl) == 0)
1445 return lang_decl_name (decl, v);
1447 /* See if this print name is lying around. */
1448 for (i = 0; i < PRINT_RING_SIZE; i++)
1449 if (decl_ring[i] == decl)
1450 /* yes, so return it. */
1451 return print_ring[i];
1453 if (++ring_counter == PRINT_RING_SIZE)
1456 if (current_function_decl != NULL_TREE)
1458 if (decl_ring[ring_counter] == current_function_decl)
1460 if (ring_counter == PRINT_RING_SIZE)
1462 if (decl_ring[ring_counter] == current_function_decl)
1463 my_friendly_abort (106);
1466 if (print_ring[ring_counter])
1467 free (print_ring[ring_counter]);
1469 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1470 decl_ring[ring_counter] = decl;
1471 return print_ring[ring_counter];
1474 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1475 listed in RAISES. */
1478 build_exception_variant (type, raises)
1482 tree v = TYPE_MAIN_VARIANT (type);
1483 int constp = TYPE_READONLY (type);
1484 int volatilep = TYPE_VOLATILE (type);
1486 for (; v; v = TYPE_NEXT_VARIANT (v))
1488 if (TYPE_READONLY (v) != constp
1489 || TYPE_VOLATILE (v) != volatilep)
1492 /* @@ This should do set equality, not exact match. */
1493 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v), raises))
1494 /* List of exceptions raised matches previously found list.
1496 @@ Nice to free up storage used in consing up the
1497 @@ list of exceptions raised. */
1501 /* Need to build a new variant. */
1502 v = build_type_copy (type);
1504 if (raises && ! TREE_PERMANENT (raises))
1506 push_obstacks_nochange ();
1507 end_temporary_allocation ();
1508 raises = copy_list (raises);
1512 TYPE_RAISES_EXCEPTIONS (v) = raises;
1516 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1517 lang_specific field and its corresponding TEMPLATE_DECL node */
1520 copy_template_template_parm (t)
1523 tree template = TYPE_NAME (t);
1524 tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1525 template = copy_node (template);
1526 copy_lang_decl (template);
1527 TREE_TYPE (template) = t2;
1528 TYPE_NAME (t2) = template;
1529 TYPE_STUB_DECL (t2) = template;
1531 /* No need to copy these */
1532 TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1533 CLASSTYPE_TEMPLATE_INFO (t2) = CLASSTYPE_TEMPLATE_INFO (t);
1537 /* Subroutine of copy_to_permanent
1539 Assuming T is a node build bottom-up, make it all exist on
1540 permanent obstack, if it is not permanent already. */
1545 tree (*func) PROTO((tree));
1552 if (tmp = func (t), tmp != NULL_TREE)
1555 switch (TREE_CODE (t))
1558 return error_mark_node;
1563 /* Rather than aborting, return error_mark_node. This allows us
1564 to report a sensible error message on code like this:
1566 void g() { int i; f<i>(7); }
1570 void g() { const int i = 7; f<i>(7); }
1572 however, we must actually return the constant initializer. */
1573 tmp = decl_constant_value (t);
1575 return mapcar (tmp, func);
1577 return error_mark_node;
1581 tree chain = TREE_CHAIN (t);
1583 TREE_CHAIN (t) = mapcar (chain, func);
1584 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1585 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1586 DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1592 tree chain = TREE_CHAIN (t);
1594 TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1595 TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1596 TREE_CHAIN (t) = mapcar (chain, func);
1602 tree chain = OVL_CHAIN (t);
1604 OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1605 OVL_CHAIN (t) = mapcar (chain, func);
1611 int len = TREE_VEC_LENGTH (t);
1615 TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1622 return copy_node (t);
1626 case AGGR_INIT_EXPR:
1628 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1629 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1630 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1635 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1642 case TRUNC_DIV_EXPR:
1643 case TRUNC_MOD_EXPR:
1651 case BIT_ANDTC_EXPR:
1652 case TRUTH_ANDIF_EXPR:
1653 case TRUTH_ORIF_EXPR:
1661 case FLOOR_DIV_EXPR:
1662 case ROUND_DIV_EXPR:
1664 case FLOOR_MOD_EXPR:
1665 case ROUND_MOD_EXPR:
1667 case PREDECREMENT_EXPR:
1668 case PREINCREMENT_EXPR:
1669 case POSTDECREMENT_EXPR:
1670 case POSTINCREMENT_EXPR:
1673 case TRY_CATCH_EXPR:
1674 case WITH_CLEANUP_EXPR:
1676 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1677 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1682 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1683 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1684 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1686 /* tree.def says that operand two is RTL, but
1687 build_call_declarator puts trees in there. */
1688 if (TREE_OPERAND (t, 2)
1689 && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1690 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1692 TREE_OPERAND (t, 2) = NULL_TREE;
1700 case TRUTH_NOT_EXPR:
1703 case CLEANUP_POINT_EXPR:
1705 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1709 tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1710 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1711 case REFERENCE_TYPE:
1712 tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1713 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1715 tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1716 mapcar (TYPE_ARG_TYPES (t), func));
1717 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1719 tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1720 mapcar (TYPE_DOMAIN (t), func));
1721 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1723 tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1724 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1726 tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1727 mapcar (TREE_TYPE (t), func));
1728 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1730 tmp = build_cplus_method_type
1731 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1732 mapcar (TREE_TYPE (t), func),
1733 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1734 return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1738 TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1739 TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1744 CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
1747 case TEMPLATE_TEMPLATE_PARM:
1748 return copy_template_template_parm (t);
1752 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1753 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1754 TREE_OPERAND (t, 2) = NULL_TREE;
1759 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1760 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1761 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1765 if (TYPE_PTRMEMFUNC_P (t))
1766 return build_ptrmemfunc_type
1767 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
1768 /* else fall through */
1770 /* This list is incomplete, but should suffice for now.
1771 It is very important that `sorry' not call
1772 `report_error_function'. That could cause an infinite loop. */
1774 sorry ("initializer contains unrecognized tree code");
1775 return error_mark_node;
1778 my_friendly_abort (107);
1787 if (TREE_PERMANENT (t))
1790 /* Support `void f () { extern int i; A<&i> a; }' */
1791 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
1796 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */
1798 make_decl_rtl (t, NULL_PTR, 1);
1805 /* Assuming T is a node built bottom-up, make it all exist on
1806 permanent obstack, if it is not permanent already. */
1809 copy_to_permanent (t)
1812 if (t == NULL_TREE || TREE_PERMANENT (t))
1815 push_obstacks_nochange ();
1816 end_temporary_allocation ();
1818 t = mapcar (t, perm_manip);
1825 #ifdef GATHER_STATISTICS
1826 extern int depth_reached;
1830 print_lang_statistics ()
1832 extern struct obstack decl_obstack;
1833 print_obstack_statistics ("class_obstack", &class_obstack);
1834 print_obstack_statistics ("decl_obstack", &decl_obstack);
1835 print_search_statistics ();
1836 print_class_statistics ();
1837 #ifdef GATHER_STATISTICS
1838 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1843 /* This is used by the `assert' macro. It is provided in libgcc.a,
1844 which `cc' doesn't know how to link. Note that the C++ front-end
1845 no longer actually uses the `assert' macro (instead, it calls
1846 my_friendly_assert). But all of the back-end files still need this. */
1849 __eprintf (string, expression, line, filename)
1852 const char *expression;
1854 const char *filename;
1862 fprintf (stderr, string, expression, line, filename);
1867 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1868 (which is an ARRAY_TYPE). This counts only elements of the top
1872 array_type_nelts_top (type)
1875 return fold (build (PLUS_EXPR, sizetype,
1876 array_type_nelts (type),
1880 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1881 (which is an ARRAY_TYPE). This one is a recursive count of all
1882 ARRAY_TYPEs that are clumped together. */
1885 array_type_nelts_total (type)
1888 tree sz = array_type_nelts_top (type);
1889 type = TREE_TYPE (type);
1890 while (TREE_CODE (type) == ARRAY_TYPE)
1892 tree n = array_type_nelts_top (type);
1893 sz = fold (build (MULT_EXPR, sizetype, sz, n));
1894 type = TREE_TYPE (type);
1904 if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
1906 else if (TREE_CODE (t) == TARGET_EXPR)
1908 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1910 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
1911 return build_cplus_new
1912 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
1915 TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t));
1916 layout_decl (TREE_OPERAND (t, 0), 0);
1919 else if (TREE_CODE (t) == CALL_EXPR)
1920 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
1925 /* Actually, we'll just clean out the target exprs for the moment. */
1928 break_out_target_exprs (t)
1931 return mapcar (t, bot_manip);
1934 /* Obstack used for allocating nodes in template function and variable
1937 /* Similar to `build_nt', except we build
1938 on the permanent_obstack, regardless. */
1941 build_min_nt VPROTO((enum tree_code code, ...))
1944 enum tree_code code;
1946 register struct obstack *ambient_obstack = expression_obstack;
1949 register int length;
1955 code = va_arg (p, enum tree_code);
1958 expression_obstack = &permanent_obstack;
1960 t = make_node (code);
1961 length = tree_code_length[(int) code];
1962 TREE_COMPLEXITY (t) = lineno;
1964 for (i = 0; i < length; i++)
1966 tree x = va_arg (p, tree);
1967 TREE_OPERAND (t, i) = copy_to_permanent (x);
1971 expression_obstack = ambient_obstack;
1975 /* Similar to `build', except we build
1976 on the permanent_obstack, regardless. */
1979 build_min VPROTO((enum tree_code code, tree tt, ...))
1982 enum tree_code code;
1985 register struct obstack *ambient_obstack = expression_obstack;
1988 register int length;
1994 code = va_arg (p, enum tree_code);
1995 tt = va_arg (p, tree);
1998 expression_obstack = &permanent_obstack;
2000 t = make_node (code);
2001 length = tree_code_length[(int) code];
2003 TREE_COMPLEXITY (t) = lineno;
2005 for (i = 0; i < length; i++)
2007 tree x = va_arg (p, tree);
2008 TREE_OPERAND (t, i) = copy_to_permanent (x);
2012 expression_obstack = ambient_obstack;
2016 /* Same as `tree_cons' but make a permanent object. */
2019 min_tree_cons (purpose, value, chain)
2020 tree purpose, value, chain;
2023 register struct obstack *ambient_obstack = current_obstack;
2024 current_obstack = &permanent_obstack;
2026 node = tree_cons (copy_to_permanent (purpose),
2027 copy_to_permanent (value), chain);
2028 current_obstack = ambient_obstack;
2036 if (TREE_CODE (t) == TYPE_DECL)
2038 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2039 return TYPE_STUB_DECL (t);
2041 my_friendly_abort (42);
2043 /* Stop compiler from complaining control reaches end of non-void function. */
2048 can_free (obstack, t)
2049 struct obstack *obstack;
2054 if (TREE_CODE (t) == TREE_VEC)
2055 size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2057 my_friendly_abort (42);
2059 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2060 & ~ obstack_alignment_mask (obstack))
2061 if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2068 /* Return first vector element whose BINFO_TYPE is ELEM.
2069 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
2072 vec_binfo_member (elem, vec)
2078 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2079 if (comptypes (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i)), 1))
2080 return TREE_VEC_ELT (vec, i);
2085 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2086 the wrong thing for decl_function_context. Hopefully the uses in the
2087 backend won't matter, since we don't need a static chain for local class
2091 hack_decl_function_context (decl)
2094 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2095 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2096 return decl_function_context (decl);
2099 /* Return truthvalue of whether T1 is the same tree structure as T2.
2100 Return 1 if they are the same.
2101 Return 0 if they are understandably different.
2102 Return -1 if either contains tree structure not understood by
2106 cp_tree_equal (t1, t2)
2109 register enum tree_code code1, code2;
2114 if (t1 == 0 || t2 == 0)
2117 code1 = TREE_CODE (t1);
2118 code2 = TREE_CODE (t2);
2120 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2122 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2123 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2125 return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2127 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2128 || code2 == NON_LVALUE_EXPR)
2129 return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2137 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2138 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2141 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2144 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2145 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2146 TREE_STRING_LENGTH (t1));
2149 /* We need to do this when determining whether or not two
2150 non-type pointer to member function template arguments
2152 if (!(comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 1)
2153 /* The first operand is RTL. */
2154 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2156 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2159 cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2162 cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2165 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2168 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2171 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2174 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2177 /* Special case: if either target is an unallocated VAR_DECL,
2178 it means that it's going to be unified with whatever the
2179 TARGET_EXPR is really supposed to initialize, so treat it
2180 as being equivalent to anything. */
2181 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2182 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2183 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2184 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2185 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2186 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2189 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2192 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2194 case WITH_CLEANUP_EXPR:
2195 cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2198 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2201 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2202 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2211 case TEMPLATE_PARM_INDEX:
2212 return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2213 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2217 if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2219 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2220 return comptypes (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0), 1);
2227 switch (TREE_CODE_CLASS (code1))
2237 for (i=0; i<tree_code_length[(int) code1]; ++i)
2239 cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2249 /* Similar to make_tree_vec, but build on a temporary obstack. */
2256 register struct obstack *ambient_obstack = current_obstack;
2257 current_obstack = expression_obstack;
2258 node = make_tree_vec (len);
2259 current_obstack = ambient_obstack;
2263 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2266 build_ptr_wrapper (ptr)
2269 tree t = make_node (WRAPPER);
2270 WRAPPER_PTR (t) = ptr;
2274 /* Same, but on the expression_obstack. */
2277 build_expr_ptr_wrapper (ptr)
2281 push_expression_obstack ();
2282 t = build_ptr_wrapper (ptr);
2287 /* Build a wrapper around some integer I so we can use it as a tree. */
2290 build_int_wrapper (i)
2293 tree t = make_node (WRAPPER);
2294 WRAPPER_INT (t) = i;
2299 build_srcloc (file, line)
2305 /* Make sure that we put these on the permanent obstack; up in
2306 add_pending_template, we pass this return value into perm_tree_cons,
2307 which also puts it on the permanent_obstack. However, this wasn't
2308 explicitly doing the same. */
2309 register struct obstack *ambient_obstack = current_obstack;
2310 current_obstack = &permanent_obstack;
2312 t = make_node (SRCLOC);
2313 SRCLOC_FILE (t) = file;
2314 SRCLOC_LINE (t) = line;
2316 current_obstack = ambient_obstack;
2322 build_srcloc_here ()
2324 return build_srcloc (input_filename, lineno);
2328 push_expression_obstack ()
2330 push_obstacks_nochange ();
2331 current_obstack = expression_obstack;
2334 /* The type of ARG when used as an lvalue. */
2340 tree type = TREE_TYPE (arg);
2341 if (TREE_CODE (arg) == OVERLOAD)
2342 type = unknown_type_node;
2343 return cp_build_type_variant
2344 (type, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg));
2347 /* The type of ARG for printing error messages; denote lvalues with
2354 tree type = TREE_TYPE (arg);
2355 if (TREE_CODE (type) == ARRAY_TYPE)
2357 else if (real_lvalue_p (arg))
2358 type = build_reference_type (lvalue_type (arg));
2359 else if (IS_AGGR_TYPE (type))
2360 type = lvalue_type (arg);
2365 /* Does FUNCTION use a variable-length argument list? */
2368 varargs_function_p (function)
2371 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2372 for (; parm; parm = TREE_CHAIN (parm))
2373 if (TREE_VALUE (parm) == void_type_node)
2378 /* Returns 1 if decl is a member of a class. */
2384 tree ctx = DECL_CONTEXT (decl);
2385 return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');