1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 1995 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. */
35 #define CEIL(x,y) (((x) + (y) - 1) / (y))
37 /* Return nonzero if REF is an lvalue valid for this language.
38 Lvalues can be assigned, unless they have TREE_READONLY.
39 Lvalues can have their address taken, unless they have DECL_REGISTER. */
45 if (! language_lvalue_valid (ref))
48 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
51 if (ref == current_class_decl && flag_this_is_variable <= 0)
54 switch (TREE_CODE (ref))
56 /* preincrements and predecrements are valid lvals, provided
57 what they refer to are valid lvals. */
58 case PREINCREMENT_EXPR:
59 case PREDECREMENT_EXPR:
62 return real_lvalue_p (TREE_OPERAND (ref, 0));
68 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
69 && DECL_LANG_SPECIFIC (ref)
70 && DECL_IN_AGGR_P (ref))
77 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
78 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
82 /* A currently unresolved scope ref. */
84 my_friendly_abort (103);
86 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
88 return real_lvalue_p (TREE_OPERAND (ref, 0))
89 && real_lvalue_p (TREE_OPERAND (ref, 1));
93 return (real_lvalue_p (TREE_OPERAND (ref, 1))
94 && real_lvalue_p (TREE_OPERAND (ref, 2)));
100 return real_lvalue_p (TREE_OPERAND (ref, 1));
104 return (real_lvalue_p (TREE_OPERAND (ref, 0))
105 && real_lvalue_p (TREE_OPERAND (ref, 1)));
115 if (! language_lvalue_valid (ref))
118 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
121 if (ref == current_class_decl && flag_this_is_variable <= 0)
124 switch (TREE_CODE (ref))
126 /* preincrements and predecrements are valid lvals, provided
127 what they refer to are valid lvals. */
128 case PREINCREMENT_EXPR:
129 case PREDECREMENT_EXPR:
132 return lvalue_p (TREE_OPERAND (ref, 0));
138 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
139 && DECL_LANG_SPECIFIC (ref)
140 && DECL_IN_AGGR_P (ref))
147 if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
148 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
156 if (IS_AGGR_TYPE (TREE_TYPE (ref)))
160 /* A currently unresolved scope ref. */
162 my_friendly_abort (103);
164 if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
166 return lvalue_p (TREE_OPERAND (ref, 0))
167 && lvalue_p (TREE_OPERAND (ref, 1));
171 return (lvalue_p (TREE_OPERAND (ref, 1))
172 && lvalue_p (TREE_OPERAND (ref, 2)));
178 return lvalue_p (TREE_OPERAND (ref, 1));
182 return (lvalue_p (TREE_OPERAND (ref, 0))
183 && lvalue_p (TREE_OPERAND (ref, 1)));
189 /* Return nonzero if REF is an lvalue valid for this language;
190 otherwise, print an error message and return zero. */
193 lvalue_or_else (ref, string)
197 int win = lvalue_p (ref);
199 error ("non-lvalue in %s", string);
203 /* INIT is a CALL_EXPR which needs info about its target.
204 TYPE is the type that this initialization should appear to have.
206 Build an encapsulation of the initialization to perform
207 and return it so that it can be processed by language-independent
208 and language-specific expression expanders. */
210 build_cplus_new (type, init)
217 slot = build (VAR_DECL, type);
218 layout_decl (slot, 0);
219 rval = build (NEW_EXPR, type,
220 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
221 TREE_SIDE_EFFECTS (rval) = 1;
222 TREE_ADDRESSABLE (rval) = 1;
223 rval = build (TARGET_EXPR, type, slot, rval, 0);
224 TREE_SIDE_EFFECTS (rval) = 1;
225 TREE_ADDRESSABLE (rval) = 1;
230 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
231 these CALL_EXPRs with tree nodes that will perform the cleanups. */
234 break_out_cleanups (exp)
239 if (TREE_CODE (tmp) == CALL_EXPR
240 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
241 return build_cplus_new (TREE_TYPE (tmp), tmp);
243 while (TREE_CODE (tmp) == NOP_EXPR
244 || TREE_CODE (tmp) == CONVERT_EXPR
245 || TREE_CODE (tmp) == NON_LVALUE_EXPR)
247 if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
248 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
250 TREE_OPERAND (tmp, 0)
251 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
252 TREE_OPERAND (tmp, 0));
256 tmp = TREE_OPERAND (tmp, 0);
261 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
262 copies where they are found. Returns a deep copy all nodes transitively
263 containing CALL_EXPRs. */
266 break_out_calls (exp)
269 register tree t1, t2;
270 register enum tree_code code;
271 register int changed = 0;
274 if (exp == NULL_TREE)
277 code = TREE_CODE (exp);
279 if (code == CALL_EXPR)
280 return copy_node (exp);
282 /* Don't try and defeat a save_expr, as it should only be done once. */
283 if (code == SAVE_EXPR)
286 switch (TREE_CODE_CLASS (code))
291 case 'c': /* a constant */
292 case 't': /* a type node */
293 case 'x': /* something random, like an identifier or an ERROR_MARK. */
296 case 'd': /* A decl node */
297 #if 0 /* This is bogus. jason 9/21/94 */
299 t1 = break_out_calls (DECL_INITIAL (exp));
300 if (t1 != DECL_INITIAL (exp))
302 exp = copy_node (exp);
303 DECL_INITIAL (exp) = t1;
308 case 'b': /* A block node */
310 /* Don't know how to handle these correctly yet. Must do a
311 break_out_calls on all DECL_INITIAL values for local variables,
312 and also break_out_calls on all sub-blocks and sub-statements. */
317 case 'e': /* an expression */
318 case 'r': /* a reference */
319 case 's': /* an expression with side effects */
320 for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
322 t1 = break_out_calls (TREE_OPERAND (exp, i));
323 if (t1 != TREE_OPERAND (exp, i))
325 exp = copy_node (exp);
326 TREE_OPERAND (exp, i) = t1;
331 case '<': /* a comparison expression */
332 case '2': /* a binary arithmetic expression */
333 t2 = break_out_calls (TREE_OPERAND (exp, 1));
334 if (t2 != TREE_OPERAND (exp, 1))
336 case '1': /* a unary arithmetic expression */
337 t1 = break_out_calls (TREE_OPERAND (exp, 0));
338 if (t1 != TREE_OPERAND (exp, 0))
342 if (tree_code_length[(int) code] == 1)
343 return build1 (code, TREE_TYPE (exp), t1);
345 return build (code, TREE_TYPE (exp), t1, t2);
352 extern struct obstack *current_obstack;
353 extern struct obstack permanent_obstack, class_obstack;
354 extern struct obstack *saveable_obstack;
356 /* Here is how primitive or already-canonicalized types' hash
357 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
358 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
360 /* Construct, lay out and return the type of methods belonging to class
361 BASETYPE and whose arguments are described by ARGTYPES and whose values
362 are described by RETTYPE. If each type exists already, reuse it. */
364 build_cplus_method_type (basetype, rettype, argtypes)
365 tree basetype, rettype, argtypes;
371 /* Make a node of the sort we want. */
372 t = make_node (METHOD_TYPE);
374 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
375 TREE_TYPE (t) = rettype;
376 if (IS_SIGNATURE (basetype))
377 ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype),
378 TYPE_READONLY (basetype),
379 TYPE_VOLATILE (basetype));
381 ptype = build_pointer_type (basetype);
383 /* The actual arglist for this function includes a "hidden" argument
384 which is "this". Put it into the list of argument types. */
386 argtypes = tree_cons (NULL_TREE, ptype, argtypes);
387 TYPE_ARG_TYPES (t) = argtypes;
388 TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */
390 /* If we already have such a type, use the old one and free this one.
391 Note that it also frees up the above cons cell if found. */
392 hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
393 t = type_hash_canon (hashcode, t);
395 if (TYPE_SIZE (t) == 0)
402 build_cplus_array_type (elt_type, index_type)
406 register struct obstack *ambient_obstack = current_obstack;
407 register struct obstack *ambient_saveable_obstack = saveable_obstack;
410 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
411 make this permanent too. */
412 if (TREE_PERMANENT (elt_type)
413 && (index_type == 0 || TREE_PERMANENT (index_type)))
415 current_obstack = &permanent_obstack;
416 saveable_obstack = &permanent_obstack;
419 if (current_template_parms)
421 t = make_node (ARRAY_TYPE);
422 TREE_TYPE (t) = elt_type;
423 TYPE_DOMAIN (t) = index_type;
426 t = build_array_type (elt_type, index_type);
428 /* Push these needs up so that initialization takes place
430 TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
431 TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
432 current_obstack = ambient_obstack;
433 saveable_obstack = ambient_saveable_obstack;
437 /* Make a variant type in the proper way for C/C++, propagating qualifiers
438 down to the element type of an array. */
441 cp_build_type_variant (type, constp, volatilep)
443 int constp, volatilep;
445 if (TREE_CODE (type) == ARRAY_TYPE)
447 tree real_main_variant = TYPE_MAIN_VARIANT (type);
449 push_obstacks (TYPE_OBSTACK (real_main_variant),
450 TYPE_OBSTACK (real_main_variant));
451 type = build_cplus_array_type (cp_build_type_variant (TREE_TYPE (type),
455 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
456 make a copy. (TYPE might have come from the hash table and
457 REAL_MAIN_VARIANT might be in some function's obstack.) */
459 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
461 type = copy_node (type);
462 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
465 TYPE_MAIN_VARIANT (type) = real_main_variant;
468 return build_type_variant (type, constp, volatilep);
471 /* Add OFFSET to all base types of T.
473 OFFSET, which is a type offset, is number of bytes.
475 Note that we don't have to worry about having two paths to the
476 same base type, since this type owns its association list. */
478 propagate_binfo_offsets (binfo, offset)
482 tree binfos = BINFO_BASETYPES (binfo);
483 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
485 for (i = 0; i < n_baselinks; /* note increment is done in the loop. */)
487 tree base_binfo = TREE_VEC_ELT (binfos, i);
489 if (TREE_VIA_VIRTUAL (base_binfo))
494 tree base_binfos = BINFO_BASETYPES (base_binfo);
497 for (j = i+1; j < n_baselinks; j++)
498 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
500 /* The next basetype offset must take into account the space
501 between the classes, not just the size of each class. */
502 delta = size_binop (MINUS_EXPR,
503 BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
504 BINFO_OFFSET (base_binfo));
509 if (BINFO_OFFSET_ZEROP (base_binfo))
510 BINFO_OFFSET (base_binfo) = offset;
512 BINFO_OFFSET (base_binfo)
513 = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
515 BINFO_OFFSET (base_binfo) = offset;
520 tree chain = NULL_TREE;
522 /* Now unshare the structure beneath BASE_BINFO. */
523 for (k = TREE_VEC_LENGTH (base_binfos)-1;
526 tree base_base_binfo = TREE_VEC_ELT (base_binfos, k);
527 if (! TREE_VIA_VIRTUAL (base_base_binfo))
528 TREE_VEC_ELT (base_binfos, k)
529 = make_binfo (BINFO_OFFSET (base_base_binfo),
531 BINFO_VTABLE (base_base_binfo),
532 BINFO_VIRTUALS (base_base_binfo),
534 chain = TREE_VEC_ELT (base_binfos, k);
535 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
536 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
537 BINFO_INHERITANCE_CHAIN (chain) = base_binfo;
539 /* Now propagate the offset to the base types. */
540 propagate_binfo_offsets (base_binfo, offset);
543 /* Go to our next class that counts for offset propagation. */
546 offset = size_binop (PLUS_EXPR, offset, delta);
551 /* Compute the actual offsets that our virtual base classes
552 will have *for this type*. This must be performed after
553 the fields are laid out, since virtual baseclasses must
554 lay down at the end of the record.
556 Returns the maximum number of virtual functions any of the virtual
557 baseclasses provide. */
559 layout_vbasetypes (rec, max)
563 /* Get all the virtual base types that this type uses.
564 The TREE_VALUE slot holds the virtual baseclass type. */
565 tree vbase_types = get_vbase_types (rec);
567 #ifdef STRUCTURE_SIZE_BOUNDARY
568 unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
570 unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
574 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
575 where CONST_SIZE is an integer
576 and VAR_SIZE is a tree expression.
577 If VAR_SIZE is null, the size is just CONST_SIZE.
578 Naturally we try to avoid using VAR_SIZE. */
579 register unsigned const_size = 0;
580 register tree var_size = 0;
581 int nonvirtual_const_size;
583 CLASSTYPE_VBASECLASSES (rec) = vbase_types;
585 if (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST)
586 const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
588 var_size = TYPE_SIZE (rec);
590 nonvirtual_const_size = const_size;
594 tree basetype = BINFO_TYPE (vbase_types);
597 desired_align = TYPE_ALIGN (basetype);
598 record_align = MAX (record_align, desired_align);
601 offset = integer_zero_node;
604 /* Give each virtual base type the alignment it wants. */
605 const_size = CEIL (const_size, TYPE_ALIGN (basetype))
606 * TYPE_ALIGN (basetype);
607 offset = size_int (CEIL (const_size, BITS_PER_UNIT));
610 if (CLASSTYPE_VSIZE (basetype) > max)
611 max = CLASSTYPE_VSIZE (basetype);
612 BINFO_OFFSET (vbase_types) = offset;
614 if (TREE_CODE (TYPE_SIZE (basetype)) == INTEGER_CST)
616 /* Every virtual baseclass takes a least a UNIT, so that we can
617 take it's address and get something different for each base. */
618 const_size += MAX (BITS_PER_UNIT,
619 TREE_INT_CST_LOW (TYPE_SIZE (basetype))
620 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype)));
622 else if (var_size == 0)
623 var_size = TYPE_SIZE (basetype);
625 var_size = size_binop (PLUS_EXPR, var_size, TYPE_SIZE (basetype));
627 vbase_types = TREE_CHAIN (vbase_types);
632 /* Because a virtual base might take a single byte above,
633 we have to re-adjust the total size to make sure it it
634 a multiple of the alignment. */
635 /* Give the whole object the alignment it wants. */
636 const_size = CEIL (const_size, record_align) * record_align;
639 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
640 here, as that is for this class, without any virtual base classes. */
641 TYPE_ALIGN (rec) = record_align;
642 if (const_size != nonvirtual_const_size)
644 CLASSTYPE_VBASE_SIZE (rec)
645 = size_int (const_size - nonvirtual_const_size);
646 TYPE_SIZE (rec) = size_int (const_size);
649 /* Now propagate offset information throughout the lattice
650 under the vbase type. */
651 for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
652 vbase_types = TREE_CHAIN (vbase_types))
654 tree base_binfos = BINFO_BASETYPES (vbase_types);
656 BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
660 tree chain = NULL_TREE;
662 /* Now unshare the structure beneath BASE_BINFO. */
664 for (j = TREE_VEC_LENGTH (base_binfos)-1;
667 tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
668 if (! TREE_VIA_VIRTUAL (base_base_binfo))
669 TREE_VEC_ELT (base_binfos, j)
670 = make_binfo (BINFO_OFFSET (base_base_binfo),
672 BINFO_VTABLE (base_base_binfo),
673 BINFO_VIRTUALS (base_base_binfo),
675 chain = TREE_VEC_ELT (base_binfos, j);
676 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
677 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
678 BINFO_INHERITANCE_CHAIN (chain) = vbase_types;
681 propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
688 /* Lay out the base types of a record type, REC.
689 Tentatively set the size and alignment of REC
690 according to the base types alone.
692 Offsets for immediate nonvirtual baseclasses are also computed here.
694 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
695 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
697 Returns list of virtual base classes in a FIELD_DECL chain. */
699 layout_basetypes (rec, binfos)
702 /* Chain to hold all the new FIELD_DECLs which point at virtual
704 tree vbase_decls = NULL_TREE;
706 #ifdef STRUCTURE_SIZE_BOUNDARY
707 unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
709 unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
712 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
713 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
714 the size is just CONST_SIZE. Naturally we try to avoid using
715 VAR_SIZE. And so far, we've been successful. */
717 register tree var_size = 0;
720 register unsigned const_size = 0;
721 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
723 /* Handle basetypes almost like fields, but record their
724 offsets differently. */
726 for (i = 0; i < n_baseclasses; i++)
728 int inc, desired_align, int_vbase_size;
729 register tree base_binfo = TREE_VEC_ELT (binfos, i);
730 register tree basetype = BINFO_TYPE (base_binfo);
733 if (TYPE_SIZE (basetype) == 0)
736 /* This error is now reported in xref_tag, thus giving better
737 location information. */
738 error_with_aggr_type (base_binfo,
739 "base class `%s' has incomplete type");
741 TREE_VIA_PUBLIC (base_binfo) = 1;
742 TREE_VIA_PROTECTED (base_binfo) = 0;
743 TREE_VIA_VIRTUAL (base_binfo) = 0;
745 /* Should handle this better so that
748 class B: private A { virtual void F(); };
750 does not dump core when compiled. */
751 my_friendly_abort (121);
756 /* All basetypes are recorded in the association list of the
759 if (TREE_VIA_VIRTUAL (base_binfo))
762 char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
763 + sizeof (VBASE_NAME) + 1);
765 /* The offset for a virtual base class is only used in computing
766 virtual function tables and for initializing virtual base
767 pointers. It is built once `get_vbase_types' is called. */
769 /* If this basetype can come from another vbase pointer
770 without an additional indirection, we will share
771 that pointer. If an indirection is involved, we
772 make our own pointer. */
773 for (j = 0; j < n_baseclasses; j++)
775 tree other_base_binfo = TREE_VEC_ELT (binfos, j);
776 if (! TREE_VIA_VIRTUAL (other_base_binfo)
777 && binfo_member (basetype,
778 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo))))
781 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
782 decl = build_lang_field_decl (FIELD_DECL, get_identifier (name),
783 build_pointer_type (basetype));
784 /* If you change any of the below, take a look at all the
785 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
787 DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
788 DECL_VIRTUAL_P (decl) = 1;
789 DECL_FIELD_CONTEXT (decl) = rec;
790 DECL_CLASS_CONTEXT (decl) = rec;
791 DECL_FCONTEXT (decl) = basetype;
792 DECL_SAVED_INSNS (decl) = NULL_RTX;
793 DECL_FIELD_SIZE (decl) = 0;
794 DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
795 TREE_CHAIN (decl) = vbase_decls;
796 BINFO_VPTR_FIELD (base_binfo) = decl;
799 if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
800 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
802 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
803 "destructor `%s' non-virtual");
804 warning ("in inheritance relationship `%s: virtual %s'",
805 TYPE_NAME_STRING (rec),
806 TYPE_NAME_STRING (basetype));
809 /* The space this decl occupies has already been accounted for. */
814 offset = integer_zero_node;
817 /* Give each base type the alignment it wants. */
818 const_size = CEIL (const_size, TYPE_ALIGN (basetype))
819 * TYPE_ALIGN (basetype);
820 offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
823 /* bpk: Disabled this check until someone is willing to
824 claim it as theirs and explain exactly what circumstances
825 warrant the warning. */
826 if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
827 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
829 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
830 "destructor `%s' non-virtual");
831 warning ("in inheritance relationship `%s:%s %s'",
832 TYPE_NAME_STRING (rec),
833 TREE_VIA_VIRTUAL (base_binfo) ? " virtual" : "",
834 TYPE_NAME_STRING (basetype));
838 BINFO_OFFSET (base_binfo) = offset;
839 if (CLASSTYPE_VSIZE (basetype))
841 BINFO_VTABLE (base_binfo) = TYPE_BINFO_VTABLE (basetype);
842 BINFO_VIRTUALS (base_binfo) = TYPE_BINFO_VIRTUALS (basetype);
844 TREE_CHAIN (base_binfo) = TYPE_BINFO (rec);
845 TYPE_BINFO (rec) = base_binfo;
847 /* Add only the amount of storage not present in
848 the virtual baseclasses. */
850 int_vbase_size = TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype));
851 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype)) > int_vbase_size)
853 inc = MAX (record_align,
854 (TREE_INT_CST_LOW (TYPE_SIZE (basetype))
857 /* Record must have at least as much alignment as any field. */
858 desired_align = TYPE_ALIGN (basetype);
859 record_align = MAX (record_align, desired_align);
866 CLASSTYPE_SIZE (rec) = size_int (const_size);
868 CLASSTYPE_SIZE (rec) = integer_zero_node;
869 CLASSTYPE_ALIGN (rec) = record_align;
874 /* Hashing of lists so that we don't make duplicates.
875 The entry point is `list_hash_canon'. */
877 /* Each hash table slot is a bucket containing a chain
878 of these structures. */
882 struct list_hash *next; /* Next structure in the bucket. */
883 int hashcode; /* Hash code of this list. */
884 tree list; /* The list recorded here. */
887 /* Now here is the hash table. When recording a list, it is added
888 to the slot whose index is the hash code mod the table size.
889 Note that the hash table is used for several kinds of lists.
890 While all these live in the same table, they are completely independent,
891 and the hash code is computed differently for each of these. */
893 #define TYPE_HASH_SIZE 59
894 struct list_hash *list_hash_table[TYPE_HASH_SIZE];
896 /* Compute a hash code for a list (chain of TREE_LIST nodes
897 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
898 TREE_COMMON slots), by adding the hash codes of the individual entries. */
904 register int hashcode = 0;
906 if (TREE_CHAIN (list))
907 hashcode += TYPE_HASH (TREE_CHAIN (list));
909 if (TREE_VALUE (list))
910 hashcode += TYPE_HASH (TREE_VALUE (list));
913 if (TREE_PURPOSE (list))
914 hashcode += TYPE_HASH (TREE_PURPOSE (list));
920 /* Look in the type hash table for a type isomorphic to TYPE.
921 If one is found, return it. Otherwise return 0. */
924 list_hash_lookup (hashcode, list)
928 register struct list_hash *h;
929 for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
930 if (h->hashcode == hashcode
931 && TREE_VIA_VIRTUAL (h->list) == TREE_VIA_VIRTUAL (list)
932 && TREE_VIA_PUBLIC (h->list) == TREE_VIA_PUBLIC (list)
933 && TREE_VIA_PROTECTED (h->list) == TREE_VIA_PROTECTED (list)
934 && TREE_PURPOSE (h->list) == TREE_PURPOSE (list)
935 && TREE_VALUE (h->list) == TREE_VALUE (list)
936 && TREE_CHAIN (h->list) == TREE_CHAIN (list))
938 my_friendly_assert (TREE_TYPE (h->list) == TREE_TYPE (list), 299);
944 /* Add an entry to the list-hash-table
945 for a list TYPE whose hash code is HASHCODE. */
948 list_hash_add (hashcode, list)
952 register struct list_hash *h;
954 h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
955 h->hashcode = hashcode;
957 h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
958 list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
961 /* Given TYPE, and HASHCODE its hash code, return the canonical
962 object for an identical list if one already exists.
963 Otherwise, return TYPE, and record it as the canonical object
964 if it is a permanent object.
966 To use this function, first create a list of the sort you want.
967 Then compute its hash code from the fields of the list that
968 make it different from other similar lists.
969 Then call this function and use the value.
970 This function frees the list you pass in if it is a duplicate. */
972 /* Set to 1 to debug without canonicalization. Never set by program. */
973 static int debug_no_list_hash = 0;
976 list_hash_canon (hashcode, list)
982 if (debug_no_list_hash)
985 t1 = list_hash_lookup (hashcode, list);
988 obstack_free (&class_obstack, list);
992 /* If this is a new list, record it for later reuse. */
993 list_hash_add (hashcode, list);
999 hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
1000 int via_public, via_virtual, via_protected;
1001 tree purpose, value, chain;
1003 struct obstack *ambient_obstack = current_obstack;
1007 current_obstack = &class_obstack;
1008 t = tree_cons (purpose, value, chain);
1009 TREE_VIA_PUBLIC (t) = via_public;
1010 TREE_VIA_PROTECTED (t) = via_protected;
1011 TREE_VIA_VIRTUAL (t) = via_virtual;
1012 hashcode = list_hash (t);
1013 t = list_hash_canon (hashcode, t);
1014 current_obstack = ambient_obstack;
1018 /* Constructor for hashed lists. */
1020 hash_tree_chain (value, chain)
1023 struct obstack *ambient_obstack = current_obstack;
1027 current_obstack = &class_obstack;
1028 t = tree_cons (NULL_TREE, value, chain);
1029 hashcode = list_hash (t);
1030 t = list_hash_canon (hashcode, t);
1031 current_obstack = ambient_obstack;
1035 /* Similar, but used for concatenating two lists. */
1037 hash_chainon (list1, list2)
1044 if (TREE_CHAIN (list1) == NULL_TREE)
1045 return hash_tree_chain (TREE_VALUE (list1), list2);
1046 return hash_tree_chain (TREE_VALUE (list1),
1047 hash_chainon (TREE_CHAIN (list1), list2));
1051 get_identifier_list (value)
1054 tree list = IDENTIFIER_AS_LIST (value);
1055 if (list != NULL_TREE
1056 && (TREE_CODE (list) != TREE_LIST
1057 || TREE_VALUE (list) != value))
1059 else if (IDENTIFIER_HAS_TYPE_VALUE (value)
1060 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE
1061 && IDENTIFIER_TYPE_VALUE (value)
1062 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value)))
1064 tree type = IDENTIFIER_TYPE_VALUE (value);
1066 if (TYPE_PTRMEMFUNC_P (type))
1068 else if (type == current_class_type)
1069 /* Don't mess up the constructor name. */
1070 list = tree_cons (NULL_TREE, value, NULL_TREE);
1074 /* This will return the correct thing for regular types,
1075 nested types, and templates. Yay! */
1076 if (TYPE_NESTED_NAME (type))
1077 id = TYPE_NESTED_NAME (type);
1079 id = TYPE_IDENTIFIER (type);
1081 if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
1082 CLASSTYPE_ID_AS_LIST (type)
1083 = perm_tree_cons (NULL_TREE, id, NULL_TREE);
1084 list = CLASSTYPE_ID_AS_LIST (type);
1091 get_decl_list (value)
1094 tree list = NULL_TREE;
1096 if (TREE_CODE (value) == IDENTIFIER_NODE)
1097 list = get_identifier_list (value);
1098 else if (TREE_CODE (value) == RECORD_TYPE
1099 && TYPE_LANG_SPECIFIC (value)
1100 && value == TYPE_MAIN_VARIANT (value))
1101 list = CLASSTYPE_AS_LIST (value);
1103 if (list != NULL_TREE)
1105 my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
1109 return build_decl_list (NULL_TREE, value);
1112 /* Build an association between TYPE and some parameters:
1114 OFFSET is the offset added to `this' to convert it to a pointer
1117 BINFO is the base binfo to use, if we are deriving from one. This
1118 is necessary, as we want specialized parent binfos from base
1119 classes, so that the VTABLE_NAMEs of bases are for the most derived
1120 type, instead of of the simple type.
1122 VTABLE is the virtual function table with which to initialize
1123 sub-objects of type TYPE.
1125 VIRTUALS are the virtual functions sitting in VTABLE.
1127 CHAIN are more associations we must retain. */
1130 make_binfo (offset, binfo, vtable, virtuals, chain)
1132 tree vtable, virtuals;
1135 tree new_binfo = make_tree_vec (6);
1138 if (TREE_CODE (binfo) == TREE_VEC)
1139 type = BINFO_TYPE (binfo);
1143 binfo = TYPE_BINFO (binfo);
1146 TREE_CHAIN (new_binfo) = chain;
1148 TREE_USED (new_binfo) = TREE_USED (chain);
1150 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1151 BINFO_OFFSET (new_binfo) = offset;
1152 BINFO_VTABLE (new_binfo) = vtable;
1153 BINFO_VIRTUALS (new_binfo) = virtuals;
1154 BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1156 if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1157 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
1161 /* Return the binfo value for ELEM in TYPE. */
1164 binfo_value (elem, type)
1168 if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1169 compiler_error ("base class `%s' ambiguous in binfo_value",
1170 TYPE_NAME_STRING (elem));
1172 return TYPE_BINFO (type);
1173 if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1175 return get_binfo (elem, type, 0);
1182 register tree prev = 0, tmp, next;
1183 for (tmp = path; tmp; tmp = next)
1185 next = BINFO_INHERITANCE_CHAIN (tmp);
1186 BINFO_INHERITANCE_CHAIN (tmp) = prev;
1196 unsigned HOST_WIDE_INT n;
1199 fprintf (stderr, "type \"%s\"; offset = %d\n",
1200 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1201 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1202 fprintf (stderr, "vtable type:\n");
1203 debug_tree (BINFO_TYPE (elem));
1204 if (BINFO_VTABLE (elem))
1205 fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1207 fprintf (stderr, "no vtable decl yet\n");
1208 fprintf (stderr, "virtuals:\n");
1209 virtuals = BINFO_VIRTUALS (elem);
1211 n = skip_rtti_stuff (&virtuals);
1215 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1216 fprintf (stderr, "%s [%d =? %d]\n",
1217 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1218 n, TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1220 virtuals = TREE_CHAIN (virtuals);
1224 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1225 We expect a null pointer to mark the end of the chain.
1226 This is the Lisp primitive `length'. */
1229 decl_list_length (t)
1233 register int len = 0;
1235 my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL
1236 || TREE_CODE (t) == TEMPLATE_DECL, 300);
1237 for (tail = t; tail; tail = DECL_CHAIN (tail))
1247 if (TREE_CODE (t) == FUNCTION_DECL)
1249 else if (TREE_CODE (t) == TREE_LIST)
1250 return decl_list_length (TREE_VALUE (t));
1252 my_friendly_abort (359);
1257 is_overloaded_fn (x)
1260 if (TREE_CODE (x) == FUNCTION_DECL)
1263 if (TREE_CODE (x) == TREE_LIST
1264 && (TREE_CODE (TREE_VALUE (x)) == FUNCTION_DECL
1265 || TREE_CODE (TREE_VALUE (x)) == TEMPLATE_DECL))
1272 really_overloaded_fn (x)
1275 if (TREE_CODE (x) == TREE_LIST
1276 && (TREE_CODE (TREE_VALUE (x)) == FUNCTION_DECL
1277 || TREE_CODE (TREE_VALUE (x)) == TEMPLATE_DECL))
1287 if (TREE_CODE (from) == FUNCTION_DECL)
1290 my_friendly_assert (TREE_CODE (from) == TREE_LIST, 9);
1292 return TREE_VALUE (from);
1296 fnaddr_from_vtable_entry (entry)
1299 if (flag_vtable_thunks)
1302 if (TREE_CODE (func) == ADDR_EXPR)
1303 func = TREE_OPERAND (func, 0);
1304 if (TREE_CODE (func) == THUNK_DECL)
1305 return DECL_INITIAL (func);
1310 return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry))));
1314 function_arg_chain (t)
1317 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t)));
1321 promotes_to_aggr_type (t, code)
1323 enum tree_code code;
1325 if (TREE_CODE (t) == code)
1327 return IS_AGGR_TYPE (t);
1331 is_aggr_type_2 (t1, t2)
1334 if (TREE_CODE (t1) != TREE_CODE (t2))
1336 return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1339 /* Give message using types TYPE1 and TYPE2 as arguments.
1340 PFN is the function which will print the message;
1341 S is the format string for PFN to use. */
1343 message_2_types (pfn, s, type1, type2)
1348 tree name1 = TYPE_NAME (type1);
1349 tree name2 = TYPE_NAME (type2);
1350 if (TREE_CODE (name1) == TYPE_DECL)
1351 name1 = DECL_NAME (name1);
1352 if (TREE_CODE (name2) == TYPE_DECL)
1353 name2 = DECL_NAME (name2);
1354 (*pfn) (s, IDENTIFIER_POINTER (name1), IDENTIFIER_POINTER (name2));
1357 #define PRINT_RING_SIZE 4
1360 lang_printable_name (decl)
1363 static tree decl_ring[PRINT_RING_SIZE];
1364 static char *print_ring[PRINT_RING_SIZE];
1365 static int ring_counter;
1368 /* Only cache functions. */
1369 if (TREE_CODE (decl) != FUNCTION_DECL
1370 || DECL_LANG_SPECIFIC (decl) == 0)
1371 return decl_as_string (decl, 1);
1373 /* See if this print name is lying around. */
1374 for (i = 0; i < PRINT_RING_SIZE; i++)
1375 if (decl_ring[i] == decl)
1376 /* yes, so return it. */
1377 return print_ring[i];
1379 if (++ring_counter == PRINT_RING_SIZE)
1382 if (current_function_decl != NULL_TREE)
1384 if (decl_ring[ring_counter] == current_function_decl)
1386 if (ring_counter == PRINT_RING_SIZE)
1388 if (decl_ring[ring_counter] == current_function_decl)
1389 my_friendly_abort (106);
1392 if (print_ring[ring_counter])
1393 free (print_ring[ring_counter]);
1396 int print_ret_type_p
1397 = (!DECL_CONSTRUCTOR_P (decl)
1398 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
1400 char *name = (char *)decl_as_string (decl, print_ret_type_p);
1401 print_ring[ring_counter] = (char *)malloc (strlen (name) + 1);
1402 strcpy (print_ring[ring_counter], name);
1403 decl_ring[ring_counter] = decl;
1405 return print_ring[ring_counter];
1408 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1409 listed in RAISES. */
1411 build_exception_variant (type, raises)
1415 tree v = TYPE_MAIN_VARIANT (type);
1416 int constp = TYPE_READONLY (type);
1417 int volatilep = TYPE_VOLATILE (type);
1419 for (; v; v = TYPE_NEXT_VARIANT (v))
1421 if (TYPE_READONLY (v) != constp
1422 || TYPE_VOLATILE (v) != volatilep)
1425 /* @@ This should do set equality, not exact match. */
1426 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v), raises))
1427 /* List of exceptions raised matches previously found list.
1429 @@ Nice to free up storage used in consing up the
1430 @@ list of exceptions raised. */
1434 /* Need to build a new variant. */
1435 v = build_type_copy (type);
1437 if (raises && ! TREE_PERMANENT (raises))
1439 push_obstacks_nochange ();
1440 end_temporary_allocation ();
1441 raises = copy_list (raises);
1445 TYPE_RAISES_EXCEPTIONS (v) = raises;
1449 /* Subroutine of copy_to_permanent
1451 Assuming T is a node build bottom-up, make it all exist on
1452 permanent obstack, if it is not permanent already. */
1464 if (tmp = func (t), tmp != NULL_TREE)
1467 switch (TREE_CODE (t))
1470 return error_mark_node;
1479 tree chain = TREE_CHAIN (t);
1481 TREE_CHAIN (t) = mapcar (chain, func);
1482 TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1483 DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1484 DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1490 tree chain = TREE_CHAIN (t);
1492 TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1493 TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1494 TREE_CHAIN (t) = mapcar (chain, func);
1500 int len = TREE_VEC_LENGTH (t);
1504 TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1511 return copy_node (t);
1517 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1518 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1519 TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1524 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1531 case TRUNC_DIV_EXPR:
1532 case TRUNC_MOD_EXPR:
1540 case BIT_ANDTC_EXPR:
1541 case TRUTH_ANDIF_EXPR:
1542 case TRUTH_ORIF_EXPR:
1550 case FLOOR_DIV_EXPR:
1551 case ROUND_DIV_EXPR:
1553 case FLOOR_MOD_EXPR:
1554 case ROUND_MOD_EXPR:
1556 case PREDECREMENT_EXPR:
1557 case PREINCREMENT_EXPR:
1558 case POSTDECREMENT_EXPR:
1559 case POSTINCREMENT_EXPR:
1564 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1565 TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1573 case TRUTH_NOT_EXPR:
1577 TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1581 return build_pointer_type (mapcar (TREE_TYPE (t), func));
1582 case REFERENCE_TYPE:
1583 return build_reference_type (mapcar (TREE_TYPE (t), func));
1585 return build_function_type (mapcar (TREE_TYPE (t), func),
1586 mapcar (TYPE_ARG_TYPES (t), func));
1588 return build_array_type (mapcar (TREE_TYPE (t), func),
1589 mapcar (TYPE_DOMAIN (t), func));
1591 return build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1594 return build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1595 mapcar (TREE_TYPE (t), func));
1597 return build_method_type
1598 (mapcar (TYPE_METHOD_BASETYPE (t), func),
1600 (mapcar (TREE_TYPE (t), func),
1601 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func)));
1604 if (TYPE_PTRMEMFUNC_P (t))
1605 return build_ptrmemfunc_type
1606 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
1607 /* else fall through */
1609 /* This list is incomplete, but should suffice for now.
1610 It is very important that `sorry' does not call
1611 `report_error_function'. That could cause an infinite loop. */
1613 sorry ("initializer contains unrecognized tree code");
1614 return error_mark_node;
1617 my_friendly_abort (107);
1626 if (TREE_PERMANENT (t))
1628 /* Support `void f () { extern int i; A<&i> a; }' */
1629 if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
1631 return copy_node (t);
1635 /* Assuming T is a node built bottom-up, make it all exist on
1636 permanent obstack, if it is not permanent already. */
1638 copy_to_permanent (t)
1641 register struct obstack *ambient_obstack = current_obstack;
1642 register struct obstack *ambient_saveable_obstack = saveable_obstack;
1645 if (t == NULL_TREE || TREE_PERMANENT (t))
1648 saveable_obstack = &permanent_obstack;
1649 current_obstack = saveable_obstack;
1650 resume = suspend_momentary ();
1652 t = mapcar (t, perm_manip);
1654 resume_momentary (resume);
1655 current_obstack = ambient_obstack;
1656 saveable_obstack = ambient_saveable_obstack;
1661 #ifdef GATHER_STATISTICS
1662 extern int depth_reached;
1666 print_lang_statistics ()
1668 extern struct obstack maybepermanent_obstack, decl_obstack;
1669 print_obstack_statistics ("class_obstack", &class_obstack);
1670 print_obstack_statistics ("decl_obstack", &decl_obstack);
1671 print_obstack_statistics ("permanent_obstack", &permanent_obstack);
1672 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
1673 print_search_statistics ();
1674 print_class_statistics ();
1675 #ifdef GATHER_STATISTICS
1676 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1681 /* This is used by the `assert' macro. It is provided in libgcc.a,
1682 which `cc' doesn't know how to link. Note that the C++ front-end
1683 no longer actually uses the `assert' macro (instead, it calls
1684 my_friendly_assert). But all of the back-end files still need this. */
1686 __eprintf (string, expression, line, filename)
1689 const char *expression;
1691 const char *filename;
1699 fprintf (stderr, string, expression, line, filename);
1704 /* Return, as an INTEGER_CST node, the number of elements for
1705 TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1708 array_type_nelts_top (type)
1711 return fold (build (PLUS_EXPR, sizetype,
1712 array_type_nelts (type),
1716 /* Return, as an INTEGER_CST node, the number of elements for
1717 TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1718 ARRAY_TYPEs that are clumped together. */
1721 array_type_nelts_total (type)
1724 tree sz = array_type_nelts_top (type);
1725 type = TREE_TYPE (type);
1726 while (TREE_CODE (type) == ARRAY_TYPE)
1728 tree n = array_type_nelts_top (type);
1729 sz = fold (build (MULT_EXPR, sizetype, sz, n));
1730 type = TREE_TYPE (type);
1740 if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
1742 else if (TREE_CODE (t) == TARGET_EXPR)
1743 return build_cplus_new (TREE_TYPE (t),
1744 break_out_target_exprs (TREE_OPERAND (t, 1)));
1748 /* Actually, we'll just clean out the target exprs for the moment. */
1750 break_out_target_exprs (t)
1753 return mapcar (t, bot_manip);
1762 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1763 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1767 /* Modify a tree in place so that all the evaluate only once things
1768 are cleared out. Return the EXPR given. */
1770 unsave_expr_now (expr)
1773 enum tree_code code;
1776 if (expr == NULL_TREE)
1779 code = TREE_CODE (expr);
1783 SAVE_EXPR_RTL (expr) = NULL_RTX;
1787 sorry ("TARGET_EXPR reused inside UNSAVE_EXPR");
1791 warning ("RTL_EXPR reused inside UNSAVE_EXPR");
1792 RTL_EXPR_SEQUENCE (expr) = NULL_RTX;
1796 CALL_EXPR_RTL (expr) = NULL_RTX;
1797 if (TREE_OPERAND (expr, 1)
1798 && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
1800 tree exp = TREE_OPERAND (expr, 1);
1803 unsave_expr_now (TREE_VALUE (exp));
1804 exp = TREE_CHAIN (exp);
1810 switch (TREE_CODE_CLASS (code))
1812 case 'c': /* a constant */
1813 case 't': /* a type node */
1814 case 'x': /* something random, like an identifier or an ERROR_MARK. */
1815 case 'd': /* A decl node */
1816 case 'b': /* A block node */
1819 case 'e': /* an expression */
1820 case 'r': /* a reference */
1821 case 's': /* an expression with side effects */
1822 case '<': /* a comparison expression */
1823 case '2': /* a binary arithmetic expression */
1824 case '1': /* a unary arithmetic expression */
1825 for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
1826 unsave_expr_now (TREE_OPERAND (expr, i));
1830 my_friendly_abort (999);
1834 /* Since cleanup may have SAVE_EXPRs in it, we protect it with an
1835 UNSAVE_EXPR as the backend cannot yet handle SAVE_EXPRs in cleanups
1838 cp_expand_decl_cleanup (decl, cleanup)
1841 return expand_decl_cleanup (decl, unsave_expr (cleanup));
1844 /* Obstack used for allocating nodes in template function and variable
1847 extern struct obstack *expression_obstack;
1849 /* Similar to `build_nt', except we build
1850 on the permanent_obstack, regardless. */
1853 build_min_nt VPROTO((enum tree_code code, ...))
1856 enum tree_code code;
1858 register struct obstack *ambient_obstack = expression_obstack;
1861 register int length;
1867 code = va_arg (p, enum tree_code);
1870 expression_obstack = &permanent_obstack;
1872 t = make_node (code);
1873 length = tree_code_length[(int) code];
1874 TREE_COMPLEXITY (t) = lineno;
1876 for (i = 0; i < length; i++)
1878 tree x = va_arg (p, tree);
1879 TREE_OPERAND (t, i) = copy_to_permanent (x);
1883 expression_obstack = ambient_obstack;
1887 /* Similar to `build', except we build
1888 on the permanent_obstack, regardless. */
1891 build_min VPROTO((enum tree_code code, tree tt, ...))
1894 enum tree_code code;
1897 register struct obstack *ambient_obstack = expression_obstack;
1900 register int length;
1906 code = va_arg (p, enum tree_code);
1907 tt = va_arg (p, tree);
1910 expression_obstack = &permanent_obstack;
1912 t = make_node (code);
1913 length = tree_code_length[(int) code];
1915 TREE_COMPLEXITY (t) = lineno;
1917 for (i = 0; i < length; i++)
1919 tree x = va_arg (p, tree);
1920 TREE_OPERAND (t, i) = copy_to_permanent (x);
1924 expression_obstack = ambient_obstack;
1928 /* Same as `tree_cons' but make a permanent object. */
1931 min_tree_cons (purpose, value, chain)
1932 tree purpose, value, chain;
1935 register struct obstack *ambient_obstack = current_obstack;
1936 current_obstack = &permanent_obstack;
1938 node = tree_cons (purpose, value, chain);
1939 current_obstack = ambient_obstack;
1947 if (TREE_CODE (t) == IDENTIFIER_NODE)
1948 return identifier_typedecl_value (t);
1949 if (TREE_CODE (t) == TYPE_DECL)
1951 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
1952 return TYPE_STUB_DECL (t);
1954 my_friendly_abort (42);
1958 can_free (obstack, t)
1959 struct obstack *obstack;
1964 if (TREE_CODE (t) == TREE_VEC)
1965 size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
1967 my_friendly_abort (42);
1969 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1970 & ~ obstack_alignment_mask (obstack))
1971 if ((char *)t + ROUND (size) == obstack_next_free (obstack))
1978 /* Return first vector element whose BINFO_TYPE is ELEM.
1979 Return 0 if ELEM is not in VEC. */
1982 vec_binfo_member (elem, vec)
1986 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
1987 if (elem == BINFO_TYPE (TREE_VEC_ELT (vec, i)))
1988 return TREE_VEC_ELT (vec, i);