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
:
83 case WITH_CLEANUP_EXPR
:
84 return real_lvalue_p (TREE_OPERAND (ref
, 0));
90 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
91 && DECL_LANG_SPECIFIC (ref
)
92 && DECL_IN_AGGR_P (ref
))
99 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
100 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
104 /* A currently unresolved scope ref. */
106 my_friendly_abort (103);
108 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
110 return real_lvalue_p (TREE_OPERAND (ref
, 0))
111 && real_lvalue_p (TREE_OPERAND (ref
, 1));
115 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
116 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
122 return real_lvalue_p (TREE_OPERAND (ref
, 1));
126 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
127 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
133 /* This differs from real_lvalue_p in that class rvalues are considered
139 if (! language_lvalue_valid (ref
))
142 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
145 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
148 switch (TREE_CODE (ref
))
150 /* preincrements and predecrements are valid lvals, provided
151 what they refer to are valid lvals. */
152 case PREINCREMENT_EXPR
:
153 case PREDECREMENT_EXPR
:
160 case WITH_CLEANUP_EXPR
:
161 return lvalue_p (TREE_OPERAND (ref
, 0));
167 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
168 && DECL_LANG_SPECIFIC (ref
)
169 && DECL_IN_AGGR_P (ref
))
176 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
177 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
185 if (IS_AGGR_TYPE (TREE_TYPE (ref
)))
189 /* A currently unresolved scope ref. */
191 my_friendly_abort (103);
193 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
195 return lvalue_p (TREE_OPERAND (ref
, 0))
196 && lvalue_p (TREE_OPERAND (ref
, 1));
200 return (lvalue_p (TREE_OPERAND (ref
, 1))
201 && lvalue_p (TREE_OPERAND (ref
, 2)));
207 return lvalue_p (TREE_OPERAND (ref
, 1));
211 return (lvalue_p (TREE_OPERAND (ref
, 0))
212 && lvalue_p (TREE_OPERAND (ref
, 1)));
218 /* Return nonzero if REF is an lvalue valid for this language;
219 otherwise, print an error message and return zero. */
222 lvalue_or_else (ref
, string
)
226 int win
= lvalue_p (ref
);
228 error ("non-lvalue in %s", string
);
232 /* INIT is a CALL_EXPR which needs info about its target.
233 TYPE is the type that this initialization should appear to have.
235 Build an encapsulation of the initialization to perform
236 and return it so that it can be processed by language-independent
237 and language-specific expression expanders. */
240 build_cplus_new (type
, init
)
247 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != NEW_EXPR
)
250 slot
= build (VAR_DECL
, type
);
251 layout_decl (slot
, 0);
252 rval
= build (NEW_EXPR
, type
,
253 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
254 TREE_SIDE_EFFECTS (rval
) = 1;
255 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
256 TREE_SIDE_EFFECTS (rval
) = 1;
261 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
262 these CALL_EXPRs with tree nodes that will perform the cleanups. */
265 break_out_cleanups (exp
)
270 if (TREE_CODE (tmp
) == CALL_EXPR
271 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
272 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
274 while (TREE_CODE (tmp
) == NOP_EXPR
275 || TREE_CODE (tmp
) == CONVERT_EXPR
276 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
278 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
279 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
281 TREE_OPERAND (tmp
, 0)
282 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
283 TREE_OPERAND (tmp
, 0));
287 tmp
= TREE_OPERAND (tmp
, 0);
292 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
293 copies where they are found. Returns a deep copy all nodes transitively
294 containing CALL_EXPRs. */
297 break_out_calls (exp
)
300 register tree t1
, t2
;
301 register enum tree_code code
;
302 register int changed
= 0;
305 if (exp
== NULL_TREE
)
308 code
= TREE_CODE (exp
);
310 if (code
== CALL_EXPR
)
311 return copy_node (exp
);
313 /* Don't try and defeat a save_expr, as it should only be done once. */
314 if (code
== SAVE_EXPR
)
317 switch (TREE_CODE_CLASS (code
))
322 case 'c': /* a constant */
323 case 't': /* a type node */
324 case 'x': /* something random, like an identifier or an ERROR_MARK. */
327 case 'd': /* A decl node */
328 #if 0 /* This is bogus. jason 9/21/94 */
330 t1
= break_out_calls (DECL_INITIAL (exp
));
331 if (t1
!= DECL_INITIAL (exp
))
333 exp
= copy_node (exp
);
334 DECL_INITIAL (exp
) = t1
;
339 case 'b': /* A block node */
341 /* Don't know how to handle these correctly yet. Must do a
342 break_out_calls on all DECL_INITIAL values for local variables,
343 and also break_out_calls on all sub-blocks and sub-statements. */
348 case 'e': /* an expression */
349 case 'r': /* a reference */
350 case 's': /* an expression with side effects */
351 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
353 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
354 if (t1
!= TREE_OPERAND (exp
, i
))
356 exp
= copy_node (exp
);
357 TREE_OPERAND (exp
, i
) = t1
;
362 case '<': /* a comparison expression */
363 case '2': /* a binary arithmetic expression */
364 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
365 if (t2
!= TREE_OPERAND (exp
, 1))
367 case '1': /* a unary arithmetic expression */
368 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
369 if (t1
!= TREE_OPERAND (exp
, 0))
373 if (tree_code_length
[(int) code
] == 1)
374 return build1 (code
, TREE_TYPE (exp
), t1
);
376 return build (code
, TREE_TYPE (exp
), t1
, t2
);
383 extern struct obstack
*current_obstack
;
384 extern struct obstack permanent_obstack
, class_obstack
;
385 extern struct obstack
*saveable_obstack
;
386 extern struct obstack
*expression_obstack
;
388 /* Here is how primitive or already-canonicalized types' hash
389 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
390 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
392 /* Construct, lay out and return the type of methods belonging to class
393 BASETYPE and whose arguments are described by ARGTYPES and whose values
394 are described by RETTYPE. If each type exists already, reuse it. */
397 build_cplus_method_type (basetype
, rettype
, argtypes
)
398 tree basetype
, rettype
, argtypes
;
404 /* Make a node of the sort we want. */
405 t
= make_node (METHOD_TYPE
);
407 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
408 TREE_TYPE (t
) = rettype
;
409 if (IS_SIGNATURE (basetype
))
410 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
411 TYPE_READONLY (basetype
),
412 TYPE_VOLATILE (basetype
));
414 ptype
= build_pointer_type (basetype
);
416 /* The actual arglist for this function includes a "hidden" argument
417 which is "this". Put it into the list of argument types. */
419 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
420 TYPE_ARG_TYPES (t
) = argtypes
;
421 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
423 /* If we already have such a type, use the old one and free this one.
424 Note that it also frees up the above cons cell if found. */
425 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
426 t
= type_hash_canon (hashcode
, t
);
428 if (TYPE_SIZE (t
) == 0)
435 build_cplus_array_type_1 (elt_type
, index_type
)
439 register struct obstack
*ambient_obstack
= current_obstack
;
440 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
443 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
444 make this permanent too. */
445 if (TREE_PERMANENT (elt_type
)
446 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
448 current_obstack
= &permanent_obstack
;
449 saveable_obstack
= &permanent_obstack
;
452 if (processing_template_decl
)
454 t
= make_node (ARRAY_TYPE
);
455 TREE_TYPE (t
) = elt_type
;
456 TYPE_DOMAIN (t
) = index_type
;
459 t
= build_array_type (elt_type
, index_type
);
461 /* Push these needs up so that initialization takes place
463 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
464 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
465 current_obstack
= ambient_obstack
;
466 saveable_obstack
= ambient_saveable_obstack
;
471 build_cplus_array_type (elt_type
, index_type
)
476 int constp
= TYPE_READONLY (elt_type
);
477 int volatilep
= TYPE_VOLATILE (elt_type
);
478 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
480 t
= build_cplus_array_type_1 (elt_type
, index_type
);
482 if (constp
|| volatilep
)
483 t
= cp_build_type_variant (t
, constp
, volatilep
);
488 /* Make a variant type in the proper way for C/C++, propagating qualifiers
489 down to the element type of an array. */
492 cp_build_type_variant (type
, constp
, volatilep
)
494 int constp
, volatilep
;
496 if (type
== error_mark_node
)
499 if (TREE_CODE (type
) == ARRAY_TYPE
)
501 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
503 push_obstacks (TYPE_OBSTACK (real_main_variant
),
504 TYPE_OBSTACK (real_main_variant
));
505 type
= build_cplus_array_type_1 (cp_build_type_variant
506 (TREE_TYPE (type
), constp
, volatilep
),
509 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
510 make a copy. (TYPE might have come from the hash table and
511 REAL_MAIN_VARIANT might be in some function's obstack.) */
513 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
515 type
= copy_node (type
);
516 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
519 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
523 return build_type_variant (type
, constp
, volatilep
);
526 /* Add OFFSET to all base types of T.
528 OFFSET, which is a type offset, is number of bytes.
530 Note that we don't have to worry about having two paths to the
531 same base type, since this type owns its association list. */
534 propagate_binfo_offsets (binfo
, offset
)
538 tree binfos
= BINFO_BASETYPES (binfo
);
539 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
541 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
543 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
545 if (TREE_VIA_VIRTUAL (base_binfo
))
550 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
553 for (j
= i
+1; j
< n_baselinks
; j
++)
554 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
556 /* The next basetype offset must take into account the space
557 between the classes, not just the size of each class. */
558 delta
= size_binop (MINUS_EXPR
,
559 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
560 BINFO_OFFSET (base_binfo
));
565 if (BINFO_OFFSET_ZEROP (base_binfo
))
566 BINFO_OFFSET (base_binfo
) = offset
;
568 BINFO_OFFSET (base_binfo
)
569 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
571 BINFO_OFFSET (base_binfo
) = offset
;
576 tree chain
= NULL_TREE
;
578 /* Now unshare the structure beneath BASE_BINFO. */
579 for (k
= TREE_VEC_LENGTH (base_binfos
)-1;
582 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, k
);
583 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
584 TREE_VEC_ELT (base_binfos
, k
)
585 = make_binfo (BINFO_OFFSET (base_base_binfo
),
587 BINFO_VTABLE (base_base_binfo
),
588 BINFO_VIRTUALS (base_base_binfo
),
590 chain
= TREE_VEC_ELT (base_binfos
, k
);
591 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
592 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
593 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
595 /* Now propagate the offset to the base types. */
596 propagate_binfo_offsets (base_binfo
, offset
);
599 /* Go to our next class that counts for offset propagation. */
602 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
607 /* Compute the actual offsets that our virtual base classes
608 will have *for this type*. This must be performed after
609 the fields are laid out, since virtual baseclasses must
610 lay down at the end of the record.
612 Returns the maximum number of virtual functions any of the virtual
613 baseclasses provide. */
616 layout_vbasetypes (rec
, max
)
620 /* Get all the virtual base types that this type uses.
621 The TREE_VALUE slot holds the virtual baseclass type. */
622 tree vbase_types
= get_vbase_types (rec
);
624 #ifdef STRUCTURE_SIZE_BOUNDARY
625 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
627 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
631 /* Record size so far is CONST_SIZE + VAR_SIZE bits,
632 where CONST_SIZE is an integer
633 and VAR_SIZE is a tree expression.
634 If VAR_SIZE is null, the size is just CONST_SIZE.
635 Naturally we try to avoid using VAR_SIZE. */
636 register unsigned const_size
= 0;
637 register tree var_size
= 0;
638 int nonvirtual_const_size
;
640 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
642 if (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
)
643 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
645 var_size
= TYPE_SIZE (rec
);
647 nonvirtual_const_size
= const_size
;
651 tree basetype
= BINFO_TYPE (vbase_types
);
654 desired_align
= TYPE_ALIGN (basetype
);
655 record_align
= MAX (record_align
, desired_align
);
658 offset
= integer_zero_node
;
661 /* Give each virtual base type the alignment it wants. */
662 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
663 * TYPE_ALIGN (basetype
);
664 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
667 if (CLASSTYPE_VSIZE (basetype
) > max
)
668 max
= CLASSTYPE_VSIZE (basetype
);
669 BINFO_OFFSET (vbase_types
) = offset
;
671 if (TREE_CODE (TYPE_SIZE (basetype
)) == INTEGER_CST
)
673 /* Every virtual baseclass takes a least a UNIT, so that we can
674 take it's address and get something different for each base. */
675 const_size
+= MAX (BITS_PER_UNIT
,
676 TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
677 - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
)));
679 else if (var_size
== 0)
680 var_size
= TYPE_SIZE (basetype
);
682 var_size
= size_binop (PLUS_EXPR
, var_size
, TYPE_SIZE (basetype
));
684 vbase_types
= TREE_CHAIN (vbase_types
);
689 /* Because a virtual base might take a single byte above,
690 we have to re-adjust the total size to make sure it it
691 a multiple of the alignment. */
692 /* Give the whole object the alignment it wants. */
693 const_size
= CEIL (const_size
, record_align
) * record_align
;
696 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
697 here, as that is for this class, without any virtual base classes. */
698 TYPE_ALIGN (rec
) = record_align
;
699 if (const_size
!= nonvirtual_const_size
)
701 CLASSTYPE_VBASE_SIZE (rec
)
702 = size_int (const_size
- nonvirtual_const_size
);
703 TYPE_SIZE (rec
) = size_int (const_size
);
706 /* Now propagate offset information throughout the lattice
707 under the vbase type. */
708 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
709 vbase_types
= TREE_CHAIN (vbase_types
))
711 tree base_binfos
= BINFO_BASETYPES (vbase_types
);
713 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
717 tree chain
= NULL_TREE
;
719 /* Now unshare the structure beneath BASE_BINFO. */
721 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
724 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
725 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
726 TREE_VEC_ELT (base_binfos
, j
)
727 = make_binfo (BINFO_OFFSET (base_base_binfo
),
729 BINFO_VTABLE (base_base_binfo
),
730 BINFO_VIRTUALS (base_base_binfo
),
732 chain
= TREE_VEC_ELT (base_binfos
, j
);
733 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
734 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
735 BINFO_INHERITANCE_CHAIN (chain
) = vbase_types
;
738 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
745 /* Lay out the base types of a record type, REC.
746 Tentatively set the size and alignment of REC
747 according to the base types alone.
749 Offsets for immediate nonvirtual baseclasses are also computed here.
751 TYPE_BINFO (REC) should be NULL_TREE on entry, and this routine
752 creates a list of base_binfos in TYPE_BINFO (REC) from BINFOS.
754 Returns list of virtual base classes in a FIELD_DECL chain. */
757 layout_basetypes (rec
, binfos
)
760 /* Chain to hold all the new FIELD_DECLs which point at virtual
762 tree vbase_decls
= NULL_TREE
;
764 #ifdef STRUCTURE_SIZE_BOUNDARY
765 unsigned record_align
= MAX (STRUCTURE_SIZE_BOUNDARY
, TYPE_ALIGN (rec
));
767 unsigned record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
770 /* Record size so far is CONST_SIZE + VAR_SIZE bits, where CONST_SIZE is
771 an integer and VAR_SIZE is a tree expression. If VAR_SIZE is null,
772 the size is just CONST_SIZE. Naturally we try to avoid using
773 VAR_SIZE. And so far, we've been successful. */
775 register tree var_size
= 0;
778 register unsigned const_size
= 0;
779 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
781 /* Handle basetypes almost like fields, but record their
782 offsets differently. */
784 for (i
= 0; i
< n_baseclasses
; i
++)
786 int inc
, desired_align
, int_vbase_size
;
787 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
788 register tree basetype
= BINFO_TYPE (base_binfo
);
791 if (TYPE_SIZE (basetype
) == 0)
794 /* This error is now reported in xref_tag, thus giving better
795 location information. */
796 error_with_aggr_type (base_binfo
,
797 "base class `%s' has incomplete type");
799 TREE_VIA_PUBLIC (base_binfo
) = 1;
800 TREE_VIA_PROTECTED (base_binfo
) = 0;
801 TREE_VIA_VIRTUAL (base_binfo
) = 0;
803 /* Should handle this better so that
806 class B: private A { virtual void F(); };
808 does not dump core when compiled. */
809 my_friendly_abort (121);
814 /* All basetypes are recorded in the association list of the
817 if (TREE_VIA_VIRTUAL (base_binfo
))
820 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
821 + sizeof (VBASE_NAME
) + 1);
823 /* The offset for a virtual base class is only used in computing
824 virtual function tables and for initializing virtual base
825 pointers. It is built once `get_vbase_types' is called. */
827 /* If this basetype can come from another vbase pointer
828 without an additional indirection, we will share
829 that pointer. If an indirection is involved, we
830 make our own pointer. */
831 for (j
= 0; j
< n_baseclasses
; j
++)
833 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
834 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
835 && binfo_member (basetype
,
836 CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo
))))
839 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
840 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
841 build_pointer_type (basetype
));
842 /* If you change any of the below, take a look at all the
843 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
845 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
846 DECL_VIRTUAL_P (decl
) = 1;
847 DECL_ARTIFICIAL (decl
) = 1;
848 DECL_FIELD_CONTEXT (decl
) = rec
;
849 DECL_CLASS_CONTEXT (decl
) = rec
;
850 DECL_FCONTEXT (decl
) = basetype
;
851 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
852 DECL_FIELD_SIZE (decl
) = 0;
853 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
854 TREE_CHAIN (decl
) = vbase_decls
;
855 BINFO_VPTR_FIELD (base_binfo
) = decl
;
859 /* The space this decl occupies has already been accounted for. */
863 /* Effective C++ rule 14. We only need to check TYPE_VIRTUAL_P
864 here because the case of virtual functions but non-virtual
865 dtor is handled in finish_struct_1. */
866 if (warn_ecpp
&& ! TYPE_VIRTUAL_P (basetype
)
867 && TYPE_HAS_DESTRUCTOR (basetype
))
868 cp_warning ("base class `%#T' has a non-virtual destructor", basetype
);
871 offset
= integer_zero_node
;
874 /* Give each base type the alignment it wants. */
875 const_size
= CEIL (const_size
, TYPE_ALIGN (basetype
))
876 * TYPE_ALIGN (basetype
);
877 offset
= size_int ((const_size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
879 BINFO_OFFSET (base_binfo
) = offset
;
880 if (CLASSTYPE_VSIZE (basetype
))
882 BINFO_VTABLE (base_binfo
) = TYPE_BINFO_VTABLE (basetype
);
883 BINFO_VIRTUALS (base_binfo
) = TYPE_BINFO_VIRTUALS (basetype
);
885 TREE_CHAIN (base_binfo
) = TYPE_BINFO (rec
);
886 TYPE_BINFO (rec
) = base_binfo
;
888 /* Add only the amount of storage not present in
889 the virtual baseclasses. */
891 int_vbase_size
= TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype
));
892 if (TREE_INT_CST_LOW (TYPE_SIZE (basetype
)) > int_vbase_size
)
894 inc
= MAX (record_align
,
895 (TREE_INT_CST_LOW (TYPE_SIZE (basetype
))
898 /* Record must have at least as much alignment as any field. */
899 desired_align
= TYPE_ALIGN (basetype
);
900 record_align
= MAX (record_align
, desired_align
);
907 CLASSTYPE_SIZE (rec
) = size_int (const_size
);
909 CLASSTYPE_SIZE (rec
) = integer_zero_node
;
910 CLASSTYPE_ALIGN (rec
) = record_align
;
915 /* Hashing of lists so that we don't make duplicates.
916 The entry point is `list_hash_canon'. */
918 /* Each hash table slot is a bucket containing a chain
919 of these structures. */
923 struct list_hash
*next
; /* Next structure in the bucket. */
924 int hashcode
; /* Hash code of this list. */
925 tree list
; /* The list recorded here. */
928 /* Now here is the hash table. When recording a list, it is added
929 to the slot whose index is the hash code mod the table size.
930 Note that the hash table is used for several kinds of lists.
931 While all these live in the same table, they are completely independent,
932 and the hash code is computed differently for each of these. */
934 #define TYPE_HASH_SIZE 59
935 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
937 /* Compute a hash code for a list (chain of TREE_LIST nodes
938 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
939 TREE_COMMON slots), by adding the hash codes of the individual entries. */
942 list_hash (purpose
, value
, chain
)
943 tree purpose
, value
, chain
;
945 register int hashcode
= 0;
948 hashcode
+= TYPE_HASH (chain
);
951 hashcode
+= TYPE_HASH (value
);
955 hashcode
+= TYPE_HASH (purpose
);
961 /* Look in the type hash table for a type isomorphic to TYPE.
962 If one is found, return it. Otherwise return 0. */
965 list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
966 purpose
, value
, chain
)
967 int hashcode
, via_public
, via_virtual
, via_protected
;
968 tree purpose
, value
, chain
;
970 register struct list_hash
*h
;
972 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
973 if (h
->hashcode
== hashcode
974 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
975 && TREE_VIA_PUBLIC (h
->list
) == via_public
976 && TREE_VIA_PROTECTED (h
->list
) == via_protected
977 && TREE_PURPOSE (h
->list
) == purpose
978 && TREE_VALUE (h
->list
) == value
979 && TREE_CHAIN (h
->list
) == chain
)
984 /* Add an entry to the list-hash-table
985 for a list TYPE whose hash code is HASHCODE. */
988 list_hash_add (hashcode
, list
)
992 register struct list_hash
*h
;
994 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
995 h
->hashcode
= hashcode
;
997 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
998 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1001 /* Given TYPE, and HASHCODE its hash code, return the canonical
1002 object for an identical list if one already exists.
1003 Otherwise, return TYPE, and record it as the canonical object
1004 if it is a permanent object.
1006 To use this function, first create a list of the sort you want.
1007 Then compute its hash code from the fields of the list that
1008 make it different from other similar lists.
1009 Then call this function and use the value.
1010 This function frees the list you pass in if it is a duplicate. */
1012 /* Set to 1 to debug without canonicalization. Never set by program. */
1014 static int debug_no_list_hash
= 0;
1017 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1018 int via_public
, via_virtual
, via_protected
;
1019 tree purpose
, value
, chain
;
1021 struct obstack
*ambient_obstack
= current_obstack
;
1025 if (! debug_no_list_hash
)
1027 hashcode
= list_hash (purpose
, value
, chain
);
1028 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1029 purpose
, value
, chain
);
1034 current_obstack
= &class_obstack
;
1036 t
= tree_cons (purpose
, value
, chain
);
1037 TREE_VIA_PUBLIC (t
) = via_public
;
1038 TREE_VIA_PROTECTED (t
) = via_protected
;
1039 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1041 /* If this is a new list, record it for later reuse. */
1042 if (! debug_no_list_hash
)
1043 list_hash_add (hashcode
, t
);
1045 current_obstack
= ambient_obstack
;
1049 /* Constructor for hashed lists. */
1052 hash_tree_chain (value
, chain
)
1055 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1058 /* Similar, but used for concatenating two lists. */
1061 hash_chainon (list1
, list2
)
1068 if (TREE_CHAIN (list1
) == NULL_TREE
)
1069 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1070 return hash_tree_chain (TREE_VALUE (list1
),
1071 hash_chainon (TREE_CHAIN (list1
), list2
));
1075 get_identifier_list (value
)
1078 tree list
= IDENTIFIER_AS_LIST (value
);
1079 if (list
!= NULL_TREE
1080 && (TREE_CODE (list
) != TREE_LIST
1081 || TREE_VALUE (list
) != value
))
1083 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1084 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1085 && IDENTIFIER_TYPE_VALUE (value
)
1086 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1088 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1090 if (TYPE_PTRMEMFUNC_P (type
))
1092 else if (type
== current_class_type
)
1093 /* Don't mess up the constructor name. */
1094 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1097 if (! CLASSTYPE_ID_AS_LIST (type
))
1098 CLASSTYPE_ID_AS_LIST (type
)
1099 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1100 list
= CLASSTYPE_ID_AS_LIST (type
);
1107 get_decl_list (value
)
1110 tree list
= NULL_TREE
;
1112 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1113 list
= get_identifier_list (value
);
1114 else if (TREE_CODE (value
) == RECORD_TYPE
1115 && TYPE_LANG_SPECIFIC (value
)
1116 && value
== TYPE_MAIN_VARIANT (value
))
1117 list
= CLASSTYPE_AS_LIST (value
);
1119 if (list
!= NULL_TREE
)
1121 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1125 return build_decl_list (NULL_TREE
, value
);
1128 /* Build an association between TYPE and some parameters:
1130 OFFSET is the offset added to `this' to convert it to a pointer
1133 BINFO is the base binfo to use, if we are deriving from one. This
1134 is necessary, as we want specialized parent binfos from base
1135 classes, so that the VTABLE_NAMEs of bases are for the most derived
1136 type, instead of of the simple type.
1138 VTABLE is the virtual function table with which to initialize
1139 sub-objects of type TYPE.
1141 VIRTUALS are the virtual functions sitting in VTABLE.
1143 CHAIN are more associations we must retain. */
1146 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1148 tree vtable
, virtuals
;
1151 tree new_binfo
= make_tree_vec (6);
1154 if (TREE_CODE (binfo
) == TREE_VEC
)
1155 type
= BINFO_TYPE (binfo
);
1159 binfo
= TYPE_BINFO (binfo
);
1162 TREE_CHAIN (new_binfo
) = chain
;
1164 TREE_USED (new_binfo
) = TREE_USED (chain
);
1166 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1167 BINFO_OFFSET (new_binfo
) = offset
;
1168 BINFO_VTABLE (new_binfo
) = vtable
;
1169 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1170 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1172 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1173 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1177 /* Return the binfo value for ELEM in TYPE. */
1180 binfo_value (elem
, type
)
1184 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1185 compiler_error ("base class `%s' ambiguous in binfo_value",
1186 TYPE_NAME_STRING (elem
));
1188 return TYPE_BINFO (type
);
1189 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1191 return get_binfo (elem
, type
, 0);
1198 register tree prev
= 0, tmp
, next
;
1199 for (tmp
= path
; tmp
; tmp
= next
)
1201 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1202 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1212 unsigned HOST_WIDE_INT n
;
1215 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1216 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1217 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1218 fprintf (stderr
, "vtable type:\n");
1219 debug_tree (BINFO_TYPE (elem
));
1220 if (BINFO_VTABLE (elem
))
1221 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1223 fprintf (stderr
, "no vtable decl yet\n");
1224 fprintf (stderr
, "virtuals:\n");
1225 virtuals
= BINFO_VIRTUALS (elem
);
1227 n
= skip_rtti_stuff (&virtuals
);
1231 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1232 fprintf (stderr
, "%s [%d =? %d]\n",
1233 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1234 n
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1236 virtuals
= TREE_CHAIN (virtuals
);
1240 /* Return the length of a chain of nodes chained through DECL_CHAIN.
1241 We expect a null pointer to mark the end of the chain.
1242 This is the Lisp primitive `length'. */
1245 decl_list_length (t
)
1249 register int len
= 0;
1251 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
1252 || TREE_CODE (t
) == TEMPLATE_DECL
, 300);
1253 for (tail
= t
; tail
; tail
= DECL_CHAIN (tail
))
1263 if (TREE_CODE (t
) == FUNCTION_DECL
)
1265 else if (TREE_CODE (t
) == TREE_LIST
)
1266 return decl_list_length (TREE_VALUE (t
));
1268 my_friendly_abort (359);
1273 is_overloaded_fn (x
)
1276 if (TREE_CODE (x
) == FUNCTION_DECL
)
1279 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1282 if (TREE_CODE (x
) == TREE_LIST
1283 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1284 || TREE_CODE (TREE_VALUE (x
)) == TEMPLATE_DECL
))
1291 really_overloaded_fn (x
)
1294 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
1297 if (TREE_CODE (x
) == TREE_LIST
1298 && (TREE_CODE (TREE_VALUE (x
)) == FUNCTION_DECL
1299 || DECL_FUNCTION_TEMPLATE_P (TREE_VALUE (x
))))
1309 if (TREE_CODE (from
) == FUNCTION_DECL
1310 || DECL_FUNCTION_TEMPLATE_P (from
))
1313 my_friendly_assert (TREE_CODE (from
) == TREE_LIST
, 9);
1315 return TREE_VALUE (from
);
1319 is_aggr_type_2 (t1
, t2
)
1322 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1324 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1327 #define PRINT_RING_SIZE 4
1330 lang_printable_name (decl
, v
)
1334 static tree decl_ring
[PRINT_RING_SIZE
];
1335 static char *print_ring
[PRINT_RING_SIZE
];
1336 static int ring_counter
;
1339 /* Only cache functions. */
1341 || TREE_CODE (decl
) != FUNCTION_DECL
1342 || DECL_LANG_SPECIFIC (decl
) == 0)
1343 return lang_decl_name (decl
, v
);
1345 /* See if this print name is lying around. */
1346 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1347 if (decl_ring
[i
] == decl
)
1348 /* yes, so return it. */
1349 return print_ring
[i
];
1351 if (++ring_counter
== PRINT_RING_SIZE
)
1354 if (current_function_decl
!= NULL_TREE
)
1356 if (decl_ring
[ring_counter
] == current_function_decl
)
1358 if (ring_counter
== PRINT_RING_SIZE
)
1360 if (decl_ring
[ring_counter
] == current_function_decl
)
1361 my_friendly_abort (106);
1364 if (print_ring
[ring_counter
])
1365 free (print_ring
[ring_counter
]);
1367 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1368 decl_ring
[ring_counter
] = decl
;
1369 return print_ring
[ring_counter
];
1372 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1373 listed in RAISES. */
1376 build_exception_variant (type
, raises
)
1380 tree v
= TYPE_MAIN_VARIANT (type
);
1381 int constp
= TYPE_READONLY (type
);
1382 int volatilep
= TYPE_VOLATILE (type
);
1384 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1386 if (TYPE_READONLY (v
) != constp
1387 || TYPE_VOLATILE (v
) != volatilep
)
1390 /* @@ This should do set equality, not exact match. */
1391 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1392 /* List of exceptions raised matches previously found list.
1394 @@ Nice to free up storage used in consing up the
1395 @@ list of exceptions raised. */
1399 /* Need to build a new variant. */
1400 v
= build_type_copy (type
);
1402 if (raises
&& ! TREE_PERMANENT (raises
))
1404 push_obstacks_nochange ();
1405 end_temporary_allocation ();
1406 raises
= copy_list (raises
);
1410 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1414 /* Subroutine of copy_to_permanent
1416 Assuming T is a node build bottom-up, make it all exist on
1417 permanent obstack, if it is not permanent already. */
1422 tree (*func
) PROTO((tree
));
1429 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1432 switch (TREE_CODE (t
))
1435 return error_mark_node
;
1444 tree chain
= TREE_CHAIN (t
);
1446 TREE_CHAIN (t
) = mapcar (chain
, func
);
1447 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1448 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1449 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1455 tree chain
= TREE_CHAIN (t
);
1457 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1458 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1459 TREE_CHAIN (t
) = mapcar (chain
, func
);
1465 int len
= TREE_VEC_LENGTH (t
);
1469 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1476 return copy_node (t
);
1482 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1483 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1484 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1489 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1496 case TRUNC_DIV_EXPR
:
1497 case TRUNC_MOD_EXPR
:
1505 case BIT_ANDTC_EXPR
:
1506 case TRUTH_ANDIF_EXPR
:
1507 case TRUTH_ORIF_EXPR
:
1515 case FLOOR_DIV_EXPR
:
1516 case ROUND_DIV_EXPR
:
1518 case FLOOR_MOD_EXPR
:
1519 case ROUND_MOD_EXPR
:
1521 case PREDECREMENT_EXPR
:
1522 case PREINCREMENT_EXPR
:
1523 case POSTDECREMENT_EXPR
:
1524 case POSTINCREMENT_EXPR
:
1528 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1529 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1534 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1535 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1536 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1538 /* tree.def says that operand two is RTL, but
1539 build_call_declarator puts trees in there. */
1540 if (TREE_OPERAND (t
, 2)
1541 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1542 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1544 TREE_OPERAND (t
, 2) = NULL_TREE
;
1552 case TRUTH_NOT_EXPR
:
1556 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1560 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1561 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1562 case REFERENCE_TYPE
:
1563 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1564 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1566 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1567 mapcar (TYPE_ARG_TYPES (t
), func
));
1568 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1570 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
1571 mapcar (TYPE_DOMAIN (t
), func
));
1572 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1574 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1575 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1577 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1578 mapcar (TREE_TYPE (t
), func
));
1579 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1581 tmp
= build_cplus_method_type
1582 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
1583 mapcar (TREE_TYPE (t
), func
),
1584 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
1585 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1589 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
1590 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
1595 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
1599 if (TYPE_PTRMEMFUNC_P (t
))
1600 return build_ptrmemfunc_type
1601 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1602 /* else fall through */
1604 /* This list is incomplete, but should suffice for now.
1605 It is very important that `sorry' not call
1606 `report_error_function'. That could cause an infinite loop. */
1608 sorry ("initializer contains unrecognized tree code");
1609 return error_mark_node
;
1612 my_friendly_abort (107);
1621 if (TREE_PERMANENT (t
))
1623 /* Support `void f () { extern int i; A<&i> a; }' */
1624 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
1626 return copy_node (t
);
1630 /* Assuming T is a node built bottom-up, make it all exist on
1631 permanent obstack, if it is not permanent already. */
1634 copy_to_permanent (t
)
1637 register struct obstack
*ambient_obstack
= current_obstack
;
1638 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
1639 register struct obstack
*ambient_expression_obstack
= expression_obstack
;
1641 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1644 saveable_obstack
= &permanent_obstack
;
1645 current_obstack
= saveable_obstack
;
1646 expression_obstack
= saveable_obstack
;
1648 t
= mapcar (t
, perm_manip
);
1650 current_obstack
= ambient_obstack
;
1651 saveable_obstack
= ambient_saveable_obstack
;
1652 expression_obstack
= ambient_expression_obstack
;
1657 #ifdef GATHER_STATISTICS
1658 extern int depth_reached
;
1662 print_lang_statistics ()
1664 extern struct obstack decl_obstack
;
1665 print_obstack_statistics ("class_obstack", &class_obstack
);
1666 print_obstack_statistics ("decl_obstack", &decl_obstack
);
1667 print_search_statistics ();
1668 print_class_statistics ();
1669 #ifdef GATHER_STATISTICS
1670 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1675 /* This is used by the `assert' macro. It is provided in libgcc.a,
1676 which `cc' doesn't know how to link. Note that the C++ front-end
1677 no longer actually uses the `assert' macro (instead, it calls
1678 my_friendly_assert). But all of the back-end files still need this. */
1681 __eprintf (string
, expression
, line
, filename
)
1684 const char *expression
;
1686 const char *filename
;
1694 fprintf (stderr
, string
, expression
, line
, filename
);
1699 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1700 (which is an ARRAY_TYPE). This counts only elements of the top
1704 array_type_nelts_top (type
)
1707 return fold (build (PLUS_EXPR
, sizetype
,
1708 array_type_nelts (type
),
1712 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1713 (which is an ARRAY_TYPE). This one is a recursive count of all
1714 ARRAY_TYPEs that are clumped together. */
1717 array_type_nelts_total (type
)
1720 tree sz
= array_type_nelts_top (type
);
1721 type
= TREE_TYPE (type
);
1722 while (TREE_CODE (type
) == ARRAY_TYPE
)
1724 tree n
= array_type_nelts_top (type
);
1725 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1726 type
= TREE_TYPE (type
);
1736 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1738 else if (TREE_CODE (t
) == TARGET_EXPR
)
1740 if (TREE_CODE (TREE_OPERAND (t
, 1)) == NEW_EXPR
)
1742 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1743 return build_cplus_new
1744 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1747 TREE_OPERAND (t
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
1748 layout_decl (TREE_OPERAND (t
, 0), 0);
1751 else if (TREE_CODE (t
) == CALL_EXPR
)
1752 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1757 /* Actually, we'll just clean out the target exprs for the moment. */
1760 break_out_target_exprs (t
)
1763 return mapcar (t
, bot_manip
);
1766 /* Obstack used for allocating nodes in template function and variable
1769 /* Similar to `build_nt', except we build
1770 on the permanent_obstack, regardless. */
1773 build_min_nt
VPROTO((enum tree_code code
, ...))
1776 enum tree_code code
;
1778 register struct obstack
*ambient_obstack
= expression_obstack
;
1781 register int length
;
1787 code
= va_arg (p
, enum tree_code
);
1790 expression_obstack
= &permanent_obstack
;
1792 t
= make_node (code
);
1793 length
= tree_code_length
[(int) code
];
1794 TREE_COMPLEXITY (t
) = lineno
;
1796 for (i
= 0; i
< length
; i
++)
1798 tree x
= va_arg (p
, tree
);
1799 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1803 expression_obstack
= ambient_obstack
;
1807 /* Similar to `build', except we build
1808 on the permanent_obstack, regardless. */
1811 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
1814 enum tree_code code
;
1817 register struct obstack
*ambient_obstack
= expression_obstack
;
1820 register int length
;
1826 code
= va_arg (p
, enum tree_code
);
1827 tt
= va_arg (p
, tree
);
1830 expression_obstack
= &permanent_obstack
;
1832 t
= make_node (code
);
1833 length
= tree_code_length
[(int) code
];
1835 TREE_COMPLEXITY (t
) = lineno
;
1837 for (i
= 0; i
< length
; i
++)
1839 tree x
= va_arg (p
, tree
);
1840 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1844 expression_obstack
= ambient_obstack
;
1848 /* Same as `tree_cons' but make a permanent object. */
1851 min_tree_cons (purpose
, value
, chain
)
1852 tree purpose
, value
, chain
;
1855 register struct obstack
*ambient_obstack
= current_obstack
;
1856 current_obstack
= &permanent_obstack
;
1858 node
= tree_cons (copy_to_permanent (purpose
),
1859 copy_to_permanent (value
), chain
);
1860 current_obstack
= ambient_obstack
;
1868 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
1869 return identifier_typedecl_value (t
);
1870 if (TREE_CODE (t
) == TYPE_DECL
)
1872 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
1873 return TYPE_STUB_DECL (t
);
1875 my_friendly_abort (42);
1879 can_free (obstack
, t
)
1880 struct obstack
*obstack
;
1885 if (TREE_CODE (t
) == TREE_VEC
)
1886 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1888 my_friendly_abort (42);
1890 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1891 & ~ obstack_alignment_mask (obstack))
1892 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1899 /* Return first vector element whose BINFO_TYPE is ELEM.
1900 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1903 vec_binfo_member (elem
, vec
)
1909 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1910 if (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
1911 return TREE_VEC_ELT (vec
, i
);
1916 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
1917 the wrong thing for decl_function_context. Hopefully the uses in the
1918 backend won't matter, since we don't need a static chain for local class
1922 hack_decl_function_context (decl
)
1925 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
1926 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
1927 return decl_function_context (decl
);
1930 /* Return truthvalue of whether T1 is the same tree structure as T2.
1931 Return 1 if they are the same.
1932 Return 0 if they are understandably different.
1933 Return -1 if either contains tree structure not understood by
1937 cp_tree_equal (t1
, t2
)
1940 register enum tree_code code1
, code2
;
1945 if (t1
== 0 || t2
== 0)
1948 code1
= TREE_CODE (t1
);
1949 code2
= TREE_CODE (t2
);
1951 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1952 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1953 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1955 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1956 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1957 || code2
== NON_LVALUE_EXPR
)
1958 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1966 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1967 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1970 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1973 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1974 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1975 TREE_STRING_LENGTH (t1
));
1981 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1984 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1987 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1990 /* Special case: if either target is an unallocated VAR_DECL,
1991 it means that it's going to be unified with whatever the
1992 TARGET_EXPR is really supposed to initialize, so treat it
1993 as being equivalent to anything. */
1994 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1995 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1996 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
1997 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1998 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1999 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2002 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2005 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2007 case WITH_CLEANUP_EXPR
:
2008 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2011 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2014 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2015 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2024 case TEMPLATE_CONST_PARM
:
2025 return TEMPLATE_CONST_IDX (t1
) == TEMPLATE_CONST_IDX (t2
)
2026 && TEMPLATE_CONST_LEVEL (t1
) == TEMPLATE_CONST_LEVEL (t2
);
2029 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2031 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2032 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2036 switch (TREE_CODE_CLASS (code1
))
2046 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2048 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2058 /* Similar to make_tree_vec, but build on a temporary obstack. */
2065 register struct obstack
*ambient_obstack
= current_obstack
;
2066 current_obstack
= expression_obstack
;
2067 node
= make_tree_vec (len
);
2068 current_obstack
= ambient_obstack
;
2073 push_expression_obstack ()
2075 push_obstacks_nochange ();
2076 current_obstack
= expression_obstack
;
2079 /* The type of ARG when used as an lvalue. */
2085 return cp_build_type_variant
2086 (TREE_TYPE (arg
), TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
2089 /* The type of ARG for printing error messages; denote lvalues with
2096 tree type
= TREE_TYPE (arg
);
2097 if (TREE_CODE (type
) == ARRAY_TYPE
)
2099 else if (real_lvalue_p (arg
))
2100 type
= build_reference_type (lvalue_type (arg
));
2101 else if (IS_AGGR_TYPE (type
))
2102 type
= lvalue_type (arg
);
2107 /* Does FUNCTION use a variable-length argument list? */
2110 varargs_function_p (function
)
2113 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2114 for (; parm
; parm
= TREE_CHAIN (parm
))
2115 if (TREE_VALUE (parm
) == void_type_node
)