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. */
28 #define CEIL(x,y) (((x) + (y) - 1) / (y))
30 /* Return nonzero if REF is an lvalue valid for this language.
31 Lvalues can be assigned, unless they have TREE_READONLY.
32 Lvalues can have their address taken, unless they have DECL_REGISTER. */
38 register enum tree_code code
= TREE_CODE (ref
);
40 if (language_lvalue_valid (ref
))
43 /* preincrements and predecrements are valid lvals, provided
44 what they refer to are valid lvals. */
45 case PREINCREMENT_EXPR
:
46 case PREDECREMENT_EXPR
:
49 return lvalue_p (TREE_OPERAND (ref
, 0));
55 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
56 && DECL_LANG_SPECIFIC (ref
)
57 && DECL_IN_AGGR_P (ref
))
64 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
65 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
70 case WITH_CLEANUP_EXPR
:
74 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
75 /* unary_complex_lvalue knows how to deal with this case. */
76 || TREE_ADDRESSABLE (TREE_TYPE (ref
)))
80 /* A currently unresolved scope ref. */
82 my_friendly_abort (103);
84 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
86 return lvalue_p (TREE_OPERAND (ref
, 0))
87 && lvalue_p (TREE_OPERAND (ref
, 1));
91 /* ANSI C++ June 5 1992 WP 5.4.14. The result of a cast to a
92 reference is an lvalue. */
93 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
98 return (lvalue_p (TREE_OPERAND (ref
, 1))
99 && lvalue_p (TREE_OPERAND (ref
, 2)));
104 /* Return nonzero if REF is an lvalue valid for this language;
105 otherwise, print an error message and return zero. */
108 lvalue_or_else (ref
, string
)
112 int win
= lvalue_p (ref
);
114 error ("invalid lvalue in %s", string
);
118 /* INIT is a CALL_EXPR which needs info about its target.
119 TYPE is the type that this initialization should appear to have.
121 Build an encapsulation of the initialization to perform
122 and return it so that it can be processed by language-independent
123 and language-specific expression expanders.
125 If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
126 Otherwise, cleanups are not built here. For example, when building
127 an initialization for a stack slot, since the called function handles
128 the cleanup, we would not want to do it here. */
130 build_cplus_new (type
, init
, with_cleanup_p
)
135 tree slot
= build (VAR_DECL
, type
);
136 tree rval
= build (NEW_EXPR
, type
,
137 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
138 TREE_SIDE_EFFECTS (rval
) = 1;
139 TREE_ADDRESSABLE (rval
) = 1;
140 rval
= build (TARGET_EXPR
, type
, slot
, rval
, 0);
141 TREE_SIDE_EFFECTS (rval
) = 1;
142 TREE_ADDRESSABLE (rval
) = 1;
144 if (with_cleanup_p
&& TYPE_NEEDS_DESTRUCTOR (type
))
146 TREE_OPERAND (rval
, 2) = error_mark_node
;
147 rval
= build (WITH_CLEANUP_EXPR
, type
, rval
, 0,
148 build_delete (TYPE_POINTER_TO (type
),
149 build_unary_op (ADDR_EXPR
, slot
, 0),
151 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0));
152 TREE_SIDE_EFFECTS (rval
) = 1;
153 TREE_ADDRESSABLE (rval
) = 1;
158 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
159 these CALL_EXPRs with tree nodes that will perform the cleanups. */
162 break_out_cleanups (exp
)
167 if (TREE_CODE (tmp
) == CALL_EXPR
168 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
169 return build_cplus_new (TREE_TYPE (tmp
), tmp
, 1);
171 while (TREE_CODE (tmp
) == NOP_EXPR
172 || TREE_CODE (tmp
) == CONVERT_EXPR
173 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
175 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
176 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
178 TREE_OPERAND (tmp
, 0)
179 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
180 TREE_OPERAND (tmp
, 0), 1);
184 tmp
= TREE_OPERAND (tmp
, 0);
189 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
190 copies where they are found. Returns a deep copy all nodes transitively
191 containing CALL_EXPRs. */
194 break_out_calls (exp
)
197 register tree t1
, t2
;
198 register enum tree_code code
;
199 register int changed
= 0;
202 if (exp
== NULL_TREE
)
205 code
= TREE_CODE (exp
);
207 if (code
== CALL_EXPR
)
208 return copy_node (exp
);
210 /* Don't try and defeat a save_expr, as it should only be done once. */
211 if (code
== SAVE_EXPR
)
214 switch (TREE_CODE_CLASS (code
))
219 case 'c': /* a constant */
220 case 't': /* a type node */
221 case 'x': /* something random, like an identifier or an ERROR_MARK. */
224 case 'd': /* A decl node */
225 t1
= break_out_calls (DECL_INITIAL (exp
));
226 if (t1
!= DECL_INITIAL (exp
))
228 exp
= copy_node (exp
);
229 DECL_INITIAL (exp
) = t1
;
233 case 'b': /* A block node */
235 /* Don't know how to handle these correctly yet. Must do a
236 break_out_calls on all DECL_INITIAL values for local variables,
237 and also break_out_calls on all sub-blocks and sub-statements. */
242 case 'e': /* an expression */
243 case 'r': /* a reference */
244 case 's': /* an expression with side effects */
245 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
247 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
248 if (t1
!= TREE_OPERAND (exp
, i
))
250 exp
= copy_node (exp
);
251 TREE_OPERAND (exp
, i
) = t1
;
256 case '<': /* a comparison expression */
257 case '2': /* a binary arithmetic expression */
258 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
259 if (t2
!= TREE_OPERAND (exp
, 1))
261 case '1': /* a unary arithmetic expression */
262 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
263 if (t1
!= TREE_OPERAND (exp
, 0))
267 if (tree_code_length
[(int) code
] == 1)
268 return build1 (code
, TREE_TYPE (exp
), t1
);
270 return build (code
, TREE_TYPE (exp
), t1
, t2
);
277 extern struct obstack
*current_obstack
;
278 extern struct obstack permanent_obstack
, class_obstack
;
279 extern struct obstack
*saveable_obstack
;
281 /* Here is how primitive or already-canonicalized types' hash
282 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
283 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
285 /* Construct, lay out and return the type of methods belonging to class
286 BASETYPE and whose arguments are described by ARGTYPES and whose values
287 are described by RETTYPE. If each type exists already, reuse it. */
289 build_cplus_method_type (basetype
, rettype
, argtypes
)
290 tree basetype
, rettype
, argtypes
;
296 /* Make a node of the sort we want. */
297 t
= make_node (METHOD_TYPE
);
299 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
300 TREE_TYPE (t
) = rettype
;
301 if (IS_SIGNATURE (basetype
))
302 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
303 TYPE_READONLY (basetype
),
304 TYPE_VOLATILE (basetype
));
307 ptype
= build_pointer_type (basetype
);
309 /* it is wrong to flag the object the pointer points to as readonly
310 when flag_this_is_variable is 0. */
311 ptype
= build_type_variant (ptype
, flag_this_is_variable
<= 0, 0);
313 ptype
= build_type_variant (ptype
, 0, 0);
316 /* The actual arglist for this function includes a "hidden" argument
317 which is "this". Put it into the list of argument types. */
319 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
320 TYPE_ARG_TYPES (t
) = argtypes
;
321 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
323 /* If we already have such a type, use the old one and free this one.
324 Note that it also frees up the above cons cell if found. */
325 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
326 t
= type_hash_canon (hashcode
, t
);
328 if (TYPE_SIZE (t
) == 0)
335 build_cplus_staticfn_type (basetype
, rettype
, argtypes
)
336 tree basetype
, rettype
, argtypes
;
341 /* Make a node of the sort we want. */
342 t
= make_node (FUNCTION_TYPE
);
344 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
345 TREE_TYPE (t
) = rettype
;
347 /* The actual arglist for this function includes a "hidden" argument
348 which is "this". Put it into the list of argument types. */
350 TYPE_ARG_TYPES (t
) = argtypes
;
352 /* If we already have such a type, use the old one and free this one.
353 Note that it also frees up the above cons cell if found. */
354 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
355 t
= type_hash_canon (hashcode
, t
);
357 if (TYPE_SIZE (t
) == 0)
364 build_cplus_array_type (elt_type
, index_type
)
368 register struct obstack
*ambient_obstack
= current_obstack
;
369 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
372 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
373 make this permanent too. */
374 if (TREE_PERMANENT (elt_type
)
375 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
377 current_obstack
= &permanent_obstack
;
378 saveable_obstack
= &permanent_obstack
;
381 t
= build_array_type (elt_type
, index_type
);
383 /* Push these needs up so that initialization takes place
385 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
386 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
387 current_obstack
= ambient_obstack
;
388 saveable_obstack
= ambient_saveable_obstack
;
392 /* Add OFFSET to all base types of T.
394 OFFSET, which is a type offset, is number of bytes.
396 Note that we don't have to worry about having two paths to the
397 same base type, since this type owns its association list. */
399 propagate_binfo_offsets (binfo
, offset
)
403 tree binfos
= BINFO_BASETYPES (binfo
);
404 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
406 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
408 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
410 if (TREE_VIA_VIRTUAL (base_binfo
))
415 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
418 for (j
= i
+1; j
< n_baselinks
; j
++)
419 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
421 /* The next basetype offset must take into account the space
422 between the classes, not just the size of each class. */
423 delta
= size_binop (MINUS_EXPR
,
424 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
425 BINFO_OFFSET (base_binfo
));
430 if (BINFO_OFFSET_ZEROP (base_binfo
))
431 BINFO_OFFSET (base_binfo
) = offset
;
433 BINFO_OFFSET (base_binfo
)
434 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
436 BINFO_OFFSET (base_binfo
) = offset
;
441 tree chain
= NULL_TREE
;
443 /* Now unshare the structure beneath BASE_BINFO. */
444 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
447 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
448 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
449 TREE_VEC_ELT (base_binfos
, k
)
450 = make_binfo (BINFO_OFFSET (base_base_binfo
),
451 BINFO_TYPE (base_base_binfo
),
452 BINFO_VTABLE (base_base_binfo
),
453 BINFO_VIRTUALS (base_base_binfo
),
455 chain
= TREE_VEC_ELT (base_binfos
, k
);
456 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
457 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
459 /* Now propagate the offset to the base types. */
460 propagate_binfo_offsets (base_binfo
, offset
);
463 /* Go to our next class that counts for offset propagation. */
466 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
471 /* Compute the actual offsets that our virtual base classes
472 will have *for this type*. This must be performed after
473 the fields are laid out, since virtual baseclasses must
474 lay down at the end of the record.
476 Returns the maximum number of virtual functions any of the virtual
477 baseclasses provide. */
479 layout_vbasetypes (rec
, max
)
483 /* Get all the virtual base types that this type uses.
484 The TREE_VALUE slot holds the virtual baseclass type. */
485 tree vbase_types
= get_vbase_types (rec
);
487 #ifdef STRUCTURE_SIZE_BOUNDARY
488 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
490 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
493 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
494 where CONST_SIZE is an integer
495 and VAR_SIZE is a tree expression.
496 If VAR_SIZE is null, the size is just CONST_SIZE.
497 Naturally we try to avoid using VAR_SIZE. */
498 register unsigned const_size
= 0;
499 register tree var_size
= 0;
500 int nonvirtual_const_size
;
501 tree nonvirtual_var_size
;
503 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
505 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
506 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
508 var_size
= TYPE_SIZE (rec
);
510 nonvirtual_const_size
= const_size
;
511 nonvirtual_var_size
= var_size
;
515 tree basetype
= BINFO_TYPE (vbase_types
);
519 offset
= integer_zero_node
;
521 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
523 if (CLASSTYPE_VSIZE (basetype
) > max
)
524 max
= CLASSTYPE_VSIZE (basetype
);
525 BINFO_OFFSET (vbase_types
) = offset
;
527 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
528 const_size
+= MAX (record_align
,
529 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
530 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
531 else if (var_size
== 0)
532 var_size
= TYPE_SIZE (basetype
);
534 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
536 vbase_types
= TREE_CHAIN (vbase_types
);
539 if (const_size
!= nonvirtual_const_size
)
541 CLASSTYPE_VBASE_SIZE (rec
)
542 = size_int (const_size
- nonvirtual_const_size
);
543 TYPE_SIZE (rec
) = size_int (const_size
);
546 /* Now propagate offset information throughout the lattice
547 under the vbase type. */
548 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
549 vbase_types
= TREE_CHAIN (vbase_types
))
551 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
555 tree chain
= NULL_TREE
;
557 /* Now unshare the structure beneath BASE_BINFO. */
559 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
562 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
563 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
564 TREE_VEC_ELT (base_binfos
, j
)
565 = make_binfo (BINFO_OFFSET (base_base_binfo
),
566 BINFO_TYPE (base_base_binfo
),
567 BINFO_VTABLE (base_base_binfo
),
568 BINFO_VIRTUALS (base_base_binfo
),
570 chain
= TREE_VEC_ELT (base_binfos
, j
);
571 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
572 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
575 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
582 /* Lay out the base types of a record type, REC.
583 Tentatively set the size and alignment of REC
584 according to the base types alone.
586 Offsets for immediate nonvirtual baseclasses are also computed here.
588 Returns list of virtual base classes in a FIELD_DECL chain. */
590 layout_basetypes (rec
, binfos
)
593 /* Chain to hold all the new FIELD_DECLs which point at virtual
595 tree vbase_decls
= NULL_TREE
;
597 #ifdef STRUCTURE_SIZE_BOUNDARY
598 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
600 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
603 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
604 where CONST_SIZE is an integer
605 and VAR_SIZE is a tree expression.
606 If VAR_SIZE is null, the size is just CONST_SIZE.
607 Naturally we try to avoid using VAR_SIZE. */
608 register unsigned const_size
= 0;
609 register tree var_size
= 0;
610 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
612 /* Handle basetypes almost like fields, but record their
613 offsets differently. */
615 for (i
= 0; i
< n_baseclasses
; i
++)
617 int inc
, desired_align
, int_vbase_size
;
618 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
619 register tree basetype
= BINFO_TYPE (base_binfo
);
622 if (TYPE_SIZE (basetype
) == 0)
625 /* This error is now reported in xref_tag, thus giving better
626 location information. */
627 error_with_aggr_type (base_binfo
,
628 "base class `%s' has incomplete type");
630 TREE_VIA_PUBLIC (base_binfo
) = 1;
631 TREE_VIA_PROTECTED (base_binfo
) = 0;
632 TREE_VIA_VIRTUAL (base_binfo
) = 0;
634 /* Should handle this better so that
637 class B: private A { virtual void F(); };
639 does not dump core when compiled. */
640 my_friendly_abort (121);
645 /* All basetypes are recorded in the association list of the
648 if (TREE_VIA_VIRTUAL (base_binfo
))
651 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
652 + sizeof (VBASE_NAME
) + 1);
654 /* The offset for a virtual base class is only used in computing
655 virtual function tables and for initializing virtual base
656 pointers. It is built once `get_vbase_types' is called. */
658 /* If this basetype can come from another vbase pointer
659 without an additional indirection, we will share
660 that pointer. If an indirection is involved, we
661 make our own pointer. */
662 for (j
= 0; j
< n_baseclasses
; j
++)
664 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
665 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
666 && binfo_member (basetype
,
667 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
670 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
671 decl
= build_lang_decl (FIELD_DECL
, get_identifier (name
),
672 build_pointer_type (basetype
));
673 /* If you change any of the below, take a look at all the
674 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
676 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
677 DECL_VIRTUAL_P (decl
) = 1;
678 DECL_FIELD_CONTEXT (decl
) = rec
;
679 DECL_CLASS_CONTEXT (decl
) = rec
;
680 DECL_FCONTEXT (decl
) = basetype
;
681 DECL_FIELD_SIZE (decl
) = 0;
682 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
683 TREE_CHAIN (decl
) = vbase_decls
;
684 BINFO_VPTR_FIELD (base_binfo
) = decl
;
687 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
688 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
690 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
691 "destructor `%s' non-virtual");
692 warning ("in inheritance relationship `%s: virtual %s'",
693 TYPE_NAME_STRING (rec
),
694 TYPE_NAME_STRING (basetype
));
697 /* The space this decl occupies has already been accounted for. */
702 offset
= integer_zero_node
;
705 /* Give each base type the alignment it wants. */
706 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
707 * TYPE_ALIGN (basetype
);
708 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
711 /* bpk: Disabled this check until someone is willing to
712 claim it as theirs and explain exactly what circumstances
713 warrant the warning. */
714 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
715 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
717 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
718 "destructor `%s' non-virtual");
719 warning ("in inheritance relationship `%s:%s %s'",
720 TYPE_NAME_STRING (rec
),
721 TREE_VIA_VIRTUAL (base_binfo
) ? " virtual" : "",
722 TYPE_NAME_STRING (basetype
));
726 BINFO_OFFSET (base_binfo
) = offset
;
727 if (CLASSTYPE_VSIZE (basetype
))
729 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
730 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
732 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
733 TYPE_BINFO (rec
) = base_binfo
;
735 /* Add only the amount of storage not present in
736 the virtual baseclasses. */
738 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
739 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
741 inc
= MAX (record_align
,
742 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
745 /* Record must have at least as much alignment as any field. */
746 desired_align
= TYPE_ALIGN (basetype
);
747 record_align
= MAX (record_align
, desired_align
);
754 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
756 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
757 CLASSTYPE_ALIGN (rec
) = record_align
;
762 /* Hashing of lists so that we don't make duplicates.
763 The entry point is `list_hash_canon'. */
765 /* Each hash table slot is a bucket containing a chain
766 of these structures. */
770 struct list_hash
*next
; /* Next structure in the bucket. */
771 int hashcode
; /* Hash code of this list. */
772 tree list
; /* The list recorded here. */
775 /* Now here is the hash table. When recording a list, it is added
776 to the slot whose index is the hash code mod the table size.
777 Note that the hash table is used for several kinds of lists.
778 While all these live in the same table, they are completely independent,
779 and the hash code is computed differently for each of these. */
781 #define TYPE_HASH_SIZE 59
782 struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
784 /* Compute a hash code for a list (chain of TREE_LIST nodes
785 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
786 TREE_COMMON slots), by adding the hash codes of the individual entries. */
792 register int hashcode
= 0;
794 if (TREE_CHAIN (list
))
795 hashcode
+= TYPE_HASH (TREE_CHAIN (list
));
797 if (TREE_VALUE (list
))
798 hashcode
+= TYPE_HASH (TREE_VALUE (list
));
801 if (TREE_PURPOSE (list
))
802 hashcode
+= TYPE_HASH (TREE_PURPOSE (list
));
808 /* Look in the type hash table for a type isomorphic to TYPE.
809 If one is found, return it. Otherwise return 0. */
812 list_hash_lookup (hashcode
, list
)
816 register struct list_hash
*h
;
817 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
818 if (h
->hashcode
== hashcode
819 && TREE_VIA_VIRTUAL (h
->list
) == TREE_VIA_VIRTUAL (list
)
820 && TREE_VIA_PUBLIC (h
->list
) == TREE_VIA_PUBLIC (list
)
821 && TREE_VIA_PROTECTED (h
->list
) == TREE_VIA_PROTECTED (list
)
822 && TREE_PURPOSE (h
->list
) == TREE_PURPOSE (list
)
823 && TREE_VALUE (h
->list
) == TREE_VALUE (list
)
824 && TREE_CHAIN (h
->list
) == TREE_CHAIN (list
))
826 my_friendly_assert (TREE_TYPE (h
->list
) == TREE_TYPE (list
), 299);
832 /* Add an entry to the list-hash-table
833 for a list TYPE whose hash code is HASHCODE. */
836 list_hash_add (hashcode
, list
)
840 register struct list_hash
*h
;
842 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
843 h
->hashcode
= hashcode
;
845 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
846 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
849 /* Given TYPE, and HASHCODE its hash code, return the canonical
850 object for an identical list if one already exists.
851 Otherwise, return TYPE, and record it as the canonical object
852 if it is a permanent object.
854 To use this function, first create a list of the sort you want.
855 Then compute its hash code from the fields of the list that
856 make it different from other similar lists.
857 Then call this function and use the value.
858 This function frees the list you pass in if it is a duplicate. */
860 /* Set to 1 to debug without canonicalization. Never set by program. */
861 int debug_no_list_hash
= 0;
864 list_hash_canon (hashcode
, list
)
870 if (debug_no_list_hash
)
873 t1
= list_hash_lookup (hashcode
, list
);
876 obstack_free (&class_obstack
, list
);
880 /* If this is a new list, record it for later reuse. */
881 list_hash_add (hashcode
, list
);
887 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
888 int via_public
, via_virtual
, via_protected
;
889 tree purpose
, value
, chain
;
891 struct obstack
*ambient_obstack
= current_obstack
;
895 current_obstack
= &class_obstack
;
896 t
= tree_cons (purpose
, value
, chain
);
897 TREE_VIA_PUBLIC (t
) = via_public
;
898 TREE_VIA_PROTECTED (t
) = via_protected
;
899 TREE_VIA_VIRTUAL (t
) = via_virtual
;
900 hashcode
= list_hash (t
);
901 t
= list_hash_canon (hashcode
, t
);
902 current_obstack
= ambient_obstack
;
906 /* Constructor for hashed lists. */
908 hash_tree_chain (value
, chain
)
911 struct obstack
*ambient_obstack
= current_obstack
;
915 current_obstack
= &class_obstack
;
916 t
= tree_cons (NULL_TREE
, value
, chain
);
917 hashcode
= list_hash (t
);
918 t
= list_hash_canon (hashcode
, t
);
919 current_obstack
= ambient_obstack
;
923 /* Similar, but used for concatenating two lists. */
925 hash_chainon (list1
, list2
)
932 if (TREE_CHAIN (list1
) == NULL_TREE
)
933 return hash_tree_chain (TREE_VALUE (list1
), list2
);
934 return hash_tree_chain (TREE_VALUE (list1
),
935 hash_chainon (TREE_CHAIN (list1
), list2
));
939 get_identifier_list (value
)
942 tree list
= IDENTIFIER_AS_LIST (value
);
943 if (list
!= NULL_TREE
944 && (TREE_CODE (list
) != TREE_LIST
945 || TREE_VALUE (list
) != value
))
947 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
948 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
)
950 tree type
= IDENTIFIER_TYPE_VALUE (value
);
952 if (TYPE_PTRMEMFUNC_P (type
))
954 else if (type
== current_class_type
)
955 /* Don't mess up the constructor name. */
956 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
960 /* This will return the correct thing for regular types,
961 nested types, and templates. Yay! */
962 if (TYPE_NESTED_NAME (type
))
963 id
= TYPE_NESTED_NAME (type
);
965 id
= TYPE_IDENTIFIER (type
);
967 if (CLASSTYPE_ID_AS_LIST (type
) == NULL_TREE
)
968 CLASSTYPE_ID_AS_LIST (type
)
969 = perm_tree_cons (NULL_TREE
, id
, NULL_TREE
);
970 list
= CLASSTYPE_ID_AS_LIST (type
);
977 get_decl_list (value
)
980 tree list
= NULL_TREE
;
982 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
983 list
= get_identifier_list (value
);
984 else if (TREE_CODE (value
) == RECORD_TYPE
985 && TYPE_LANG_SPECIFIC (value
))
986 list
= CLASSTYPE_AS_LIST (value
);
988 if (list
!= NULL_TREE
)
990 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
994 return build_decl_list (NULL_TREE
, value
);
997 /* Look in the type hash table for a type isomorphic to
998 `build_tree_list (NULL_TREE, VALUE)'.
999 If one is found, return it. Otherwise return 0. */
1002 list_hash_lookup_or_cons (value
)
1005 register int hashcode
= TYPE_HASH (value
);
1006 register struct list_hash
*h
;
1007 struct obstack
*ambient_obstack
;
1008 tree list
= NULL_TREE
;
1010 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1011 list
= get_identifier_list (value
);
1012 else if (TREE_CODE (value
) == TYPE_DECL
1013 && TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
1014 && TYPE_LANG_SPECIFIC (TREE_TYPE (value
)))
1015 list
= CLASSTYPE_ID_AS_LIST (TREE_TYPE (value
));
1016 else if (TREE_CODE (value
) == RECORD_TYPE
1017 && TYPE_LANG_SPECIFIC (value
))
1018 list
= CLASSTYPE_AS_LIST (value
);
1020 if (list
!= NULL_TREE
)
1022 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 302);
1026 if (debug_no_list_hash
)
1027 return hash_tree_chain (value
, NULL_TREE
);
1029 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1030 if (h
->hashcode
== hashcode
1031 && TREE_VIA_VIRTUAL (h
->list
) == 0
1032 && TREE_VIA_PUBLIC (h
->list
) == 0
1033 && TREE_VIA_PROTECTED (h
->list
) == 0
1034 && TREE_PURPOSE (h
->list
) == 0
1035 && TREE_VALUE (h
->list
) == value
)
1037 my_friendly_assert (TREE_TYPE (h
->list
) == 0, 303);
1038 my_friendly_assert (TREE_CHAIN (h
->list
) == 0, 304);
1042 ambient_obstack
= current_obstack
;
1043 current_obstack
= &class_obstack
;
1044 list
= build_tree_list (NULL_TREE
, value
);
1045 list_hash_add (hashcode
, list
);
1046 current_obstack
= ambient_obstack
;
1050 /* Build an association between TYPE and some parameters:
1052 OFFSET is the offset added to `this' to convert it to a pointer
1055 VTABLE is the virtual function table with which to initialize
1056 sub-objects of type TYPE.
1058 VIRTUALS are the virtual functions sitting in VTABLE.
1060 CHAIN are more associations we must retain. */
1063 make_binfo (offset
, type
, vtable
, virtuals
, chain
)
1065 tree vtable
, virtuals
;
1068 tree binfo
= make_tree_vec (6);
1069 tree old_binfo
= TYPE_BINFO (type
);
1072 TREE_CHAIN (binfo
) = chain
;
1074 TREE_USED (binfo
) = TREE_USED (chain
);
1076 TREE_TYPE (binfo
) = TYPE_MAIN_VARIANT (type
);
1077 BINFO_OFFSET (binfo
) = offset
;
1078 BINFO_VTABLE (binfo
) = vtable
;
1079 BINFO_VIRTUALS (binfo
) = virtuals
;
1080 BINFO_VPTR_FIELD (binfo
) = NULL_TREE
;
1083 if (old_binfo
!= NULL_TREE
1084 && BINFO_BASETYPES (old_binfo
) != NULL_TREE
)
1086 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
1087 tree binfos
= TYPE_BINFO_BASETYPES (type
);
1089 BINFO_BASETYPES (binfo
) = make_tree_vec (n_baseclasses
);
1090 for (i
= 0; i
< n_baseclasses
; i
++)
1092 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1093 tree old_base_binfo
= old_binfo
? BINFO_BASETYPE (old_binfo
, i
) : 0;
1094 BINFO_BASETYPE (binfo
, i
) = base_binfo
;
1097 TREE_VIA_PUBLIC (base_binfo
) = TREE_VIA_PUBLIC (old_base_binfo
);
1098 TREE_VIA_PROTECTED (base_binfo
) = TREE_VIA_PROTECTED (old_base_binfo
);
1099 TREE_VIA_VIRTUAL (base_binfo
) = TREE_VIA_VIRTUAL (old_base_binfo
);
1110 tree binfo
= copy_list (list
);
1114 TREE_USED (binfo
) = 0;
1115 if (BINFO_BASETYPES (binfo
))
1116 BINFO_BASETYPES (binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1117 binfo
= TREE_CHAIN (binfo
);
1122 /* Return the binfo value for ELEM in TYPE. */
1125 binfo_value (elem
, type
)
1129 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1130 compiler_error ("base class `%s' ambiguous in binfo_value",
1131 TYPE_NAME_STRING (elem
));
1133 return TYPE_BINFO (type
);
1134 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1136 return get_binfo (elem
, type
, 0);
1143 register tree prev
= 0, tmp
, next
;
1144 for (tmp
= path
; tmp
; tmp
= next
)
1146 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1147 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1154 virtual_member (elem
, list
)
1161 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1162 if (elem
== BINFO_TYPE (t
))
1165 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1167 tree binfos
= BINFO_BASETYPES (t
);
1170 if (binfos
!= NULL_TREE
)
1171 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1173 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1176 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1177 my_friendly_abort (104);
1185 /* Return the offset (as an INTEGER_CST) for ELEM in LIST.
1186 INITIAL_OFFSET is the value to add to the offset that ELEM's
1187 binfo entry in LIST provides.
1189 Returns NULL if ELEM does not have an binfo value in LIST. */
1192 virtual_offset (elem
, list
, initial_offset
)
1195 tree initial_offset
;
1200 for (vb
= list
; vb
; vb
= TREE_CHAIN (vb
))
1201 if (elem
== BINFO_TYPE (vb
))
1202 return size_binop (PLUS_EXPR
, initial_offset
, BINFO_OFFSET (vb
));
1204 for (vb
= list
; vb
; vb
= TREE_CHAIN (vb
))
1206 tree binfos
= BINFO_BASETYPES (vb
);
1209 if (binfos
== NULL_TREE
)
1212 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1214 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1217 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1218 my_friendly_abort (105);
1219 offset
= BINFO_OFFSET (vb
);
1224 if (rval
== NULL_TREE
)
1226 return size_binop (PLUS_EXPR
, offset
, BINFO_OFFSET (rval
));
1236 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1237 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1238 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1239 fprintf (stderr
, "vtable type:\n");
1240 debug_tree (BINFO_TYPE (elem
));
1241 if (BINFO_VTABLE (elem
))
1242 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1244 fprintf (stderr
, "no vtable decl yet\n");
1245 fprintf (stderr
, "virtuals:\n");
1246 virtuals
= BINFO_VIRTUALS (elem
);
1249 virtuals
= TREE_CHAIN (virtuals
);
1251 virtuals
= TREE_CHAIN (virtuals
);
1256 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1257 fprintf (stderr
, "%s [%d =? %d]\n",
1258 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1259 i
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1260 virtuals
= TREE_CHAIN (virtuals
);
1265 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1266 We expect a null pointer to mark the end of the chain.
1267 This is the Lisp primitive `length'. */
1270 decl_list_length (t
)
1274 register int len
= 0;
1276 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1277 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1278 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1288 if (TREE_CODE (t
) == FUNCTION_DECL
)
1291 return decl_list_length (TREE_VALUE (t
));
1294 /* Like value_member, but for DECL_CHAINs. */
1296 decl_value_member (elem
, list
)
1303 list
= DECL_CHAIN (list
);
1309 is_overloaded_fn (x
)
1312 if (TREE_CODE (x
) == FUNCTION_DECL
)
1315 if (TREE_CODE (x
) == TREE_LIST
1316 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1317 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1327 if (TREE_CODE (from
) == FUNCTION_DECL
)
1330 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1332 return TREE_VALUE (from
);
1336 fnaddr_from_vtable_entry (entry
)
1339 return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
))));
1343 set_fnaddr_from_vtable_entry (entry
, value
)
1346 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
)))) = value
;
1350 function_arg_chain (t
)
1353 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t
)));
1357 promotes_to_aggr_type (t
, code
)
1359 enum tree_code code
;
1361 if (TREE_CODE (t
) == code
)
1363 return IS_AGGR_TYPE (t
);
1367 is_aggr_type_2 (t1
, t2
)
1370 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1372 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1375 /* Give message using types TYPE1 and TYPE2 as arguments.
1376 PFN is the function which will print the message;
1377 S is the format string for PFN to use. */
1379 message_2_types (pfn
, s
, type1
, type2
)
1384 tree name1
= TYPE_NAME (type1
);
1385 tree name2
= TYPE_NAME (type2
);
1386 if (TREE_CODE (name1
) == TYPE_DECL
)
1387 name1
= DECL_NAME (name1
);
1388 if (TREE_CODE (name2
) == TYPE_DECL
)
1389 name2
= DECL_NAME (name2
);
1390 (*pfn
) (s
, IDENTIFIER_POINTER (name1
), IDENTIFIER_POINTER (name2
));
1393 #define PRINT_RING_SIZE 4
1396 lang_printable_name (decl
)
1399 static tree decl_ring
[PRINT_RING_SIZE
];
1400 static char *print_ring
[PRINT_RING_SIZE
];
1401 static int ring_counter
;
1404 /* Only cache functions. */
1405 if (TREE_CODE (decl
) != FUNCTION_DECL
1406 || DECL_LANG_SPECIFIC (decl
) == 0)
1407 return decl_as_string (decl
, 1);
1409 /* See if this print name is lying around. */
1410 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1411 if (decl_ring
[i
] == decl
)
1412 /* yes, so return it. */
1413 return print_ring
[i
];
1415 if (++ring_counter
== PRINT_RING_SIZE
)
1418 if (current_function_decl
!= NULL_TREE
)
1420 if (decl_ring
[ring_counter
] == current_function_decl
)
1422 if (ring_counter
== PRINT_RING_SIZE
)
1424 if (decl_ring
[ring_counter
] == current_function_decl
)
1425 my_friendly_abort (106);
1428 if (print_ring
[ring_counter
])
1429 free (print_ring
[ring_counter
]);
1432 int print_ret_type_p
1433 = (!DECL_CONSTRUCTOR_P (decl
)
1434 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)));
1436 char *name
= (char *)decl_as_string (decl
, print_ret_type_p
);
1437 print_ring
[ring_counter
] = (char *)malloc (strlen (name
) + 1);
1438 strcpy (print_ring
[ring_counter
], name
);
1439 decl_ring
[ring_counter
] = decl
;
1441 return print_ring
[ring_counter
];
1444 /* Comparison function for sorting identifiers in RAISES lists.
1445 Note that because IDENTIFIER_NODEs are unique, we can sort
1446 them by address, saving an indirection. */
1451 return (HOST_WIDE_INT
)TREE_VALUE (*p1
) - (HOST_WIDE_INT
)TREE_VALUE (*p2
);
1454 /* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
1455 listed in RAISES. */
1457 build_exception_variant (ctype
, type
, raises
)
1462 tree v
= TYPE_MAIN_VARIANT (type
);
1464 tree
*a
= (tree
*)alloca ((list_length (raises
)+1) * sizeof (tree
));
1465 int constp
= TYPE_READONLY (type
);
1466 int volatilep
= TYPE_VOLATILE (type
);
1468 if (raises
&& TREE_CHAIN (raises
))
1470 for (i
= 0, t
= raises
; t
; t
= TREE_CHAIN (t
), i
++)
1472 /* NULL terminator for list. */
1474 qsort (a
, i
, sizeof (tree
), id_cmp
);
1476 TREE_CHAIN (a
[i
]) = a
[i
+1];
1482 return build_type_variant (v
, constp
, volatilep
);
1486 cname
= TYPE_NAME (ctype
);
1487 if (TREE_CODE (cname
) == TYPE_DECL
)
1488 cname
= DECL_NAME (cname
);
1493 for (t
= raises
; t
; t
= TREE_CHAIN (t
))
1495 /* See that all the exceptions we are thinking about
1496 raising have been declared. */
1497 tree this_cname
= lookup_exception_cname (ctype
, cname
, t
);
1498 tree decl
= lookup_exception_object (this_cname
, TREE_VALUE (t
), 1);
1500 if (decl
== NULL_TREE
)
1501 decl
= lookup_exception_object (this_cname
, TREE_VALUE (t
), 0);
1502 /* Place canonical exception decl into TREE_TYPE of RAISES list. */
1503 TREE_TYPE (t
) = decl
;
1506 for (v
= TYPE_NEXT_VARIANT (v
); v
; v
= TYPE_NEXT_VARIANT (v
))
1508 if (TYPE_READONLY (v
) != constp
1509 || TYPE_VOLATILE (v
) != volatilep
)
1513 t2
= TYPE_RAISES_EXCEPTIONS (v
);
1516 if (TREE_TYPE (t
) == TREE_TYPE (t2
))
1519 t2
= TREE_CHAIN (t2
);
1525 /* List of exceptions raised matches previously found list.
1527 @@ Nice to free up storage used in consing up the
1528 @@ list of exceptions raised. */
1532 /* Need to build a new variant. */
1533 v
= copy_node (type
);
1534 TYPE_NEXT_VARIANT (v
) = TYPE_NEXT_VARIANT (type
);
1535 TYPE_NEXT_VARIANT (type
) = v
;
1536 if (raises
&& ! TREE_PERMANENT (raises
))
1538 push_obstacks_nochange ();
1539 end_temporary_allocation ();
1540 raises
= copy_list (raises
);
1543 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1547 /* Subroutine of copy_to_permanent
1549 Assuming T is a node build bottom-up, make it all exist on
1550 permanent obstack, if it is not permanent already. */
1555 enum tree_code code
;
1557 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1560 switch (code
= TREE_CODE (t
))
1563 return error_mark_node
;
1572 tree chain
= TREE_CHAIN (t
);
1574 TREE_CHAIN (t
) = make_deep_copy (chain
);
1575 TREE_TYPE (t
) = make_deep_copy (TREE_TYPE (t
));
1576 DECL_INITIAL (t
) = make_deep_copy (DECL_INITIAL (t
));
1577 DECL_SIZE (t
) = make_deep_copy (DECL_SIZE (t
));
1583 tree chain
= TREE_CHAIN (t
);
1585 TREE_PURPOSE (t
) = make_deep_copy (TREE_PURPOSE (t
));
1586 TREE_VALUE (t
) = make_deep_copy (TREE_VALUE (t
));
1587 TREE_CHAIN (t
) = make_deep_copy (chain
);
1593 int len
= TREE_VEC_LENGTH (t
);
1597 TREE_VEC_ELT (t
, len
) = make_deep_copy (TREE_VEC_ELT (t
, len
));
1604 return copy_node (t
);
1610 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1611 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1612 TREE_OPERAND (t
, 2) = make_deep_copy (TREE_OPERAND (t
, 2));
1617 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1624 case TRUNC_DIV_EXPR
:
1625 case TRUNC_MOD_EXPR
:
1633 case BIT_ANDTC_EXPR
:
1634 case TRUTH_ANDIF_EXPR
:
1635 case TRUTH_ORIF_EXPR
:
1643 case FLOOR_DIV_EXPR
:
1644 case ROUND_DIV_EXPR
:
1646 case FLOOR_MOD_EXPR
:
1647 case ROUND_MOD_EXPR
:
1649 case PREDECREMENT_EXPR
:
1650 case PREINCREMENT_EXPR
:
1651 case POSTDECREMENT_EXPR
:
1652 case POSTINCREMENT_EXPR
:
1655 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1656 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1664 case TRUTH_NOT_EXPR
:
1668 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1671 /* This list is incomplete, but should suffice for now.
1672 It is very important that `sorry' does not call
1673 `report_error_function'. That could cause an infinite loop. */
1675 sorry ("initializer contains unrecognized tree code");
1676 return error_mark_node
;
1679 my_friendly_abort (107);
1684 /* Assuming T is a node built bottom-up, make it all exist on
1685 permanent obstack, if it is not permanent already. */
1687 copy_to_permanent (t
)
1690 register struct obstack
*ambient_obstack
= current_obstack
;
1691 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1693 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1696 saveable_obstack
= &permanent_obstack
;
1697 current_obstack
= saveable_obstack
;
1699 t
= make_deep_copy (t
);
1701 current_obstack
= ambient_obstack
;
1702 saveable_obstack
= ambient_saveable_obstack
;
1708 print_lang_statistics ()
1710 extern struct obstack maybepermanent_obstack
;
1711 print_obstack_statistics ("class_obstack", &class_obstack
);
1712 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1713 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1714 print_search_statistics ();
1715 print_class_statistics ();
1718 /* This is used by the `assert' macro. It is provided in libgcc.a,
1719 which `cc' doesn't know how to link. Note that the C++ front-end
1720 no longer actually uses the `assert' macro (instead, it calls
1721 my_friendly_assert). But all of the back-end files still need this. */
1723 __eprintf (string
, expression
, line
, filename
)
1726 const char *expression
;
1728 const char *filename
;
1736 fprintf (stderr
, string
, expression
, line
, filename
);
1741 /* Return, as an INTEGER_CST node, the number of elements for
1742 TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1745 array_type_nelts_top (type
)
1748 return fold (build (PLUS_EXPR
, integer_type_node
,
1749 array_type_nelts (type
),
1753 /* Return, as an INTEGER_CST node, the number of elements for
1754 TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1755 ARRAY_TYPEs that are clumped together. */
1758 array_type_nelts_total (type
)
1761 tree sz
= array_type_nelts_top (type
);
1762 type
= TREE_TYPE (type
);
1763 while (TREE_CODE (type
) == ARRAY_TYPE
)
1765 tree n
= array_type_nelts_top (type
);
1766 sz
= fold (build (MULT_EXPR
, integer_type_node
, sz
, n
));
1767 type
= TREE_TYPE (type
);