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
))
42 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
47 /* preincrements and predecrements are valid lvals, provided
48 what they refer to are valid lvals. */
49 case PREINCREMENT_EXPR
:
50 case PREDECREMENT_EXPR
:
53 return lvalue_p (TREE_OPERAND (ref
, 0));
59 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
60 && DECL_LANG_SPECIFIC (ref
)
61 && DECL_IN_AGGR_P (ref
))
68 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
69 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
74 case WITH_CLEANUP_EXPR
:
77 /* A currently unresolved scope ref. */
79 my_friendly_abort (103);
81 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
83 return lvalue_p (TREE_OPERAND (ref
, 0))
84 && lvalue_p (TREE_OPERAND (ref
, 1));
88 return (lvalue_p (TREE_OPERAND (ref
, 1))
89 && lvalue_p (TREE_OPERAND (ref
, 2)));
95 return lvalue_p (TREE_OPERAND (ref
, 1));
101 /* Return nonzero if REF is an lvalue valid for this language;
102 otherwise, print an error message and return zero. */
105 lvalue_or_else (ref
, string
)
109 int win
= lvalue_p (ref
);
111 error ("non-lvalue in %s", string
);
115 /* INIT is a CALL_EXPR which needs info about its target.
116 TYPE is the type that this initialization should appear to have.
118 Build an encapsulation of the initialization to perform
119 and return it so that it can be processed by language-independent
120 and language-specific expression expanders.
122 If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
123 Otherwise, cleanups are not built here. For example, when building
124 an initialization for a stack slot, since the called function handles
125 the cleanup, we would not want to do it here. */
127 build_cplus_new (type
, init
, with_cleanup_p
)
132 tree slot
= build (VAR_DECL
, type
);
133 tree rval
= build (NEW_EXPR
, type
,
134 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
135 TREE_SIDE_EFFECTS (rval
) = 1;
136 TREE_ADDRESSABLE (rval
) = 1;
137 rval
= build (TARGET_EXPR
, type
, slot
, rval
, 0);
138 TREE_SIDE_EFFECTS (rval
) = 1;
139 TREE_ADDRESSABLE (rval
) = 1;
141 if (with_cleanup_p
&& TYPE_NEEDS_DESTRUCTOR (type
))
143 TREE_OPERAND (rval
, 2) = error_mark_node
;
144 rval
= build (WITH_CLEANUP_EXPR
, type
, rval
, 0,
145 build_delete (TYPE_POINTER_TO (type
),
146 build_unary_op (ADDR_EXPR
, slot
, 0),
148 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0));
149 TREE_SIDE_EFFECTS (rval
) = 1;
150 TREE_ADDRESSABLE (rval
) = 1;
155 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
156 these CALL_EXPRs with tree nodes that will perform the cleanups. */
159 break_out_cleanups (exp
)
164 if (TREE_CODE (tmp
) == CALL_EXPR
165 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
166 return build_cplus_new (TREE_TYPE (tmp
), tmp
, 1);
168 while (TREE_CODE (tmp
) == NOP_EXPR
169 || TREE_CODE (tmp
) == CONVERT_EXPR
170 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
172 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
173 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
175 TREE_OPERAND (tmp
, 0)
176 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
177 TREE_OPERAND (tmp
, 0), 1);
181 tmp
= TREE_OPERAND (tmp
, 0);
186 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
187 copies where they are found. Returns a deep copy all nodes transitively
188 containing CALL_EXPRs. */
191 break_out_calls (exp
)
194 register tree t1
, t2
;
195 register enum tree_code code
;
196 register int changed
= 0;
199 if (exp
== NULL_TREE
)
202 code
= TREE_CODE (exp
);
204 if (code
== CALL_EXPR
)
205 return copy_node (exp
);
207 /* Don't try and defeat a save_expr, as it should only be done once. */
208 if (code
== SAVE_EXPR
)
211 switch (TREE_CODE_CLASS (code
))
216 case 'c': /* a constant */
217 case 't': /* a type node */
218 case 'x': /* something random, like an identifier or an ERROR_MARK. */
221 case 'd': /* A decl node */
222 t1
= break_out_calls (DECL_INITIAL (exp
));
223 if (t1
!= DECL_INITIAL (exp
))
225 exp
= copy_node (exp
);
226 DECL_INITIAL (exp
) = t1
;
230 case 'b': /* A block node */
232 /* Don't know how to handle these correctly yet. Must do a
233 break_out_calls on all DECL_INITIAL values for local variables,
234 and also break_out_calls on all sub-blocks and sub-statements. */
239 case 'e': /* an expression */
240 case 'r': /* a reference */
241 case 's': /* an expression with side effects */
242 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
244 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
245 if (t1
!= TREE_OPERAND (exp
, i
))
247 exp
= copy_node (exp
);
248 TREE_OPERAND (exp
, i
) = t1
;
253 case '<': /* a comparison expression */
254 case '2': /* a binary arithmetic expression */
255 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
256 if (t2
!= TREE_OPERAND (exp
, 1))
258 case '1': /* a unary arithmetic expression */
259 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
260 if (t1
!= TREE_OPERAND (exp
, 0))
264 if (tree_code_length
[(int) code
] == 1)
265 return build1 (code
, TREE_TYPE (exp
), t1
);
267 return build (code
, TREE_TYPE (exp
), t1
, t2
);
274 extern struct obstack
*current_obstack
;
275 extern struct obstack permanent_obstack
, class_obstack
;
276 extern struct obstack
*saveable_obstack
;
278 /* Here is how primitive or already-canonicalized types' hash
279 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
280 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
282 /* Construct, lay out and return the type of methods belonging to class
283 BASETYPE and whose arguments are described by ARGTYPES and whose values
284 are described by RETTYPE. If each type exists already, reuse it. */
286 build_cplus_method_type (basetype
, rettype
, argtypes
)
287 tree basetype
, rettype
, argtypes
;
293 /* Make a node of the sort we want. */
294 t
= make_node (METHOD_TYPE
);
296 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
297 TREE_TYPE (t
) = rettype
;
298 if (IS_SIGNATURE (basetype
))
299 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
300 TYPE_READONLY (basetype
),
301 TYPE_VOLATILE (basetype
));
304 ptype
= build_pointer_type (basetype
);
305 ptype
= build_type_variant (ptype
, 1, 0);
307 /* The actual arglist for this function includes a "hidden" argument
308 which is "this". Put it into the list of argument types. */
310 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
311 TYPE_ARG_TYPES (t
) = argtypes
;
312 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
314 /* If we already have such a type, use the old one and free this one.
315 Note that it also frees up the above cons cell if found. */
316 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
317 t
= type_hash_canon (hashcode
, t
);
319 if (TYPE_SIZE (t
) == 0)
326 build_cplus_staticfn_type (basetype
, rettype
, argtypes
)
327 tree basetype
, rettype
, argtypes
;
332 /* Make a node of the sort we want. */
333 t
= make_node (FUNCTION_TYPE
);
335 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
336 TREE_TYPE (t
) = rettype
;
338 /* The actual arglist for this function includes a "hidden" argument
339 which is "this". Put it into the list of argument types. */
341 TYPE_ARG_TYPES (t
) = argtypes
;
343 /* If we already have such a type, use the old one and free this one.
344 Note that it also frees up the above cons cell if found. */
345 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
346 t
= type_hash_canon (hashcode
, t
);
348 if (TYPE_SIZE (t
) == 0)
355 build_cplus_array_type (elt_type
, index_type
)
359 register struct obstack
*ambient_obstack
= current_obstack
;
360 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
363 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
364 make this permanent too. */
365 if (TREE_PERMANENT (elt_type
)
366 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
368 current_obstack
= &permanent_obstack
;
369 saveable_obstack
= &permanent_obstack
;
372 t
= build_array_type (elt_type
, index_type
);
374 /* Push these needs up so that initialization takes place
376 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
377 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
378 current_obstack
= ambient_obstack
;
379 saveable_obstack
= ambient_saveable_obstack
;
383 /* Add OFFSET to all base types of T.
385 OFFSET, which is a type offset, is number of bytes.
387 Note that we don't have to worry about having two paths to the
388 same base type, since this type owns its association list. */
390 propagate_binfo_offsets (binfo
, offset
)
394 tree binfos
= BINFO_BASETYPES (binfo
);
395 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
397 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
399 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
401 if (TREE_VIA_VIRTUAL (base_binfo
))
406 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
409 for (j
= i
+1; j
< n_baselinks
; j
++)
410 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
412 /* The next basetype offset must take into account the space
413 between the classes, not just the size of each class. */
414 delta
= size_binop (MINUS_EXPR
,
415 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
416 BINFO_OFFSET (base_binfo
));
421 if (BINFO_OFFSET_ZEROP (base_binfo
))
422 BINFO_OFFSET (base_binfo
) = offset
;
424 BINFO_OFFSET (base_binfo
)
425 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
427 BINFO_OFFSET (base_binfo
) = offset
;
432 tree chain
= NULL_TREE
;
434 /* Now unshare the structure beneath BASE_BINFO. */
435 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
438 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
439 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
440 TREE_VEC_ELT (base_binfos
, k
)
441 = make_binfo (BINFO_OFFSET (base_base_binfo
),
443 BINFO_VTABLE (base_base_binfo
),
444 BINFO_VIRTUALS (base_base_binfo
),
446 chain
= TREE_VEC_ELT (base_binfos
, k
);
447 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
448 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
450 /* Now propagate the offset to the base types. */
451 propagate_binfo_offsets (base_binfo
, offset
);
454 /* Go to our next class that counts for offset propagation. */
457 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
462 /* Compute the actual offsets that our virtual base classes
463 will have *for this type*. This must be performed after
464 the fields are laid out, since virtual baseclasses must
465 lay down at the end of the record.
467 Returns the maximum number of virtual functions any of the virtual
468 baseclasses provide. */
470 layout_vbasetypes (rec
, max
)
474 /* Get all the virtual base types that this type uses.
475 The TREE_VALUE slot holds the virtual baseclass type. */
476 tree vbase_types
= get_vbase_types (rec
);
478 #ifdef STRUCTURE_SIZE_BOUNDARY
479 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
481 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
485 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
486 where CONST_SIZE is an integer
487 and VAR_SIZE is a tree expression.
488 If VAR_SIZE is null, the size is just CONST_SIZE.
489 Naturally we try to avoid using VAR_SIZE. */
490 register unsigned const_size
= 0;
491 register tree var_size
= 0;
492 int nonvirtual_const_size
;
493 tree nonvirtual_var_size
;
495 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
497 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
498 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
500 var_size
= TYPE_SIZE (rec
);
502 nonvirtual_const_size
= const_size
;
503 nonvirtual_var_size
= var_size
;
507 tree basetype
= BINFO_TYPE (vbase_types
);
510 desired_align
= TYPE_ALIGN (basetype
);
511 record_align
= MAX (record_align
, desired_align
);
514 offset
= integer_zero_node
;
517 /* Give each virtual base type the alignment it wants. */
518 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
519 * TYPE_ALIGN (basetype
);
520 offset
= size_int (CEIL (const_size
, 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 (BITS_PER_UNIT
,
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 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
540 here, as that is for this class, without any virtual base classes. */
541 TYPE_ALIGN (rec
) = record_align
;
542 if (const_size
!= nonvirtual_const_size
)
544 CLASSTYPE_VBASE_SIZE (rec
)
545 = size_int (const_size
- nonvirtual_const_size
);
546 TYPE_SIZE (rec
) = size_int (const_size
);
549 /* Now propagate offset information throughout the lattice
550 under the vbase type. */
551 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
552 vbase_types
= TREE_CHAIN (vbase_types
))
554 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
558 tree chain
= NULL_TREE
;
560 /* Now unshare the structure beneath BASE_BINFO. */
562 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
565 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
566 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
567 TREE_VEC_ELT (base_binfos
, j
)
568 = make_binfo (BINFO_OFFSET (base_base_binfo
),
570 BINFO_VTABLE (base_base_binfo
),
571 BINFO_VIRTUALS (base_base_binfo
),
573 chain
= TREE_VEC_ELT (base_binfos
, j
);
574 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
575 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
578 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
585 /* Lay out the base types of a record type, REC.
586 Tentatively set the size and alignment of REC
587 according to the base types alone.
589 Offsets for immediate nonvirtual baseclasses are also computed here.
591 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
592 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
594 Returns list of virtual base classes in a FIELD_DECL chain. */
596 layout_basetypes (rec
, binfos
)
599 /* Chain to hold all the new FIELD_DECLs which point at virtual
601 tree vbase_decls
= NULL_TREE
;
603 #ifdef STRUCTURE_SIZE_BOUNDARY
604 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
606 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
609 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
610 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
611 the size is just CONST_SIZE. Naturally we try to avoid using
612 VAR_SIZE. And so far, we've been sucessful. */
614 register tree var_size
= 0;
617 register unsigned const_size
= 0;
618 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
620 /* Handle basetypes almost like fields, but record their
621 offsets differently. */
623 for (i
= 0; i
< n_baseclasses
; i
++)
625 int inc
, desired_align
, int_vbase_size
;
626 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
627 register tree basetype
= BINFO_TYPE (base_binfo
);
630 if (TYPE_SIZE (basetype
) == 0)
633 /* This error is now reported in xref_tag, thus giving better
634 location information. */
635 error_with_aggr_type (base_binfo
,
636 "base class `%s' has incomplete type");
638 TREE_VIA_PUBLIC (base_binfo
) = 1;
639 TREE_VIA_PROTECTED (base_binfo
) = 0;
640 TREE_VIA_VIRTUAL (base_binfo
) = 0;
642 /* Should handle this better so that
645 class B: private A { virtual void F(); };
647 does not dump core when compiled. */
648 my_friendly_abort (121);
653 /* All basetypes are recorded in the association list of the
656 if (TREE_VIA_VIRTUAL (base_binfo
))
659 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
660 + sizeof (VBASE_NAME
) + 1);
662 /* The offset for a virtual base class is only used in computing
663 virtual function tables and for initializing virtual base
664 pointers. It is built once `get_vbase_types' is called. */
666 /* If this basetype can come from another vbase pointer
667 without an additional indirection, we will share
668 that pointer. If an indirection is involved, we
669 make our own pointer. */
670 for (j
= 0; j
< n_baseclasses
; j
++)
672 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
673 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
674 && binfo_member (basetype
,
675 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
678 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
679 decl
= build_lang_decl (FIELD_DECL
, get_identifier (name
),
680 build_pointer_type (basetype
));
681 /* If you change any of the below, take a look at all the
682 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
684 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
685 DECL_VIRTUAL_P (decl
) = 1;
686 DECL_FIELD_CONTEXT (decl
) = rec
;
687 DECL_CLASS_CONTEXT (decl
) = rec
;
688 DECL_FCONTEXT (decl
) = basetype
;
689 DECL_FIELD_SIZE (decl
) = 0;
690 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
691 TREE_CHAIN (decl
) = vbase_decls
;
692 BINFO_VPTR_FIELD (base_binfo
) = decl
;
695 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
696 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
698 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
699 "destructor `%s' non-virtual");
700 warning ("in inheritance relationship `%s: virtual %s'",
701 TYPE_NAME_STRING (rec
),
702 TYPE_NAME_STRING (basetype
));
705 /* The space this decl occupies has already been accounted for. */
710 offset
= integer_zero_node
;
713 /* Give each base type the alignment it wants. */
714 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
715 * TYPE_ALIGN (basetype
);
716 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
719 /* bpk: Disabled this check until someone is willing to
720 claim it as theirs and explain exactly what circumstances
721 warrant the warning. */
722 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
723 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0)) == NULL_TREE
)
725 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0),
726 "destructor `%s' non-virtual");
727 warning ("in inheritance relationship `%s:%s %s'",
728 TYPE_NAME_STRING (rec
),
729 TREE_VIA_VIRTUAL (base_binfo
) ? " virtual" : "",
730 TYPE_NAME_STRING (basetype
));
734 BINFO_OFFSET (base_binfo
) = offset
;
735 if (CLASSTYPE_VSIZE (basetype
))
737 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
738 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
740 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
741 TYPE_BINFO (rec
) = base_binfo
;
743 /* Add only the amount of storage not present in
744 the virtual baseclasses. */
746 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
747 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
749 inc
= MAX (record_align
,
750 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
753 /* Record must have at least as much alignment as any field. */
754 desired_align
= TYPE_ALIGN (basetype
);
755 record_align
= MAX (record_align
, desired_align
);
762 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
764 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
765 CLASSTYPE_ALIGN (rec
) = record_align
;
770 /* Hashing of lists so that we don't make duplicates.
771 The entry point is `list_hash_canon'. */
773 /* Each hash table slot is a bucket containing a chain
774 of these structures. */
778 struct list_hash
*next
; /* Next structure in the bucket. */
779 int hashcode
; /* Hash code of this list. */
780 tree list
; /* The list recorded here. */
783 /* Now here is the hash table. When recording a list, it is added
784 to the slot whose index is the hash code mod the table size.
785 Note that the hash table is used for several kinds of lists.
786 While all these live in the same table, they are completely independent,
787 and the hash code is computed differently for each of these. */
789 #define TYPE_HASH_SIZE 59
790 struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
792 /* Compute a hash code for a list (chain of TREE_LIST nodes
793 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
794 TREE_COMMON slots), by adding the hash codes of the individual entries. */
800 register int hashcode
= 0;
802 if (TREE_CHAIN (list
))
803 hashcode
+= TYPE_HASH (TREE_CHAIN (list
));
805 if (TREE_VALUE (list
))
806 hashcode
+= TYPE_HASH (TREE_VALUE (list
));
809 if (TREE_PURPOSE (list
))
810 hashcode
+= TYPE_HASH (TREE_PURPOSE (list
));
816 /* Look in the type hash table for a type isomorphic to TYPE.
817 If one is found, return it. Otherwise return 0. */
820 list_hash_lookup (hashcode
, list
)
824 register struct list_hash
*h
;
825 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
826 if (h
->hashcode
== hashcode
827 && TREE_VIA_VIRTUAL (h
->list
) == TREE_VIA_VIRTUAL (list
)
828 && TREE_VIA_PUBLIC (h
->list
) == TREE_VIA_PUBLIC (list
)
829 && TREE_VIA_PROTECTED (h
->list
) == TREE_VIA_PROTECTED (list
)
830 && TREE_PURPOSE (h
->list
) == TREE_PURPOSE (list
)
831 && TREE_VALUE (h
->list
) == TREE_VALUE (list
)
832 && TREE_CHAIN (h
->list
) == TREE_CHAIN (list
))
834 my_friendly_assert (TREE_TYPE (h
->list
) == TREE_TYPE (list
), 299);
840 /* Add an entry to the list-hash-table
841 for a list TYPE whose hash code is HASHCODE. */
844 list_hash_add (hashcode
, list
)
848 register struct list_hash
*h
;
850 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
851 h
->hashcode
= hashcode
;
853 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
854 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
857 /* Given TYPE, and HASHCODE its hash code, return the canonical
858 object for an identical list if one already exists.
859 Otherwise, return TYPE, and record it as the canonical object
860 if it is a permanent object.
862 To use this function, first create a list of the sort you want.
863 Then compute its hash code from the fields of the list that
864 make it different from other similar lists.
865 Then call this function and use the value.
866 This function frees the list you pass in if it is a duplicate. */
868 /* Set to 1 to debug without canonicalization. Never set by program. */
869 static int debug_no_list_hash
= 0;
872 list_hash_canon (hashcode
, list
)
878 if (debug_no_list_hash
)
881 t1
= list_hash_lookup (hashcode
, list
);
884 obstack_free (&class_obstack
, list
);
888 /* If this is a new list, record it for later reuse. */
889 list_hash_add (hashcode
, list
);
895 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
896 int via_public
, via_virtual
, via_protected
;
897 tree purpose
, value
, chain
;
899 struct obstack
*ambient_obstack
= current_obstack
;
903 current_obstack
= &class_obstack
;
904 t
= tree_cons (purpose
, value
, chain
);
905 TREE_VIA_PUBLIC (t
) = via_public
;
906 TREE_VIA_PROTECTED (t
) = via_protected
;
907 TREE_VIA_VIRTUAL (t
) = via_virtual
;
908 hashcode
= list_hash (t
);
909 t
= list_hash_canon (hashcode
, t
);
910 current_obstack
= ambient_obstack
;
914 /* Constructor for hashed lists. */
916 hash_tree_chain (value
, chain
)
919 struct obstack
*ambient_obstack
= current_obstack
;
923 current_obstack
= &class_obstack
;
924 t
= tree_cons (NULL_TREE
, value
, chain
);
925 hashcode
= list_hash (t
);
926 t
= list_hash_canon (hashcode
, t
);
927 current_obstack
= ambient_obstack
;
931 /* Similar, but used for concatenating two lists. */
933 hash_chainon (list1
, list2
)
940 if (TREE_CHAIN (list1
) == NULL_TREE
)
941 return hash_tree_chain (TREE_VALUE (list1
), list2
);
942 return hash_tree_chain (TREE_VALUE (list1
),
943 hash_chainon (TREE_CHAIN (list1
), list2
));
947 get_identifier_list (value
)
950 tree list
= IDENTIFIER_AS_LIST (value
);
951 if (list
!= NULL_TREE
952 && (TREE_CODE (list
) != TREE_LIST
953 || TREE_VALUE (list
) != value
))
955 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
956 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
957 && IDENTIFIER_TYPE_VALUE (value
)
958 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
960 tree type
= IDENTIFIER_TYPE_VALUE (value
);
962 if (TYPE_PTRMEMFUNC_P (type
))
964 else if (type
== current_class_type
)
965 /* Don't mess up the constructor name. */
966 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
970 /* This will return the correct thing for regular types,
971 nested types, and templates. Yay! */
972 if (TYPE_NESTED_NAME (type
))
973 id
= TYPE_NESTED_NAME (type
);
975 id
= TYPE_IDENTIFIER (type
);
977 if (CLASSTYPE_ID_AS_LIST (type
) == NULL_TREE
)
978 CLASSTYPE_ID_AS_LIST (type
)
979 = perm_tree_cons (NULL_TREE
, id
, NULL_TREE
);
980 list
= CLASSTYPE_ID_AS_LIST (type
);
987 get_decl_list (value
)
990 tree list
= NULL_TREE
;
992 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
993 list
= get_identifier_list (value
);
994 else if (TREE_CODE (value
) == RECORD_TYPE
995 && TYPE_LANG_SPECIFIC (value
))
996 list
= CLASSTYPE_AS_LIST (value
);
998 if (list
!= NULL_TREE
)
1000 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1004 return build_decl_list (NULL_TREE
, value
);
1007 /* Look in the type hash table for a type isomorphic to
1008 `build_tree_list (NULL_TREE, VALUE)'.
1009 If one is found, return it. Otherwise return 0. */
1012 list_hash_lookup_or_cons (value
)
1015 register int hashcode
= TYPE_HASH (value
);
1016 register struct list_hash
*h
;
1017 struct obstack
*ambient_obstack
;
1018 tree list
= NULL_TREE
;
1020 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1021 list
= get_identifier_list (value
);
1022 else if (TREE_CODE (value
) == TYPE_DECL
1023 && TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
1024 && TYPE_LANG_SPECIFIC (TREE_TYPE (value
)))
1025 list
= CLASSTYPE_ID_AS_LIST (TREE_TYPE (value
));
1026 else if (TREE_CODE (value
) == RECORD_TYPE
1027 && TYPE_LANG_SPECIFIC (value
))
1028 list
= CLASSTYPE_AS_LIST (value
);
1030 if (list
!= NULL_TREE
)
1032 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 302);
1036 if (debug_no_list_hash
)
1037 return hash_tree_chain (value
, NULL_TREE
);
1039 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1040 if (h
->hashcode
== hashcode
1041 && TREE_VIA_VIRTUAL (h
->list
) == 0
1042 && TREE_VIA_PUBLIC (h
->list
) == 0
1043 && TREE_VIA_PROTECTED (h
->list
) == 0
1044 && TREE_PURPOSE (h
->list
) == 0
1045 && TREE_VALUE (h
->list
) == value
)
1047 my_friendly_assert (TREE_TYPE (h
->list
) == 0, 303);
1048 my_friendly_assert (TREE_CHAIN (h
->list
) == 0, 304);
1052 ambient_obstack
= current_obstack
;
1053 current_obstack
= &class_obstack
;
1054 list
= build_tree_list (NULL_TREE
, value
);
1055 list_hash_add (hashcode
, list
);
1056 current_obstack
= ambient_obstack
;
1060 /* Build an association between TYPE and some parameters:
1062 OFFSET is the offset added to `this' to convert it to a pointer
1065 BINFO is the base binfo to use, if we are deriving from one. This
1066 is necessary, as we want specialized parent binfos from base
1067 classes, so that the VTABLE_NAMEs of bases are for the most derived
1068 type, instead of of the simple type.
1070 VTABLE is the virtual function table with which to initialize
1071 sub-objects of type TYPE.
1073 VIRTUALS are the virtual functions sitting in VTABLE.
1075 CHAIN are more associations we must retain. */
1078 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1080 tree vtable
, virtuals
;
1083 tree new_binfo
= make_tree_vec (6);
1086 if (TREE_CODE (binfo
) == TREE_VEC
)
1087 type
= BINFO_TYPE (binfo
);
1091 binfo
= TYPE_BINFO (binfo
);
1094 TREE_CHAIN (new_binfo
) = chain
;
1096 TREE_USED (new_binfo
) = TREE_USED (chain
);
1098 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1099 BINFO_OFFSET (new_binfo
) = offset
;
1100 BINFO_VTABLE (new_binfo
) = vtable
;
1101 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1102 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1104 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1105 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1113 tree binfo
= copy_list (list
);
1117 TREE_USED (binfo
) = 0;
1118 if (BINFO_BASETYPES (binfo
))
1119 BINFO_BASETYPES (binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1120 binfo
= TREE_CHAIN (binfo
);
1125 /* Return the binfo value for ELEM in TYPE. */
1128 binfo_value (elem
, type
)
1132 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1133 compiler_error ("base class `%s' ambiguous in binfo_value",
1134 TYPE_NAME_STRING (elem
));
1136 return TYPE_BINFO (type
);
1137 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1139 return get_binfo (elem
, type
, 0);
1146 register tree prev
= 0, tmp
, next
;
1147 for (tmp
= path
; tmp
; tmp
= next
)
1149 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1150 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1157 virtual_member (elem
, list
)
1164 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1165 if (elem
== BINFO_TYPE (t
))
1168 for (t
= list
; t
; t
= TREE_CHAIN (t
))
1170 tree binfos
= BINFO_BASETYPES (t
);
1173 if (binfos
!= NULL_TREE
)
1174 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1176 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1179 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1180 my_friendly_abort (104);
1188 /* Return the offset (as an INTEGER_CST) for ELEM in LIST.
1189 INITIAL_OFFSET is the value to add to the offset that ELEM's
1190 binfo entry in LIST provides.
1192 Returns NULL if ELEM does not have an binfo value in LIST. */
1195 virtual_offset (elem
, list
, initial_offset
)
1198 tree initial_offset
;
1203 for (vb
= list
; vb
; vb
= TREE_CHAIN (vb
))
1204 if (elem
== BINFO_TYPE (vb
))
1205 return size_binop (PLUS_EXPR
, initial_offset
, BINFO_OFFSET (vb
));
1207 for (vb
= list
; vb
; vb
= TREE_CHAIN (vb
))
1209 tree binfos
= BINFO_BASETYPES (vb
);
1212 if (binfos
== NULL_TREE
)
1215 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1217 nval
= binfo_value (elem
, BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
1220 if (rval
&& BINFO_OFFSET (nval
) != BINFO_OFFSET (rval
))
1221 my_friendly_abort (105);
1222 offset
= BINFO_OFFSET (vb
);
1227 if (rval
== NULL_TREE
)
1229 return size_binop (PLUS_EXPR
, offset
, BINFO_OFFSET (rval
));
1239 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1240 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1241 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1242 fprintf (stderr
, "vtable type:\n");
1243 debug_tree (BINFO_TYPE (elem
));
1244 if (BINFO_VTABLE (elem
))
1245 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1247 fprintf (stderr
, "no vtable decl yet\n");
1248 fprintf (stderr
, "virtuals:\n");
1249 virtuals
= BINFO_VIRTUALS (elem
);
1252 virtuals
= TREE_CHAIN (virtuals
);
1254 virtuals
= TREE_CHAIN (virtuals
);
1259 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1260 fprintf (stderr
, "%s [%d =? %d]\n",
1261 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1262 i
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1263 virtuals
= TREE_CHAIN (virtuals
);
1268 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1269 We expect a null pointer to mark the end of the chain.
1270 This is the Lisp primitive `length'. */
1273 decl_list_length (t
)
1277 register int len
= 0;
1279 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1280 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1281 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1291 if (TREE_CODE (t
) == FUNCTION_DECL
)
1294 return decl_list_length (TREE_VALUE (t
));
1297 /* Like value_member, but for DECL_CHAINs. */
1299 decl_value_member (elem
, list
)
1306 list
= DECL_CHAIN (list
);
1312 is_overloaded_fn (x
)
1315 if (TREE_CODE (x
) == FUNCTION_DECL
)
1318 if (TREE_CODE (x
) == TREE_LIST
1319 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1320 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1327 really_overloaded_fn (x
)
1330 if (TREE_CODE (x
) == TREE_LIST
1331 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1332 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1342 if (TREE_CODE (from
) == FUNCTION_DECL
)
1345 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1347 return TREE_VALUE (from
);
1351 fnaddr_from_vtable_entry (entry
)
1354 if (flag_vtable_thunks
)
1357 if (TREE_CODE (func
) == ADDR_EXPR
)
1358 func
= TREE_OPERAND (func
, 0);
1359 if (TREE_CODE (func
) == THUNK_DECL
)
1360 return DECL_INITIAL (func
);
1365 return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
))));
1369 set_fnaddr_from_vtable_entry (entry
, value
)
1372 if (flag_vtable_thunks
)
1375 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry
)))) = value
;
1379 function_arg_chain (t
)
1382 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t
)));
1386 promotes_to_aggr_type (t
, code
)
1388 enum tree_code code
;
1390 if (TREE_CODE (t
) == code
)
1392 return IS_AGGR_TYPE (t
);
1396 is_aggr_type_2 (t1
, t2
)
1399 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1401 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1404 /* Give message using types TYPE1 and TYPE2 as arguments.
1405 PFN is the function which will print the message;
1406 S is the format string for PFN to use. */
1408 message_2_types (pfn
, s
, type1
, type2
)
1413 tree name1
= TYPE_NAME (type1
);
1414 tree name2
= TYPE_NAME (type2
);
1415 if (TREE_CODE (name1
) == TYPE_DECL
)
1416 name1
= DECL_NAME (name1
);
1417 if (TREE_CODE (name2
) == TYPE_DECL
)
1418 name2
= DECL_NAME (name2
);
1419 (*pfn
) (s
, IDENTIFIER_POINTER (name1
), IDENTIFIER_POINTER (name2
));
1422 #define PRINT_RING_SIZE 4
1425 lang_printable_name (decl
)
1428 static tree decl_ring
[PRINT_RING_SIZE
];
1429 static char *print_ring
[PRINT_RING_SIZE
];
1430 static int ring_counter
;
1433 /* Only cache functions. */
1434 if (TREE_CODE (decl
) != FUNCTION_DECL
1435 || DECL_LANG_SPECIFIC (decl
) == 0)
1436 return decl_as_string (decl
, 1);
1438 /* See if this print name is lying around. */
1439 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1440 if (decl_ring
[i
] == decl
)
1441 /* yes, so return it. */
1442 return print_ring
[i
];
1444 if (++ring_counter
== PRINT_RING_SIZE
)
1447 if (current_function_decl
!= NULL_TREE
)
1449 if (decl_ring
[ring_counter
] == current_function_decl
)
1451 if (ring_counter
== PRINT_RING_SIZE
)
1453 if (decl_ring
[ring_counter
] == current_function_decl
)
1454 my_friendly_abort (106);
1457 if (print_ring
[ring_counter
])
1458 free (print_ring
[ring_counter
]);
1461 int print_ret_type_p
1462 = (!DECL_CONSTRUCTOR_P (decl
)
1463 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)));
1465 char *name
= (char *)decl_as_string (decl
, print_ret_type_p
);
1466 print_ring
[ring_counter
] = (char *)malloc (strlen (name
) + 1);
1467 strcpy (print_ring
[ring_counter
], name
);
1468 decl_ring
[ring_counter
] = decl
;
1470 return print_ring
[ring_counter
];
1473 /* Comparison function for sorting identifiers in RAISES lists.
1474 Note that because IDENTIFIER_NODEs are unique, we can sort
1475 them by address, saving an indirection. */
1480 return (HOST_WIDE_INT
)TREE_VALUE (*p1
) - (HOST_WIDE_INT
)TREE_VALUE (*p2
);
1483 /* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
1484 listed in RAISES. */
1486 build_exception_variant (ctype
, type
, raises
)
1491 tree v
= TYPE_MAIN_VARIANT (type
);
1493 tree
*a
= (tree
*)alloca ((list_length (raises
)+1) * sizeof (tree
));
1494 int constp
= TYPE_READONLY (type
);
1495 int volatilep
= TYPE_VOLATILE (type
);
1497 for (v
= TYPE_NEXT_VARIANT (v
); v
; v
= TYPE_NEXT_VARIANT (v
))
1499 if (TYPE_READONLY (v
) != constp
1500 || TYPE_VOLATILE (v
) != volatilep
)
1504 t2
= TYPE_RAISES_EXCEPTIONS (v
);
1507 if (TREE_TYPE (t
) == TREE_TYPE (t2
))
1510 t2
= TREE_CHAIN (t2
);
1516 /* List of exceptions raised matches previously found list.
1518 @@ Nice to free up storage used in consing up the
1519 @@ list of exceptions raised. */
1523 /* Need to build a new variant. */
1524 v
= copy_node (type
);
1525 TYPE_NEXT_VARIANT (v
) = TYPE_NEXT_VARIANT (type
);
1526 TYPE_NEXT_VARIANT (type
) = v
;
1527 if (raises
&& ! TREE_PERMANENT (raises
))
1529 push_obstacks_nochange ();
1530 end_temporary_allocation ();
1531 raises
= copy_list (raises
);
1534 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1538 /* Subroutine of copy_to_permanent
1540 Assuming T is a node build bottom-up, make it all exist on
1541 permanent obstack, if it is not permanent already. */
1546 enum tree_code code
;
1548 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1551 switch (code
= TREE_CODE (t
))
1554 return error_mark_node
;
1563 tree chain
= TREE_CHAIN (t
);
1565 TREE_CHAIN (t
) = make_deep_copy (chain
);
1566 TREE_TYPE (t
) = make_deep_copy (TREE_TYPE (t
));
1567 DECL_INITIAL (t
) = make_deep_copy (DECL_INITIAL (t
));
1568 DECL_SIZE (t
) = make_deep_copy (DECL_SIZE (t
));
1574 tree chain
= TREE_CHAIN (t
);
1576 TREE_PURPOSE (t
) = make_deep_copy (TREE_PURPOSE (t
));
1577 TREE_VALUE (t
) = make_deep_copy (TREE_VALUE (t
));
1578 TREE_CHAIN (t
) = make_deep_copy (chain
);
1584 int len
= TREE_VEC_LENGTH (t
);
1588 TREE_VEC_ELT (t
, len
) = make_deep_copy (TREE_VEC_ELT (t
, len
));
1595 return copy_node (t
);
1601 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1602 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1603 TREE_OPERAND (t
, 2) = make_deep_copy (TREE_OPERAND (t
, 2));
1608 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1615 case TRUNC_DIV_EXPR
:
1616 case TRUNC_MOD_EXPR
:
1624 case BIT_ANDTC_EXPR
:
1625 case TRUTH_ANDIF_EXPR
:
1626 case TRUTH_ORIF_EXPR
:
1634 case FLOOR_DIV_EXPR
:
1635 case ROUND_DIV_EXPR
:
1637 case FLOOR_MOD_EXPR
:
1638 case ROUND_MOD_EXPR
:
1640 case PREDECREMENT_EXPR
:
1641 case PREINCREMENT_EXPR
:
1642 case POSTDECREMENT_EXPR
:
1643 case POSTINCREMENT_EXPR
:
1646 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1647 TREE_OPERAND (t
, 1) = make_deep_copy (TREE_OPERAND (t
, 1));
1655 case TRUTH_NOT_EXPR
:
1659 TREE_OPERAND (t
, 0) = make_deep_copy (TREE_OPERAND (t
, 0));
1662 /* This list is incomplete, but should suffice for now.
1663 It is very important that `sorry' does not call
1664 `report_error_function'. That could cause an infinite loop. */
1666 sorry ("initializer contains unrecognized tree code");
1667 return error_mark_node
;
1670 my_friendly_abort (107);
1675 /* Assuming T is a node built bottom-up, make it all exist on
1676 permanent obstack, if it is not permanent already. */
1678 copy_to_permanent (t
)
1681 register struct obstack
*ambient_obstack
= current_obstack
;
1682 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1684 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1687 saveable_obstack
= &permanent_obstack
;
1688 current_obstack
= saveable_obstack
;
1690 t
= make_deep_copy (t
);
1692 current_obstack
= ambient_obstack
;
1693 saveable_obstack
= ambient_saveable_obstack
;
1699 print_lang_statistics ()
1701 extern struct obstack maybepermanent_obstack
;
1702 print_obstack_statistics ("class_obstack", &class_obstack
);
1703 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1704 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1705 print_search_statistics ();
1706 print_class_statistics ();
1709 /* This is used by the `assert' macro. It is provided in libgcc.a,
1710 which `cc' doesn't know how to link. Note that the C++ front-end
1711 no longer actually uses the `assert' macro (instead, it calls
1712 my_friendly_assert). But all of the back-end files still need this. */
1714 __eprintf (string
, expression
, line
, filename
)
1717 const char *expression
;
1719 const char *filename
;
1727 fprintf (stderr
, string
, expression
, line
, filename
);
1732 /* Return, as an INTEGER_CST node, the number of elements for
1733 TYPE (which is an ARRAY_TYPE). This counts only elements of the top array. */
1736 array_type_nelts_top (type
)
1739 return fold (build (PLUS_EXPR
, integer_type_node
,
1740 array_type_nelts (type
),
1744 /* Return, as an INTEGER_CST node, the number of elements for
1745 TYPE (which is an ARRAY_TYPE). This one is a recursive count of all
1746 ARRAY_TYPEs that are clumped together. */
1749 array_type_nelts_total (type
)
1752 tree sz
= array_type_nelts_top (type
);
1753 type
= TREE_TYPE (type
);
1754 while (TREE_CODE (type
) == ARRAY_TYPE
)
1756 tree n
= array_type_nelts_top (type
);
1757 sz
= fold (build (MULT_EXPR
, integer_type_node
, sz
, n
));
1758 type
= TREE_TYPE (type
);