1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
35 #define CEIL(x,y) (((x) + (y) - 1) / (y))
37 /* Return nonzero if REF is an lvalue valid for this language.
38 Lvalues can be assigned, unless they have TREE_READONLY.
39 Lvalues can have their address taken, unless they have DECL_REGISTER. */
45 if (! language_lvalue_valid (ref
))
48 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
51 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
54 switch (TREE_CODE (ref
))
56 /* preincrements and predecrements are valid lvals, provided
57 what they refer to are valid lvals. */
58 case PREINCREMENT_EXPR
:
59 case PREDECREMENT_EXPR
:
62 return real_lvalue_p (TREE_OPERAND (ref
, 0));
68 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
69 && DECL_LANG_SPECIFIC (ref
)
70 && DECL_IN_AGGR_P (ref
))
77 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
78 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
82 /* A currently unresolved scope ref. */
84 my_friendly_abort (103);
86 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
88 return real_lvalue_p (TREE_OPERAND (ref
, 0))
89 && real_lvalue_p (TREE_OPERAND (ref
, 1));
93 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
94 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
100 return real_lvalue_p (TREE_OPERAND (ref
, 1));
104 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
105 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
115 if (! language_lvalue_valid (ref
))
118 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
121 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
124 switch (TREE_CODE (ref
))
126 /* preincrements and predecrements are valid lvals, provided
127 what they refer to are valid lvals. */
128 case PREINCREMENT_EXPR
:
129 case PREDECREMENT_EXPR
:
132 return lvalue_p (TREE_OPERAND (ref
, 0));
138 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
139 && DECL_LANG_SPECIFIC (ref
)
140 && DECL_IN_AGGR_P (ref
))
147 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
148 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
156 if (IS_AGGR_TYPE (TREE_TYPE (ref
)))
160 /* A currently unresolved scope ref. */
162 my_friendly_abort (103);
164 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
166 return lvalue_p (TREE_OPERAND (ref
, 0))
167 && lvalue_p (TREE_OPERAND (ref
, 1));
171 return (lvalue_p (TREE_OPERAND (ref
, 1))
172 && lvalue_p (TREE_OPERAND (ref
, 2)));
178 return lvalue_p (TREE_OPERAND (ref
, 1));
182 return (lvalue_p (TREE_OPERAND (ref
, 0))
183 && lvalue_p (TREE_OPERAND (ref
, 1)));
189 /* Return nonzero if REF is an lvalue valid for this language;
190 otherwise, print an error message and return zero. */
193 lvalue_or_else (ref
, string
)
197 int win
= lvalue_p (ref
);
199 error ("non-lvalue in %s", string
);
203 /* INIT is a CALL_EXPR which needs info about its target.
204 TYPE is the type that this initialization should appear to have.
206 Build an encapsulation of the initialization to perform
207 and return it so that it can be processed by language-independent
208 and language-specific expression expanders. */
211 build_cplus_new (type
, init
)
218 slot
= build (VAR_DECL
, type
);
219 layout_decl (slot
, 0);
220 rval
= build (NEW_EXPR
, type
,
221 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
222 TREE_SIDE_EFFECTS (rval
) = 1;
223 TREE_ADDRESSABLE (rval
) = 1;
224 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
225 TREE_SIDE_EFFECTS (rval
) = 1;
226 TREE_ADDRESSABLE (rval
) = 1;
231 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
232 these CALL_EXPRs with tree nodes that will perform the cleanups. */
235 break_out_cleanups (exp
)
240 if (TREE_CODE (tmp
) == CALL_EXPR
241 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
242 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
244 while (TREE_CODE (tmp
) == NOP_EXPR
245 || TREE_CODE (tmp
) == CONVERT_EXPR
246 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
248 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
249 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
251 TREE_OPERAND (tmp
, 0)
252 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
253 TREE_OPERAND (tmp
, 0));
257 tmp
= TREE_OPERAND (tmp
, 0);
262 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
263 copies where they are found. Returns a deep copy all nodes transitively
264 containing CALL_EXPRs. */
267 break_out_calls (exp
)
270 register tree t1
, t2
;
271 register enum tree_code code
;
272 register int changed
= 0;
275 if (exp
== NULL_TREE
)
278 code
= TREE_CODE (exp
);
280 if (code
== CALL_EXPR
)
281 return copy_node (exp
);
283 /* Don't try and defeat a save_expr, as it should only be done once. */
284 if (code
== SAVE_EXPR
)
287 switch (TREE_CODE_CLASS (code
))
292 case 'c': /* a constant */
293 case 't': /* a type node */
294 case 'x': /* something random, like an identifier or an ERROR_MARK. */
297 case 'd': /* A decl node */
298 #if 0 /* This is bogus. jason 9/21/94 */
300 t1
= break_out_calls (DECL_INITIAL (exp
));
301 if (t1
!= DECL_INITIAL (exp
))
303 exp
= copy_node (exp
);
304 DECL_INITIAL (exp
) = t1
;
309 case 'b': /* A block node */
311 /* Don't know how to handle these correctly yet. Must do a
312 break_out_calls on all DECL_INITIAL values for local variables,
313 and also break_out_calls on all sub-blocks and sub-statements. */
318 case 'e': /* an expression */
319 case 'r': /* a reference */
320 case 's': /* an expression with side effects */
321 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
323 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
324 if (t1
!= TREE_OPERAND (exp
, i
))
326 exp
= copy_node (exp
);
327 TREE_OPERAND (exp
, i
) = t1
;
332 case '<': /* a comparison expression */
333 case '2': /* a binary arithmetic expression */
334 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
335 if (t2
!= TREE_OPERAND (exp
, 1))
337 case '1': /* a unary arithmetic expression */
338 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
339 if (t1
!= TREE_OPERAND (exp
, 0))
343 if (tree_code_length
[(int) code
] == 1)
344 return build1 (code
, TREE_TYPE (exp
), t1
);
346 return build (code
, TREE_TYPE (exp
), t1
, t2
);
353 extern struct obstack
*current_obstack
;
354 extern struct obstack permanent_obstack
, class_obstack
;
355 extern struct obstack
*saveable_obstack
;
357 /* Here is how primitive or already-canonicalized types' hash
358 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
359 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
361 /* Construct, lay out and return the type of methods belonging to class
362 BASETYPE and whose arguments are described by ARGTYPES and whose values
363 are described by RETTYPE. If each type exists already, reuse it. */
366 build_cplus_method_type (basetype
, rettype
, argtypes
)
367 tree basetype
, rettype
, argtypes
;
373 /* Make a node of the sort we want. */
374 t
= make_node (METHOD_TYPE
);
376 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
377 TREE_TYPE (t
) = rettype
;
378 if (IS_SIGNATURE (basetype
))
379 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
380 TYPE_READONLY (basetype
),
381 TYPE_VOLATILE (basetype
));
383 ptype
= build_pointer_type (basetype
);
385 /* The actual arglist for this function includes a "hidden" argument
386 which is "this". Put it into the list of argument types. */
388 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
389 TYPE_ARG_TYPES (t
) = argtypes
;
390 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
392 /* If we already have such a type, use the old one and free this one.
393 Note that it also frees up the above cons cell if found. */
394 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
395 t
= type_hash_canon (hashcode
, t
);
397 if (TYPE_SIZE (t
) == 0)
404 build_cplus_array_type_1 (elt_type
, index_type
)
408 register struct obstack
*ambient_obstack
= current_obstack
;
409 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
412 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
413 make this permanent too. */
414 if (TREE_PERMANENT (elt_type
)
415 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
417 current_obstack
= &permanent_obstack
;
418 saveable_obstack
= &permanent_obstack
;
421 if (current_template_parms
)
423 t
= make_node (ARRAY_TYPE
);
424 TREE_TYPE (t
) = elt_type
;
425 TYPE_DOMAIN (t
) = index_type
;
428 t
= build_array_type (elt_type
, index_type
);
430 /* Push these needs up so that initialization takes place
432 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
433 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
434 current_obstack
= ambient_obstack
;
435 saveable_obstack
= ambient_saveable_obstack
;
440 build_cplus_array_type (elt_type
, index_type
)
445 int constp
= TYPE_READONLY (elt_type
);
446 int volatilep
= TYPE_VOLATILE (elt_type
);
447 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
449 t
= build_cplus_array_type_1 (elt_type
, index_type
);
451 if (constp
|| volatilep
)
452 t
= cp_build_type_variant (t
, constp
, volatilep
);
457 /* Make a variant type in the proper way for C/C++, propagating qualifiers
458 down to the element type of an array. */
461 cp_build_type_variant (type
, constp
, volatilep
)
463 int constp
, volatilep
;
465 if (type
== error_mark_node
)
468 if (TREE_CODE (type
) == ARRAY_TYPE
)
470 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
472 push_obstacks (TYPE_OBSTACK (real_main_variant
),
473 TYPE_OBSTACK (real_main_variant
));
474 type
= build_cplus_array_type_1 (cp_build_type_variant
475 (TREE_TYPE (type
), constp
, volatilep
),
478 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
479 make a copy. (TYPE might have come from the hash table and
480 REAL_MAIN_VARIANT might be in some function's obstack.) */
482 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
484 type
= copy_node (type
);
485 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
488 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
492 return build_type_variant (type
, constp
, volatilep
);
495 /* Add OFFSET to all base types of T.
497 OFFSET, which is a type offset, is number of bytes.
499 Note that we don't have to worry about having two paths to the
500 same base type, since this type owns its association list. */
503 propagate_binfo_offsets (binfo
, offset
)
507 tree binfos
= BINFO_BASETYPES (binfo
);
508 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
510 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
512 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
514 if (TREE_VIA_VIRTUAL (base_binfo
))
519 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
522 for (j
= i
+1; j
< n_baselinks
; j
++)
523 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
525 /* The next basetype offset must take into account the space
526 between the classes, not just the size of each class. */
527 delta
= size_binop (MINUS_EXPR
,
528 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
529 BINFO_OFFSET (base_binfo
));
534 if (BINFO_OFFSET_ZEROP (base_binfo
))
535 BINFO_OFFSET (base_binfo
) = offset
;
537 BINFO_OFFSET (base_binfo
)
538 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
540 BINFO_OFFSET (base_binfo
) = offset
;
545 tree chain
= NULL_TREE
;
547 /* Now unshare the structure beneath BASE_BINFO. */
548 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
551 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
552 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
553 TREE_VEC_ELT (base_binfos
, k
)
554 = make_binfo (BINFO_OFFSET (base_base_binfo
),
556 BINFO_VTABLE (base_base_binfo
),
557 BINFO_VIRTUALS (base_base_binfo
),
559 chain
= TREE_VEC_ELT (base_binfos
, k
);
560 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
561 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
562 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
564 /* Now propagate the offset to the base types. */
565 propagate_binfo_offsets (base_binfo
, offset
);
568 /* Go to our next class that counts for offset propagation. */
571 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
576 /* Compute the actual offsets that our virtual base classes
577 will have *for this type*. This must be performed after
578 the fields are laid out, since virtual baseclasses must
579 lay down at the end of the record.
581 Returns the maximum number of virtual functions any of the virtual
582 baseclasses provide. */
585 layout_vbasetypes (rec
, max
)
589 /* Get all the virtual base types that this type uses.
590 The TREE_VALUE slot holds the virtual baseclass type. */
591 tree vbase_types
= get_vbase_types (rec
);
593 #ifdef STRUCTURE_SIZE_BOUNDARY
594 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
596 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
600 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
601 where CONST_SIZE is an integer
602 and VAR_SIZE is a tree expression.
603 If VAR_SIZE is null, the size is just CONST_SIZE.
604 Naturally we try to avoid using VAR_SIZE. */
605 register unsigned const_size
= 0;
606 register tree var_size
= 0;
607 int nonvirtual_const_size
;
609 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
611 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
612 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
614 var_size
= TYPE_SIZE (rec
);
616 nonvirtual_const_size
= const_size
;
620 tree basetype
= BINFO_TYPE (vbase_types
);
623 desired_align
= TYPE_ALIGN (basetype
);
624 record_align
= MAX (record_align
, desired_align
);
627 offset
= integer_zero_node
;
630 /* Give each virtual base type the alignment it wants. */
631 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
632 * TYPE_ALIGN (basetype
);
633 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
636 if (CLASSTYPE_VSIZE (basetype
) > max
)
637 max
= CLASSTYPE_VSIZE (basetype
);
638 BINFO_OFFSET (vbase_types
) = offset
;
640 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
642 /* Every virtual baseclass takes a least a UNIT, so that we can
643 take it's address and get something different for each base. */
644 const_size
+= MAX (BITS_PER_UNIT
,
645 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
646 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
648 else if (var_size
== 0)
649 var_size
= TYPE_SIZE (basetype
);
651 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
653 vbase_types
= TREE_CHAIN (vbase_types
);
658 /* Because a virtual base might take a single byte above,
659 we have to re-adjust the total size to make sure it it
660 a multiple of the alignment. */
661 /* Give the whole object the alignment it wants. */
662 const_size
= CEIL (const_size
, record_align
) * record_align
;
665 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
666 here, as that is for this class, without any virtual base classes. */
667 TYPE_ALIGN (rec
) = record_align
;
668 if (const_size
!= nonvirtual_const_size
)
670 CLASSTYPE_VBASE_SIZE (rec
)
671 = size_int (const_size
- nonvirtual_const_size
);
672 TYPE_SIZE (rec
) = size_int (const_size
);
675 /* Now propagate offset information throughout the lattice
676 under the vbase type. */
677 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
678 vbase_types
= TREE_CHAIN (vbase_types
))
680 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
682 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
686 tree chain
= NULL_TREE
;
688 /* Now unshare the structure beneath BASE_BINFO. */
690 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
693 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
694 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
695 TREE_VEC_ELT (base_binfos
, j
)
696 = make_binfo (BINFO_OFFSET (base_base_binfo
),
698 BINFO_VTABLE (base_base_binfo
),
699 BINFO_VIRTUALS (base_base_binfo
),
701 chain
= TREE_VEC_ELT (base_binfos
, j
);
702 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
703 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
704 BINFO_INHERITANCE_CHAIN (chain
) = vbase_types
;
707 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
714 /* Lay out the base types of a record type, REC.
715 Tentatively set the size and alignment of REC
716 according to the base types alone.
718 Offsets for immediate nonvirtual baseclasses are also computed here.
720 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
721 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
723 Returns list of virtual base classes in a FIELD_DECL chain. */
726 layout_basetypes (rec
, binfos
)
729 /* Chain to hold all the new FIELD_DECLs which point at virtual
731 tree vbase_decls
= NULL_TREE
;
733 #ifdef STRUCTURE_SIZE_BOUNDARY
734 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
736 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
739 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
740 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
741 the size is just CONST_SIZE. Naturally we try to avoid using
742 VAR_SIZE. And so far, we've been successful. */
744 register tree var_size
= 0;
747 register unsigned const_size
= 0;
748 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
750 /* Handle basetypes almost like fields, but record their
751 offsets differently. */
753 for (i
= 0; i
< n_baseclasses
; i
++)
755 int inc
, desired_align
, int_vbase_size
;
756 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
757 register tree basetype
= BINFO_TYPE (base_binfo
);
760 if (TYPE_SIZE (basetype
) == 0)
763 /* This error is now reported in xref_tag, thus giving better
764 location information. */
765 error_with_aggr_type (base_binfo
,
766 "base class `%s' has incomplete type");
768 TREE_VIA_PUBLIC (base_binfo
) = 1;
769 TREE_VIA_PROTECTED (base_binfo
) = 0;
770 TREE_VIA_VIRTUAL (base_binfo
) = 0;
772 /* Should handle this better so that
775 class B: private A { virtual void F(); };
777 does not dump core when compiled. */
778 my_friendly_abort (121);
783 /* All basetypes are recorded in the association list of the
786 if (TREE_VIA_VIRTUAL (base_binfo
))
789 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
790 + sizeof (VBASE_NAME
) + 1);
792 /* The offset for a virtual base class is only used in computing
793 virtual function tables and for initializing virtual base
794 pointers. It is built once `get_vbase_types' is called. */
796 /* If this basetype can come from another vbase pointer
797 without an additional indirection, we will share
798 that pointer. If an indirection is involved, we
799 make our own pointer. */
800 for (j
= 0; j
< n_baseclasses
; j
++)
802 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
803 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
804 && binfo_member (basetype
,
805 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
808 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
809 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
810 build_pointer_type (basetype
));
811 /* If you change any of the below, take a look at all the
812 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
814 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
815 DECL_VIRTUAL_P (decl
) = 1;
816 DECL_FIELD_CONTEXT (decl
) = rec
;
817 DECL_CLASS_CONTEXT (decl
) = rec
;
818 DECL_FCONTEXT (decl
) = basetype
;
819 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
820 DECL_FIELD_SIZE (decl
) = 0;
821 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
822 TREE_CHAIN (decl
) = vbase_decls
;
823 BINFO_VPTR_FIELD (base_binfo
) = decl
;
826 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
827 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1)) == NULL_TREE
)
829 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1),
830 "destructor `%s' non-virtual");
831 warning ("in inheritance relationship `%s: virtual %s'",
832 TYPE_NAME_STRING (rec
),
833 TYPE_NAME_STRING (basetype
));
836 /* The space this decl occupies has already been accounted for. */
841 offset
= integer_zero_node
;
844 /* Give each base type the alignment it wants. */
845 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
846 * TYPE_ALIGN (basetype
);
847 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
850 /* bpk: Disabled this check until someone is willing to
851 claim it as theirs and explain exactly what circumstances
852 warrant the warning. */
853 if (warn_nonvdtor
&& TYPE_HAS_DESTRUCTOR (basetype
)
854 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1)) == NULL_TREE
)
856 warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 1),
857 "destructor `%s' non-virtual");
858 warning ("in inheritance relationship `%s:%s %s'",
859 TYPE_NAME_STRING (rec
),
860 TREE_VIA_VIRTUAL (base_binfo
) ? " virtual" : "",
861 TYPE_NAME_STRING (basetype
));
865 BINFO_OFFSET (base_binfo
) = offset
;
866 if (CLASSTYPE_VSIZE (basetype
))
868 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
869 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
871 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
872 TYPE_BINFO (rec
) = base_binfo
;
874 /* Add only the amount of storage not present in
875 the virtual baseclasses. */
877 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
878 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
880 inc
= MAX (record_align
,
881 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
884 /* Record must have at least as much alignment as any field. */
885 desired_align
= TYPE_ALIGN (basetype
);
886 record_align
= MAX (record_align
, desired_align
);
893 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
895 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
896 CLASSTYPE_ALIGN (rec
) = record_align
;
901 /* Hashing of lists so that we don't make duplicates.
902 The entry point is `list_hash_canon'. */
904 /* Each hash table slot is a bucket containing a chain
905 of these structures. */
909 struct list_hash
*next
; /* Next structure in the bucket. */
910 int hashcode
; /* Hash code of this list. */
911 tree list
; /* The list recorded here. */
914 /* Now here is the hash table. When recording a list, it is added
915 to the slot whose index is the hash code mod the table size.
916 Note that the hash table is used for several kinds of lists.
917 While all these live in the same table, they are completely independent,
918 and the hash code is computed differently for each of these. */
920 #define TYPE_HASH_SIZE 59
921 struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
923 /* Compute a hash code for a list (chain of TREE_LIST nodes
924 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
925 TREE_COMMON slots), by adding the hash codes of the individual entries. */
931 register int hashcode
= 0;
933 if (TREE_CHAIN (list
))
934 hashcode
+= TYPE_HASH (TREE_CHAIN (list
));
936 if (TREE_VALUE (list
))
937 hashcode
+= TYPE_HASH (TREE_VALUE (list
));
940 if (TREE_PURPOSE (list
))
941 hashcode
+= TYPE_HASH (TREE_PURPOSE (list
));
947 /* Look in the type hash table for a type isomorphic to TYPE.
948 If one is found, return it. Otherwise return 0. */
951 list_hash_lookup (hashcode
, list
)
955 register struct list_hash
*h
;
956 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
957 if (h
->hashcode
== hashcode
958 && TREE_VIA_VIRTUAL (h
->list
) == TREE_VIA_VIRTUAL (list
)
959 && TREE_VIA_PUBLIC (h
->list
) == TREE_VIA_PUBLIC (list
)
960 && TREE_VIA_PROTECTED (h
->list
) == TREE_VIA_PROTECTED (list
)
961 && TREE_PURPOSE (h
->list
) == TREE_PURPOSE (list
)
962 && TREE_VALUE (h
->list
) == TREE_VALUE (list
)
963 && TREE_CHAIN (h
->list
) == TREE_CHAIN (list
))
965 my_friendly_assert (TREE_TYPE (h
->list
) == TREE_TYPE (list
), 299);
971 /* Add an entry to the list-hash-table
972 for a list TYPE whose hash code is HASHCODE. */
975 list_hash_add (hashcode
, list
)
979 register struct list_hash
*h
;
981 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
982 h
->hashcode
= hashcode
;
984 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
985 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
988 /* Given TYPE, and HASHCODE its hash code, return the canonical
989 object for an identical list if one already exists.
990 Otherwise, return TYPE, and record it as the canonical object
991 if it is a permanent object.
993 To use this function, first create a list of the sort you want.
994 Then compute its hash code from the fields of the list that
995 make it different from other similar lists.
996 Then call this function and use the value.
997 This function frees the list you pass in if it is a duplicate. */
999 /* Set to 1 to debug without canonicalization. Never set by program. */
1001 static int debug_no_list_hash
= 0;
1004 list_hash_canon (hashcode
, list
)
1010 if (debug_no_list_hash
)
1013 t1
= list_hash_lookup (hashcode
, list
);
1016 obstack_free (&class_obstack
, list
);
1020 /* If this is a new list, record it for later reuse. */
1021 list_hash_add (hashcode
, list
);
1027 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1028 int via_public
, via_virtual
, via_protected
;
1029 tree purpose
, value
, chain
;
1031 struct obstack
*ambient_obstack
= current_obstack
;
1035 current_obstack
= &class_obstack
;
1036 t
= tree_cons (purpose
, value
, chain
);
1037 TREE_VIA_PUBLIC (t
) = via_public
;
1038 TREE_VIA_PROTECTED (t
) = via_protected
;
1039 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1040 hashcode
= list_hash (t
);
1041 t
= list_hash_canon (hashcode
, t
);
1042 current_obstack
= ambient_obstack
;
1046 /* Constructor for hashed lists. */
1049 hash_tree_chain (value
, chain
)
1052 struct obstack
*ambient_obstack
= current_obstack
;
1056 current_obstack
= &class_obstack
;
1057 t
= tree_cons (NULL_TREE
, value
, chain
);
1058 hashcode
= list_hash (t
);
1059 t
= list_hash_canon (hashcode
, t
);
1060 current_obstack
= ambient_obstack
;
1064 /* Similar, but used for concatenating two lists. */
1067 hash_chainon (list1
, list2
)
1074 if (TREE_CHAIN (list1
) == NULL_TREE
)
1075 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1076 return hash_tree_chain (TREE_VALUE (list1
),
1077 hash_chainon (TREE_CHAIN (list1
), list2
));
1081 get_identifier_list (value
)
1084 tree list
= IDENTIFIER_AS_LIST (value
);
1085 if (list
!= NULL_TREE
1086 && (TREE_CODE (list
) != TREE_LIST
1087 || TREE_VALUE (list
) != value
))
1089 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1090 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1091 && IDENTIFIER_TYPE_VALUE (value
)
1092 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1094 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1096 if (TYPE_PTRMEMFUNC_P (type
))
1098 else if (type
== current_class_type
)
1099 /* Don't mess up the constructor name. */
1100 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1103 if (! CLASSTYPE_ID_AS_LIST (type
))
1104 CLASSTYPE_ID_AS_LIST (type
)
1105 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1106 list
= CLASSTYPE_ID_AS_LIST (type
);
1113 get_decl_list (value
)
1116 tree list
= NULL_TREE
;
1118 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1119 list
= get_identifier_list (value
);
1120 else if (TREE_CODE (value
) == RECORD_TYPE
1121 && TYPE_LANG_SPECIFIC (value
)
1122 && value
== TYPE_MAIN_VARIANT (value
))
1123 list
= CLASSTYPE_AS_LIST (value
);
1125 if (list
!= NULL_TREE
)
1127 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1131 return build_decl_list (NULL_TREE
, value
);
1134 /* Build an association between TYPE and some parameters:
1136 OFFSET is the offset added to `this' to convert it to a pointer
1139 BINFO is the base binfo to use, if we are deriving from one. This
1140 is necessary, as we want specialized parent binfos from base
1141 classes, so that the VTABLE_NAMEs of bases are for the most derived
1142 type, instead of of the simple type.
1144 VTABLE is the virtual function table with which to initialize
1145 sub-objects of type TYPE.
1147 VIRTUALS are the virtual functions sitting in VTABLE.
1149 CHAIN are more associations we must retain. */
1152 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1154 tree vtable
, virtuals
;
1157 tree new_binfo
= make_tree_vec (6);
1160 if (TREE_CODE (binfo
) == TREE_VEC
)
1161 type
= BINFO_TYPE (binfo
);
1165 binfo
= TYPE_BINFO (binfo
);
1168 TREE_CHAIN (new_binfo
) = chain
;
1170 TREE_USED (new_binfo
) = TREE_USED (chain
);
1172 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1173 BINFO_OFFSET (new_binfo
) = offset
;
1174 BINFO_VTABLE (new_binfo
) = vtable
;
1175 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1176 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1178 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1179 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1183 /* Return the binfo value for ELEM in TYPE. */
1186 binfo_value (elem
, type
)
1190 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1191 compiler_error ("base class `%s' ambiguous in binfo_value",
1192 TYPE_NAME_STRING (elem
));
1194 return TYPE_BINFO (type
);
1195 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1197 return get_binfo (elem
, type
, 0);
1204 register tree prev
= 0, tmp
, next
;
1205 for (tmp
= path
; tmp
; tmp
= next
)
1207 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1208 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1218 unsigned HOST_WIDE_INT n
;
1221 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1222 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1223 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1224 fprintf (stderr
, "vtable type:\n");
1225 debug_tree (BINFO_TYPE (elem
));
1226 if (BINFO_VTABLE (elem
))
1227 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1229 fprintf (stderr
, "no vtable decl yet\n");
1230 fprintf (stderr
, "virtuals:\n");
1231 virtuals
= BINFO_VIRTUALS (elem
);
1233 n
= skip_rtti_stuff (&virtuals
);
1237 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1238 fprintf (stderr
, "%s [%d =? %d]\n",
1239 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1240 n
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1242 virtuals
= TREE_CHAIN (virtuals
);
1246 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1247 We expect a null pointer to mark the end of the chain.
1248 This is the Lisp primitive `length'. */
1251 decl_list_length (t
)
1255 register int len
= 0;
1257 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1258 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1259 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1269 if (TREE_CODE (t
) == FUNCTION_DECL
)
1271 else if (TREE_CODE (t
) == TREE_LIST
)
1272 return decl_list_length (TREE_VALUE (t
));
1274 my_friendly_abort (359);
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 function_arg_chain (t
)
1339 return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t
)));
1343 promotes_to_aggr_type (t
, code
)
1345 enum tree_code code
;
1347 if (TREE_CODE (t
) == code
)
1349 return IS_AGGR_TYPE (t
);
1353 is_aggr_type_2 (t1
, t2
)
1356 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1358 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1361 /* Give message using types TYPE1 and TYPE2 as arguments.
1362 PFN is the function which will print the message;
1363 S is the format string for PFN to use. */
1366 message_2_types (pfn
, s
, type1
, type2
)
1371 tree name1
= TYPE_NAME (type1
);
1372 tree name2
= TYPE_NAME (type2
);
1373 if (TREE_CODE (name1
) == TYPE_DECL
)
1374 name1
= DECL_NAME (name1
);
1375 if (TREE_CODE (name2
) == TYPE_DECL
)
1376 name2
= DECL_NAME (name2
);
1377 (*pfn
) (s
, IDENTIFIER_POINTER (name1
), IDENTIFIER_POINTER (name2
));
1380 #define PRINT_RING_SIZE 4
1383 lang_printable_name (decl
)
1386 static tree decl_ring
[PRINT_RING_SIZE
];
1387 static char *print_ring
[PRINT_RING_SIZE
];
1388 static int ring_counter
;
1391 /* Only cache functions. */
1392 if (TREE_CODE (decl
) != FUNCTION_DECL
1393 || DECL_LANG_SPECIFIC (decl
) == 0)
1394 return decl_as_string (decl
, 1);
1396 /* See if this print name is lying around. */
1397 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1398 if (decl_ring
[i
] == decl
)
1399 /* yes, so return it. */
1400 return print_ring
[i
];
1402 if (++ring_counter
== PRINT_RING_SIZE
)
1405 if (current_function_decl
!= NULL_TREE
)
1407 if (decl_ring
[ring_counter
] == current_function_decl
)
1409 if (ring_counter
== PRINT_RING_SIZE
)
1411 if (decl_ring
[ring_counter
] == current_function_decl
)
1412 my_friendly_abort (106);
1415 if (print_ring
[ring_counter
])
1416 free (print_ring
[ring_counter
]);
1419 int print_ret_type_p
1420 = (!DECL_CONSTRUCTOR_P (decl
)
1421 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)));
1423 char *name
= (char *)decl_as_string (decl
, print_ret_type_p
);
1424 print_ring
[ring_counter
] = (char *)malloc (strlen (name
) + 1);
1425 strcpy (print_ring
[ring_counter
], name
);
1426 decl_ring
[ring_counter
] = decl
;
1428 return print_ring
[ring_counter
];
1431 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1432 listed in RAISES. */
1435 build_exception_variant (type
, raises
)
1439 tree v
= TYPE_MAIN_VARIANT (type
);
1440 int constp
= TYPE_READONLY (type
);
1441 int volatilep
= TYPE_VOLATILE (type
);
1443 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1445 if (TYPE_READONLY (v
) != constp
1446 || TYPE_VOLATILE (v
) != volatilep
)
1449 /* @@ This should do set equality, not exact match. */
1450 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1451 /* List of exceptions raised matches previously found list.
1453 @@ Nice to free up storage used in consing up the
1454 @@ list of exceptions raised. */
1458 /* Need to build a new variant. */
1459 v
= build_type_copy (type
);
1461 if (raises
&& ! TREE_PERMANENT (raises
))
1463 push_obstacks_nochange ();
1464 end_temporary_allocation ();
1465 raises
= copy_list (raises
);
1469 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1473 /* Subroutine of copy_to_permanent
1475 Assuming T is a node build bottom-up, make it all exist on
1476 permanent obstack, if it is not permanent already. */
1488 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1491 switch (TREE_CODE (t
))
1494 return error_mark_node
;
1503 tree chain
= TREE_CHAIN (t
);
1505 TREE_CHAIN (t
) = mapcar (chain
, func
);
1506 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1507 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1508 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1514 tree chain
= TREE_CHAIN (t
);
1516 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1517 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1518 TREE_CHAIN (t
) = mapcar (chain
, func
);
1524 int len
= TREE_VEC_LENGTH (t
);
1528 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1535 return copy_node (t
);
1541 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1542 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1543 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1548 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1555 case TRUNC_DIV_EXPR
:
1556 case TRUNC_MOD_EXPR
:
1564 case BIT_ANDTC_EXPR
:
1565 case TRUTH_ANDIF_EXPR
:
1566 case TRUTH_ORIF_EXPR
:
1574 case FLOOR_DIV_EXPR
:
1575 case ROUND_DIV_EXPR
:
1577 case FLOOR_MOD_EXPR
:
1578 case ROUND_MOD_EXPR
:
1580 case PREDECREMENT_EXPR
:
1581 case PREINCREMENT_EXPR
:
1582 case POSTDECREMENT_EXPR
:
1583 case POSTINCREMENT_EXPR
:
1588 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1589 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1597 case TRUTH_NOT_EXPR
:
1601 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1605 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1606 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1607 case REFERENCE_TYPE
:
1608 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1609 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1611 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1612 mapcar (TYPE_ARG_TYPES (t
), func
));
1613 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1615 tmp
= build_array_type (mapcar (TREE_TYPE (t
), func
),
1616 mapcar (TYPE_DOMAIN (t
), func
));
1617 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1619 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1620 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1622 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1623 mapcar (TREE_TYPE (t
), func
));
1624 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1626 tmp
= build_cplus_method_type
1627 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
1628 mapcar (TREE_TYPE (t
), func
),
1629 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
1630 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1633 if (TYPE_PTRMEMFUNC_P (t
))
1634 return build_ptrmemfunc_type
1635 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1636 /* else fall through */
1638 /* This list is incomplete, but should suffice for now.
1639 It is very important that `sorry' not call
1640 `report_error_function'. That could cause an infinite loop. */
1642 sorry ("initializer contains unrecognized tree code");
1643 return error_mark_node
;
1646 my_friendly_abort (107);
1655 if (TREE_PERMANENT (t
))
1657 /* Support `void f () { extern int i; A<&i> a; }' */
1658 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
1660 return copy_node (t
);
1664 /* Assuming T is a node built bottom-up, make it all exist on
1665 permanent obstack, if it is not permanent already. */
1668 copy_to_permanent (t
)
1671 register struct obstack
*ambient_obstack
= current_obstack
;
1672 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1675 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1678 saveable_obstack
= &permanent_obstack
;
1679 current_obstack
= saveable_obstack
;
1680 resume
= suspend_momentary ();
1682 t
= mapcar (t
, perm_manip
);
1684 resume_momentary (resume
);
1685 current_obstack
= ambient_obstack
;
1686 saveable_obstack
= ambient_saveable_obstack
;
1691 #ifdef GATHER_STATISTICS
1692 extern int depth_reached
;
1696 print_lang_statistics ()
1698 extern struct obstack maybepermanent_obstack
, decl_obstack
;
1699 print_obstack_statistics ("class_obstack", &class_obstack
);
1700 print_obstack_statistics ("decl_obstack", &decl_obstack
);
1701 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1702 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1703 print_search_statistics ();
1704 print_class_statistics ();
1705 #ifdef GATHER_STATISTICS
1706 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1711 /* This is used by the `assert' macro. It is provided in libgcc.a,
1712 which `cc' doesn't know how to link. Note that the C++ front-end
1713 no longer actually uses the `assert' macro (instead, it calls
1714 my_friendly_assert). But all of the back-end files still need this. */
1717 __eprintf (string
, expression
, line
, filename
)
1720 const char *expression
;
1722 const char *filename
;
1730 fprintf (stderr
, string
, expression
, line
, filename
);
1735 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1736 (which is an ARRAY_TYPE). This counts only elements of the top
1740 array_type_nelts_top (type
)
1743 return fold (build (PLUS_EXPR
, sizetype
,
1744 array_type_nelts (type
),
1748 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1749 (which is an ARRAY_TYPE). This one is a recursive count of all
1750 ARRAY_TYPEs that are clumped together. */
1753 array_type_nelts_total (type
)
1756 tree sz
= array_type_nelts_top (type
);
1757 type
= TREE_TYPE (type
);
1758 while (TREE_CODE (type
) == ARRAY_TYPE
)
1760 tree n
= array_type_nelts_top (type
);
1761 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1762 type
= TREE_TYPE (type
);
1772 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1774 else if (TREE_CODE (t
) == TARGET_EXPR
)
1775 return build_cplus_new (TREE_TYPE (t
),
1776 break_out_target_exprs (TREE_OPERAND (t
, 1)));
1780 /* Actually, we'll just clean out the target exprs for the moment. */
1783 break_out_target_exprs (t
)
1786 return mapcar (t
, bot_manip
);
1789 /* Obstack used for allocating nodes in template function and variable
1792 extern struct obstack
*expression_obstack
;
1794 /* Similar to `build_nt', except we build
1795 on the permanent_obstack, regardless. */
1798 build_min_nt
VPROTO((enum tree_code code
, ...))
1801 enum tree_code code
;
1803 register struct obstack
*ambient_obstack
= expression_obstack
;
1806 register int length
;
1812 code
= va_arg (p
, enum tree_code
);
1815 expression_obstack
= &permanent_obstack
;
1817 t
= make_node (code
);
1818 length
= tree_code_length
[(int) code
];
1819 TREE_COMPLEXITY (t
) = lineno
;
1821 for (i
= 0; i
< length
; i
++)
1823 tree x
= va_arg (p
, tree
);
1824 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1828 expression_obstack
= ambient_obstack
;
1832 /* Similar to `build', except we build
1833 on the permanent_obstack, regardless. */
1836 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
1839 enum tree_code code
;
1842 register struct obstack
*ambient_obstack
= expression_obstack
;
1845 register int length
;
1851 code
= va_arg (p
, enum tree_code
);
1852 tt
= va_arg (p
, tree
);
1855 expression_obstack
= &permanent_obstack
;
1857 t
= make_node (code
);
1858 length
= tree_code_length
[(int) code
];
1860 TREE_COMPLEXITY (t
) = lineno
;
1862 for (i
= 0; i
< length
; i
++)
1864 tree x
= va_arg (p
, tree
);
1865 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1869 expression_obstack
= ambient_obstack
;
1873 /* Same as `tree_cons' but make a permanent object. */
1876 min_tree_cons (purpose
, value
, chain
)
1877 tree purpose
, value
, chain
;
1880 register struct obstack
*ambient_obstack
= current_obstack
;
1881 current_obstack
= &permanent_obstack
;
1883 node
= tree_cons (copy_to_permanent (purpose
),
1884 copy_to_permanent (value
), chain
);
1885 current_obstack
= ambient_obstack
;
1893 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1894 return identifier_typedecl_value (t
);
1895 if (TREE_CODE (t
) == TYPE_DECL
)
1897 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
1898 return TYPE_STUB_DECL (t
);
1900 my_friendly_abort (42);
1904 can_free (obstack
, t
)
1905 struct obstack
*obstack
;
1910 if (TREE_CODE (t
) == TREE_VEC
)
1911 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1913 my_friendly_abort (42);
1915 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1916 & ~ obstack_alignment_mask (obstack))
1917 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1924 /* Return first vector element whose BINFO_TYPE is ELEM.
1925 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1928 vec_binfo_member (elem
, vec
)
1934 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1935 if (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
1936 return TREE_VEC_ELT (vec
, i
);
1941 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
1942 the wrong thing for decl_function_context. Hopefully the uses in the
1943 backend won't matter, since we don't need a static chain for local class
1947 hack_decl_function_context (decl
)
1950 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
1951 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
1952 return decl_function_context (decl
);
1955 /* Return truthvalue of whether T1 is the same tree structure as T2.
1956 Return 1 if they are the same.
1957 Return 0 if they are understandably different.
1958 Return -1 if either contains tree structure not understood by
1962 cp_tree_equal (t1
, t2
)
1965 register enum tree_code code1
, code2
;
1970 if (t1
== 0 || t2
== 0)
1973 code1
= TREE_CODE (t1
);
1974 code2
= TREE_CODE (t2
);
1976 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1977 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1978 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1980 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1981 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1982 || code2
== NON_LVALUE_EXPR
)
1983 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1991 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1992 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1995 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1998 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1999 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2000 TREE_STRING_LENGTH (t1
));
2006 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2009 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2012 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2015 /* Special case: if either target is an unallocated VAR_DECL,
2016 it means that it's going to be unified with whatever the
2017 TARGET_EXPR is really supposed to initialize, so treat it
2018 as being equivalent to anything. */
2019 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
2020 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
2021 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
2022 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
2023 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
2024 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2027 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2030 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2032 case WITH_CLEANUP_EXPR
:
2033 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2036 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2039 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2040 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2049 case TEMPLATE_CONST_PARM
:
2050 return TEMPLATE_CONST_IDX (t1
) == TEMPLATE_CONST_IDX (t2
);
2053 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2055 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2056 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2060 switch (TREE_CODE_CLASS (code1
))
2070 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2072 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));