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 if (! language_lvalue_valid (ref
))
41 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
44 if (ref
== current_class_decl
&& flag_this_is_variable
<= 0)
47 switch (TREE_CODE (ref
))
49 /* preincrements and predecrements are valid lvals, provided
50 what they refer to are valid lvals. */
51 case PREINCREMENT_EXPR
:
52 case PREDECREMENT_EXPR
:
55 return lvalue_p (TREE_OPERAND (ref
, 0));
61 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
62 && DECL_LANG_SPECIFIC (ref
)
63 && DECL_IN_AGGR_P (ref
))
70 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
71 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
75 case WITH_CLEANUP_EXPR
:
76 return lvalue_p (TREE_OPERAND (ref
, 0));
82 if (TREE_ADDRESSABLE (TREE_TYPE (ref
)))
86 /* A currently unresolved scope ref. */
88 my_friendly_abort (103);
90 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
92 return lvalue_p (TREE_OPERAND (ref
, 0))
93 && lvalue_p (TREE_OPERAND (ref
, 1));
97 return (lvalue_p (TREE_OPERAND (ref
, 1))
98 && lvalue_p (TREE_OPERAND (ref
, 2)));
104 return lvalue_p (TREE_OPERAND (ref
, 1));
110 /* Return nonzero if REF is an lvalue valid for this language;
111 otherwise, print an error message and return zero. */
114 lvalue_or_else (ref
, string
)
118 int win
= lvalue_p (ref
);
120 error ("non-lvalue in %s", string
);
124 /* INIT is a CALL_EXPR which needs info about its target.
125 TYPE is the type that this initialization should appear to have.
127 Build an encapsulation of the initialization to perform
128 and return it so that it can be processed by language-independent
129 and language-specific expression expanders.
131 If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
132 Otherwise, cleanups are not built here. For example, when building
133 an initialization for a stack slot, since the called function handles
134 the cleanup, we would not want to do it here. */
136 build_cplus_new (type
, init
, with_cleanup_p
)
141 tree slot
= build (VAR_DECL
, type
);
142 tree rval
= build (NEW_EXPR
, type
,
143 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
144 TREE_SIDE_EFFECTS (rval
) = 1;
145 TREE_ADDRESSABLE (rval
) = 1;
146 rval
= build (TARGET_EXPR
, type
, slot
, rval
, 0);
147 TREE_SIDE_EFFECTS (rval
) = 1;
148 TREE_ADDRESSABLE (rval
) = 1;
151 if (with_cleanup_p
&& TYPE_NEEDS_DESTRUCTOR (type
))
153 TREE_OPERAND (rval
, 2) = error_mark_node
;
154 rval
= build (WITH_CLEANUP_EXPR
, type
, rval
, 0,
155 build_delete (TYPE_POINTER_TO (type
),
156 build_unary_op (ADDR_EXPR
, slot
, 0),
158 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0));
159 TREE_SIDE_EFFECTS (rval
) = 1;
160 TREE_ADDRESSABLE (rval
) = 1;
166 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
167 these CALL_EXPRs with tree nodes that will perform the cleanups. */
170 break_out_cleanups (exp
)
175 if (TREE_CODE (tmp
) == CALL_EXPR
176 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
177 return build_cplus_new (TREE_TYPE (tmp
), tmp
, 1);
179 while (TREE_CODE (tmp
) == NOP_EXPR
180 || TREE_CODE (tmp
) == CONVERT_EXPR
181 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
183 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
184 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
186 TREE_OPERAND (tmp
, 0)
187 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
188 TREE_OPERAND (tmp
, 0), 1);
192 tmp
= TREE_OPERAND (tmp
, 0);
197 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
198 copies where they are found. Returns a deep copy all nodes transitively
199 containing CALL_EXPRs. */
202 break_out_calls (exp
)
205 register tree t1
, t2
;
206 register enum tree_code code
;
207 register int changed
= 0;
210 if (exp
== NULL_TREE
)
213 code
= TREE_CODE (exp
);
215 if (code
== CALL_EXPR
)
216 return copy_node (exp
);
218 /* Don't try and defeat a save_expr, as it should only be done once. */
219 if (code
== SAVE_EXPR
)
222 switch (TREE_CODE_CLASS (code
))
227 case 'c': /* a constant */
228 case 't': /* a type node */
229 case 'x': /* something random, like an identifier or an ERROR_MARK. */
232 case 'd': /* A decl node */
233 t1
= break_out_calls (DECL_INITIAL (exp
));
234 if (t1
!= DECL_INITIAL (exp
))
236 exp
= copy_node (exp
);
237 DECL_INITIAL (exp
) = t1
;
241 case 'b': /* A block node */
243 /* Don't know how to handle these correctly yet. Must do a
244 break_out_calls on all DECL_INITIAL values for local variables,
245 and also break_out_calls on all sub-blocks and sub-statements. */
250 case 'e': /* an expression */
251 case 'r': /* a reference */
252 case 's': /* an expression with side effects */
253 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
255 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
256 if (t1
!= TREE_OPERAND (exp
, i
))
258 exp
= copy_node (exp
);
259 TREE_OPERAND (exp
, i
) = t1
;
264 case '<': /* a comparison expression */
265 case '2': /* a binary arithmetic expression */
266 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
267 if (t2
!= TREE_OPERAND (exp
, 1))
269 case '1': /* a unary arithmetic expression */
270 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
271 if (t1
!= TREE_OPERAND (exp
, 0))
275 if (tree_code_length
[(int) code
] == 1)
276 return build1 (code
, TREE_TYPE (exp
), t1
);
278 return build (code
, TREE_TYPE (exp
), t1
, t2
);
285 extern struct obstack
*current_obstack
;
286 extern struct obstack permanent_obstack
, class_obstack
;
287 extern struct obstack
*saveable_obstack
;
289 /* Here is how primitive or already-canonicalized types' hash
290 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
291 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
293 /* Construct, lay out and return the type of methods belonging to class
294 BASETYPE and whose arguments are described by ARGTYPES and whose values
295 are described by RETTYPE. If each type exists already, reuse it. */
297 build_cplus_method_type (basetype
, rettype
, argtypes
)
298 tree basetype
, rettype
, argtypes
;
304 /* Make a node of the sort we want. */
305 t
= make_node (METHOD_TYPE
);
307 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
308 TREE_TYPE (t
) = rettype
;
309 if (IS_SIGNATURE (basetype
))
310 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
311 TYPE_READONLY (basetype
),
312 TYPE_VOLATILE (basetype
));
315 ptype
= build_pointer_type (basetype
);
316 ptype
= build_type_variant (ptype
, 1, 0);
318 /* The actual arglist for this function includes a "hidden" argument
319 which is "this". Put it into the list of argument types. */
321 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
322 TYPE_ARG_TYPES (t
) = argtypes
;
323 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
325 /* If we already have such a type, use the old one and free this one.
326 Note that it also frees up the above cons cell if found. */
327 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
328 t
= type_hash_canon (hashcode
, t
);
330 if (TYPE_SIZE (t
) == 0)
337 build_cplus_staticfn_type (basetype
, rettype
, argtypes
)
338 tree basetype
, rettype
, argtypes
;
343 /* Make a node of the sort we want. */
344 t
= make_node (FUNCTION_TYPE
);
346 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
347 TREE_TYPE (t
) = rettype
;
349 TYPE_ARG_TYPES (t
) = argtypes
;
351 /* If we already have such a type, use the old one and free this one.
352 Note that it also frees up the above cons cell if found. */
353 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
354 t
= type_hash_canon (hashcode
, t
);
356 if (TYPE_SIZE (t
) == 0)
363 build_cplus_array_type (elt_type
, index_type
)
367 register struct obstack
*ambient_obstack
= current_obstack
;
368 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
371 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
372 make this permanent too. */
373 if (TREE_PERMANENT (elt_type
)
374 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
376 current_obstack
= &permanent_obstack
;
377 saveable_obstack
= &permanent_obstack
;
380 t
= build_array_type (elt_type
, index_type
);
382 /* Push these needs up so that initialization takes place
384 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
385 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
386 current_obstack
= ambient_obstack
;
387 saveable_obstack
= ambient_saveable_obstack
;
391 /* Add OFFSET to all base types of T.
393 OFFSET, which is a type offset, is number of bytes.
395 Note that we don't have to worry about having two paths to the
396 same base type, since this type owns its association list. */
398 propagate_binfo_offsets (binfo
, offset
)
402 tree binfos
= BINFO_BASETYPES (binfo
);
403 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
405 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
407 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
409 if (TREE_VIA_VIRTUAL (base_binfo
))
414 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
417 for (j
= i
+1; j
< n_baselinks
; j
++)
418 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
420 /* The next basetype offset must take into account the space
421 between the classes, not just the size of each class. */
422 delta
= size_binop (MINUS_EXPR
,
423 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
424 BINFO_OFFSET (base_binfo
));
429 if (BINFO_OFFSET_ZEROP (base_binfo
))
430 BINFO_OFFSET (base_binfo
) = offset
;
432 BINFO_OFFSET (base_binfo
)
433 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
435 BINFO_OFFSET (base_binfo
) = offset
;
440 tree chain
= NULL_TREE
;
442 /* Now unshare the structure beneath BASE_BINFO. */
443 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
446 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
447 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
448 TREE_VEC_ELT (base_binfos
, k
)
449 = make_binfo (BINFO_OFFSET (base_base_binfo
),
451 BINFO_VTABLE (base_base_binfo
),
452 BINFO_VIRTUALS (base_base_binfo
),
454 chain
= TREE_VEC_ELT (base_binfos
, k
);
455 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
456 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
458 /* Now propagate the offset to the base types. */
459 propagate_binfo_offsets (base_binfo
, offset
);
462 /* Go to our next class that counts for offset propagation. */
465 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
470 /* Compute the actual offsets that our virtual base classes
471 will have *for this type*. This must be performed after
472 the fields are laid out, since virtual baseclasses must
473 lay down at the end of the record.
475 Returns the maximum number of virtual functions any of the virtual
476 baseclasses provide. */
478 layout_vbasetypes (rec
, max
)
482 /* Get all the virtual base types that this type uses.
483 The TREE_VALUE slot holds the virtual baseclass type. */
484 tree vbase_types
= get_vbase_types (rec
);
486 #ifdef STRUCTURE_SIZE_BOUNDARY
487 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
489 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
);
518 desired_align
= TYPE_ALIGN (basetype
);
519 record_align
= MAX (record_align
, desired_align
);
522 offset
= integer_zero_node
;
525 /* Give each virtual base type the alignment it wants. */
526 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
527 * TYPE_ALIGN (basetype
);
528 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
531 if (CLASSTYPE_VSIZE (basetype
) > max
)
532 max
= CLASSTYPE_VSIZE (basetype
);
533 BINFO_OFFSET (vbase_types
) = offset
;
535 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
536 const_size
+= MAX (BITS_PER_UNIT
,
537 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
538 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
539 else if (var_size
== 0)
540 var_size
= TYPE_SIZE (basetype
);
542 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
544 vbase_types
= TREE_CHAIN (vbase_types
);
547 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
548 here, as that is for this class, without any virtual base classes. */
549 TYPE_ALIGN (rec
) = record_align
;
550 if (const_size
!= nonvirtual_const_size
)
552 CLASSTYPE_VBASE_SIZE (rec
)
553 = size_int (const_size
- nonvirtual_const_size
);
554 TYPE_SIZE (rec
) = size_int (const_size
);
557 /* Now propagate offset information throughout the lattice
558 under the vbase type. */
559 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
560 vbase_types
= TREE_CHAIN (vbase_types
))
562 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
566 tree chain
= NULL_TREE
;
568 /* Now unshare the structure beneath BASE_BINFO. */
570 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
573 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
574 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
575 TREE_VEC_ELT (base_binfos
, j
)
576 = make_binfo (BINFO_OFFSET (base_base_binfo
),
578 BINFO_VTABLE (base_base_binfo
),
579 BINFO_VIRTUALS (base_base_binfo
),
581 chain
= TREE_VEC_ELT (base_binfos
, j
);
582 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
583 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
586 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
593 /* Lay out the base types of a record type, REC.
594 Tentatively set the size and alignment of REC
595 according to the base types alone.
597 Offsets for immediate nonvirtual baseclasses are also computed here.
599 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
600 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
602 Returns list of virtual base classes in a FIELD_DECL chain. */
604 layout_basetypes (rec
, binfos
)
607 /* Chain to hold all the new FIELD_DECLs which point at virtual
609 tree vbase_decls
= NULL_TREE
;
611 #ifdef STRUCTURE_SIZE_BOUNDARY
612 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
614 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
617 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
618 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
619 the size is just CONST_SIZE. Naturally we try to avoid using
620 VAR_SIZE. And so far, we've been sucessful. */
622 register tree var_size
= 0;
625 register unsigned const_size
= 0;
626 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
628 /* Handle basetypes almost like fields, but record their
629 offsets differently. */
631 for (i
= 0; i
< n_baseclasses
; i
++)
633 int inc
, desired_align
, int_vbase_size
;
634 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
635 register tree basetype
= BINFO_TYPE (base_binfo
);
638 if (TYPE_SIZE (basetype
) == 0)
641 /* This error is now reported in xref_tag, thus giving better
642 location information. */
643 error_with_aggr_type (base_binfo
,
644 "base class `%s' has incomplete type");
646 TREE_VIA_PUBLIC (base_binfo
) = 1;
647 TREE_VIA_PROTECTED (base_binfo
) = 0;
648 TREE_VIA_VIRTUAL (base_binfo
) = 0;
650 /* Should handle this better so that
653 class B: private A { virtual void F(); };
655 does not dump core when compiled. */
656 my_friendly_abort (121);
661 /* All basetypes are recorded in the association list of the
664 if (TREE_VIA_VIRTUAL (base_binfo
))
667 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
668 + sizeof (VBASE_NAME
) + 1);
670 /* The offset for a virtual base class is only used in computing
671 virtual function tables and for initializing virtual base
672 pointers. It is built once `get_vbase_types' is called. */
674 /* If this basetype can come from another vbase pointer
675 without an additional indirection, we will share
676 that pointer. If an indirection is involved, we
677 make our own pointer. */
678 for (j
= 0; j
< n_baseclasses
; j
++)
680 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
681 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
682 && binfo_member (basetype
,
683 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
686 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
687 decl
= build_lang_decl (FIELD_DECL
, get_identifier (name
),
688 build_pointer_type (basetype
));
689 /* If you change any of the below, take a look at all the
690 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
692 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
693 DECL_VIRTUAL_P (decl
) = 1;
694 DECL_FIELD_CONTEXT (decl
) = rec
;
695 DECL_CLASS_CONTEXT (decl
) = rec
;
696 DECL_FCONTEXT (decl
) = basetype
;
697 DECL_FIELD_SIZE (decl
) = 0;
698 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
699 TREE_CHAIN (decl
) = vbase_decls
;
700 BINFO_VPTR_FIELD (base_binfo
) = decl
;
703 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
704 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
706 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
707 "destructor `%s' non-virtual");
708 warning ("in inheritance relationship `%s: virtual %s'",
709 TYPE_NAME_STRING (rec
),
710 TYPE_NAME_STRING (basetype
));
713 /* The space this decl occupies has already been accounted for. */
718 offset
= integer_zero_node
;
721 /* Give each base type the alignment it wants. */
722 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
723 * TYPE_ALIGN (basetype
);
724 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
727 /* bpk: Disabled this check until someone is willing to
728 claim it as theirs and explain exactly what circumstances
729 warrant the warning. */
730 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
731 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
733 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
734 "destructor `%s' non-virtual");
735 warning ("in inheritance relationship `%s:%s %s'",
736 TYPE_NAME_STRING (rec
),
737 TREE_VIA_VIRTUAL (base_binfo
) ? " virtual" : "",
738 TYPE_NAME_STRING (basetype
));
742 BINFO_OFFSET (base_binfo
) = offset
;
743 if (CLASSTYPE_VSIZE (basetype
))
745 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
746 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
748 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
749 TYPE_BINFO (rec
) = base_binfo
;
751 /* Add only the amount of storage not present in
752 the virtual baseclasses. */
754 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
755 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
757 inc
= MAX (record_align
,
758 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
761 /* Record must have at least as much alignment as any field. */
762 desired_align
= TYPE_ALIGN (basetype
);
763 record_align
= MAX (record_align
, desired_align
);
770 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
772 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
773 CLASSTYPE_ALIGN (rec
) = record_align
;
778 /* Hashing of lists so that we don't make duplicates.
779 The entry point is `list_hash_canon'. */
781 /* Each hash table slot is a bucket containing a chain
782 of these structures. */
786 struct list_hash
*next
; /* Next structure in the bucket. */
787 int hashcode
; /* Hash code of this list. */
788 tree list
; /* The list recorded here. */
791 /* Now here is the hash table. When recording a list, it is added
792 to the slot whose index is the hash code mod the table size.
793 Note that the hash table is used for several kinds of lists.
794 While all these live in the same table, they are completely independent,
795 and the hash code is computed differently for each of these. */
797 #define TYPE_HASH_SIZE 59
798 struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
800 /* Compute a hash code for a list (chain of TREE_LIST nodes
801 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
802 TREE_COMMON slots), by adding the hash codes of the individual entries. */
808 register int hashcode
= 0;
810 if (TREE_CHAIN (list
))
811 hashcode
+= TYPE_HASH (TREE_CHAIN (list
));
813 if (TREE_VALUE (list
))
814 hashcode
+= TYPE_HASH (TREE_VALUE (list
));
817 if (TREE_PURPOSE (list
))
818 hashcode
+= TYPE_HASH (TREE_PURPOSE (list
));
824 /* Look in the type hash table for a type isomorphic to TYPE.
825 If one is found, return it. Otherwise return 0. */
828 list_hash_lookup (hashcode
, list
)
832 register struct list_hash
*h
;
833 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
834 if (h
->hashcode
== hashcode
835 && TREE_VIA_VIRTUAL (h
->list
) == TREE_VIA_VIRTUAL (list
)
836 && TREE_VIA_PUBLIC (h
->list
) == TREE_VIA_PUBLIC (list
)
837 && TREE_VIA_PROTECTED (h
->list
) == TREE_VIA_PROTECTED (list
)
838 && TREE_PURPOSE (h
->list
) == TREE_PURPOSE (list
)
839 && TREE_VALUE (h
->list
) == TREE_VALUE (list
)
840 && TREE_CHAIN (h
->list
) == TREE_CHAIN (list
))
842 my_friendly_assert (TREE_TYPE (h
->list
) == TREE_TYPE (list
), 299);
848 /* Add an entry to the list-hash-table
849 for a list TYPE whose hash code is HASHCODE. */
852 list_hash_add (hashcode
, list
)
856 register struct list_hash
*h
;
858 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
859 h
->hashcode
= hashcode
;
861 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
862 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
865 /* Given TYPE, and HASHCODE its hash code, return the canonical
866 object for an identical list if one already exists.
867 Otherwise, return TYPE, and record it as the canonical object
868 if it is a permanent object.
870 To use this function, first create a list of the sort you want.
871 Then compute its hash code from the fields of the list that
872 make it different from other similar lists.
873 Then call this function and use the value.
874 This function frees the list you pass in if it is a duplicate. */
876 /* Set to 1 to debug without canonicalization. Never set by program. */
877 static int debug_no_list_hash
= 0;
880 list_hash_canon (hashcode
, list
)
886 if (debug_no_list_hash
)
889 t1
= list_hash_lookup (hashcode
, list
);
892 obstack_free (&class_obstack
, list
);
896 /* If this is a new list, record it for later reuse. */
897 list_hash_add (hashcode
, list
);
903 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
904 int via_public
, via_virtual
, via_protected
;
905 tree purpose
, value
, chain
;
907 struct obstack
*ambient_obstack
= current_obstack
;
911 current_obstack
= &class_obstack
;
912 t
= tree_cons (purpose
, value
, chain
);
913 TREE_VIA_PUBLIC (t
) = via_public
;
914 TREE_VIA_PROTECTED (t
) = via_protected
;
915 TREE_VIA_VIRTUAL (t
) = via_virtual
;
916 hashcode
= list_hash (t
);
917 t
= list_hash_canon (hashcode
, t
);
918 current_obstack
= ambient_obstack
;
922 /* Constructor for hashed lists. */
924 hash_tree_chain (value
, chain
)
927 struct obstack
*ambient_obstack
= current_obstack
;
931 current_obstack
= &class_obstack
;
932 t
= tree_cons (NULL_TREE
, value
, chain
);
933 hashcode
= list_hash (t
);
934 t
= list_hash_canon (hashcode
, t
);
935 current_obstack
= ambient_obstack
;
939 /* Similar, but used for concatenating two lists. */
941 hash_chainon (list1
, list2
)
948 if (TREE_CHAIN (list1
) == NULL_TREE
)
949 return hash_tree_chain (TREE_VALUE (list1
), list2
);
950 return hash_tree_chain (TREE_VALUE (list1
),
951 hash_chainon (TREE_CHAIN (list1
), list2
));
955 get_identifier_list (value
)
958 tree list
= IDENTIFIER_AS_LIST (value
);
959 if (list
!= NULL_TREE
960 && (TREE_CODE (list
) != TREE_LIST
961 || TREE_VALUE (list
) != value
))
963 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
964 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
965 && IDENTIFIER_TYPE_VALUE (value
)
966 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
968 tree type
= IDENTIFIER_TYPE_VALUE (value
);
970 if (TYPE_PTRMEMFUNC_P (type
))
972 else if (type
== current_class_type
)
973 /* Don't mess up the constructor name. */
974 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
978 /* This will return the correct thing for regular types,
979 nested types, and templates. Yay! */
980 if (TYPE_NESTED_NAME (type
))
981 id
= TYPE_NESTED_NAME (type
);
983 id
= TYPE_IDENTIFIER (type
);
985 if (CLASSTYPE_ID_AS_LIST (type
) == NULL_TREE
)
986 CLASSTYPE_ID_AS_LIST (type
)
987 = perm_tree_cons (NULL_TREE
, id
, NULL_TREE
);
988 list
= CLASSTYPE_ID_AS_LIST (type
);
995 get_decl_list (value
)
998 tree list
= NULL_TREE
;
1000 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1001 list
= get_identifier_list (value
);
1002 else if (TREE_CODE (value
) == RECORD_TYPE
1003 && TYPE_LANG_SPECIFIC (value
))
1004 list
= CLASSTYPE_AS_LIST (value
);
1006 if (list
!= NULL_TREE
)
1008 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1012 return build_decl_list (NULL_TREE
, value
);
1015 /* Look in the type hash table for a type isomorphic to
1016 `build_tree_list (NULL_TREE, VALUE)'.
1017 If one is found, return it. Otherwise return 0. */
1020 list_hash_lookup_or_cons (value
)
1023 register int hashcode
= TYPE_HASH (value
);
1024 register struct list_hash
*h
;
1025 struct obstack
*ambient_obstack
;
1026 tree list
= NULL_TREE
;
1028 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1029 list
= get_identifier_list (value
);
1030 else if (TREE_CODE (value
) == TYPE_DECL
1031 && TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
1032 && TYPE_LANG_SPECIFIC (TREE_TYPE (value
)))
1033 list
= CLASSTYPE_ID_AS_LIST (TREE_TYPE (value
));
1034 else if (TREE_CODE (value
) == RECORD_TYPE
1035 && TYPE_LANG_SPECIFIC (value
))
1036 list
= CLASSTYPE_AS_LIST (value
);
1038 if (list
!= NULL_TREE
)
1040 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 302);
1044 if (debug_no_list_hash
)
1045 return hash_tree_chain (value
, NULL_TREE
);
1047 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1048 if (h
->hashcode
== hashcode
1049 && TREE_VIA_VIRTUAL (h
->list
) == 0
1050 && TREE_VIA_PUBLIC (h
->list
) == 0
1051 && TREE_VIA_PROTECTED (h
->list
) == 0
1052 && TREE_PURPOSE (h
->list
) == 0
1053 && TREE_VALUE (h
->list
) == value
)
1055 my_friendly_assert (TREE_TYPE (h
->list
) == 0, 303);
1056 my_friendly_assert (TREE_CHAIN (h
->list
) == 0, 304);
1060 ambient_obstack
= current_obstack
;
1061 current_obstack
= &class_obstack
;
1062 list
= build_tree_list (NULL_TREE
, value
);
1063 list_hash_add (hashcode
, list
);
1064 current_obstack
= ambient_obstack
;
1068 /* Build an association between TYPE and some parameters:
1070 OFFSET is the offset added to `this' to convert it to a pointer
1073 BINFO is the base binfo to use, if we are deriving from one. This
1074 is necessary, as we want specialized parent binfos from base
1075 classes, so that the VTABLE_NAMEs of bases are for the most derived
1076 type, instead of of the simple type.
1078 VTABLE is the virtual function table with which to initialize
1079 sub-objects of type TYPE.
1081 VIRTUALS are the virtual functions sitting in VTABLE.
1083 CHAIN are more associations we must retain. */
1086 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1088 tree vtable
, virtuals
;
1091 tree new_binfo
= make_tree_vec (6);
1094 if (TREE_CODE (binfo
) == TREE_VEC
)
1095 type
= BINFO_TYPE (binfo
);
1099 binfo
= TYPE_BINFO (binfo
);
1102 TREE_CHAIN (new_binfo
) = chain
;
1104 TREE_USED (new_binfo
) = TREE_USED (chain
);
1106 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1107 BINFO_OFFSET (new_binfo
) = offset
;
1108 BINFO_VTABLE (new_binfo
) = vtable
;
1109 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1110 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1112 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1113 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1121 tree binfo
= copy_list (list
);
1125 TREE_USED (binfo
) = 0;
1126 if (BINFO_BASETYPES (binfo
))
1127 BINFO_BASETYPES (binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1128 binfo
= TREE_CHAIN (binfo
);
1133 /* Return the binfo value for ELEM in TYPE. */
1136 binfo_value (elem
, type
)
1140 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1141 compiler_error ("base class `%s' ambiguous in binfo_value",
1142 TYPE_NAME_STRING (elem
));
1144 return TYPE_BINFO (type
);
1145 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1147 return get_binfo (elem
, type
, 0);
1154 register tree prev
= 0, tmp
, next
;
1155 for (tmp
= path
; tmp
; tmp
= next
)
1157 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1158 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1165 virtual_member (elem
, list
)
1172 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1173 if (elem
== BINFO_TYPE (t
))
1176 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1178 tree binfos
= BINFO_BASETYPES (t
);
1181 if (binfos
!= NULL_TREE
)
1182 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1184 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1187 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1188 my_friendly_abort (104);
1203 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1204 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1205 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1206 fprintf (stderr
, "vtable type:\n");
1207 debug_tree (BINFO_TYPE (elem
));
1208 if (BINFO_VTABLE (elem
))
1209 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1211 fprintf (stderr
, "no vtable decl yet\n");
1212 fprintf (stderr
, "virtuals:\n");
1213 virtuals
= BINFO_VIRTUALS (elem
);
1216 virtuals
= TREE_CHAIN (virtuals
);
1218 virtuals
= TREE_CHAIN (virtuals
);
1223 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1224 fprintf (stderr
, "%s [%d =? %d]\n",
1225 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1226 i
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1227 virtuals
= TREE_CHAIN (virtuals
);
1232 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1233 We expect a null pointer to mark the end of the chain.
1234 This is the Lisp primitive `length'. */
1237 decl_list_length (t
)
1241 register int len
= 0;
1243 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1244 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1245 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1255 if (TREE_CODE (t
) == FUNCTION_DECL
)
1257 else if (TREE_CODE (t
) == TREE_LIST
)
1258 return decl_list_length (TREE_VALUE (t
));
1260 my_friendly_abort (359);
1264 /* Like value_member, but for DECL_CHAINs. */
1266 decl_value_member (elem
, list
)
1273 list
= DECL_CHAIN (list
);
1279 is_overloaded_fn (x
)
1282 if (TREE_CODE (x
) == FUNCTION_DECL
)
1285 if (TREE_CODE (x
) == TREE_LIST
1286 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1287 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1294 really_overloaded_fn (x
)
1297 if (TREE_CODE (x
) == TREE_LIST
1298 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1299 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1309 if (TREE_CODE (from
) == FUNCTION_DECL
)
1312 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1314 return TREE_VALUE (from
);
1318 fnaddr_from_vtable_entry (entry
)
1321 if (flag_vtable_thunks
)
1324 if (TREE_CODE (func
) == ADDR_EXPR
)
1325 func
= TREE_OPERAND (func
, 0);
1326 if (TREE_CODE (func
) == THUNK_DECL
)
1327 return DECL_INITIAL (func
);
1332 return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
))));
1336 set_fnaddr_from_vtable_entry (entry
, value
)
1339 if (flag_vtable_thunks
)
1342 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
)))) = value
;
1346 function_arg_chain (t
)
1349 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t
)));
1353 promotes_to_aggr_type (t
, code
)
1355 enum tree_code code
;
1357 if (TREE_CODE (t
) == code
)
1359 return IS_AGGR_TYPE (t
);
1363 is_aggr_type_2 (t1
, t2
)
1366 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1368 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1371 /* Give message using types TYPE1 and TYPE2 as arguments.
1372 PFN is the function which will print the message;
1373 S is the format string for PFN to use. */
1375 message_2_types (pfn
, s
, type1
, type2
)
1380 tree name1
= TYPE_NAME (type1
);
1381 tree name2
= TYPE_NAME (type2
);
1382 if (TREE_CODE (name1
) == TYPE_DECL
)
1383 name1
= DECL_NAME (name1
);
1384 if (TREE_CODE (name2
) == TYPE_DECL
)
1385 name2
= DECL_NAME (name2
);
1386 (*pfn
) (s
, IDENTIFIER_POINTER (name1
), IDENTIFIER_POINTER (name2
));
1389 #define PRINT_RING_SIZE 4
1392 lang_printable_name (decl
)
1395 static tree decl_ring
[PRINT_RING_SIZE
];
1396 static char *print_ring
[PRINT_RING_SIZE
];
1397 static int ring_counter
;
1400 /* Only cache functions. */
1401 if (TREE_CODE (decl
) != FUNCTION_DECL
1402 || DECL_LANG_SPECIFIC (decl
) == 0)
1403 return decl_as_string (decl
, 1);
1405 /* See if this print name is lying around. */
1406 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1407 if (decl_ring
[i
] == decl
)
1408 /* yes, so return it. */
1409 return print_ring
[i
];
1411 if (++ring_counter
== PRINT_RING_SIZE
)
1414 if (current_function_decl
!= NULL_TREE
)
1416 if (decl_ring
[ring_counter
] == current_function_decl
)
1418 if (ring_counter
== PRINT_RING_SIZE
)
1420 if (decl_ring
[ring_counter
] == current_function_decl
)
1421 my_friendly_abort (106);
1424 if (print_ring
[ring_counter
])
1425 free (print_ring
[ring_counter
]);
1428 int print_ret_type_p
1429 = (!DECL_CONSTRUCTOR_P (decl
)
1430 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)));
1432 char *name
= (char *)decl_as_string (decl
, print_ret_type_p
);
1433 print_ring
[ring_counter
] = (char *)malloc (strlen (name
) + 1);
1434 strcpy (print_ring
[ring_counter
], name
);
1435 decl_ring
[ring_counter
] = decl
;
1437 return print_ring
[ring_counter
];
1440 /* Comparison function for sorting identifiers in RAISES lists.
1441 Note that because IDENTIFIER_NODEs are unique, we can sort
1442 them by address, saving an indirection. */
1447 return (HOST_WIDE_INT
)TREE_VALUE (*p1
) - (HOST_WIDE_INT
)TREE_VALUE (*p2
);
1450 /* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
1451 listed in RAISES. */
1453 build_exception_variant (ctype
, type
, raises
)
1458 tree v
= TYPE_MAIN_VARIANT (type
);
1460 tree
*a
= (tree
*)alloca ((list_length (raises
)+1) * sizeof (tree
));
1461 int constp
= TYPE_READONLY (type
);
1462 int volatilep
= TYPE_VOLATILE (type
);
1464 for (v
= TYPE_NEXT_VARIANT (v
); v
; v
= TYPE_NEXT_VARIANT (v
))
1466 if (TYPE_READONLY (v
) != constp
1467 || TYPE_VOLATILE (v
) != volatilep
)
1471 t2
= TYPE_RAISES_EXCEPTIONS (v
);
1474 if (TREE_TYPE (t
) == TREE_TYPE (t2
))
1477 t2
= TREE_CHAIN (t2
);
1483 /* List of exceptions raised matches previously found list.
1485 @@ Nice to free up storage used in consing up the
1486 @@ list of exceptions raised. */
1490 /* Need to build a new variant. */
1491 v
= copy_node (type
);
1492 TYPE_NEXT_VARIANT (v
) = TYPE_NEXT_VARIANT (type
);
1493 TYPE_NEXT_VARIANT (type
) = v
;
1494 if (raises
&& ! TREE_PERMANENT (raises
))
1496 push_obstacks_nochange ();
1497 end_temporary_allocation ();
1498 raises
= copy_list (raises
);
1501 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1505 /* Subroutine of copy_to_permanent
1507 Assuming T is a node build bottom-up, make it all exist on
1508 permanent obstack, if it is not permanent already. */
1513 enum tree_code code
;
1515 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1518 switch (code
= TREE_CODE (t
))
1521 return error_mark_node
;
1530 tree chain
= TREE_CHAIN (t
);
1532 TREE_CHAIN (t
) = make_deep_copy (chain
);
1533 TREE_TYPE (t
) = make_deep_copy (TREE_TYPE (t
));
1534 DECL_INITIAL (t
) = make_deep_copy (DECL_INITIAL (t
));
1535 DECL_SIZE (t
) = make_deep_copy (DECL_SIZE (t
));
1541 tree chain
= TREE_CHAIN (t
);
1543 TREE_PURPOSE (t
) = make_deep_copy (TREE_PURPOSE (t
));
1544 TREE_VALUE (t
) = make_deep_copy (TREE_VALUE (t
));
1545 TREE_CHAIN (t
) = make_deep_copy (chain
);
1551 int len
= TREE_VEC_LENGTH (t
);
1555 TREE_VEC_ELT (t
, len
) = make_deep_copy (TREE_VEC_ELT (t
, len
));
1562 return copy_node (t
);
1568 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1569 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1570 TREE_OPERAND (t
, 2) = make_deep_copy (TREE_OPERAND (t
, 2));
1575 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1582 case TRUNC_DIV_EXPR
:
1583 case TRUNC_MOD_EXPR
:
1591 case BIT_ANDTC_EXPR
:
1592 case TRUTH_ANDIF_EXPR
:
1593 case TRUTH_ORIF_EXPR
:
1601 case FLOOR_DIV_EXPR
:
1602 case ROUND_DIV_EXPR
:
1604 case FLOOR_MOD_EXPR
:
1605 case ROUND_MOD_EXPR
:
1607 case PREDECREMENT_EXPR
:
1608 case PREINCREMENT_EXPR
:
1609 case POSTDECREMENT_EXPR
:
1610 case POSTINCREMENT_EXPR
:
1613 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1614 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1622 case TRUTH_NOT_EXPR
:
1626 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1629 /* This list is incomplete, but should suffice for now.
1630 It is very important that `sorry' does not call
1631 `report_error_function'. That could cause an infinite loop. */
1633 sorry ("initializer contains unrecognized tree code");
1634 return error_mark_node
;
1637 my_friendly_abort (107);
1642 /* Assuming T is a node built bottom-up, make it all exist on
1643 permanent obstack, if it is not permanent already. */
1645 copy_to_permanent (t
)
1648 register struct obstack
*ambient_obstack
= current_obstack
;
1649 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1651 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1654 saveable_obstack
= &permanent_obstack
;
1655 current_obstack
= saveable_obstack
;
1657 t
= make_deep_copy (t
);
1659 current_obstack
= ambient_obstack
;
1660 saveable_obstack
= ambient_saveable_obstack
;
1666 print_lang_statistics ()
1668 extern struct obstack maybepermanent_obstack
;
1669 print_obstack_statistics ("class_obstack", &class_obstack
);
1670 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1671 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1672 print_search_statistics ();
1673 print_class_statistics ();
1676 /* This is used by the `assert' macro. It is provided in libgcc.a,
1677 which `cc' doesn't know how to link. Note that the C++ front-end
1678 no longer actually uses the `assert' macro (instead, it calls
1679 my_friendly_assert). But all of the back-end files still need this. */
1681 __eprintf (string
, expression
, line
, filename
)
1684 const char *expression
;
1686 const char *filename
;
1694 fprintf (stderr
, string
, expression
, line
, filename
);
1699 /* Return, as an INTEGER_CST node, the number of elements for
1700 TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1703 array_type_nelts_top (type
)
1706 return fold (build (PLUS_EXPR
, integer_type_node
,
1707 array_type_nelts (type
),
1711 /* Return, as an INTEGER_CST node, the number of elements for
1712 TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1713 ARRAY_TYPEs that are clumped together. */
1716 array_type_nelts_total (type
)
1719 tree sz
= array_type_nelts_top (type
);
1720 type
= TREE_TYPE (type
);
1721 while (TREE_CODE (type
) == ARRAY_TYPE
)
1723 tree n
= array_type_nelts_top (type
);
1724 sz
= fold (build (MULT_EXPR
, integer_type_node
, sz
, n
));
1725 type
= TREE_TYPE (type
);