1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #define CEIL(x,y) (((x) + (y) - 1) / (y))
31 /* Return nonzero if REF is an lvalue valid for this language.
32 Lvalues can be assigned, unless they have TREE_READONLY.
33 Lvalues can have their address taken, unless they have DECL_REGISTER. */
39 if (! language_lvalue_valid (ref
))
42 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
45 if (ref
== current_class_decl
&& flag_this_is_variable
<= 0)
48 switch (TREE_CODE (ref
))
50 /* preincrements and predecrements are valid lvals, provided
51 what they refer to are valid lvals. */
52 case PREINCREMENT_EXPR
:
53 case PREDECREMENT_EXPR
:
56 return real_lvalue_p (TREE_OPERAND (ref
, 0));
62 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
63 && DECL_LANG_SPECIFIC (ref
)
64 && DECL_IN_AGGR_P (ref
))
71 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
72 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
76 case WITH_CLEANUP_EXPR
:
77 return real_lvalue_p (TREE_OPERAND (ref
, 0));
79 /* A currently unresolved scope ref. */
81 my_friendly_abort (103);
83 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
85 return real_lvalue_p (TREE_OPERAND (ref
, 0))
86 && real_lvalue_p (TREE_OPERAND (ref
, 1));
90 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
91 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
97 return real_lvalue_p (TREE_OPERAND (ref
, 1));
101 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
102 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
112 if (! language_lvalue_valid (ref
))
115 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
118 if (ref
== current_class_decl
&& flag_this_is_variable
<= 0)
121 switch (TREE_CODE (ref
))
123 /* preincrements and predecrements are valid lvals, provided
124 what they refer to are valid lvals. */
125 case PREINCREMENT_EXPR
:
126 case PREDECREMENT_EXPR
:
129 return lvalue_p (TREE_OPERAND (ref
, 0));
135 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
136 && DECL_LANG_SPECIFIC (ref
)
137 && DECL_IN_AGGR_P (ref
))
144 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
145 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
149 case WITH_CLEANUP_EXPR
:
150 return lvalue_p (TREE_OPERAND (ref
, 0));
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 If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
211 Otherwise, cleanups are not built here. For example, when building
212 an initialization for a stack slot, since the called function handles
213 the cleanup, we would not want to do it here. */
215 build_cplus_new (type
, init
, with_cleanup_p
)
223 slot
= build (VAR_DECL
, type
);
224 layout_decl (slot
, 0);
225 rval
= build (NEW_EXPR
, type
,
226 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
227 TREE_SIDE_EFFECTS (rval
) = 1;
228 TREE_ADDRESSABLE (rval
) = 1;
229 rval
= build (TARGET_EXPR
, type
, slot
, rval
, 0);
230 TREE_SIDE_EFFECTS (rval
) = 1;
231 TREE_ADDRESSABLE (rval
) = 1;
234 if (with_cleanup_p
&& TYPE_NEEDS_DESTRUCTOR (type
))
236 TREE_OPERAND (rval
, 2) = error_mark_node
;
237 rval
= build (WITH_CLEANUP_EXPR
, type
, rval
, 0,
238 build_delete (TYPE_POINTER_TO (type
),
239 build_unary_op (ADDR_EXPR
, slot
, 0),
241 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0));
242 TREE_SIDE_EFFECTS (rval
) = 1;
243 TREE_ADDRESSABLE (rval
) = 1;
249 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
250 these CALL_EXPRs with tree nodes that will perform the cleanups. */
253 break_out_cleanups (exp
)
258 if (TREE_CODE (tmp
) == CALL_EXPR
259 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
260 return build_cplus_new (TREE_TYPE (tmp
), tmp
, 1);
262 while (TREE_CODE (tmp
) == NOP_EXPR
263 || TREE_CODE (tmp
) == CONVERT_EXPR
264 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
266 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
267 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
269 TREE_OPERAND (tmp
, 0)
270 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
271 TREE_OPERAND (tmp
, 0), 1);
275 tmp
= TREE_OPERAND (tmp
, 0);
280 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
281 copies where they are found. Returns a deep copy all nodes transitively
282 containing CALL_EXPRs. */
285 break_out_calls (exp
)
288 register tree t1
, t2
;
289 register enum tree_code code
;
290 register int changed
= 0;
293 if (exp
== NULL_TREE
)
296 code
= TREE_CODE (exp
);
298 if (code
== CALL_EXPR
)
299 return copy_node (exp
);
301 /* Don't try and defeat a save_expr, as it should only be done once. */
302 if (code
== SAVE_EXPR
)
305 switch (TREE_CODE_CLASS (code
))
310 case 'c': /* a constant */
311 case 't': /* a type node */
312 case 'x': /* something random, like an identifier or an ERROR_MARK. */
315 case 'd': /* A decl node */
316 #if 0 /* This is bogus. jason 9/21/94 */
318 t1
= break_out_calls (DECL_INITIAL (exp
));
319 if (t1
!= DECL_INITIAL (exp
))
321 exp
= copy_node (exp
);
322 DECL_INITIAL (exp
) = t1
;
327 case 'b': /* A block node */
329 /* Don't know how to handle these correctly yet. Must do a
330 break_out_calls on all DECL_INITIAL values for local variables,
331 and also break_out_calls on all sub-blocks and sub-statements. */
336 case 'e': /* an expression */
337 case 'r': /* a reference */
338 case 's': /* an expression with side effects */
339 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
341 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
342 if (t1
!= TREE_OPERAND (exp
, i
))
344 exp
= copy_node (exp
);
345 TREE_OPERAND (exp
, i
) = t1
;
350 case '<': /* a comparison expression */
351 case '2': /* a binary arithmetic expression */
352 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
353 if (t2
!= TREE_OPERAND (exp
, 1))
355 case '1': /* a unary arithmetic expression */
356 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
357 if (t1
!= TREE_OPERAND (exp
, 0))
361 if (tree_code_length
[(int) code
] == 1)
362 return build1 (code
, TREE_TYPE (exp
), t1
);
364 return build (code
, TREE_TYPE (exp
), t1
, t2
);
371 extern struct obstack
*current_obstack
;
372 extern struct obstack permanent_obstack
, class_obstack
;
373 extern struct obstack
*saveable_obstack
;
375 /* Here is how primitive or already-canonicalized types' hash
376 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
377 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
379 /* Construct, lay out and return the type of methods belonging to class
380 BASETYPE and whose arguments are described by ARGTYPES and whose values
381 are described by RETTYPE. If each type exists already, reuse it. */
383 build_cplus_method_type (basetype
, rettype
, argtypes
)
384 tree basetype
, rettype
, argtypes
;
390 /* Make a node of the sort we want. */
391 t
= make_node (METHOD_TYPE
);
393 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
394 TREE_TYPE (t
) = rettype
;
395 if (IS_SIGNATURE (basetype
))
396 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
397 TYPE_READONLY (basetype
),
398 TYPE_VOLATILE (basetype
));
400 ptype
= build_pointer_type (basetype
);
402 /* The actual arglist for this function includes a "hidden" argument
403 which is "this". Put it into the list of argument types. */
405 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
406 TYPE_ARG_TYPES (t
) = argtypes
;
407 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
409 /* If we already have such a type, use the old one and free this one.
410 Note that it also frees up the above cons cell if found. */
411 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
412 t
= type_hash_canon (hashcode
, t
);
414 if (TYPE_SIZE (t
) == 0)
421 build_cplus_staticfn_type (basetype
, rettype
, argtypes
)
422 tree basetype
, rettype
, argtypes
;
427 /* Make a node of the sort we want. */
428 t
= make_node (FUNCTION_TYPE
);
430 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
431 TREE_TYPE (t
) = rettype
;
433 TYPE_ARG_TYPES (t
) = argtypes
;
435 /* If we already have such a type, use the old one and free this one.
436 Note that it also frees up the above cons cell if found. */
437 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
438 t
= type_hash_canon (hashcode
, t
);
440 if (TYPE_SIZE (t
) == 0)
447 build_cplus_array_type (elt_type
, index_type
)
451 register struct obstack
*ambient_obstack
= current_obstack
;
452 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
455 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
456 make this permanent too. */
457 if (TREE_PERMANENT (elt_type
)
458 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
460 current_obstack
= &permanent_obstack
;
461 saveable_obstack
= &permanent_obstack
;
464 t
= build_array_type (elt_type
, index_type
);
466 /* Push these needs up so that initialization takes place
468 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
469 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
470 current_obstack
= ambient_obstack
;
471 saveable_obstack
= ambient_saveable_obstack
;
475 /* Make a variant type in the proper way for C/C++, propagating qualifiers
476 down to the element type of an array. */
479 cp_build_type_variant (type
, constp
, volatilep
)
481 int constp
, volatilep
;
483 if (TREE_CODE (type
) == ARRAY_TYPE
)
485 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
487 push_obstacks (TYPE_OBSTACK (real_main_variant
),
488 TYPE_OBSTACK (real_main_variant
));
489 type
= build_cplus_array_type (cp_build_type_variant (TREE_TYPE (type
),
493 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
494 make a copy. (TYPE might have come from the hash table and
495 REAL_MAIN_VARIANT might be in some function's obstack.) */
497 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
499 type
= copy_node (type
);
500 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
503 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
506 return build_type_variant (type
, constp
, volatilep
);
509 /* Add OFFSET to all base types of T.
511 OFFSET, which is a type offset, is number of bytes.
513 Note that we don't have to worry about having two paths to the
514 same base type, since this type owns its association list. */
516 propagate_binfo_offsets (binfo
, offset
)
520 tree binfos
= BINFO_BASETYPES (binfo
);
521 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
523 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
525 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
527 if (TREE_VIA_VIRTUAL (base_binfo
))
532 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
535 for (j
= i
+1; j
< n_baselinks
; j
++)
536 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
538 /* The next basetype offset must take into account the space
539 between the classes, not just the size of each class. */
540 delta
= size_binop (MINUS_EXPR
,
541 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
542 BINFO_OFFSET (base_binfo
));
547 if (BINFO_OFFSET_ZEROP (base_binfo
))
548 BINFO_OFFSET (base_binfo
) = offset
;
550 BINFO_OFFSET (base_binfo
)
551 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
553 BINFO_OFFSET (base_binfo
) = offset
;
558 tree chain
= NULL_TREE
;
560 /* Now unshare the structure beneath BASE_BINFO. */
561 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
564 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
565 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
566 TREE_VEC_ELT (base_binfos
, k
)
567 = make_binfo (BINFO_OFFSET (base_base_binfo
),
569 BINFO_VTABLE (base_base_binfo
),
570 BINFO_VIRTUALS (base_base_binfo
),
572 chain
= TREE_VEC_ELT (base_binfos
, k
);
573 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
574 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
575 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
577 /* Now propagate the offset to the base types. */
578 propagate_binfo_offsets (base_binfo
, offset
);
581 /* Go to our next class that counts for offset propagation. */
584 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
589 /* Compute the actual offsets that our virtual base classes
590 will have *for this type*. This must be performed after
591 the fields are laid out, since virtual baseclasses must
592 lay down at the end of the record.
594 Returns the maximum number of virtual functions any of the virtual
595 baseclasses provide. */
597 layout_vbasetypes (rec
, max
)
601 /* Get all the virtual base types that this type uses.
602 The TREE_VALUE slot holds the virtual baseclass type. */
603 tree vbase_types
= get_vbase_types (rec
);
605 #ifdef STRUCTURE_SIZE_BOUNDARY
606 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
608 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
612 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
613 where CONST_SIZE is an integer
614 and VAR_SIZE is a tree expression.
615 If VAR_SIZE is null, the size is just CONST_SIZE.
616 Naturally we try to avoid using VAR_SIZE. */
617 register unsigned const_size
= 0;
618 register tree var_size
= 0;
619 int nonvirtual_const_size
;
620 tree nonvirtual_var_size
;
622 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
624 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
625 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
627 var_size
= TYPE_SIZE (rec
);
629 nonvirtual_const_size
= const_size
;
630 nonvirtual_var_size
= var_size
;
634 tree basetype
= BINFO_TYPE (vbase_types
);
637 desired_align
= TYPE_ALIGN (basetype
);
638 record_align
= MAX (record_align
, desired_align
);
641 offset
= integer_zero_node
;
644 /* Give each virtual base type the alignment it wants. */
645 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
646 * TYPE_ALIGN (basetype
);
647 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
650 if (CLASSTYPE_VSIZE (basetype
) > max
)
651 max
= CLASSTYPE_VSIZE (basetype
);
652 BINFO_OFFSET (vbase_types
) = offset
;
654 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
656 /* Every virtual baseclass takes a least a UNIT, so that we can
657 take it's address and get something different for each base. */
658 const_size
+= MAX (BITS_PER_UNIT
,
659 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
660 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
662 else if (var_size
== 0)
663 var_size
= TYPE_SIZE (basetype
);
665 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
667 vbase_types
= TREE_CHAIN (vbase_types
);
672 /* Because a virtual base might take a single byte above,
673 we have to re-adjust the total size to make sure it it
674 a multiple of the alignment. */
675 /* Give the whole object the alignment it wants. */
676 const_size
= CEIL (const_size
, record_align
) * record_align
;
679 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
680 here, as that is for this class, without any virtual base classes. */
681 TYPE_ALIGN (rec
) = record_align
;
682 if (const_size
!= nonvirtual_const_size
)
684 CLASSTYPE_VBASE_SIZE (rec
)
685 = size_int (const_size
- nonvirtual_const_size
);
686 TYPE_SIZE (rec
) = size_int (const_size
);
689 /* Now propagate offset information throughout the lattice
690 under the vbase type. */
691 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
692 vbase_types
= TREE_CHAIN (vbase_types
))
694 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
696 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
700 tree chain
= NULL_TREE
;
702 /* Now unshare the structure beneath BASE_BINFO. */
704 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
707 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
708 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
709 TREE_VEC_ELT (base_binfos
, j
)
710 = make_binfo (BINFO_OFFSET (base_base_binfo
),
712 BINFO_VTABLE (base_base_binfo
),
713 BINFO_VIRTUALS (base_base_binfo
),
715 chain
= TREE_VEC_ELT (base_binfos
, j
);
716 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
717 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
718 BINFO_INHERITANCE_CHAIN (chain
) = vbase_types
;
721 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
728 /* Lay out the base types of a record type, REC.
729 Tentatively set the size and alignment of REC
730 according to the base types alone.
732 Offsets for immediate nonvirtual baseclasses are also computed here.
734 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
735 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
737 Returns list of virtual base classes in a FIELD_DECL chain. */
739 layout_basetypes (rec
, binfos
)
742 /* Chain to hold all the new FIELD_DECLs which point at virtual
744 tree vbase_decls
= NULL_TREE
;
746 #ifdef STRUCTURE_SIZE_BOUNDARY
747 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
749 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
752 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
753 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
754 the size is just CONST_SIZE. Naturally we try to avoid using
755 VAR_SIZE. And so far, we've been sucessful. */
757 register tree var_size
= 0;
760 register unsigned const_size
= 0;
761 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
763 /* Handle basetypes almost like fields, but record their
764 offsets differently. */
766 for (i
= 0; i
< n_baseclasses
; i
++)
768 int inc
, desired_align
, int_vbase_size
;
769 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
770 register tree basetype
= BINFO_TYPE (base_binfo
);
773 if (TYPE_SIZE (basetype
) == 0)
776 /* This error is now reported in xref_tag, thus giving better
777 location information. */
778 error_with_aggr_type (base_binfo
,
779 "base class `%s' has incomplete type");
781 TREE_VIA_PUBLIC (base_binfo
) = 1;
782 TREE_VIA_PROTECTED (base_binfo
) = 0;
783 TREE_VIA_VIRTUAL (base_binfo
) = 0;
785 /* Should handle this better so that
788 class B: private A { virtual void F(); };
790 does not dump core when compiled. */
791 my_friendly_abort (121);
796 /* All basetypes are recorded in the association list of the
799 if (TREE_VIA_VIRTUAL (base_binfo
))
802 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
803 + sizeof (VBASE_NAME
) + 1);
805 /* The offset for a virtual base class is only used in computing
806 virtual function tables and for initializing virtual base
807 pointers. It is built once `get_vbase_types' is called. */
809 /* If this basetype can come from another vbase pointer
810 without an additional indirection, we will share
811 that pointer. If an indirection is involved, we
812 make our own pointer. */
813 for (j
= 0; j
< n_baseclasses
; j
++)
815 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
816 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
817 && binfo_member (basetype
,
818 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
821 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
822 decl
= build_lang_decl (FIELD_DECL
, get_identifier (name
),
823 build_pointer_type (basetype
));
824 /* If you change any of the below, take a look at all the
825 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
827 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
828 DECL_VIRTUAL_P (decl
) = 1;
829 DECL_FIELD_CONTEXT (decl
) = rec
;
830 DECL_CLASS_CONTEXT (decl
) = rec
;
831 DECL_FCONTEXT (decl
) = basetype
;
832 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
833 DECL_FIELD_SIZE (decl
) = 0;
834 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
835 TREE_CHAIN (decl
) = vbase_decls
;
836 BINFO_VPTR_FIELD (base_binfo
) = decl
;
839 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
840 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
842 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
843 "destructor `%s' non-virtual");
844 warning ("in inheritance relationship `%s: virtual %s'",
845 TYPE_NAME_STRING (rec
),
846 TYPE_NAME_STRING (basetype
));
849 /* The space this decl occupies has already been accounted for. */
854 offset
= integer_zero_node
;
857 /* Give each base type the alignment it wants. */
858 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
859 * TYPE_ALIGN (basetype
);
860 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
863 /* bpk: Disabled this check until someone is willing to
864 claim it as theirs and explain exactly what circumstances
865 warrant the warning. */
866 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
867 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
869 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
870 "destructor `%s' non-virtual");
871 warning ("in inheritance relationship `%s:%s %s'",
872 TYPE_NAME_STRING (rec
),
873 TREE_VIA_VIRTUAL (base_binfo
) ? " virtual" : "",
874 TYPE_NAME_STRING (basetype
));
878 BINFO_OFFSET (base_binfo
) = offset
;
879 if (CLASSTYPE_VSIZE (basetype
))
881 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
882 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
884 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
885 TYPE_BINFO (rec
) = base_binfo
;
887 /* Add only the amount of storage not present in
888 the virtual baseclasses. */
890 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
891 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
893 inc
= MAX (record_align
,
894 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
897 /* Record must have at least as much alignment as any field. */
898 desired_align
= TYPE_ALIGN (basetype
);
899 record_align
= MAX (record_align
, desired_align
);
906 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
908 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
909 CLASSTYPE_ALIGN (rec
) = record_align
;
914 /* Hashing of lists so that we don't make duplicates.
915 The entry point is `list_hash_canon'. */
917 /* Each hash table slot is a bucket containing a chain
918 of these structures. */
922 struct list_hash
*next
; /* Next structure in the bucket. */
923 int hashcode
; /* Hash code of this list. */
924 tree list
; /* The list recorded here. */
927 /* Now here is the hash table. When recording a list, it is added
928 to the slot whose index is the hash code mod the table size.
929 Note that the hash table is used for several kinds of lists.
930 While all these live in the same table, they are completely independent,
931 and the hash code is computed differently for each of these. */
933 #define TYPE_HASH_SIZE 59
934 struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
936 /* Compute a hash code for a list (chain of TREE_LIST nodes
937 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
938 TREE_COMMON slots), by adding the hash codes of the individual entries. */
944 register int hashcode
= 0;
946 if (TREE_CHAIN (list
))
947 hashcode
+= TYPE_HASH (TREE_CHAIN (list
));
949 if (TREE_VALUE (list
))
950 hashcode
+= TYPE_HASH (TREE_VALUE (list
));
953 if (TREE_PURPOSE (list
))
954 hashcode
+= TYPE_HASH (TREE_PURPOSE (list
));
960 /* Look in the type hash table for a type isomorphic to TYPE.
961 If one is found, return it. Otherwise return 0. */
964 list_hash_lookup (hashcode
, list
)
968 register struct list_hash
*h
;
969 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
970 if (h
->hashcode
== hashcode
971 && TREE_VIA_VIRTUAL (h
->list
) == TREE_VIA_VIRTUAL (list
)
972 && TREE_VIA_PUBLIC (h
->list
) == TREE_VIA_PUBLIC (list
)
973 && TREE_VIA_PROTECTED (h
->list
) == TREE_VIA_PROTECTED (list
)
974 && TREE_PURPOSE (h
->list
) == TREE_PURPOSE (list
)
975 && TREE_VALUE (h
->list
) == TREE_VALUE (list
)
976 && TREE_CHAIN (h
->list
) == TREE_CHAIN (list
))
978 my_friendly_assert (TREE_TYPE (h
->list
) == TREE_TYPE (list
), 299);
984 /* Add an entry to the list-hash-table
985 for a list TYPE whose hash code is HASHCODE. */
988 list_hash_add (hashcode
, list
)
992 register struct list_hash
*h
;
994 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
995 h
->hashcode
= hashcode
;
997 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
998 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1001 /* Given TYPE, and HASHCODE its hash code, return the canonical
1002 object for an identical list if one already exists.
1003 Otherwise, return TYPE, and record it as the canonical object
1004 if it is a permanent object.
1006 To use this function, first create a list of the sort you want.
1007 Then compute its hash code from the fields of the list that
1008 make it different from other similar lists.
1009 Then call this function and use the value.
1010 This function frees the list you pass in if it is a duplicate. */
1012 /* Set to 1 to debug without canonicalization. Never set by program. */
1013 static int debug_no_list_hash
= 0;
1016 list_hash_canon (hashcode
, list
)
1022 if (debug_no_list_hash
)
1025 t1
= list_hash_lookup (hashcode
, list
);
1028 obstack_free (&class_obstack
, list
);
1032 /* If this is a new list, record it for later reuse. */
1033 list_hash_add (hashcode
, list
);
1039 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1040 int via_public
, via_virtual
, via_protected
;
1041 tree purpose
, value
, chain
;
1043 struct obstack
*ambient_obstack
= current_obstack
;
1047 current_obstack
= &class_obstack
;
1048 t
= tree_cons (purpose
, value
, chain
);
1049 TREE_VIA_PUBLIC (t
) = via_public
;
1050 TREE_VIA_PROTECTED (t
) = via_protected
;
1051 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1052 hashcode
= list_hash (t
);
1053 t
= list_hash_canon (hashcode
, t
);
1054 current_obstack
= ambient_obstack
;
1058 /* Constructor for hashed lists. */
1060 hash_tree_chain (value
, chain
)
1063 struct obstack
*ambient_obstack
= current_obstack
;
1067 current_obstack
= &class_obstack
;
1068 t
= tree_cons (NULL_TREE
, value
, chain
);
1069 hashcode
= list_hash (t
);
1070 t
= list_hash_canon (hashcode
, t
);
1071 current_obstack
= ambient_obstack
;
1075 /* Similar, but used for concatenating two lists. */
1077 hash_chainon (list1
, list2
)
1084 if (TREE_CHAIN (list1
) == NULL_TREE
)
1085 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1086 return hash_tree_chain (TREE_VALUE (list1
),
1087 hash_chainon (TREE_CHAIN (list1
), list2
));
1091 get_identifier_list (value
)
1094 tree list
= IDENTIFIER_AS_LIST (value
);
1095 if (list
!= NULL_TREE
1096 && (TREE_CODE (list
) != TREE_LIST
1097 || TREE_VALUE (list
) != value
))
1099 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1100 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1101 && IDENTIFIER_TYPE_VALUE (value
)
1102 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1104 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1106 if (TYPE_PTRMEMFUNC_P (type
))
1108 else if (type
== current_class_type
)
1109 /* Don't mess up the constructor name. */
1110 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1114 /* This will return the correct thing for regular types,
1115 nested types, and templates. Yay! */
1116 if (TYPE_NESTED_NAME (type
))
1117 id
= TYPE_NESTED_NAME (type
);
1119 id
= TYPE_IDENTIFIER (type
);
1121 if (CLASSTYPE_ID_AS_LIST (type
) == NULL_TREE
)
1122 CLASSTYPE_ID_AS_LIST (type
)
1123 = perm_tree_cons (NULL_TREE
, id
, NULL_TREE
);
1124 list
= CLASSTYPE_ID_AS_LIST (type
);
1131 get_decl_list (value
)
1134 tree list
= NULL_TREE
;
1136 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1137 list
= get_identifier_list (value
);
1138 else if (TREE_CODE (value
) == RECORD_TYPE
1139 && TYPE_LANG_SPECIFIC (value
))
1140 list
= CLASSTYPE_AS_LIST (value
);
1142 if (list
!= NULL_TREE
)
1144 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1148 return build_decl_list (NULL_TREE
, value
);
1151 /* Look in the type hash table for a type isomorphic to
1152 `build_tree_list (NULL_TREE, VALUE)'.
1153 If one is found, return it. Otherwise return 0. */
1156 list_hash_lookup_or_cons (value
)
1159 register int hashcode
= TYPE_HASH (value
);
1160 register struct list_hash
*h
;
1161 struct obstack
*ambient_obstack
;
1162 tree list
= NULL_TREE
;
1164 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1165 list
= get_identifier_list (value
);
1166 else if (TREE_CODE (value
) == TYPE_DECL
1167 && TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
1168 && TYPE_LANG_SPECIFIC (TREE_TYPE (value
)))
1169 list
= CLASSTYPE_ID_AS_LIST (TREE_TYPE (value
));
1170 else if (TREE_CODE (value
) == RECORD_TYPE
1171 && TYPE_LANG_SPECIFIC (value
))
1172 list
= CLASSTYPE_AS_LIST (value
);
1174 if (list
!= NULL_TREE
)
1176 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 302);
1180 if (debug_no_list_hash
)
1181 return hash_tree_chain (value
, NULL_TREE
);
1183 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1184 if (h
->hashcode
== hashcode
1185 && TREE_VIA_VIRTUAL (h
->list
) == 0
1186 && TREE_VIA_PUBLIC (h
->list
) == 0
1187 && TREE_VIA_PROTECTED (h
->list
) == 0
1188 && TREE_PURPOSE (h
->list
) == 0
1189 && TREE_VALUE (h
->list
) == value
)
1191 my_friendly_assert (TREE_TYPE (h
->list
) == 0, 303);
1192 my_friendly_assert (TREE_CHAIN (h
->list
) == 0, 304);
1196 ambient_obstack
= current_obstack
;
1197 current_obstack
= &class_obstack
;
1198 list
= build_tree_list (NULL_TREE
, value
);
1199 list_hash_add (hashcode
, list
);
1200 current_obstack
= ambient_obstack
;
1204 /* Build an association between TYPE and some parameters:
1206 OFFSET is the offset added to `this' to convert it to a pointer
1209 BINFO is the base binfo to use, if we are deriving from one. This
1210 is necessary, as we want specialized parent binfos from base
1211 classes, so that the VTABLE_NAMEs of bases are for the most derived
1212 type, instead of of the simple type.
1214 VTABLE is the virtual function table with which to initialize
1215 sub-objects of type TYPE.
1217 VIRTUALS are the virtual functions sitting in VTABLE.
1219 CHAIN are more associations we must retain. */
1222 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1224 tree vtable
, virtuals
;
1227 tree new_binfo
= make_tree_vec (6);
1230 if (TREE_CODE (binfo
) == TREE_VEC
)
1231 type
= BINFO_TYPE (binfo
);
1235 binfo
= TYPE_BINFO (binfo
);
1238 TREE_CHAIN (new_binfo
) = chain
;
1240 TREE_USED (new_binfo
) = TREE_USED (chain
);
1242 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1243 BINFO_OFFSET (new_binfo
) = offset
;
1244 BINFO_VTABLE (new_binfo
) = vtable
;
1245 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1246 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1248 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1249 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1253 /* Return the binfo value for ELEM in TYPE. */
1256 binfo_value (elem
, type
)
1260 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1261 compiler_error ("base class `%s' ambiguous in binfo_value",
1262 TYPE_NAME_STRING (elem
));
1264 return TYPE_BINFO (type
);
1265 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1267 return get_binfo (elem
, type
, 0);
1274 register tree prev
= 0, tmp
, next
;
1275 for (tmp
= path
; tmp
; tmp
= next
)
1277 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1278 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1285 virtual_member (elem
, list
)
1292 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1293 if (elem
== BINFO_TYPE (t
))
1296 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1298 tree binfos
= BINFO_BASETYPES (t
);
1301 if (binfos
!= NULL_TREE
)
1302 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1304 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1307 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1308 my_friendly_abort (104);
1323 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1324 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1325 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1326 fprintf (stderr
, "vtable type:\n");
1327 debug_tree (BINFO_TYPE (elem
));
1328 if (BINFO_VTABLE (elem
))
1329 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1331 fprintf (stderr
, "no vtable decl yet\n");
1332 fprintf (stderr
, "virtuals:\n");
1333 virtuals
= BINFO_VIRTUALS (elem
);
1336 /* skip the rtti type descriptor entry */
1337 virtuals
= TREE_CHAIN (virtuals
);
1342 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1343 fprintf (stderr
, "%s [%d =? %d]\n",
1344 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1345 i
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1346 virtuals
= TREE_CHAIN (virtuals
);
1351 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1352 We expect a null pointer to mark the end of the chain.
1353 This is the Lisp primitive `length'. */
1356 decl_list_length (t
)
1360 register int len
= 0;
1362 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1363 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1364 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1374 if (TREE_CODE (t
) == FUNCTION_DECL
)
1376 else if (TREE_CODE (t
) == TREE_LIST
)
1377 return decl_list_length (TREE_VALUE (t
));
1379 my_friendly_abort (359);
1383 /* Like value_member, but for DECL_CHAINs. */
1385 decl_value_member (elem
, list
)
1392 list
= DECL_CHAIN (list
);
1398 is_overloaded_fn (x
)
1401 if (TREE_CODE (x
) == FUNCTION_DECL
)
1404 if (TREE_CODE (x
) == TREE_LIST
1405 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1406 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1413 really_overloaded_fn (x
)
1416 if (TREE_CODE (x
) == TREE_LIST
1417 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1418 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1428 if (TREE_CODE (from
) == FUNCTION_DECL
)
1431 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1433 return TREE_VALUE (from
);
1437 fnaddr_from_vtable_entry (entry
)
1440 if (flag_vtable_thunks
)
1443 if (TREE_CODE (func
) == ADDR_EXPR
)
1444 func
= TREE_OPERAND (func
, 0);
1445 if (TREE_CODE (func
) == THUNK_DECL
)
1446 return DECL_INITIAL (func
);
1451 return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
))));
1455 set_fnaddr_from_vtable_entry (entry
, value
)
1458 if (flag_vtable_thunks
)
1461 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
)))) = value
;
1465 function_arg_chain (t
)
1468 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t
)));
1472 promotes_to_aggr_type (t
, code
)
1474 enum tree_code code
;
1476 if (TREE_CODE (t
) == code
)
1478 return IS_AGGR_TYPE (t
);
1482 is_aggr_type_2 (t1
, t2
)
1485 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1487 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1490 /* Give message using types TYPE1 and TYPE2 as arguments.
1491 PFN is the function which will print the message;
1492 S is the format string for PFN to use. */
1494 message_2_types (pfn
, s
, type1
, type2
)
1499 tree name1
= TYPE_NAME (type1
);
1500 tree name2
= TYPE_NAME (type2
);
1501 if (TREE_CODE (name1
) == TYPE_DECL
)
1502 name1
= DECL_NAME (name1
);
1503 if (TREE_CODE (name2
) == TYPE_DECL
)
1504 name2
= DECL_NAME (name2
);
1505 (*pfn
) (s
, IDENTIFIER_POINTER (name1
), IDENTIFIER_POINTER (name2
));
1508 #define PRINT_RING_SIZE 4
1511 lang_printable_name (decl
)
1514 static tree decl_ring
[PRINT_RING_SIZE
];
1515 static char *print_ring
[PRINT_RING_SIZE
];
1516 static int ring_counter
;
1519 /* Only cache functions. */
1520 if (TREE_CODE (decl
) != FUNCTION_DECL
1521 || DECL_LANG_SPECIFIC (decl
) == 0)
1522 return decl_as_string (decl
, 1);
1524 /* See if this print name is lying around. */
1525 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1526 if (decl_ring
[i
] == decl
)
1527 /* yes, so return it. */
1528 return print_ring
[i
];
1530 if (++ring_counter
== PRINT_RING_SIZE
)
1533 if (current_function_decl
!= NULL_TREE
)
1535 if (decl_ring
[ring_counter
] == current_function_decl
)
1537 if (ring_counter
== PRINT_RING_SIZE
)
1539 if (decl_ring
[ring_counter
] == current_function_decl
)
1540 my_friendly_abort (106);
1543 if (print_ring
[ring_counter
])
1544 free (print_ring
[ring_counter
]);
1547 int print_ret_type_p
1548 = (!DECL_CONSTRUCTOR_P (decl
)
1549 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)));
1551 char *name
= (char *)decl_as_string (decl
, print_ret_type_p
);
1552 print_ring
[ring_counter
] = (char *)malloc (strlen (name
) + 1);
1553 strcpy (print_ring
[ring_counter
], name
);
1554 decl_ring
[ring_counter
] = decl
;
1556 return print_ring
[ring_counter
];
1559 /* Comparison function for sorting identifiers in RAISES lists.
1560 Note that because IDENTIFIER_NODEs are unique, we can sort
1561 them by address, saving an indirection. */
1566 return (HOST_WIDE_INT
)TREE_VALUE (*p1
) - (HOST_WIDE_INT
)TREE_VALUE (*p2
);
1569 /* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
1570 listed in RAISES. */
1572 build_exception_variant (ctype
, type
, raises
)
1577 tree v
= TYPE_MAIN_VARIANT (type
);
1579 tree
*a
= (tree
*)alloca ((list_length (raises
)+1) * sizeof (tree
));
1580 int constp
= TYPE_READONLY (type
);
1581 int volatilep
= TYPE_VOLATILE (type
);
1583 for (v
= TYPE_NEXT_VARIANT (v
); v
; v
= TYPE_NEXT_VARIANT (v
))
1585 if (TYPE_READONLY (v
) != constp
1586 || TYPE_VOLATILE (v
) != volatilep
)
1589 /* @@ This should do set equality, not exact match. */
1590 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1591 /* List of exceptions raised matches previously found list.
1593 @@ Nice to free up storage used in consing up the
1594 @@ list of exceptions raised. */
1598 /* Need to build a new variant. */
1599 v
= copy_node (type
);
1600 TYPE_NEXT_VARIANT (v
) = TYPE_NEXT_VARIANT (type
);
1601 TYPE_NEXT_VARIANT (type
) = v
;
1602 if (raises
&& ! TREE_PERMANENT (raises
))
1604 push_obstacks_nochange ();
1605 end_temporary_allocation ();
1606 raises
= copy_list (raises
);
1609 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1613 /* Subroutine of copy_to_permanent
1615 Assuming T is a node build bottom-up, make it all exist on
1616 permanent obstack, if it is not permanent already. */
1623 enum tree_code code
;
1629 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1632 switch (code
= TREE_CODE (t
))
1635 return error_mark_node
;
1644 tree chain
= TREE_CHAIN (t
);
1646 TREE_CHAIN (t
) = mapcar (chain
, func
);
1647 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1648 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1649 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1655 tree chain
= TREE_CHAIN (t
);
1657 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1658 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1659 TREE_CHAIN (t
) = mapcar (chain
, func
);
1665 int len
= TREE_VEC_LENGTH (t
);
1669 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1676 return copy_node (t
);
1682 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1683 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1684 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1689 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1696 case TRUNC_DIV_EXPR
:
1697 case TRUNC_MOD_EXPR
:
1705 case BIT_ANDTC_EXPR
:
1706 case TRUTH_ANDIF_EXPR
:
1707 case TRUTH_ORIF_EXPR
:
1715 case FLOOR_DIV_EXPR
:
1716 case ROUND_DIV_EXPR
:
1718 case FLOOR_MOD_EXPR
:
1719 case ROUND_MOD_EXPR
:
1721 case PREDECREMENT_EXPR
:
1722 case PREINCREMENT_EXPR
:
1723 case POSTDECREMENT_EXPR
:
1724 case POSTINCREMENT_EXPR
:
1727 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1728 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1736 case TRUTH_NOT_EXPR
:
1740 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1744 return build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1745 case REFERENCE_TYPE
:
1746 return build_reference_type (mapcar (TREE_TYPE (t
), func
));
1748 return build_function_type (mapcar (TREE_TYPE (t
), func
),
1749 mapcar (TYPE_ARG_TYPES (t
), func
));
1751 return build_array_type (mapcar (TREE_TYPE (t
), func
),
1752 mapcar (TYPE_DOMAIN (t
), func
));
1754 return build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1757 return build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1758 mapcar (TREE_TYPE (t
), func
));
1760 return build_method_type
1761 (mapcar (TYPE_METHOD_BASETYPE (t
), func
),
1763 (mapcar (TREE_TYPE (t
), func
),
1764 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
)));
1767 if (TYPE_PTRMEMFUNC_P (t
))
1768 return build_ptrmemfunc_type
1769 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1770 /* else fall through */
1772 /* This list is incomplete, but should suffice for now.
1773 It is very important that `sorry' does not call
1774 `report_error_function'. That could cause an infinite loop. */
1776 sorry ("initializer contains unrecognized tree code");
1777 return error_mark_node
;
1780 my_friendly_abort (107);
1789 if (TREE_PERMANENT (t
))
1794 /* Assuming T is a node built bottom-up, make it all exist on
1795 permanent obstack, if it is not permanent already. */
1797 copy_to_permanent (t
)
1800 register struct obstack
*ambient_obstack
= current_obstack
;
1801 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1804 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1807 saveable_obstack
= &permanent_obstack
;
1808 current_obstack
= saveable_obstack
;
1809 resume
= suspend_momentary ();
1811 t
= mapcar (t
, perm_manip
);
1813 resume_momentary (resume
);
1814 current_obstack
= ambient_obstack
;
1815 saveable_obstack
= ambient_saveable_obstack
;
1821 print_lang_statistics ()
1823 extern struct obstack maybepermanent_obstack
;
1824 print_obstack_statistics ("class_obstack", &class_obstack
);
1825 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1826 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1827 print_search_statistics ();
1828 print_class_statistics ();
1831 /* This is used by the `assert' macro. It is provided in libgcc.a,
1832 which `cc' doesn't know how to link. Note that the C++ front-end
1833 no longer actually uses the `assert' macro (instead, it calls
1834 my_friendly_assert). But all of the back-end files still need this. */
1836 __eprintf (string
, expression
, line
, filename
)
1839 const char *expression
;
1841 const char *filename
;
1849 fprintf (stderr
, string
, expression
, line
, filename
);
1854 /* Return, as an INTEGER_CST node, the number of elements for
1855 TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1858 array_type_nelts_top (type
)
1861 return fold (build (PLUS_EXPR
, sizetype
,
1862 array_type_nelts (type
),
1866 /* Return, as an INTEGER_CST node, the number of elements for
1867 TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1868 ARRAY_TYPEs that are clumped together. */
1871 array_type_nelts_total (type
)
1874 tree sz
= array_type_nelts_top (type
);
1875 type
= TREE_TYPE (type
);
1876 while (TREE_CODE (type
) == ARRAY_TYPE
)
1878 tree n
= array_type_nelts_top (type
);
1879 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1880 type
= TREE_TYPE (type
);
1890 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1892 else if (TREE_CODE (t
) == TARGET_EXPR
)
1893 return build_cplus_new (TREE_TYPE (t
),
1894 break_out_target_exprs (TREE_OPERAND (t
, 1)), 0);
1898 /* Actually, we'll just clean out the target exprs for the moment. */
1900 break_out_target_exprs (t
)
1903 return mapcar (t
, bot_manip
);