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 extern void compiler_error ();
37 static tree get_identifier_list
PROTO((tree
));
38 static tree bot_manip
PROTO((tree
));
39 static tree perm_manip
PROTO((tree
));
40 static tree build_cplus_array_type_1
PROTO((tree
, tree
));
41 static void list_hash_add
PROTO((int, tree
));
42 static int list_hash
PROTO((tree
, tree
, tree
));
43 static tree list_hash_lookup
PROTO((int, int, int, int, tree
, tree
,
46 #define CEIL(x,y) (((x) + (y) - 1) / (y))
48 /* Return nonzero if REF is an lvalue valid for this language.
49 Lvalues can be assigned, unless they have TREE_READONLY.
50 Lvalues can have their address taken, unless they have DECL_REGISTER. */
56 if (! language_lvalue_valid (ref
))
59 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
62 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
65 switch (TREE_CODE (ref
))
67 /* preincrements and predecrements are valid lvals, provided
68 what they refer to are valid lvals. */
69 case PREINCREMENT_EXPR
:
70 case PREDECREMENT_EXPR
:
73 return real_lvalue_p (TREE_OPERAND (ref
, 0));
79 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
80 && DECL_LANG_SPECIFIC (ref
)
81 && DECL_IN_AGGR_P (ref
))
88 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
89 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
93 /* A currently unresolved scope ref. */
95 my_friendly_abort (103);
97 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
99 return real_lvalue_p (TREE_OPERAND (ref
, 0))
100 && real_lvalue_p (TREE_OPERAND (ref
, 1));
104 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
105 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
111 return real_lvalue_p (TREE_OPERAND (ref
, 1));
115 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
116 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
122 /* This differs from real_lvalue_p in that class rvalues are considered
128 if (! language_lvalue_valid (ref
))
131 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
134 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
137 switch (TREE_CODE (ref
))
139 /* preincrements and predecrements are valid lvals, provided
140 what they refer to are valid lvals. */
141 case PREINCREMENT_EXPR
:
142 case PREDECREMENT_EXPR
:
147 return lvalue_p (TREE_OPERAND (ref
, 0));
153 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
154 && DECL_LANG_SPECIFIC (ref
)
155 && DECL_IN_AGGR_P (ref
))
162 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
163 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
171 if (IS_AGGR_TYPE (TREE_TYPE (ref
)))
175 /* A currently unresolved scope ref. */
177 my_friendly_abort (103);
179 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
181 return lvalue_p (TREE_OPERAND (ref
, 0))
182 && lvalue_p (TREE_OPERAND (ref
, 1));
186 return (lvalue_p (TREE_OPERAND (ref
, 1))
187 && lvalue_p (TREE_OPERAND (ref
, 2)));
193 return lvalue_p (TREE_OPERAND (ref
, 1));
197 return (lvalue_p (TREE_OPERAND (ref
, 0))
198 && lvalue_p (TREE_OPERAND (ref
, 1)));
204 /* Return nonzero if REF is an lvalue valid for this language;
205 otherwise, print an error message and return zero. */
208 lvalue_or_else (ref
, string
)
212 int win
= lvalue_p (ref
);
214 error ("non-lvalue in %s", string
);
218 /* INIT is a CALL_EXPR which needs info about its target.
219 TYPE is the type that this initialization should appear to have.
221 Build an encapsulation of the initialization to perform
222 and return it so that it can be processed by language-independent
223 and language-specific expression expanders. */
226 build_cplus_new (type
, init
)
233 if (TREE_CODE (init
) == TARGET_EXPR
|| init
== error_mark_node
)
236 slot
= build (VAR_DECL
, type
);
237 layout_decl (slot
, 0);
238 rval
= build (NEW_EXPR
, type
,
239 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
240 TREE_SIDE_EFFECTS (rval
) = 1;
241 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
242 TREE_SIDE_EFFECTS (rval
) = 1;
247 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
248 these CALL_EXPRs with tree nodes that will perform the cleanups. */
251 break_out_cleanups (exp
)
256 if (TREE_CODE (tmp
) == CALL_EXPR
257 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
258 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
260 while (TREE_CODE (tmp
) == NOP_EXPR
261 || TREE_CODE (tmp
) == CONVERT_EXPR
262 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
264 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
265 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
267 TREE_OPERAND (tmp
, 0)
268 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
269 TREE_OPERAND (tmp
, 0));
273 tmp
= TREE_OPERAND (tmp
, 0);
278 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
279 copies where they are found. Returns a deep copy all nodes transitively
280 containing CALL_EXPRs. */
283 break_out_calls (exp
)
286 register tree t1
, t2
;
287 register enum tree_code code
;
288 register int changed
= 0;
291 if (exp
== NULL_TREE
)
294 code
= TREE_CODE (exp
);
296 if (code
== CALL_EXPR
)
297 return copy_node (exp
);
299 /* Don't try and defeat a save_expr, as it should only be done once. */
300 if (code
== SAVE_EXPR
)
303 switch (TREE_CODE_CLASS (code
))
308 case 'c': /* a constant */
309 case 't': /* a type node */
310 case 'x': /* something random, like an identifier or an ERROR_MARK. */
313 case 'd': /* A decl node */
314 #if 0 /* This is bogus. jason 9/21/94 */
316 t1
= break_out_calls (DECL_INITIAL (exp
));
317 if (t1
!= DECL_INITIAL (exp
))
319 exp
= copy_node (exp
);
320 DECL_INITIAL (exp
) = t1
;
325 case 'b': /* A block node */
327 /* Don't know how to handle these correctly yet. Must do a
328 break_out_calls on all DECL_INITIAL values for local variables,
329 and also break_out_calls on all sub-blocks and sub-statements. */
334 case 'e': /* an expression */
335 case 'r': /* a reference */
336 case 's': /* an expression with side effects */
337 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
339 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
340 if (t1
!= TREE_OPERAND (exp
, i
))
342 exp
= copy_node (exp
);
343 TREE_OPERAND (exp
, i
) = t1
;
348 case '<': /* a comparison expression */
349 case '2': /* a binary arithmetic expression */
350 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
351 if (t2
!= TREE_OPERAND (exp
, 1))
353 case '1': /* a unary arithmetic expression */
354 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
355 if (t1
!= TREE_OPERAND (exp
, 0))
359 if (tree_code_length
[(int) code
] == 1)
360 return build1 (code
, TREE_TYPE (exp
), t1
);
362 return build (code
, TREE_TYPE (exp
), t1
, t2
);
369 extern struct obstack
*current_obstack
;
370 extern struct obstack permanent_obstack
, class_obstack
;
371 extern struct obstack
*saveable_obstack
;
372 extern struct obstack
*expression_obstack
;
374 /* Here is how primitive or already-canonicalized types' hash
375 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
376 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
378 /* Construct, lay out and return the type of methods belonging to class
379 BASETYPE and whose arguments are described by ARGTYPES and whose values
380 are described by RETTYPE. If each type exists already, reuse it. */
383 build_cplus_method_type (basetype
, rettype
, argtypes
)
384 tree basetype
, rettype
, argtypes
;
390 /* Make a node of the sort we want. */
391 t
= make_node (METHOD_TYPE
);
393 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
394 TREE_TYPE (t
) = rettype
;
395 if (IS_SIGNATURE (basetype
))
396 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
397 TYPE_READONLY (basetype
),
398 TYPE_VOLATILE (basetype
));
400 ptype
= build_pointer_type (basetype
);
402 /* The actual arglist for this function includes a "hidden" argument
403 which is "this". Put it into the list of argument types. */
405 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
406 TYPE_ARG_TYPES (t
) = argtypes
;
407 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
409 /* If we already have such a type, use the old one and free this one.
410 Note that it also frees up the above cons cell if found. */
411 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
412 t
= type_hash_canon (hashcode
, t
);
414 if (TYPE_SIZE (t
) == 0)
421 build_cplus_array_type_1 (elt_type
, index_type
)
425 register struct obstack
*ambient_obstack
= current_obstack
;
426 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
429 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
430 make this permanent too. */
431 if (TREE_PERMANENT (elt_type
)
432 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
434 current_obstack
= &permanent_obstack
;
435 saveable_obstack
= &permanent_obstack
;
438 if (processing_template_decl
)
440 t
= make_node (ARRAY_TYPE
);
441 TREE_TYPE (t
) = elt_type
;
442 TYPE_DOMAIN (t
) = index_type
;
445 t
= build_array_type (elt_type
, index_type
);
447 /* Push these needs up so that initialization takes place
449 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
450 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
451 current_obstack
= ambient_obstack
;
452 saveable_obstack
= ambient_saveable_obstack
;
457 build_cplus_array_type (elt_type
, index_type
)
462 int constp
= TYPE_READONLY (elt_type
);
463 int volatilep
= TYPE_VOLATILE (elt_type
);
464 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
466 t
= build_cplus_array_type_1 (elt_type
, index_type
);
468 if (constp
|| volatilep
)
469 t
= cp_build_type_variant (t
, constp
, volatilep
);
474 /* Make a variant type in the proper way for C/C++, propagating qualifiers
475 down to the element type of an array. */
478 cp_build_type_variant (type
, constp
, volatilep
)
480 int constp
, volatilep
;
482 if (type
== error_mark_node
)
485 if (TREE_CODE (type
) == ARRAY_TYPE
)
487 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
489 push_obstacks (TYPE_OBSTACK (real_main_variant
),
490 TYPE_OBSTACK (real_main_variant
));
491 type
= build_cplus_array_type_1 (cp_build_type_variant
492 (TREE_TYPE (type
), constp
, volatilep
),
495 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
496 make a copy. (TYPE might have come from the hash table and
497 REAL_MAIN_VARIANT might be in some function's obstack.) */
499 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
501 type
= copy_node (type
);
502 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
505 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
509 return build_type_variant (type
, constp
, volatilep
);
512 /* Add OFFSET to all base types of T.
514 OFFSET, which is a type offset, is number of bytes.
516 Note that we don't have to worry about having two paths to the
517 same base type, since this type owns its association list. */
520 propagate_binfo_offsets (binfo
, offset
)
524 tree binfos
= BINFO_BASETYPES (binfo
);
525 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
527 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
529 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
531 if (TREE_VIA_VIRTUAL (base_binfo
))
536 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
539 for (j
= i
+1; j
< n_baselinks
; j
++)
540 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
542 /* The next basetype offset must take into account the space
543 between the classes, not just the size of each class. */
544 delta
= size_binop (MINUS_EXPR
,
545 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
546 BINFO_OFFSET (base_binfo
));
551 if (BINFO_OFFSET_ZEROP (base_binfo
))
552 BINFO_OFFSET (base_binfo
) = offset
;
554 BINFO_OFFSET (base_binfo
)
555 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
557 BINFO_OFFSET (base_binfo
) = offset
;
562 tree chain
= NULL_TREE
;
564 /* Now unshare the structure beneath BASE_BINFO. */
565 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
568 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
569 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
570 TREE_VEC_ELT (base_binfos
, k
)
571 = make_binfo (BINFO_OFFSET (base_base_binfo
),
573 BINFO_VTABLE (base_base_binfo
),
574 BINFO_VIRTUALS (base_base_binfo
),
576 chain
= TREE_VEC_ELT (base_binfos
, k
);
577 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
578 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
579 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
581 /* Now propagate the offset to the base types. */
582 propagate_binfo_offsets (base_binfo
, offset
);
585 /* Go to our next class that counts for offset propagation. */
588 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
593 /* Compute the actual offsets that our virtual base classes
594 will have *for this type*. This must be performed after
595 the fields are laid out, since virtual baseclasses must
596 lay down at the end of the record.
598 Returns the maximum number of virtual functions any of the virtual
599 baseclasses provide. */
602 layout_vbasetypes (rec
, max
)
606 /* Get all the virtual base types that this type uses.
607 The TREE_VALUE slot holds the virtual baseclass type. */
608 tree vbase_types
= get_vbase_types (rec
);
610 #ifdef STRUCTURE_SIZE_BOUNDARY
611 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
613 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
617 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
618 where CONST_SIZE is an integer
619 and VAR_SIZE is a tree expression.
620 If VAR_SIZE is null, the size is just CONST_SIZE.
621 Naturally we try to avoid using VAR_SIZE. */
622 register unsigned const_size
= 0;
623 register tree var_size
= 0;
624 int nonvirtual_const_size
;
626 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
628 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
629 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
631 var_size
= TYPE_SIZE (rec
);
633 nonvirtual_const_size
= const_size
;
637 tree basetype
= BINFO_TYPE (vbase_types
);
640 desired_align
= TYPE_ALIGN (basetype
);
641 record_align
= MAX (record_align
, desired_align
);
644 offset
= integer_zero_node
;
647 /* Give each virtual base type the alignment it wants. */
648 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
649 * TYPE_ALIGN (basetype
);
650 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
653 if (CLASSTYPE_VSIZE (basetype
) > max
)
654 max
= CLASSTYPE_VSIZE (basetype
);
655 BINFO_OFFSET (vbase_types
) = offset
;
657 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
659 /* Every virtual baseclass takes a least a UNIT, so that we can
660 take it's address and get something different for each base. */
661 const_size
+= MAX (BITS_PER_UNIT
,
662 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
663 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
665 else if (var_size
== 0)
666 var_size
= TYPE_SIZE (basetype
);
668 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
670 vbase_types
= TREE_CHAIN (vbase_types
);
675 /* Because a virtual base might take a single byte above,
676 we have to re-adjust the total size to make sure it it
677 a multiple of the alignment. */
678 /* Give the whole object the alignment it wants. */
679 const_size
= CEIL (const_size
, record_align
) * record_align
;
682 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
683 here, as that is for this class, without any virtual base classes. */
684 TYPE_ALIGN (rec
) = record_align
;
685 if (const_size
!= nonvirtual_const_size
)
687 CLASSTYPE_VBASE_SIZE (rec
)
688 = size_int (const_size
- nonvirtual_const_size
);
689 TYPE_SIZE (rec
) = size_int (const_size
);
692 /* Now propagate offset information throughout the lattice
693 under the vbase type. */
694 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
695 vbase_types
= TREE_CHAIN (vbase_types
))
697 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
699 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
703 tree chain
= NULL_TREE
;
705 /* Now unshare the structure beneath BASE_BINFO. */
707 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
710 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
711 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
712 TREE_VEC_ELT (base_binfos
, j
)
713 = make_binfo (BINFO_OFFSET (base_base_binfo
),
715 BINFO_VTABLE (base_base_binfo
),
716 BINFO_VIRTUALS (base_base_binfo
),
718 chain
= TREE_VEC_ELT (base_binfos
, j
);
719 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
720 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
721 BINFO_INHERITANCE_CHAIN (chain
) = vbase_types
;
724 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
731 /* Lay out the base types of a record type, REC.
732 Tentatively set the size and alignment of REC
733 according to the base types alone.
735 Offsets for immediate nonvirtual baseclasses are also computed here.
737 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
738 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
740 Returns list of virtual base classes in a FIELD_DECL chain. */
743 layout_basetypes (rec
, binfos
)
746 /* Chain to hold all the new FIELD_DECLs which point at virtual
748 tree vbase_decls
= NULL_TREE
;
750 #ifdef STRUCTURE_SIZE_BOUNDARY
751 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
753 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
756 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
757 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
758 the size is just CONST_SIZE. Naturally we try to avoid using
759 VAR_SIZE. And so far, we've been successful. */
761 register tree var_size
= 0;
764 register unsigned const_size
= 0;
765 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
767 /* Handle basetypes almost like fields, but record their
768 offsets differently. */
770 for (i
= 0; i
< n_baseclasses
; i
++)
772 int inc
, desired_align
, int_vbase_size
;
773 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
774 register tree basetype
= BINFO_TYPE (base_binfo
);
777 if (TYPE_SIZE (basetype
) == 0)
780 /* This error is now reported in xref_tag, thus giving better
781 location information. */
782 error_with_aggr_type (base_binfo
,
783 "base class `%s' has incomplete type");
785 TREE_VIA_PUBLIC (base_binfo
) = 1;
786 TREE_VIA_PROTECTED (base_binfo
) = 0;
787 TREE_VIA_VIRTUAL (base_binfo
) = 0;
789 /* Should handle this better so that
792 class B: private A { virtual void F(); };
794 does not dump core when compiled. */
795 my_friendly_abort (121);
800 /* All basetypes are recorded in the association list of the
803 if (TREE_VIA_VIRTUAL (base_binfo
))
806 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
807 + sizeof (VBASE_NAME
) + 1);
809 /* The offset for a virtual base class is only used in computing
810 virtual function tables and for initializing virtual base
811 pointers. It is built once `get_vbase_types' is called. */
813 /* If this basetype can come from another vbase pointer
814 without an additional indirection, we will share
815 that pointer. If an indirection is involved, we
816 make our own pointer. */
817 for (j
= 0; j
< n_baseclasses
; j
++)
819 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
820 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
821 && binfo_member (basetype
,
822 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
825 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
826 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
827 build_pointer_type (basetype
));
828 /* If you change any of the below, take a look at all the
829 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
831 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
832 DECL_VIRTUAL_P (decl
) = 1;
833 DECL_ARTIFICIAL (decl
) = 1;
834 DECL_FIELD_CONTEXT (decl
) = rec
;
835 DECL_CLASS_CONTEXT (decl
) = rec
;
836 DECL_FCONTEXT (decl
) = basetype
;
837 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
838 DECL_FIELD_SIZE (decl
) = 0;
839 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
840 TREE_CHAIN (decl
) = vbase_decls
;
841 BINFO_VPTR_FIELD (base_binfo
) = decl
;
845 /* The space this decl occupies has already been accounted for. */
849 /* Effective C++ rule 14. We only need to check TYPE_VIRTUAL_P
850 here because the case of virtual functions but non-virtual
851 dtor is handled in finish_struct_1. */
852 if (warn_ecpp
&& ! TYPE_VIRTUAL_P (basetype
)
853 && TYPE_HAS_DESTRUCTOR (basetype
))
854 cp_warning ("base class `%#T' has a non-virtual destructor", basetype
);
857 offset
= integer_zero_node
;
860 /* Give each base type the alignment it wants. */
861 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
862 * TYPE_ALIGN (basetype
);
863 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
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 static 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. */
928 list_hash (purpose
, value
, chain
)
929 tree purpose
, value
, chain
;
931 register int hashcode
= 0;
934 hashcode
+= TYPE_HASH (chain
);
937 hashcode
+= TYPE_HASH (value
);
941 hashcode
+= TYPE_HASH (purpose
);
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
, via_public
, via_protected
, via_virtual
,
952 purpose
, value
, chain
)
953 int hashcode
, via_public
, via_virtual
, via_protected
;
954 tree purpose
, value
, chain
;
956 register struct list_hash
*h
;
958 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
959 if (h
->hashcode
== hashcode
960 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
961 && TREE_VIA_PUBLIC (h
->list
) == via_public
962 && TREE_VIA_PROTECTED (h
->list
) == via_protected
963 && TREE_PURPOSE (h
->list
) == purpose
964 && TREE_VALUE (h
->list
) == value
965 && TREE_CHAIN (h
->list
) == chain
)
970 /* Add an entry to the list-hash-table
971 for a list TYPE whose hash code is HASHCODE. */
974 list_hash_add (hashcode
, list
)
978 register struct list_hash
*h
;
980 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
981 h
->hashcode
= hashcode
;
983 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
984 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
987 /* Given TYPE, and HASHCODE its hash code, return the canonical
988 object for an identical list if one already exists.
989 Otherwise, return TYPE, and record it as the canonical object
990 if it is a permanent object.
992 To use this function, first create a list of the sort you want.
993 Then compute its hash code from the fields of the list that
994 make it different from other similar lists.
995 Then call this function and use the value.
996 This function frees the list you pass in if it is a duplicate. */
998 /* Set to 1 to debug without canonicalization. Never set by program. */
1000 static int debug_no_list_hash
= 0;
1003 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1004 int via_public
, via_virtual
, via_protected
;
1005 tree purpose
, value
, chain
;
1007 struct obstack
*ambient_obstack
= current_obstack
;
1011 if (! debug_no_list_hash
)
1013 hashcode
= list_hash (purpose
, value
, chain
);
1014 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1015 purpose
, value
, chain
);
1020 current_obstack
= &class_obstack
;
1022 t
= tree_cons (purpose
, value
, chain
);
1023 TREE_VIA_PUBLIC (t
) = via_public
;
1024 TREE_VIA_PROTECTED (t
) = via_protected
;
1025 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1027 /* If this is a new list, record it for later reuse. */
1028 if (! debug_no_list_hash
)
1029 list_hash_add (hashcode
, t
);
1031 current_obstack
= ambient_obstack
;
1035 /* Constructor for hashed lists. */
1038 hash_tree_chain (value
, chain
)
1041 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1044 /* Similar, but used for concatenating two lists. */
1047 hash_chainon (list1
, list2
)
1054 if (TREE_CHAIN (list1
) == NULL_TREE
)
1055 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1056 return hash_tree_chain (TREE_VALUE (list1
),
1057 hash_chainon (TREE_CHAIN (list1
), list2
));
1061 get_identifier_list (value
)
1064 tree list
= IDENTIFIER_AS_LIST (value
);
1065 if (list
!= NULL_TREE
1066 && (TREE_CODE (list
) != TREE_LIST
1067 || TREE_VALUE (list
) != value
))
1069 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1070 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1071 && IDENTIFIER_TYPE_VALUE (value
)
1072 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1074 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1076 if (TYPE_PTRMEMFUNC_P (type
))
1078 else if (type
== current_class_type
)
1079 /* Don't mess up the constructor name. */
1080 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1083 if (! CLASSTYPE_ID_AS_LIST (type
))
1084 CLASSTYPE_ID_AS_LIST (type
)
1085 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1086 list
= CLASSTYPE_ID_AS_LIST (type
);
1093 get_decl_list (value
)
1096 tree list
= NULL_TREE
;
1098 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1099 list
= get_identifier_list (value
);
1100 else if (TREE_CODE (value
) == RECORD_TYPE
1101 && TYPE_LANG_SPECIFIC (value
)
1102 && value
== TYPE_MAIN_VARIANT (value
))
1103 list
= CLASSTYPE_AS_LIST (value
);
1105 if (list
!= NULL_TREE
)
1107 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1111 return build_decl_list (NULL_TREE
, value
);
1114 /* Build an association between TYPE and some parameters:
1116 OFFSET is the offset added to `this' to convert it to a pointer
1119 BINFO is the base binfo to use, if we are deriving from one. This
1120 is necessary, as we want specialized parent binfos from base
1121 classes, so that the VTABLE_NAMEs of bases are for the most derived
1122 type, instead of of the simple type.
1124 VTABLE is the virtual function table with which to initialize
1125 sub-objects of type TYPE.
1127 VIRTUALS are the virtual functions sitting in VTABLE.
1129 CHAIN are more associations we must retain. */
1132 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1134 tree vtable
, virtuals
;
1137 tree new_binfo
= make_tree_vec (6);
1140 if (TREE_CODE (binfo
) == TREE_VEC
)
1141 type
= BINFO_TYPE (binfo
);
1145 binfo
= TYPE_BINFO (binfo
);
1148 TREE_CHAIN (new_binfo
) = chain
;
1150 TREE_USED (new_binfo
) = TREE_USED (chain
);
1152 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1153 BINFO_OFFSET (new_binfo
) = offset
;
1154 BINFO_VTABLE (new_binfo
) = vtable
;
1155 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1156 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1158 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1159 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1163 /* Return the binfo value for ELEM in TYPE. */
1166 binfo_value (elem
, type
)
1170 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1171 compiler_error ("base class `%s' ambiguous in binfo_value",
1172 TYPE_NAME_STRING (elem
));
1174 return TYPE_BINFO (type
);
1175 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1177 return get_binfo (elem
, type
, 0);
1184 register tree prev
= 0, tmp
, next
;
1185 for (tmp
= path
; tmp
; tmp
= next
)
1187 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1188 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1198 unsigned HOST_WIDE_INT n
;
1201 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1202 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1203 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1204 fprintf (stderr
, "vtable type:\n");
1205 debug_tree (BINFO_TYPE (elem
));
1206 if (BINFO_VTABLE (elem
))
1207 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1209 fprintf (stderr
, "no vtable decl yet\n");
1210 fprintf (stderr
, "virtuals:\n");
1211 virtuals
= BINFO_VIRTUALS (elem
);
1213 n
= skip_rtti_stuff (&virtuals
);
1217 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1218 fprintf (stderr
, "%s [%d =? %d]\n",
1219 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1220 n
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1222 virtuals
= TREE_CHAIN (virtuals
);
1226 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1227 We expect a null pointer to mark the end of the chain.
1228 This is the Lisp primitive `length'. */
1231 decl_list_length (t
)
1235 register int len
= 0;
1237 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1238 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1239 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1249 if (TREE_CODE (t
) == FUNCTION_DECL
)
1251 else if (TREE_CODE (t
) == TREE_LIST
)
1252 return decl_list_length (TREE_VALUE (t
));
1254 my_friendly_abort (359);
1259 is_overloaded_fn (x
)
1262 if (TREE_CODE (x
) == FUNCTION_DECL
)
1265 if (TREE_CODE (x
) == TREE_LIST
1266 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1267 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1274 really_overloaded_fn (x
)
1277 if (TREE_CODE (x
) == TREE_LIST
1278 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1279 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1289 if (TREE_CODE (from
) == FUNCTION_DECL
)
1292 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1294 return TREE_VALUE (from
);
1298 is_aggr_type_2 (t1
, t2
)
1301 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1303 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1306 #define PRINT_RING_SIZE 4
1309 lang_printable_name (decl
, v
)
1313 static tree decl_ring
[PRINT_RING_SIZE
];
1314 static char *print_ring
[PRINT_RING_SIZE
];
1315 static int ring_counter
;
1318 /* Only cache functions. */
1320 || TREE_CODE (decl
) != FUNCTION_DECL
1321 || DECL_LANG_SPECIFIC (decl
) == 0)
1322 return lang_decl_name (decl
, v
);
1324 /* See if this print name is lying around. */
1325 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1326 if (decl_ring
[i
] == decl
)
1327 /* yes, so return it. */
1328 return print_ring
[i
];
1330 if (++ring_counter
== PRINT_RING_SIZE
)
1333 if (current_function_decl
!= NULL_TREE
)
1335 if (decl_ring
[ring_counter
] == current_function_decl
)
1337 if (ring_counter
== PRINT_RING_SIZE
)
1339 if (decl_ring
[ring_counter
] == current_function_decl
)
1340 my_friendly_abort (106);
1343 if (print_ring
[ring_counter
])
1344 free (print_ring
[ring_counter
]);
1346 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1347 decl_ring
[ring_counter
] = decl
;
1348 return print_ring
[ring_counter
];
1351 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1352 listed in RAISES. */
1355 build_exception_variant (type
, raises
)
1359 tree v
= TYPE_MAIN_VARIANT (type
);
1360 int constp
= TYPE_READONLY (type
);
1361 int volatilep
= TYPE_VOLATILE (type
);
1363 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1365 if (TYPE_READONLY (v
) != constp
1366 || TYPE_VOLATILE (v
) != volatilep
)
1369 /* @@ This should do set equality, not exact match. */
1370 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1371 /* List of exceptions raised matches previously found list.
1373 @@ Nice to free up storage used in consing up the
1374 @@ list of exceptions raised. */
1378 /* Need to build a new variant. */
1379 v
= build_type_copy (type
);
1381 if (raises
&& ! TREE_PERMANENT (raises
))
1383 push_obstacks_nochange ();
1384 end_temporary_allocation ();
1385 raises
= copy_list (raises
);
1389 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1393 /* Subroutine of copy_to_permanent
1395 Assuming T is a node build bottom-up, make it all exist on
1396 permanent obstack, if it is not permanent already. */
1401 tree (*func
) PROTO((tree
));
1408 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1411 switch (TREE_CODE (t
))
1414 return error_mark_node
;
1423 tree chain
= TREE_CHAIN (t
);
1425 TREE_CHAIN (t
) = mapcar (chain
, func
);
1426 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1427 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1428 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1434 tree chain
= TREE_CHAIN (t
);
1436 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1437 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1438 TREE_CHAIN (t
) = mapcar (chain
, func
);
1444 int len
= TREE_VEC_LENGTH (t
);
1448 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1455 return copy_node (t
);
1461 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1462 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1463 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1468 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1475 case TRUNC_DIV_EXPR
:
1476 case TRUNC_MOD_EXPR
:
1484 case BIT_ANDTC_EXPR
:
1485 case TRUTH_ANDIF_EXPR
:
1486 case TRUTH_ORIF_EXPR
:
1494 case FLOOR_DIV_EXPR
:
1495 case ROUND_DIV_EXPR
:
1497 case FLOOR_MOD_EXPR
:
1498 case ROUND_MOD_EXPR
:
1500 case PREDECREMENT_EXPR
:
1501 case PREINCREMENT_EXPR
:
1502 case POSTDECREMENT_EXPR
:
1503 case POSTINCREMENT_EXPR
:
1507 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1508 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1513 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1514 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1515 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1517 /* tree.def says that operand two is RTL, but
1518 build_call_declarator puts trees in there. */
1519 if (TREE_OPERAND (t
, 2)
1520 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1521 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1523 TREE_OPERAND (t
, 2) = NULL_TREE
;
1531 case TRUTH_NOT_EXPR
:
1535 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1539 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1540 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1541 case REFERENCE_TYPE
:
1542 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1543 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1545 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1546 mapcar (TYPE_ARG_TYPES (t
), func
));
1547 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1549 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
1550 mapcar (TYPE_DOMAIN (t
), func
));
1551 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1553 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1554 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1556 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1557 mapcar (TREE_TYPE (t
), func
));
1558 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1560 tmp
= build_cplus_method_type
1561 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
1562 mapcar (TREE_TYPE (t
), func
),
1563 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
1564 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1568 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
1569 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
1574 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
1578 if (TYPE_PTRMEMFUNC_P (t
))
1579 return build_ptrmemfunc_type
1580 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1581 /* else fall through */
1583 /* This list is incomplete, but should suffice for now.
1584 It is very important that `sorry' not call
1585 `report_error_function'. That could cause an infinite loop. */
1587 sorry ("initializer contains unrecognized tree code");
1588 return error_mark_node
;
1591 my_friendly_abort (107);
1600 if (TREE_PERMANENT (t
))
1602 /* Support `void f () { extern int i; A<&i> a; }' */
1603 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
1605 return copy_node (t
);
1609 /* Assuming T is a node built bottom-up, make it all exist on
1610 permanent obstack, if it is not permanent already. */
1613 copy_to_permanent (t
)
1616 register struct obstack
*ambient_obstack
= current_obstack
;
1617 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1618 register struct obstack
*ambient_expression_obstack
= expression_obstack
;
1620 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1623 saveable_obstack
= &permanent_obstack
;
1624 current_obstack
= saveable_obstack
;
1625 expression_obstack
= saveable_obstack
;
1627 t
= mapcar (t
, perm_manip
);
1629 current_obstack
= ambient_obstack
;
1630 saveable_obstack
= ambient_saveable_obstack
;
1631 expression_obstack
= ambient_expression_obstack
;
1636 #ifdef GATHER_STATISTICS
1637 extern int depth_reached
;
1641 print_lang_statistics ()
1643 extern struct obstack maybepermanent_obstack
, decl_obstack
;
1644 print_obstack_statistics ("class_obstack", &class_obstack
);
1645 print_obstack_statistics ("decl_obstack", &decl_obstack
);
1646 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
1647 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
1648 print_search_statistics ();
1649 print_class_statistics ();
1650 #ifdef GATHER_STATISTICS
1651 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1656 /* This is used by the `assert' macro. It is provided in libgcc.a,
1657 which `cc' doesn't know how to link. Note that the C++ front-end
1658 no longer actually uses the `assert' macro (instead, it calls
1659 my_friendly_assert). But all of the back-end files still need this. */
1662 __eprintf (string
, expression
, line
, filename
)
1665 const char *expression
;
1667 const char *filename
;
1675 fprintf (stderr
, string
, expression
, line
, filename
);
1680 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1681 (which is an ARRAY_TYPE). This counts only elements of the top
1685 array_type_nelts_top (type
)
1688 return fold (build (PLUS_EXPR
, sizetype
,
1689 array_type_nelts (type
),
1693 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1694 (which is an ARRAY_TYPE). This one is a recursive count of all
1695 ARRAY_TYPEs that are clumped together. */
1698 array_type_nelts_total (type
)
1701 tree sz
= array_type_nelts_top (type
);
1702 type
= TREE_TYPE (type
);
1703 while (TREE_CODE (type
) == ARRAY_TYPE
)
1705 tree n
= array_type_nelts_top (type
);
1706 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1707 type
= TREE_TYPE (type
);
1717 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1719 else if (TREE_CODE (t
) == TARGET_EXPR
)
1721 if (TREE_CODE (TREE_OPERAND (t
, 1)) == NEW_EXPR
)
1723 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1724 return build_cplus_new
1725 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1728 TREE_OPERAND (t
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
1729 layout_decl (TREE_OPERAND (t
, 0), 0);
1732 else if (TREE_CODE (t
) == CALL_EXPR
)
1733 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1738 /* Actually, we'll just clean out the target exprs for the moment. */
1741 break_out_target_exprs (t
)
1744 return mapcar (t
, bot_manip
);
1747 /* Obstack used for allocating nodes in template function and variable
1750 extern struct obstack
*expression_obstack
;
1752 /* Similar to `build_nt', except we build
1753 on the permanent_obstack, regardless. */
1756 build_min_nt
VPROTO((enum tree_code code
, ...))
1759 enum tree_code code
;
1761 register struct obstack
*ambient_obstack
= expression_obstack
;
1764 register int length
;
1770 code
= va_arg (p
, enum tree_code
);
1773 expression_obstack
= &permanent_obstack
;
1775 t
= make_node (code
);
1776 length
= tree_code_length
[(int) code
];
1777 TREE_COMPLEXITY (t
) = lineno
;
1779 for (i
= 0; i
< length
; i
++)
1781 tree x
= va_arg (p
, tree
);
1782 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1786 expression_obstack
= ambient_obstack
;
1790 /* Similar to `build', except we build
1791 on the permanent_obstack, regardless. */
1794 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
1797 enum tree_code code
;
1800 register struct obstack
*ambient_obstack
= expression_obstack
;
1803 register int length
;
1809 code
= va_arg (p
, enum tree_code
);
1810 tt
= va_arg (p
, tree
);
1813 expression_obstack
= &permanent_obstack
;
1815 t
= make_node (code
);
1816 length
= tree_code_length
[(int) code
];
1818 TREE_COMPLEXITY (t
) = lineno
;
1820 for (i
= 0; i
< length
; i
++)
1822 tree x
= va_arg (p
, tree
);
1823 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1827 expression_obstack
= ambient_obstack
;
1831 /* Same as `tree_cons' but make a permanent object. */
1834 min_tree_cons (purpose
, value
, chain
)
1835 tree purpose
, value
, chain
;
1838 register struct obstack
*ambient_obstack
= current_obstack
;
1839 current_obstack
= &permanent_obstack
;
1841 node
= tree_cons (copy_to_permanent (purpose
),
1842 copy_to_permanent (value
), chain
);
1843 current_obstack
= ambient_obstack
;
1851 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1852 return identifier_typedecl_value (t
);
1853 if (TREE_CODE (t
) == TYPE_DECL
)
1855 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
1856 return TYPE_STUB_DECL (t
);
1858 my_friendly_abort (42);
1862 can_free (obstack
, t
)
1863 struct obstack
*obstack
;
1868 if (TREE_CODE (t
) == TREE_VEC
)
1869 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1871 my_friendly_abort (42);
1873 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1874 & ~ obstack_alignment_mask (obstack))
1875 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1882 /* Return first vector element whose BINFO_TYPE is ELEM.
1883 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1886 vec_binfo_member (elem
, vec
)
1892 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1893 if (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
1894 return TREE_VEC_ELT (vec
, i
);
1899 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
1900 the wrong thing for decl_function_context. Hopefully the uses in the
1901 backend won't matter, since we don't need a static chain for local class
1905 hack_decl_function_context (decl
)
1908 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
1909 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
1910 return decl_function_context (decl
);
1913 /* Return truthvalue of whether T1 is the same tree structure as T2.
1914 Return 1 if they are the same.
1915 Return 0 if they are understandably different.
1916 Return -1 if either contains tree structure not understood by
1920 cp_tree_equal (t1
, t2
)
1923 register enum tree_code code1
, code2
;
1928 if (t1
== 0 || t2
== 0)
1931 code1
= TREE_CODE (t1
);
1932 code2
= TREE_CODE (t2
);
1934 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1935 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1936 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1938 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1939 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1940 || code2
== NON_LVALUE_EXPR
)
1941 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1949 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1950 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1953 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1956 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1957 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1958 TREE_STRING_LENGTH (t1
));
1964 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1967 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1970 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1973 /* Special case: if either target is an unallocated VAR_DECL,
1974 it means that it's going to be unified with whatever the
1975 TARGET_EXPR is really supposed to initialize, so treat it
1976 as being equivalent to anything. */
1977 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1978 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1979 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
1980 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1981 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1982 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
1985 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1988 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1990 case WITH_CLEANUP_EXPR
:
1991 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1994 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
1997 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
1998 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2007 case TEMPLATE_CONST_PARM
:
2008 return TEMPLATE_CONST_IDX (t1
) == TEMPLATE_CONST_IDX (t2
)
2009 && TEMPLATE_CONST_LEVEL (t1
) == TEMPLATE_CONST_LEVEL (t2
);
2012 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2014 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2015 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2019 switch (TREE_CODE_CLASS (code1
))
2029 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2031 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2041 /* Similar to make_tree_vec, but build on a temporary obstack. */
2048 push_obstacks_nochange ();
2049 resume_temporary_allocation ();
2050 node
= make_tree_vec (len
);
2055 /* The type of ARG when used as an lvalue. */
2061 return cp_build_type_variant
2062 (TREE_TYPE (arg
), TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
2065 /* The type of ARG for printing error messages; denote lvalues with
2072 tree type
= TREE_TYPE (arg
);
2073 if (TREE_CODE (type
) == ARRAY_TYPE
)
2075 else if (real_lvalue_p (arg
))
2076 type
= build_reference_type (lvalue_type (arg
));
2077 else if (IS_AGGR_TYPE (type
))
2078 type
= lvalue_type (arg
);
2083 /* Does FUNCTION use a variable-length argument list? */
2086 varargs_function_p (function
)
2089 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2090 for (; parm
; parm
= TREE_CHAIN (parm
))
2091 if (TREE_VALUE (parm
) == void_type_node
)