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. */
39 #ifdef NEED_DECLARATION_FREE
40 extern void free
PROTO((void *));
43 extern void compiler_error ();
45 static tree get_identifier_list
PROTO((tree
));
46 static tree bot_manip
PROTO((tree
));
47 static tree perm_manip
PROTO((tree
));
48 static tree build_cplus_array_type_1
PROTO((tree
, tree
));
49 static void list_hash_add
PROTO((int, tree
));
50 static int list_hash
PROTO((tree
, tree
, tree
));
51 static tree list_hash_lookup
PROTO((int, int, int, int, tree
, tree
,
54 #define CEIL(x,y) (((x) + (y) - 1) / (y))
56 /* Return nonzero if REF is an lvalue valid for this language.
57 Lvalues can be assigned, unless they have TREE_READONLY.
58 Lvalues can have their address taken, unless they have DECL_REGISTER. */
64 if (! language_lvalue_valid (ref
))
67 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
70 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
73 switch (TREE_CODE (ref
))
75 /* preincrements and predecrements are valid lvals, provided
76 what they refer to are valid lvals. */
77 case PREINCREMENT_EXPR
:
78 case PREDECREMENT_EXPR
:
81 return real_lvalue_p (TREE_OPERAND (ref
, 0));
87 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
88 && DECL_LANG_SPECIFIC (ref
)
89 && DECL_IN_AGGR_P (ref
))
96 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
97 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
101 /* A currently unresolved scope ref. */
103 my_friendly_abort (103);
105 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
107 return real_lvalue_p (TREE_OPERAND (ref
, 0))
108 && real_lvalue_p (TREE_OPERAND (ref
, 1));
112 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
113 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
119 return real_lvalue_p (TREE_OPERAND (ref
, 1));
123 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
124 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
130 /* This differs from real_lvalue_p in that class rvalues are considered
136 if (! language_lvalue_valid (ref
))
139 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
142 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
145 switch (TREE_CODE (ref
))
147 /* preincrements and predecrements are valid lvals, provided
148 what they refer to are valid lvals. */
149 case PREINCREMENT_EXPR
:
150 case PREDECREMENT_EXPR
:
155 return lvalue_p (TREE_OPERAND (ref
, 0));
161 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
162 && DECL_LANG_SPECIFIC (ref
)
163 && DECL_IN_AGGR_P (ref
))
170 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
171 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
179 if (IS_AGGR_TYPE (TREE_TYPE (ref
)))
183 /* A currently unresolved scope ref. */
185 my_friendly_abort (103);
187 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
189 return lvalue_p (TREE_OPERAND (ref
, 0))
190 && lvalue_p (TREE_OPERAND (ref
, 1));
194 return (lvalue_p (TREE_OPERAND (ref
, 1))
195 && lvalue_p (TREE_OPERAND (ref
, 2)));
201 return lvalue_p (TREE_OPERAND (ref
, 1));
205 return (lvalue_p (TREE_OPERAND (ref
, 0))
206 && lvalue_p (TREE_OPERAND (ref
, 1)));
212 /* Return nonzero if REF is an lvalue valid for this language;
213 otherwise, print an error message and return zero. */
216 lvalue_or_else (ref
, string
)
220 int win
= lvalue_p (ref
);
222 error ("non-lvalue in %s", string
);
226 /* INIT is a CALL_EXPR which needs info about its target.
227 TYPE is the type that this initialization should appear to have.
229 Build an encapsulation of the initialization to perform
230 and return it so that it can be processed by language-independent
231 and language-specific expression expanders. */
234 build_cplus_new (type
, init
)
241 if (TREE_CODE (init
) == TARGET_EXPR
|| init
== error_mark_node
)
244 slot
= build (VAR_DECL
, type
);
245 layout_decl (slot
, 0);
246 rval
= build (NEW_EXPR
, type
,
247 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
248 TREE_SIDE_EFFECTS (rval
) = 1;
249 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
250 TREE_SIDE_EFFECTS (rval
) = 1;
255 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
256 these CALL_EXPRs with tree nodes that will perform the cleanups. */
259 break_out_cleanups (exp
)
264 if (TREE_CODE (tmp
) == CALL_EXPR
265 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
266 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
268 while (TREE_CODE (tmp
) == NOP_EXPR
269 || TREE_CODE (tmp
) == CONVERT_EXPR
270 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
272 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
273 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
275 TREE_OPERAND (tmp
, 0)
276 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
277 TREE_OPERAND (tmp
, 0));
281 tmp
= TREE_OPERAND (tmp
, 0);
286 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
287 copies where they are found. Returns a deep copy all nodes transitively
288 containing CALL_EXPRs. */
291 break_out_calls (exp
)
294 register tree t1
, t2
;
295 register enum tree_code code
;
296 register int changed
= 0;
299 if (exp
== NULL_TREE
)
302 code
= TREE_CODE (exp
);
304 if (code
== CALL_EXPR
)
305 return copy_node (exp
);
307 /* Don't try and defeat a save_expr, as it should only be done once. */
308 if (code
== SAVE_EXPR
)
311 switch (TREE_CODE_CLASS (code
))
316 case 'c': /* a constant */
317 case 't': /* a type node */
318 case 'x': /* something random, like an identifier or an ERROR_MARK. */
321 case 'd': /* A decl node */
322 #if 0 /* This is bogus. jason 9/21/94 */
324 t1
= break_out_calls (DECL_INITIAL (exp
));
325 if (t1
!= DECL_INITIAL (exp
))
327 exp
= copy_node (exp
);
328 DECL_INITIAL (exp
) = t1
;
333 case 'b': /* A block node */
335 /* Don't know how to handle these correctly yet. Must do a
336 break_out_calls on all DECL_INITIAL values for local variables,
337 and also break_out_calls on all sub-blocks and sub-statements. */
342 case 'e': /* an expression */
343 case 'r': /* a reference */
344 case 's': /* an expression with side effects */
345 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
347 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
348 if (t1
!= TREE_OPERAND (exp
, i
))
350 exp
= copy_node (exp
);
351 TREE_OPERAND (exp
, i
) = t1
;
356 case '<': /* a comparison expression */
357 case '2': /* a binary arithmetic expression */
358 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
359 if (t2
!= TREE_OPERAND (exp
, 1))
361 case '1': /* a unary arithmetic expression */
362 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
363 if (t1
!= TREE_OPERAND (exp
, 0))
367 if (tree_code_length
[(int) code
] == 1)
368 return build1 (code
, TREE_TYPE (exp
), t1
);
370 return build (code
, TREE_TYPE (exp
), t1
, t2
);
377 extern struct obstack
*current_obstack
;
378 extern struct obstack permanent_obstack
, class_obstack
;
379 extern struct obstack
*saveable_obstack
;
380 extern struct obstack
*expression_obstack
;
382 /* Here is how primitive or already-canonicalized types' hash
383 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
384 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
386 /* Construct, lay out and return the type of methods belonging to class
387 BASETYPE and whose arguments are described by ARGTYPES and whose values
388 are described by RETTYPE. If each type exists already, reuse it. */
391 build_cplus_method_type (basetype
, rettype
, argtypes
)
392 tree basetype
, rettype
, argtypes
;
398 /* Make a node of the sort we want. */
399 t
= make_node (METHOD_TYPE
);
401 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
402 TREE_TYPE (t
) = rettype
;
403 if (IS_SIGNATURE (basetype
))
404 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
405 TYPE_READONLY (basetype
),
406 TYPE_VOLATILE (basetype
));
408 ptype
= build_pointer_type (basetype
);
410 /* The actual arglist for this function includes a "hidden" argument
411 which is "this". Put it into the list of argument types. */
413 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
414 TYPE_ARG_TYPES (t
) = argtypes
;
415 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
417 /* If we already have such a type, use the old one and free this one.
418 Note that it also frees up the above cons cell if found. */
419 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
420 t
= type_hash_canon (hashcode
, t
);
422 if (TYPE_SIZE (t
) == 0)
429 build_cplus_array_type_1 (elt_type
, index_type
)
433 register struct obstack
*ambient_obstack
= current_obstack
;
434 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
437 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
438 make this permanent too. */
439 if (TREE_PERMANENT (elt_type
)
440 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
442 current_obstack
= &permanent_obstack
;
443 saveable_obstack
= &permanent_obstack
;
446 if (processing_template_decl
)
448 t
= make_node (ARRAY_TYPE
);
449 TREE_TYPE (t
) = elt_type
;
450 TYPE_DOMAIN (t
) = index_type
;
453 t
= build_array_type (elt_type
, index_type
);
455 /* Push these needs up so that initialization takes place
457 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
458 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
459 current_obstack
= ambient_obstack
;
460 saveable_obstack
= ambient_saveable_obstack
;
465 build_cplus_array_type (elt_type
, index_type
)
470 int constp
= TYPE_READONLY (elt_type
);
471 int volatilep
= TYPE_VOLATILE (elt_type
);
472 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
474 t
= build_cplus_array_type_1 (elt_type
, index_type
);
476 if (constp
|| volatilep
)
477 t
= cp_build_type_variant (t
, constp
, volatilep
);
482 /* Make a variant type in the proper way for C/C++, propagating qualifiers
483 down to the element type of an array. */
486 cp_build_type_variant (type
, constp
, volatilep
)
488 int constp
, volatilep
;
490 if (type
== error_mark_node
)
493 if (TREE_CODE (type
) == ARRAY_TYPE
)
495 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
497 push_obstacks (TYPE_OBSTACK (real_main_variant
),
498 TYPE_OBSTACK (real_main_variant
));
499 type
= build_cplus_array_type_1 (cp_build_type_variant
500 (TREE_TYPE (type
), constp
, volatilep
),
503 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
504 make a copy. (TYPE might have come from the hash table and
505 REAL_MAIN_VARIANT might be in some function's obstack.) */
507 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
509 type
= copy_node (type
);
510 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
513 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
517 return build_type_variant (type
, constp
, volatilep
);
520 /* Add OFFSET to all base types of T.
522 OFFSET, which is a type offset, is number of bytes.
524 Note that we don't have to worry about having two paths to the
525 same base type, since this type owns its association list. */
528 propagate_binfo_offsets (binfo
, offset
)
532 tree binfos
= BINFO_BASETYPES (binfo
);
533 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
535 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
537 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
539 if (TREE_VIA_VIRTUAL (base_binfo
))
544 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
547 for (j
= i
+1; j
< n_baselinks
; j
++)
548 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
550 /* The next basetype offset must take into account the space
551 between the classes, not just the size of each class. */
552 delta
= size_binop (MINUS_EXPR
,
553 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
554 BINFO_OFFSET (base_binfo
));
559 if (BINFO_OFFSET_ZEROP (base_binfo
))
560 BINFO_OFFSET (base_binfo
) = offset
;
562 BINFO_OFFSET (base_binfo
)
563 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
565 BINFO_OFFSET (base_binfo
) = offset
;
570 tree chain
= NULL_TREE
;
572 /* Now unshare the structure beneath BASE_BINFO. */
573 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
576 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
577 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
578 TREE_VEC_ELT (base_binfos
, k
)
579 = make_binfo (BINFO_OFFSET (base_base_binfo
),
581 BINFO_VTABLE (base_base_binfo
),
582 BINFO_VIRTUALS (base_base_binfo
),
584 chain
= TREE_VEC_ELT (base_binfos
, k
);
585 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
586 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
587 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
589 /* Now propagate the offset to the base types. */
590 propagate_binfo_offsets (base_binfo
, offset
);
593 /* Go to our next class that counts for offset propagation. */
596 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
601 /* Compute the actual offsets that our virtual base classes
602 will have *for this type*. This must be performed after
603 the fields are laid out, since virtual baseclasses must
604 lay down at the end of the record.
606 Returns the maximum number of virtual functions any of the virtual
607 baseclasses provide. */
610 layout_vbasetypes (rec
, max
)
614 /* Get all the virtual base types that this type uses.
615 The TREE_VALUE slot holds the virtual baseclass type. */
616 tree vbase_types
= get_vbase_types (rec
);
618 #ifdef STRUCTURE_SIZE_BOUNDARY
619 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
621 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
625 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
626 where CONST_SIZE is an integer
627 and VAR_SIZE is a tree expression.
628 If VAR_SIZE is null, the size is just CONST_SIZE.
629 Naturally we try to avoid using VAR_SIZE. */
630 register unsigned const_size
= 0;
631 register tree var_size
= 0;
632 int nonvirtual_const_size
;
634 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
636 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
637 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
639 var_size
= TYPE_SIZE (rec
);
641 nonvirtual_const_size
= const_size
;
645 tree basetype
= BINFO_TYPE (vbase_types
);
648 desired_align
= TYPE_ALIGN (basetype
);
649 record_align
= MAX (record_align
, desired_align
);
652 offset
= integer_zero_node
;
655 /* Give each virtual base type the alignment it wants. */
656 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
657 * TYPE_ALIGN (basetype
);
658 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
661 if (CLASSTYPE_VSIZE (basetype
) > max
)
662 max
= CLASSTYPE_VSIZE (basetype
);
663 BINFO_OFFSET (vbase_types
) = offset
;
665 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
667 /* Every virtual baseclass takes a least a UNIT, so that we can
668 take it's address and get something different for each base. */
669 const_size
+= MAX (BITS_PER_UNIT
,
670 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
671 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
673 else if (var_size
== 0)
674 var_size
= TYPE_SIZE (basetype
);
676 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
678 vbase_types
= TREE_CHAIN (vbase_types
);
683 /* Because a virtual base might take a single byte above,
684 we have to re-adjust the total size to make sure it it
685 a multiple of the alignment. */
686 /* Give the whole object the alignment it wants. */
687 const_size
= CEIL (const_size
, record_align
) * record_align
;
690 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
691 here, as that is for this class, without any virtual base classes. */
692 TYPE_ALIGN (rec
) = record_align
;
693 if (const_size
!= nonvirtual_const_size
)
695 CLASSTYPE_VBASE_SIZE (rec
)
696 = size_int (const_size
- nonvirtual_const_size
);
697 TYPE_SIZE (rec
) = size_int (const_size
);
700 /* Now propagate offset information throughout the lattice
701 under the vbase type. */
702 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
703 vbase_types
= TREE_CHAIN (vbase_types
))
705 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
707 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
711 tree chain
= NULL_TREE
;
713 /* Now unshare the structure beneath BASE_BINFO. */
715 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
718 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
719 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
720 TREE_VEC_ELT (base_binfos
, j
)
721 = make_binfo (BINFO_OFFSET (base_base_binfo
),
723 BINFO_VTABLE (base_base_binfo
),
724 BINFO_VIRTUALS (base_base_binfo
),
726 chain
= TREE_VEC_ELT (base_binfos
, j
);
727 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
728 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
729 BINFO_INHERITANCE_CHAIN (chain
) = vbase_types
;
732 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
739 /* Lay out the base types of a record type, REC.
740 Tentatively set the size and alignment of REC
741 according to the base types alone.
743 Offsets for immediate nonvirtual baseclasses are also computed here.
745 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
746 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
748 Returns list of virtual base classes in a FIELD_DECL chain. */
751 layout_basetypes (rec
, binfos
)
754 /* Chain to hold all the new FIELD_DECLs which point at virtual
756 tree vbase_decls
= NULL_TREE
;
758 #ifdef STRUCTURE_SIZE_BOUNDARY
759 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
761 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
764 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
765 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
766 the size is just CONST_SIZE. Naturally we try to avoid using
767 VAR_SIZE. And so far, we've been successful. */
769 register tree var_size
= 0;
772 register unsigned const_size
= 0;
773 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
775 /* Handle basetypes almost like fields, but record their
776 offsets differently. */
778 for (i
= 0; i
< n_baseclasses
; i
++)
780 int inc
, desired_align
, int_vbase_size
;
781 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
782 register tree basetype
= BINFO_TYPE (base_binfo
);
785 if (TYPE_SIZE (basetype
) == 0)
788 /* This error is now reported in xref_tag, thus giving better
789 location information. */
790 error_with_aggr_type (base_binfo
,
791 "base class `%s' has incomplete type");
793 TREE_VIA_PUBLIC (base_binfo
) = 1;
794 TREE_VIA_PROTECTED (base_binfo
) = 0;
795 TREE_VIA_VIRTUAL (base_binfo
) = 0;
797 /* Should handle this better so that
800 class B: private A { virtual void F(); };
802 does not dump core when compiled. */
803 my_friendly_abort (121);
808 /* All basetypes are recorded in the association list of the
811 if (TREE_VIA_VIRTUAL (base_binfo
))
814 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
815 + sizeof (VBASE_NAME
) + 1);
817 /* The offset for a virtual base class is only used in computing
818 virtual function tables and for initializing virtual base
819 pointers. It is built once `get_vbase_types' is called. */
821 /* If this basetype can come from another vbase pointer
822 without an additional indirection, we will share
823 that pointer. If an indirection is involved, we
824 make our own pointer. */
825 for (j
= 0; j
< n_baseclasses
; j
++)
827 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
828 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
829 && binfo_member (basetype
,
830 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
833 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
834 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
835 build_pointer_type (basetype
));
836 /* If you change any of the below, take a look at all the
837 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
839 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
840 DECL_VIRTUAL_P (decl
) = 1;
841 DECL_ARTIFICIAL (decl
) = 1;
842 DECL_FIELD_CONTEXT (decl
) = rec
;
843 DECL_CLASS_CONTEXT (decl
) = rec
;
844 DECL_FCONTEXT (decl
) = basetype
;
845 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
846 DECL_FIELD_SIZE (decl
) = 0;
847 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
848 TREE_CHAIN (decl
) = vbase_decls
;
849 BINFO_VPTR_FIELD (base_binfo
) = decl
;
853 /* The space this decl occupies has already been accounted for. */
857 /* Effective C++ rule 14. We only need to check TYPE_VIRTUAL_P
858 here because the case of virtual functions but non-virtual
859 dtor is handled in finish_struct_1. */
860 if (warn_ecpp
&& ! TYPE_VIRTUAL_P (basetype
)
861 && TYPE_HAS_DESTRUCTOR (basetype
))
862 cp_warning ("base class `%#T' has a non-virtual destructor", basetype
);
865 offset
= integer_zero_node
;
868 /* Give each base type the alignment it wants. */
869 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
870 * TYPE_ALIGN (basetype
);
871 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
873 BINFO_OFFSET (base_binfo
) = offset
;
874 if (CLASSTYPE_VSIZE (basetype
))
876 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
877 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
879 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
880 TYPE_BINFO (rec
) = base_binfo
;
882 /* Add only the amount of storage not present in
883 the virtual baseclasses. */
885 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
886 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
888 inc
= MAX (record_align
,
889 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
892 /* Record must have at least as much alignment as any field. */
893 desired_align
= TYPE_ALIGN (basetype
);
894 record_align
= MAX (record_align
, desired_align
);
901 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
903 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
904 CLASSTYPE_ALIGN (rec
) = record_align
;
909 /* Hashing of lists so that we don't make duplicates.
910 The entry point is `list_hash_canon'. */
912 /* Each hash table slot is a bucket containing a chain
913 of these structures. */
917 struct list_hash
*next
; /* Next structure in the bucket. */
918 int hashcode
; /* Hash code of this list. */
919 tree list
; /* The list recorded here. */
922 /* Now here is the hash table. When recording a list, it is added
923 to the slot whose index is the hash code mod the table size.
924 Note that the hash table is used for several kinds of lists.
925 While all these live in the same table, they are completely independent,
926 and the hash code is computed differently for each of these. */
928 #define TYPE_HASH_SIZE 59
929 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
931 /* Compute a hash code for a list (chain of TREE_LIST nodes
932 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
933 TREE_COMMON slots), by adding the hash codes of the individual entries. */
936 list_hash (purpose
, value
, chain
)
937 tree purpose
, value
, chain
;
939 register int hashcode
= 0;
942 hashcode
+= TYPE_HASH (chain
);
945 hashcode
+= TYPE_HASH (value
);
949 hashcode
+= TYPE_HASH (purpose
);
955 /* Look in the type hash table for a type isomorphic to TYPE.
956 If one is found, return it. Otherwise return 0. */
959 list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
960 purpose
, value
, chain
)
961 int hashcode
, via_public
, via_virtual
, via_protected
;
962 tree purpose
, value
, chain
;
964 register struct list_hash
*h
;
966 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
967 if (h
->hashcode
== hashcode
968 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
969 && TREE_VIA_PUBLIC (h
->list
) == via_public
970 && TREE_VIA_PROTECTED (h
->list
) == via_protected
971 && TREE_PURPOSE (h
->list
) == purpose
972 && TREE_VALUE (h
->list
) == value
973 && TREE_CHAIN (h
->list
) == chain
)
978 /* Add an entry to the list-hash-table
979 for a list TYPE whose hash code is HASHCODE. */
982 list_hash_add (hashcode
, list
)
986 register struct list_hash
*h
;
988 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
989 h
->hashcode
= hashcode
;
991 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
992 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
995 /* Given TYPE, and HASHCODE its hash code, return the canonical
996 object for an identical list if one already exists.
997 Otherwise, return TYPE, and record it as the canonical object
998 if it is a permanent object.
1000 To use this function, first create a list of the sort you want.
1001 Then compute its hash code from the fields of the list that
1002 make it different from other similar lists.
1003 Then call this function and use the value.
1004 This function frees the list you pass in if it is a duplicate. */
1006 /* Set to 1 to debug without canonicalization. Never set by program. */
1008 static int debug_no_list_hash
= 0;
1011 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1012 int via_public
, via_virtual
, via_protected
;
1013 tree purpose
, value
, chain
;
1015 struct obstack
*ambient_obstack
= current_obstack
;
1019 if (! debug_no_list_hash
)
1021 hashcode
= list_hash (purpose
, value
, chain
);
1022 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1023 purpose
, value
, chain
);
1028 current_obstack
= &class_obstack
;
1030 t
= tree_cons (purpose
, value
, chain
);
1031 TREE_VIA_PUBLIC (t
) = via_public
;
1032 TREE_VIA_PROTECTED (t
) = via_protected
;
1033 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1035 /* If this is a new list, record it for later reuse. */
1036 if (! debug_no_list_hash
)
1037 list_hash_add (hashcode
, t
);
1039 current_obstack
= ambient_obstack
;
1043 /* Constructor for hashed lists. */
1046 hash_tree_chain (value
, chain
)
1049 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1052 /* Similar, but used for concatenating two lists. */
1055 hash_chainon (list1
, list2
)
1062 if (TREE_CHAIN (list1
) == NULL_TREE
)
1063 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1064 return hash_tree_chain (TREE_VALUE (list1
),
1065 hash_chainon (TREE_CHAIN (list1
), list2
));
1069 get_identifier_list (value
)
1072 tree list
= IDENTIFIER_AS_LIST (value
);
1073 if (list
!= NULL_TREE
1074 && (TREE_CODE (list
) != TREE_LIST
1075 || TREE_VALUE (list
) != value
))
1077 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1078 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1079 && IDENTIFIER_TYPE_VALUE (value
)
1080 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1082 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1084 if (TYPE_PTRMEMFUNC_P (type
))
1086 else if (type
== current_class_type
)
1087 /* Don't mess up the constructor name. */
1088 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1091 if (! CLASSTYPE_ID_AS_LIST (type
))
1092 CLASSTYPE_ID_AS_LIST (type
)
1093 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1094 list
= CLASSTYPE_ID_AS_LIST (type
);
1101 get_decl_list (value
)
1104 tree list
= NULL_TREE
;
1106 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1107 list
= get_identifier_list (value
);
1108 else if (TREE_CODE (value
) == RECORD_TYPE
1109 && TYPE_LANG_SPECIFIC (value
)
1110 && value
== TYPE_MAIN_VARIANT (value
))
1111 list
= CLASSTYPE_AS_LIST (value
);
1113 if (list
!= NULL_TREE
)
1115 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1119 return build_decl_list (NULL_TREE
, value
);
1122 /* Build an association between TYPE and some parameters:
1124 OFFSET is the offset added to `this' to convert it to a pointer
1127 BINFO is the base binfo to use, if we are deriving from one. This
1128 is necessary, as we want specialized parent binfos from base
1129 classes, so that the VTABLE_NAMEs of bases are for the most derived
1130 type, instead of of the simple type.
1132 VTABLE is the virtual function table with which to initialize
1133 sub-objects of type TYPE.
1135 VIRTUALS are the virtual functions sitting in VTABLE.
1137 CHAIN are more associations we must retain. */
1140 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1142 tree vtable
, virtuals
;
1145 tree new_binfo
= make_tree_vec (6);
1148 if (TREE_CODE (binfo
) == TREE_VEC
)
1149 type
= BINFO_TYPE (binfo
);
1153 binfo
= TYPE_BINFO (binfo
);
1156 TREE_CHAIN (new_binfo
) = chain
;
1158 TREE_USED (new_binfo
) = TREE_USED (chain
);
1160 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1161 BINFO_OFFSET (new_binfo
) = offset
;
1162 BINFO_VTABLE (new_binfo
) = vtable
;
1163 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1164 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1166 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1167 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1171 /* Return the binfo value for ELEM in TYPE. */
1174 binfo_value (elem
, type
)
1178 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1179 compiler_error ("base class `%s' ambiguous in binfo_value",
1180 TYPE_NAME_STRING (elem
));
1182 return TYPE_BINFO (type
);
1183 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1185 return get_binfo (elem
, type
, 0);
1192 register tree prev
= 0, tmp
, next
;
1193 for (tmp
= path
; tmp
; tmp
= next
)
1195 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1196 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1206 unsigned HOST_WIDE_INT n
;
1209 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1210 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1211 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1212 fprintf (stderr
, "vtable type:\n");
1213 debug_tree (BINFO_TYPE (elem
));
1214 if (BINFO_VTABLE (elem
))
1215 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1217 fprintf (stderr
, "no vtable decl yet\n");
1218 fprintf (stderr
, "virtuals:\n");
1219 virtuals
= BINFO_VIRTUALS (elem
);
1221 n
= skip_rtti_stuff (&virtuals
);
1225 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1226 fprintf (stderr
, "%s [%d =? %d]\n",
1227 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1228 n
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1230 virtuals
= TREE_CHAIN (virtuals
);
1234 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1235 We expect a null pointer to mark the end of the chain.
1236 This is the Lisp primitive `length'. */
1239 decl_list_length (t
)
1243 register int len
= 0;
1245 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1246 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1247 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1257 if (TREE_CODE (t
) == FUNCTION_DECL
)
1259 else if (TREE_CODE (t
) == TREE_LIST
)
1260 return decl_list_length (TREE_VALUE (t
));
1262 my_friendly_abort (359);
1267 is_overloaded_fn (x
)
1270 if (TREE_CODE (x
) == FUNCTION_DECL
)
1273 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1276 if (TREE_CODE (x
) == TREE_LIST
1277 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1278 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1285 really_overloaded_fn (x
)
1288 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1291 if (TREE_CODE (x
) == TREE_LIST
1292 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1293 || DECL_FUNCTION_TEMPLATE_P (TREE_VALUE (x
))))
1303 if (TREE_CODE (from
) == FUNCTION_DECL
1304 || DECL_FUNCTION_TEMPLATE_P (from
))
1307 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1309 return TREE_VALUE (from
);
1313 is_aggr_type_2 (t1
, t2
)
1316 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1318 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1321 #define PRINT_RING_SIZE 4
1324 lang_printable_name (decl
, v
)
1328 static tree decl_ring
[PRINT_RING_SIZE
];
1329 static char *print_ring
[PRINT_RING_SIZE
];
1330 static int ring_counter
;
1333 /* Only cache functions. */
1335 || TREE_CODE (decl
) != FUNCTION_DECL
1336 || DECL_LANG_SPECIFIC (decl
) == 0)
1337 return lang_decl_name (decl
, v
);
1339 /* See if this print name is lying around. */
1340 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1341 if (decl_ring
[i
] == decl
)
1342 /* yes, so return it. */
1343 return print_ring
[i
];
1345 if (++ring_counter
== PRINT_RING_SIZE
)
1348 if (current_function_decl
!= NULL_TREE
)
1350 if (decl_ring
[ring_counter
] == current_function_decl
)
1352 if (ring_counter
== PRINT_RING_SIZE
)
1354 if (decl_ring
[ring_counter
] == current_function_decl
)
1355 my_friendly_abort (106);
1358 if (print_ring
[ring_counter
])
1359 free (print_ring
[ring_counter
]);
1361 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1362 decl_ring
[ring_counter
] = decl
;
1363 return print_ring
[ring_counter
];
1366 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1367 listed in RAISES. */
1370 build_exception_variant (type
, raises
)
1374 tree v
= TYPE_MAIN_VARIANT (type
);
1375 int constp
= TYPE_READONLY (type
);
1376 int volatilep
= TYPE_VOLATILE (type
);
1378 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1380 if (TYPE_READONLY (v
) != constp
1381 || TYPE_VOLATILE (v
) != volatilep
)
1384 /* @@ This should do set equality, not exact match. */
1385 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1386 /* List of exceptions raised matches previously found list.
1388 @@ Nice to free up storage used in consing up the
1389 @@ list of exceptions raised. */
1393 /* Need to build a new variant. */
1394 v
= build_type_copy (type
);
1396 if (raises
&& ! TREE_PERMANENT (raises
))
1398 push_obstacks_nochange ();
1399 end_temporary_allocation ();
1400 raises
= copy_list (raises
);
1404 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1408 /* Subroutine of copy_to_permanent
1410 Assuming T is a node build bottom-up, make it all exist on
1411 permanent obstack, if it is not permanent already. */
1416 tree (*func
) PROTO((tree
));
1423 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1426 switch (TREE_CODE (t
))
1429 return error_mark_node
;
1438 tree chain
= TREE_CHAIN (t
);
1440 TREE_CHAIN (t
) = mapcar (chain
, func
);
1441 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1442 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1443 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1449 tree chain
= TREE_CHAIN (t
);
1451 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1452 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1453 TREE_CHAIN (t
) = mapcar (chain
, func
);
1459 int len
= TREE_VEC_LENGTH (t
);
1463 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1470 return copy_node (t
);
1476 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1477 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1478 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1483 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1490 case TRUNC_DIV_EXPR
:
1491 case TRUNC_MOD_EXPR
:
1499 case BIT_ANDTC_EXPR
:
1500 case TRUTH_ANDIF_EXPR
:
1501 case TRUTH_ORIF_EXPR
:
1509 case FLOOR_DIV_EXPR
:
1510 case ROUND_DIV_EXPR
:
1512 case FLOOR_MOD_EXPR
:
1513 case ROUND_MOD_EXPR
:
1515 case PREDECREMENT_EXPR
:
1516 case PREINCREMENT_EXPR
:
1517 case POSTDECREMENT_EXPR
:
1518 case POSTINCREMENT_EXPR
:
1522 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1523 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1528 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1529 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1530 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1532 /* tree.def says that operand two is RTL, but
1533 build_call_declarator puts trees in there. */
1534 if (TREE_OPERAND (t
, 2)
1535 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1536 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1538 TREE_OPERAND (t
, 2) = NULL_TREE
;
1546 case TRUTH_NOT_EXPR
:
1550 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1554 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1555 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1556 case REFERENCE_TYPE
:
1557 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1558 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1560 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1561 mapcar (TYPE_ARG_TYPES (t
), func
));
1562 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1564 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
1565 mapcar (TYPE_DOMAIN (t
), func
));
1566 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1568 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1569 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1571 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1572 mapcar (TREE_TYPE (t
), func
));
1573 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1575 tmp
= build_cplus_method_type
1576 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
1577 mapcar (TREE_TYPE (t
), func
),
1578 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
1579 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1583 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
1584 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
1589 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
1593 if (TYPE_PTRMEMFUNC_P (t
))
1594 return build_ptrmemfunc_type
1595 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1596 /* else fall through */
1598 /* This list is incomplete, but should suffice for now.
1599 It is very important that `sorry' not call
1600 `report_error_function'. That could cause an infinite loop. */
1602 sorry ("initializer contains unrecognized tree code");
1603 return error_mark_node
;
1606 my_friendly_abort (107);
1615 if (TREE_PERMANENT (t
))
1617 /* Support `void f () { extern int i; A<&i> a; }' */
1618 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
1620 return copy_node (t
);
1624 /* Assuming T is a node built bottom-up, make it all exist on
1625 permanent obstack, if it is not permanent already. */
1628 copy_to_permanent (t
)
1631 register struct obstack
*ambient_obstack
= current_obstack
;
1632 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1633 register struct obstack
*ambient_expression_obstack
= expression_obstack
;
1635 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1638 saveable_obstack
= &permanent_obstack
;
1639 current_obstack
= saveable_obstack
;
1640 expression_obstack
= saveable_obstack
;
1642 t
= mapcar (t
, perm_manip
);
1644 current_obstack
= ambient_obstack
;
1645 saveable_obstack
= ambient_saveable_obstack
;
1646 expression_obstack
= ambient_expression_obstack
;
1651 #ifdef GATHER_STATISTICS
1652 extern int depth_reached
;
1656 print_lang_statistics ()
1658 extern struct obstack decl_obstack
;
1659 print_obstack_statistics ("class_obstack", &class_obstack
);
1660 print_obstack_statistics ("decl_obstack", &decl_obstack
);
1661 print_search_statistics ();
1662 print_class_statistics ();
1663 #ifdef GATHER_STATISTICS
1664 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1669 /* This is used by the `assert' macro. It is provided in libgcc.a,
1670 which `cc' doesn't know how to link. Note that the C++ front-end
1671 no longer actually uses the `assert' macro (instead, it calls
1672 my_friendly_assert). But all of the back-end files still need this. */
1675 __eprintf (string
, expression
, line
, filename
)
1678 const char *expression
;
1680 const char *filename
;
1688 fprintf (stderr
, string
, expression
, line
, filename
);
1693 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1694 (which is an ARRAY_TYPE). This counts only elements of the top
1698 array_type_nelts_top (type
)
1701 return fold (build (PLUS_EXPR
, sizetype
,
1702 array_type_nelts (type
),
1706 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1707 (which is an ARRAY_TYPE). This one is a recursive count of all
1708 ARRAY_TYPEs that are clumped together. */
1711 array_type_nelts_total (type
)
1714 tree sz
= array_type_nelts_top (type
);
1715 type
= TREE_TYPE (type
);
1716 while (TREE_CODE (type
) == ARRAY_TYPE
)
1718 tree n
= array_type_nelts_top (type
);
1719 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1720 type
= TREE_TYPE (type
);
1730 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1732 else if (TREE_CODE (t
) == TARGET_EXPR
)
1734 if (TREE_CODE (TREE_OPERAND (t
, 1)) == NEW_EXPR
)
1736 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1737 return build_cplus_new
1738 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1741 TREE_OPERAND (t
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
1742 layout_decl (TREE_OPERAND (t
, 0), 0);
1745 else if (TREE_CODE (t
) == CALL_EXPR
)
1746 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1751 /* Actually, we'll just clean out the target exprs for the moment. */
1754 break_out_target_exprs (t
)
1757 return mapcar (t
, bot_manip
);
1760 /* Obstack used for allocating nodes in template function and variable
1763 /* Similar to `build_nt', except we build
1764 on the permanent_obstack, regardless. */
1767 build_min_nt
VPROTO((enum tree_code code
, ...))
1770 enum tree_code code
;
1772 register struct obstack
*ambient_obstack
= expression_obstack
;
1775 register int length
;
1781 code
= va_arg (p
, enum tree_code
);
1784 expression_obstack
= &permanent_obstack
;
1786 t
= make_node (code
);
1787 length
= tree_code_length
[(int) code
];
1788 TREE_COMPLEXITY (t
) = lineno
;
1790 for (i
= 0; i
< length
; i
++)
1792 tree x
= va_arg (p
, tree
);
1793 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1797 expression_obstack
= ambient_obstack
;
1801 /* Similar to `build', except we build
1802 on the permanent_obstack, regardless. */
1805 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
1808 enum tree_code code
;
1811 register struct obstack
*ambient_obstack
= expression_obstack
;
1814 register int length
;
1820 code
= va_arg (p
, enum tree_code
);
1821 tt
= va_arg (p
, tree
);
1824 expression_obstack
= &permanent_obstack
;
1826 t
= make_node (code
);
1827 length
= tree_code_length
[(int) code
];
1829 TREE_COMPLEXITY (t
) = lineno
;
1831 for (i
= 0; i
< length
; i
++)
1833 tree x
= va_arg (p
, tree
);
1834 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1838 expression_obstack
= ambient_obstack
;
1842 /* Same as `tree_cons' but make a permanent object. */
1845 min_tree_cons (purpose
, value
, chain
)
1846 tree purpose
, value
, chain
;
1849 register struct obstack
*ambient_obstack
= current_obstack
;
1850 current_obstack
= &permanent_obstack
;
1852 node
= tree_cons (copy_to_permanent (purpose
),
1853 copy_to_permanent (value
), chain
);
1854 current_obstack
= ambient_obstack
;
1862 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1863 return identifier_typedecl_value (t
);
1864 if (TREE_CODE (t
) == TYPE_DECL
)
1866 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
1867 return TYPE_STUB_DECL (t
);
1869 my_friendly_abort (42);
1873 can_free (obstack
, t
)
1874 struct obstack
*obstack
;
1879 if (TREE_CODE (t
) == TREE_VEC
)
1880 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1882 my_friendly_abort (42);
1884 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1885 & ~ obstack_alignment_mask (obstack))
1886 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1893 /* Return first vector element whose BINFO_TYPE is ELEM.
1894 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1897 vec_binfo_member (elem
, vec
)
1903 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1904 if (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
1905 return TREE_VEC_ELT (vec
, i
);
1910 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
1911 the wrong thing for decl_function_context. Hopefully the uses in the
1912 backend won't matter, since we don't need a static chain for local class
1916 hack_decl_function_context (decl
)
1919 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
1920 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
1921 return decl_function_context (decl
);
1924 /* Return truthvalue of whether T1 is the same tree structure as T2.
1925 Return 1 if they are the same.
1926 Return 0 if they are understandably different.
1927 Return -1 if either contains tree structure not understood by
1931 cp_tree_equal (t1
, t2
)
1934 register enum tree_code code1
, code2
;
1939 if (t1
== 0 || t2
== 0)
1942 code1
= TREE_CODE (t1
);
1943 code2
= TREE_CODE (t2
);
1945 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1946 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1947 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1949 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1950 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1951 || code2
== NON_LVALUE_EXPR
)
1952 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1960 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1961 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1964 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1967 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1968 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1969 TREE_STRING_LENGTH (t1
));
1975 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1978 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1981 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1984 /* Special case: if either target is an unallocated VAR_DECL,
1985 it means that it's going to be unified with whatever the
1986 TARGET_EXPR is really supposed to initialize, so treat it
1987 as being equivalent to anything. */
1988 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1989 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1990 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
1991 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1992 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1993 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
1996 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1999 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2001 case WITH_CLEANUP_EXPR
:
2002 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2005 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2008 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2009 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2018 case TEMPLATE_CONST_PARM
:
2019 return TEMPLATE_CONST_IDX (t1
) == TEMPLATE_CONST_IDX (t2
)
2020 && TEMPLATE_CONST_LEVEL (t1
) == TEMPLATE_CONST_LEVEL (t2
);
2023 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2025 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2026 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2030 switch (TREE_CODE_CLASS (code1
))
2040 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2042 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2052 /* Similar to make_tree_vec, but build on a temporary obstack. */
2059 register struct obstack
*ambient_obstack
= current_obstack
;
2060 current_obstack
= expression_obstack
;
2061 node
= make_tree_vec (len
);
2062 current_obstack
= ambient_obstack
;
2067 push_expression_obstack ()
2069 push_obstacks_nochange ();
2070 current_obstack
= expression_obstack
;
2073 /* The type of ARG when used as an lvalue. */
2079 return cp_build_type_variant
2080 (TREE_TYPE (arg
), TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
2083 /* The type of ARG for printing error messages; denote lvalues with
2090 tree type
= TREE_TYPE (arg
);
2091 if (TREE_CODE (type
) == ARRAY_TYPE
)
2093 else if (real_lvalue_p (arg
))
2094 type
= build_reference_type (lvalue_type (arg
));
2095 else if (IS_AGGR_TYPE (type
))
2096 type
= lvalue_type (arg
);
2101 /* Does FUNCTION use a variable-length argument list? */
2104 varargs_function_p (function
)
2107 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2108 for (; parm
; parm
= TREE_CHAIN (parm
))
2109 if (TREE_VALUE (parm
) == void_type_node
)