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. */
37 extern void compiler_error ();
39 static tree get_identifier_list
PROTO((tree
));
40 static tree bot_manip
PROTO((tree
));
41 static tree perm_manip
PROTO((tree
));
42 static tree build_cplus_array_type_1
PROTO((tree
, tree
));
43 static void list_hash_add
PROTO((int, tree
));
44 static int list_hash
PROTO((tree
, tree
, tree
));
45 static tree list_hash_lookup
PROTO((int, int, int, int, tree
, tree
,
47 static void propagate_binfo_offsets
PROTO((tree
, tree
));
48 static void unshare_base_binfos
PROTO((tree
));
49 static int avoid_overlap
PROTO((tree
, tree
));
51 #define CEIL(x,y) (((x) + (y) - 1) / (y))
53 /* Return nonzero if REF is an lvalue valid for this language.
54 Lvalues can be assigned, unless they have TREE_READONLY.
55 Lvalues can have their address taken, unless they have DECL_REGISTER. */
61 if (! language_lvalue_valid (ref
))
64 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
67 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
70 switch (TREE_CODE (ref
))
72 /* preincrements and predecrements are valid lvals, provided
73 what they refer to are valid lvals. */
74 case PREINCREMENT_EXPR
:
75 case PREDECREMENT_EXPR
:
80 case WITH_CLEANUP_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)));
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)));
221 /* Return nonzero if REF is an lvalue valid for this language;
222 otherwise, print an error message and return zero. */
225 lvalue_or_else (ref
, string
)
229 int win
= lvalue_p (ref
);
231 error ("non-lvalue in %s", string
);
235 /* INIT is a CALL_EXPR which needs info about its target.
236 TYPE is the type that this initialization should appear to have.
238 Build an encapsulation of the initialization to perform
239 and return it so that it can be processed by language-independent
240 and language-specific expression expanders. */
243 build_cplus_new (type
, init
)
250 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
253 slot
= build (VAR_DECL
, type
);
254 DECL_ARTIFICIAL (slot
) = 1;
255 layout_decl (slot
, 0);
256 rval
= build (AGGR_INIT_EXPR
, type
,
257 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
258 TREE_SIDE_EFFECTS (rval
) = 1;
259 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
260 TREE_SIDE_EFFECTS (rval
) = 1;
265 /* Encapsulate the expression INIT in a TARGET_EXPR. */
268 get_target_expr (init
)
274 slot
= build (VAR_DECL
, TREE_TYPE (init
));
275 DECL_ARTIFICIAL (slot
) = 1;
276 layout_decl (slot
, 0);
277 rval
= build (TARGET_EXPR
, TREE_TYPE (init
), slot
, init
,
278 NULL_TREE
, NULL_TREE
);
279 TREE_SIDE_EFFECTS (rval
) = 1;
284 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
285 these CALL_EXPRs with tree nodes that will perform the cleanups. */
288 break_out_cleanups (exp
)
293 if (TREE_CODE (tmp
) == CALL_EXPR
294 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
295 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
297 while (TREE_CODE (tmp
) == NOP_EXPR
298 || TREE_CODE (tmp
) == CONVERT_EXPR
299 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
301 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
302 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
304 TREE_OPERAND (tmp
, 0)
305 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
306 TREE_OPERAND (tmp
, 0));
310 tmp
= TREE_OPERAND (tmp
, 0);
315 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
316 copies where they are found. Returns a deep copy all nodes transitively
317 containing CALL_EXPRs. */
320 break_out_calls (exp
)
323 register tree t1
, t2
= NULL_TREE
;
324 register enum tree_code code
;
325 register int changed
= 0;
328 if (exp
== NULL_TREE
)
331 code
= TREE_CODE (exp
);
333 if (code
== CALL_EXPR
)
334 return copy_node (exp
);
336 /* Don't try and defeat a save_expr, as it should only be done once. */
337 if (code
== SAVE_EXPR
)
340 switch (TREE_CODE_CLASS (code
))
345 case 'c': /* a constant */
346 case 't': /* a type node */
347 case 'x': /* something random, like an identifier or an ERROR_MARK. */
350 case 'd': /* A decl node */
351 #if 0 /* This is bogus. jason 9/21/94 */
353 t1
= break_out_calls (DECL_INITIAL (exp
));
354 if (t1
!= DECL_INITIAL (exp
))
356 exp
= copy_node (exp
);
357 DECL_INITIAL (exp
) = t1
;
362 case 'b': /* A block node */
364 /* Don't know how to handle these correctly yet. Must do a
365 break_out_calls on all DECL_INITIAL values for local variables,
366 and also break_out_calls on all sub-blocks and sub-statements. */
371 case 'e': /* an expression */
372 case 'r': /* a reference */
373 case 's': /* an expression with side effects */
374 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
376 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
377 if (t1
!= TREE_OPERAND (exp
, i
))
379 exp
= copy_node (exp
);
380 TREE_OPERAND (exp
, i
) = t1
;
385 case '<': /* a comparison expression */
386 case '2': /* a binary arithmetic expression */
387 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
388 if (t2
!= TREE_OPERAND (exp
, 1))
390 case '1': /* a unary arithmetic expression */
391 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
392 if (t1
!= TREE_OPERAND (exp
, 0))
396 if (tree_code_length
[(int) code
] == 1)
397 return build1 (code
, TREE_TYPE (exp
), t1
);
399 return build (code
, TREE_TYPE (exp
), t1
, t2
);
406 extern struct obstack
*current_obstack
;
407 extern struct obstack permanent_obstack
, class_obstack
;
408 extern struct obstack
*saveable_obstack
;
409 extern struct obstack
*expression_obstack
;
411 /* Here is how primitive or already-canonicalized types' hash
412 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
413 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
415 /* Construct, lay out and return the type of methods belonging to class
416 BASETYPE and whose arguments are described by ARGTYPES and whose values
417 are described by RETTYPE. If each type exists already, reuse it. */
420 build_cplus_method_type (basetype
, rettype
, argtypes
)
421 tree basetype
, rettype
, argtypes
;
427 /* Make a node of the sort we want. */
428 t
= make_node (METHOD_TYPE
);
430 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
431 TREE_TYPE (t
) = rettype
;
432 if (IS_SIGNATURE (basetype
))
433 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
434 TYPE_READONLY (basetype
),
435 TYPE_VOLATILE (basetype
));
437 ptype
= build_pointer_type (basetype
);
439 /* The actual arglist for this function includes a "hidden" argument
440 which is "this". Put it into the list of argument types. */
442 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
443 TYPE_ARG_TYPES (t
) = argtypes
;
444 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
446 /* If we already have such a type, use the old one and free this one.
447 Note that it also frees up the above cons cell if found. */
448 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
449 t
= type_hash_canon (hashcode
, t
);
451 if (TYPE_SIZE (t
) == 0)
458 build_cplus_array_type_1 (elt_type
, index_type
)
462 register struct obstack
*ambient_obstack
= current_obstack
;
463 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
466 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
467 make this permanent too. */
468 if (TREE_PERMANENT (elt_type
)
469 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
471 current_obstack
= &permanent_obstack
;
472 saveable_obstack
= &permanent_obstack
;
475 if (processing_template_decl
)
477 t
= make_node (ARRAY_TYPE
);
478 TREE_TYPE (t
) = elt_type
;
479 TYPE_DOMAIN (t
) = index_type
;
482 t
= build_array_type (elt_type
, index_type
);
484 /* Push these needs up so that initialization takes place
486 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
487 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
488 current_obstack
= ambient_obstack
;
489 saveable_obstack
= ambient_saveable_obstack
;
494 build_cplus_array_type (elt_type
, index_type
)
499 int constp
= TYPE_READONLY (elt_type
);
500 int volatilep
= TYPE_VOLATILE (elt_type
);
501 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
503 t
= build_cplus_array_type_1 (elt_type
, index_type
);
505 if (constp
|| volatilep
)
506 t
= cp_build_type_variant (t
, constp
, volatilep
);
511 /* Make a variant type in the proper way for C/C++, propagating qualifiers
512 down to the element type of an array. */
515 cp_build_type_variant (type
, constp
, volatilep
)
517 int constp
, volatilep
;
519 if (type
== error_mark_node
)
522 if (TREE_CODE (type
) == ARRAY_TYPE
)
524 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
526 push_obstacks (TYPE_OBSTACK (real_main_variant
),
527 TYPE_OBSTACK (real_main_variant
));
528 type
= build_cplus_array_type_1 (cp_build_type_variant
529 (TREE_TYPE (type
), constp
, volatilep
),
532 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
533 make a copy. (TYPE might have come from the hash table and
534 REAL_MAIN_VARIANT might be in some function's obstack.) */
536 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
538 type
= copy_node (type
);
539 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
542 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
546 return build_type_variant (type
, constp
, volatilep
);
549 /* Add OFFSET to all base types of T.
551 OFFSET, which is a type offset, is number of bytes.
553 Note that we don't have to worry about having two paths to the
554 same base type, since this type owns its association list. */
557 propagate_binfo_offsets (binfo
, offset
)
561 tree binfos
= BINFO_BASETYPES (binfo
);
562 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
564 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
566 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
568 if (TREE_VIA_VIRTUAL (base_binfo
))
573 tree delta
= NULL_TREE
;
575 for (j
= i
+1; j
< n_baselinks
; j
++)
576 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
578 /* The next basetype offset must take into account the space
579 between the classes, not just the size of each class. */
580 delta
= size_binop (MINUS_EXPR
,
581 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
582 BINFO_OFFSET (base_binfo
));
587 if (BINFO_OFFSET_ZEROP (base_binfo
))
588 BINFO_OFFSET (base_binfo
) = offset
;
590 BINFO_OFFSET (base_binfo
)
591 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
593 BINFO_OFFSET (base_binfo
) = offset
;
596 unshare_base_binfos (base_binfo
);
598 /* Go to our next class that counts for offset propagation. */
601 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
606 /* Makes new binfos for the indirect bases under BASE_BINFO, and updates
607 BINFO_OFFSET for them and their bases. */
610 unshare_base_binfos (base_binfo
)
613 if (BINFO_BASETYPES (base_binfo
))
615 tree base_binfos
= BINFO_BASETYPES (base_binfo
);
616 tree chain
= NULL_TREE
;
619 /* Now unshare the structure beneath BASE_BINFO. */
620 for (j
= TREE_VEC_LENGTH (base_binfos
)-1;
623 tree base_base_binfo
= TREE_VEC_ELT (base_binfos
, j
);
624 if (! TREE_VIA_VIRTUAL (base_base_binfo
))
625 TREE_VEC_ELT (base_binfos
, j
)
626 = make_binfo (BINFO_OFFSET (base_base_binfo
),
628 BINFO_VTABLE (base_base_binfo
),
629 BINFO_VIRTUALS (base_base_binfo
),
631 chain
= TREE_VEC_ELT (base_binfos
, j
);
632 TREE_VIA_PUBLIC (chain
) = TREE_VIA_PUBLIC (base_base_binfo
);
633 TREE_VIA_PROTECTED (chain
) = TREE_VIA_PROTECTED (base_base_binfo
);
634 BINFO_INHERITANCE_CHAIN (chain
) = base_binfo
;
637 /* Completely unshare potentially shared data, and
638 update what is ours. */
639 propagate_binfo_offsets (base_binfo
, BINFO_OFFSET (base_binfo
));
643 /* Finish the work of layout_record, now taking virtual bases into account.
644 Also compute the actual offsets that our base classes will have.
645 This must be performed after the fields are laid out, since virtual
646 baseclasses must lay down at the end of the record.
648 Returns the maximum number of virtual functions any of the
649 baseclasses provide. */
652 layout_basetypes (rec
, max
)
656 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
657 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
659 /* Get all the virtual base types that this type uses.
660 The TREE_VALUE slot holds the virtual baseclass type. */
661 tree vbase_types
= get_vbase_types (rec
);
663 unsigned int record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
664 unsigned int desired_align
;
666 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
667 register unsigned int const_size
= 0;
668 unsigned int nonvirtual_const_size
;
670 #ifdef STRUCTURE_SIZE_BOUNDARY
671 /* Packed structures don't need to have minimum size. */
672 if (! TYPE_PACKED (rec
))
673 record_align
= MAX (record_align
, STRUCTURE_SIZE_BOUNDARY
);
676 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
;
678 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
, 19970302);
679 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
681 nonvirtual_const_size
= const_size
;
685 tree basetype
= BINFO_TYPE (vbase_types
);
688 desired_align
= TYPE_ALIGN (basetype
);
689 record_align
= MAX (record_align
, desired_align
);
692 offset
= integer_zero_node
;
695 /* Give each virtual base type the alignment it wants. */
696 const_size
= CEIL (const_size
, desired_align
) * desired_align
;
697 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
700 if (CLASSTYPE_VSIZE (basetype
) > max
)
701 max
= CLASSTYPE_VSIZE (basetype
);
702 BINFO_OFFSET (vbase_types
) = offset
;
704 /* Every virtual baseclass takes a least a UNIT, so that we can
705 take it's address and get something different for each base. */
706 const_size
+= MAX (BITS_PER_UNIT
,
707 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype
)));
709 vbase_types
= TREE_CHAIN (vbase_types
);
714 /* Because a virtual base might take a single byte above,
715 we have to re-adjust the total size to make sure it is
716 a multiple of the alignment. */
717 /* Give the whole object the alignment it wants. */
718 const_size
= CEIL (const_size
, record_align
) * record_align
;
721 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
722 here, as that is for this class, without any virtual base classes. */
723 TYPE_ALIGN (rec
) = record_align
;
724 if (const_size
!= nonvirtual_const_size
)
725 TYPE_SIZE (rec
) = size_int (const_size
);
727 /* Now propagate offset information throughout the lattice. */
728 for (i
= 0; i
< n_baseclasses
; i
++)
730 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
731 register tree basetype
= BINFO_TYPE (base_binfo
);
732 tree field
= TYPE_FIELDS (rec
);
734 if (TREE_VIA_VIRTUAL (base_binfo
))
737 my_friendly_assert (TREE_TYPE (field
) == basetype
, 23897);
738 BINFO_OFFSET (base_binfo
)
739 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
)),
741 unshare_base_binfos (base_binfo
);
742 TYPE_FIELDS (rec
) = TREE_CHAIN (field
);
745 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
746 vbase_types
= TREE_CHAIN (vbase_types
))
748 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
749 unshare_base_binfos (vbase_types
);
755 /* If the empty base field in DECL overlaps with a base of the same type in
756 NEWDECL, which is either another base field or the first data field of
757 the class, pad the base just before NEWDECL and return 1. Otherwise,
761 avoid_overlap (decl
, newdecl
)
766 if (newdecl
== NULL_TREE
767 || ! types_overlap_p (TREE_TYPE (decl
), TREE_TYPE (newdecl
)))
770 for (field
= decl
; TREE_CHAIN (field
) && TREE_CHAIN (field
) != newdecl
;
771 field
= TREE_CHAIN (field
))
774 DECL_SIZE (field
) = integer_one_node
;
779 /* Returns a list of fields to stand in for the base class subobjects
780 of REC. These fields are later removed by layout_basetypes. */
783 build_base_fields (rec
)
786 /* Chain to hold all the new FIELD_DECLs which stand in for base class
788 tree base_decls
= NULL_TREE
;
789 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
790 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
792 int i
, saw_empty
= 0;
793 unsigned int base_align
= 0;
795 for (i
= 0; i
< n_baseclasses
; ++i
)
797 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
798 register tree basetype
= BINFO_TYPE (base_binfo
);
800 if (TYPE_SIZE (basetype
) == 0)
801 /* This error is now reported in xref_tag, thus giving better
802 location information. */
805 if (TREE_VIA_VIRTUAL (base_binfo
))
808 decl
= build_lang_field_decl (FIELD_DECL
, NULL_TREE
, basetype
);
809 DECL_ARTIFICIAL (decl
) = 1;
810 DECL_FIELD_CONTEXT (decl
) = DECL_CLASS_CONTEXT (decl
) = rec
;
811 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
812 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
813 TREE_CHAIN (decl
) = base_decls
;
818 /* Brain damage for backwards compatibility. For no good reason,
819 the old layout_basetypes made every base at least as large as
820 the alignment for the bases up to that point, gratuitously
821 wasting space. So we do the same thing here. */
822 base_align
= MAX (base_align
, DECL_ALIGN (decl
));
824 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl
)),
827 else if (DECL_SIZE (decl
) == integer_zero_node
)
831 /* Reverse the list of fields so we allocate the bases in the proper
833 base_decls
= nreverse (base_decls
);
835 /* In the presence of empty base classes, we run the risk of allocating
836 two objects of the same class on top of one another. Avoid that. */
837 if (flag_new_abi
&& saw_empty
)
838 for (decl
= base_decls
; decl
; decl
= TREE_CHAIN (decl
))
840 if (DECL_SIZE (decl
) == integer_zero_node
)
842 /* First step through the following bases until we find
843 an overlap or a non-empty base. */
844 for (nextdecl
= TREE_CHAIN (decl
); nextdecl
;
845 nextdecl
= TREE_CHAIN (nextdecl
))
847 if (avoid_overlap (decl
, nextdecl
)
848 || DECL_SIZE (nextdecl
) != integer_zero_node
)
852 /* If we're still looking, also check against the first
854 for (nextdecl
= TYPE_FIELDS (rec
);
855 nextdecl
&& TREE_CODE (nextdecl
) != FIELD_DECL
;
856 nextdecl
= TREE_CHAIN (nextdecl
))
858 avoid_overlap (decl
, nextdecl
);
866 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
869 build_vbase_pointer_fields (rec
)
872 /* Chain to hold all the new FIELD_DECLs which point at virtual
874 tree vbase_decls
= NULL_TREE
;
875 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
876 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
880 /* Handle basetypes almost like fields, but record their
881 offsets differently. */
883 for (i
= 0; i
< n_baseclasses
; i
++)
885 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
886 register tree basetype
= BINFO_TYPE (base_binfo
);
888 if (TYPE_SIZE (basetype
) == 0)
889 /* This error is now reported in xref_tag, thus giving better
890 location information. */
893 /* All basetypes are recorded in the association list of the
896 if (TREE_VIA_VIRTUAL (base_binfo
))
899 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
900 + sizeof (VBASE_NAME
) + 1);
902 /* The offset for a virtual base class is only used in computing
903 virtual function tables and for initializing virtual base
904 pointers. It is built once `get_vbase_types' is called. */
906 /* If this basetype can come from another vbase pointer
907 without an additional indirection, we will share
908 that pointer. If an indirection is involved, we
909 make our own pointer. */
910 for (j
= 0; j
< n_baseclasses
; j
++)
912 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
913 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
914 && binfo_member (basetype
,
915 CLASSTYPE_VBASECLASSES (BINFO_TYPE
920 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
921 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
922 build_pointer_type (basetype
));
923 /* If you change any of the below, take a look at all the
924 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
926 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
927 DECL_VIRTUAL_P (decl
) = 1;
928 DECL_ARTIFICIAL (decl
) = 1;
929 DECL_FIELD_CONTEXT (decl
) = rec
;
930 DECL_CLASS_CONTEXT (decl
) = rec
;
931 DECL_FCONTEXT (decl
) = basetype
;
932 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
933 DECL_FIELD_SIZE (decl
) = 0;
934 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
935 TREE_CHAIN (decl
) = vbase_decls
;
936 BINFO_VPTR_FIELD (base_binfo
) = decl
;
940 /* The space this decl occupies has already been accounted for. */
948 /* Hashing of lists so that we don't make duplicates.
949 The entry point is `list_hash_canon'. */
951 /* Each hash table slot is a bucket containing a chain
952 of these structures. */
956 struct list_hash
*next
; /* Next structure in the bucket. */
957 int hashcode
; /* Hash code of this list. */
958 tree list
; /* The list recorded here. */
961 /* Now here is the hash table. When recording a list, it is added
962 to the slot whose index is the hash code mod the table size.
963 Note that the hash table is used for several kinds of lists.
964 While all these live in the same table, they are completely independent,
965 and the hash code is computed differently for each of these. */
967 #define TYPE_HASH_SIZE 59
968 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
970 /* Compute a hash code for a list (chain of TREE_LIST nodes
971 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
972 TREE_COMMON slots), by adding the hash codes of the individual entries. */
975 list_hash (purpose
, value
, chain
)
976 tree purpose
, value
, chain
;
978 register int hashcode
= 0;
981 hashcode
+= TYPE_HASH (chain
);
984 hashcode
+= TYPE_HASH (value
);
988 hashcode
+= TYPE_HASH (purpose
);
994 /* Look in the type hash table for a type isomorphic to TYPE.
995 If one is found, return it. Otherwise return 0. */
998 list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
999 purpose
, value
, chain
)
1000 int hashcode
, via_public
, via_virtual
, via_protected
;
1001 tree purpose
, value
, chain
;
1003 register struct list_hash
*h
;
1005 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1006 if (h
->hashcode
== hashcode
1007 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
1008 && TREE_VIA_PUBLIC (h
->list
) == via_public
1009 && TREE_VIA_PROTECTED (h
->list
) == via_protected
1010 && TREE_PURPOSE (h
->list
) == purpose
1011 && TREE_VALUE (h
->list
) == value
1012 && TREE_CHAIN (h
->list
) == chain
)
1017 /* Add an entry to the list-hash-table
1018 for a list TYPE whose hash code is HASHCODE. */
1021 list_hash_add (hashcode
, list
)
1025 register struct list_hash
*h
;
1027 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
1028 h
->hashcode
= hashcode
;
1030 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
1031 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1034 /* Given TYPE, and HASHCODE its hash code, return the canonical
1035 object for an identical list if one already exists.
1036 Otherwise, return TYPE, and record it as the canonical object
1037 if it is a permanent object.
1039 To use this function, first create a list of the sort you want.
1040 Then compute its hash code from the fields of the list that
1041 make it different from other similar lists.
1042 Then call this function and use the value.
1043 This function frees the list you pass in if it is a duplicate. */
1045 /* Set to 1 to debug without canonicalization. Never set by program. */
1047 static int debug_no_list_hash
= 0;
1050 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1051 int via_public
, via_virtual
, via_protected
;
1052 tree purpose
, value
, chain
;
1054 struct obstack
*ambient_obstack
= current_obstack
;
1058 if (! debug_no_list_hash
)
1060 hashcode
= list_hash (purpose
, value
, chain
);
1061 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1062 purpose
, value
, chain
);
1067 current_obstack
= &class_obstack
;
1069 t
= tree_cons (purpose
, value
, chain
);
1070 TREE_VIA_PUBLIC (t
) = via_public
;
1071 TREE_VIA_PROTECTED (t
) = via_protected
;
1072 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1074 /* If this is a new list, record it for later reuse. */
1075 if (! debug_no_list_hash
)
1076 list_hash_add (hashcode
, t
);
1078 current_obstack
= ambient_obstack
;
1082 /* Constructor for hashed lists. */
1085 hash_tree_chain (value
, chain
)
1088 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1091 /* Similar, but used for concatenating two lists. */
1094 hash_chainon (list1
, list2
)
1101 if (TREE_CHAIN (list1
) == NULL_TREE
)
1102 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1103 return hash_tree_chain (TREE_VALUE (list1
),
1104 hash_chainon (TREE_CHAIN (list1
), list2
));
1108 get_identifier_list (value
)
1111 tree list
= IDENTIFIER_AS_LIST (value
);
1112 if (list
!= NULL_TREE
1113 && (TREE_CODE (list
) != TREE_LIST
1114 || TREE_VALUE (list
) != value
))
1116 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1117 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1118 && IDENTIFIER_TYPE_VALUE (value
)
1119 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1121 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1123 if (TYPE_PTRMEMFUNC_P (type
))
1125 else if (type
== current_class_type
)
1126 /* Don't mess up the constructor name. */
1127 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1130 if (! CLASSTYPE_ID_AS_LIST (type
))
1131 CLASSTYPE_ID_AS_LIST (type
)
1132 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1133 list
= CLASSTYPE_ID_AS_LIST (type
);
1140 get_decl_list (value
)
1143 tree list
= NULL_TREE
;
1145 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1146 list
= get_identifier_list (value
);
1147 else if (TREE_CODE (value
) == RECORD_TYPE
1148 && TYPE_LANG_SPECIFIC (value
)
1149 && value
== TYPE_MAIN_VARIANT (value
))
1150 list
= CLASSTYPE_AS_LIST (value
);
1152 if (list
!= NULL_TREE
)
1154 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1158 return build_decl_list (NULL_TREE
, value
);
1161 /* Build an association between TYPE and some parameters:
1163 OFFSET is the offset added to `this' to convert it to a pointer
1166 BINFO is the base binfo to use, if we are deriving from one. This
1167 is necessary, as we want specialized parent binfos from base
1168 classes, so that the VTABLE_NAMEs of bases are for the most derived
1169 type, instead of the simple type.
1171 VTABLE is the virtual function table with which to initialize
1172 sub-objects of type TYPE.
1174 VIRTUALS are the virtual functions sitting in VTABLE.
1176 CHAIN are more associations we must retain. */
1179 make_binfo (offset
, binfo
, vtable
, virtuals
, chain
)
1181 tree vtable
, virtuals
;
1184 tree new_binfo
= make_tree_vec (6);
1187 if (TREE_CODE (binfo
) == TREE_VEC
)
1188 type
= BINFO_TYPE (binfo
);
1192 binfo
= TYPE_BINFO (binfo
);
1195 TREE_CHAIN (new_binfo
) = chain
;
1197 TREE_USED (new_binfo
) = TREE_USED (chain
);
1199 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1200 BINFO_OFFSET (new_binfo
) = offset
;
1201 BINFO_VTABLE (new_binfo
) = vtable
;
1202 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1203 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1205 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1206 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1210 /* Return the binfo value for ELEM in TYPE. */
1213 binfo_value (elem
, type
)
1217 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1218 compiler_error ("base class `%s' ambiguous in binfo_value",
1219 TYPE_NAME_STRING (elem
));
1221 return TYPE_BINFO (type
);
1222 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1224 return get_binfo (elem
, type
, 0);
1231 register tree prev
= 0, tmp
, next
;
1232 for (tmp
= path
; tmp
; tmp
= next
)
1234 next
= BINFO_INHERITANCE_CHAIN (tmp
);
1235 BINFO_INHERITANCE_CHAIN (tmp
) = prev
;
1245 unsigned HOST_WIDE_INT n
;
1248 fprintf (stderr
, "type \"%s\"; offset = %d\n",
1249 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1250 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1251 fprintf (stderr
, "vtable type:\n");
1252 debug_tree (BINFO_TYPE (elem
));
1253 if (BINFO_VTABLE (elem
))
1254 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1256 fprintf (stderr
, "no vtable decl yet\n");
1257 fprintf (stderr
, "virtuals:\n");
1258 virtuals
= BINFO_VIRTUALS (elem
);
1260 n
= skip_rtti_stuff (&virtuals
);
1264 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1265 fprintf (stderr
, "%s [%d =? %d]\n",
1266 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1267 n
, TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1269 virtuals
= TREE_CHAIN (virtuals
);
1273 /* Initialize an CPLUS_BINDING node that does not live on an obstack. */
1277 struct tree_binding
* node
;
1279 static struct tree_binding
* source
;
1282 extern struct obstack permanent_obstack
;
1283 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1284 source
= (struct tree_binding
*)make_node (CPLUS_BINDING
);
1288 TREE_PERMANENT ((tree
)node
) = 0;
1297 if (TREE_CODE (t
) == FUNCTION_DECL
)
1299 else if (TREE_CODE (t
) == OVERLOAD
)
1301 for (i
=0; t
; t
= OVL_CHAIN (t
))
1306 my_friendly_abort (359);
1311 is_overloaded_fn (x
)
1314 /* XXX A baselink is also considered an overloaded function.
1315 As is a placeholder from push_class_decls. */
1316 if (TREE_CODE (x
) == TREE_LIST
)
1318 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x
)) == TREE_VEC
1319 || TREE_CODE (TREE_PURPOSE (x
)) == IDENTIFIER_NODE
,
1323 return (TREE_CODE (x
) == FUNCTION_DECL
1324 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
1325 || DECL_FUNCTION_TEMPLATE_P (x
)
1326 || TREE_CODE (x
) == OVERLOAD
);
1330 really_overloaded_fn (x
)
1333 /* A baselink is also considered an overloaded function.
1334 This might also be an ambiguous class member. */
1335 while (TREE_CODE (x
) == TREE_LIST
)
1337 return (TREE_CODE (x
) == OVERLOAD
1338 && (TREE_CHAIN (x
) != NULL_TREE
1339 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
1346 my_friendly_assert (is_overloaded_fn (from
), 9);
1347 /* A baselink is also considered an overloaded function. */
1348 if (TREE_CODE (from
) == TREE_LIST
)
1349 from
= TREE_VALUE (from
);
1350 return OVL_CURRENT (from
);
1353 /* Return a new OVL node, concatenating it with the old one. */
1356 ovl_cons (decl
, chain
)
1360 tree result
= make_node (OVERLOAD
);
1361 TREE_TYPE (result
) = unknown_type_node
;
1362 OVL_FUNCTION (result
) = decl
;
1363 TREE_CHAIN (result
) = chain
;
1368 /* Same as ovl_cons, but on the scratch_obstack. */
1371 scratch_ovl_cons (value
, chain
)
1375 register struct obstack
*ambient_obstack
= current_obstack
;
1376 extern struct obstack
*expression_obstack
;
1377 current_obstack
= expression_obstack
;
1378 node
= ovl_cons (value
, chain
);
1379 current_obstack
= ambient_obstack
;
1383 /* Build a new overloaded function. If this is the first one,
1384 just return it; otherwise, ovl_cons the _DECLs */
1387 build_overload (decl
, chain
)
1393 if (TREE_CODE (chain
) != OVERLOAD
)
1394 chain
= ovl_cons (chain
, NULL_TREE
);
1395 return ovl_cons (decl
, chain
);
1398 /* True if fn is in ovl. */
1401 ovl_member (fn
, ovl
)
1407 if (!ovl
|| TREE_CODE (ovl
) != OVERLOAD
)
1409 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1410 if (OVL_FUNCTION (ovl
) == fn
)
1416 is_aggr_type_2 (t1
, t2
)
1419 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1421 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1424 #define PRINT_RING_SIZE 4
1427 lang_printable_name (decl
, v
)
1431 static tree decl_ring
[PRINT_RING_SIZE
];
1432 static char *print_ring
[PRINT_RING_SIZE
];
1433 static int ring_counter
;
1436 /* Only cache functions. */
1438 || TREE_CODE (decl
) != FUNCTION_DECL
1439 || DECL_LANG_SPECIFIC (decl
) == 0)
1440 return lang_decl_name (decl
, v
);
1442 /* See if this print name is lying around. */
1443 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1444 if (decl_ring
[i
] == decl
)
1445 /* yes, so return it. */
1446 return print_ring
[i
];
1448 if (++ring_counter
== PRINT_RING_SIZE
)
1451 if (current_function_decl
!= NULL_TREE
)
1453 if (decl_ring
[ring_counter
] == current_function_decl
)
1455 if (ring_counter
== PRINT_RING_SIZE
)
1457 if (decl_ring
[ring_counter
] == current_function_decl
)
1458 my_friendly_abort (106);
1461 if (print_ring
[ring_counter
])
1462 free (print_ring
[ring_counter
]);
1464 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1465 decl_ring
[ring_counter
] = decl
;
1466 return print_ring
[ring_counter
];
1469 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1470 listed in RAISES. */
1473 build_exception_variant (type
, raises
)
1477 tree v
= TYPE_MAIN_VARIANT (type
);
1478 int constp
= TYPE_READONLY (type
);
1479 int volatilep
= TYPE_VOLATILE (type
);
1481 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1483 if (TYPE_READONLY (v
) != constp
1484 || TYPE_VOLATILE (v
) != volatilep
)
1487 /* @@ This should do set equality, not exact match. */
1488 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1489 /* List of exceptions raised matches previously found list.
1491 @@ Nice to free up storage used in consing up the
1492 @@ list of exceptions raised. */
1496 /* Need to build a new variant. */
1497 v
= build_type_copy (type
);
1499 if (raises
&& ! TREE_PERMANENT (raises
))
1501 push_obstacks_nochange ();
1502 end_temporary_allocation ();
1503 raises
= copy_list (raises
);
1507 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1511 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1512 lang_specific field and its corresponding TEMPLATE_DECL node */
1515 copy_template_template_parm (t
)
1518 tree
template = TYPE_NAME (t
);
1519 tree t2
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1520 template = copy_node (template);
1521 copy_lang_decl (template);
1522 TREE_TYPE (template) = t2
;
1523 TYPE_NAME (t2
) = template;
1524 TYPE_STUB_DECL (t2
) = template;
1526 /* No need to copy these */
1527 TYPE_FIELDS (t2
) = TYPE_FIELDS (t
);
1528 CLASSTYPE_TEMPLATE_INFO (t2
) = CLASSTYPE_TEMPLATE_INFO (t
);
1532 /* Subroutine of copy_to_permanent
1534 Assuming T is a node build bottom-up, make it all exist on
1535 permanent obstack, if it is not permanent already. */
1540 tree (*func
) PROTO((tree
));
1547 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1550 switch (TREE_CODE (t
))
1553 return error_mark_node
;
1558 /* Rather than aborting, return error_mark_node. This allows us
1559 to report a sensible error message on code like this:
1561 void g() { int i; f<i>(7); }
1565 void g() { const int i = 7; f<i>(7); }
1567 however, we must actually return the constant initializer. */
1568 tmp
= decl_constant_value (t
);
1570 return mapcar (tmp
, func
);
1572 return error_mark_node
;
1576 tree chain
= TREE_CHAIN (t
);
1578 TREE_CHAIN (t
) = mapcar (chain
, func
);
1579 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1580 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1581 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1587 tree chain
= TREE_CHAIN (t
);
1589 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1590 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1591 TREE_CHAIN (t
) = mapcar (chain
, func
);
1597 tree chain
= OVL_CHAIN (t
);
1599 OVL_FUNCTION (t
) = mapcar (OVL_FUNCTION (t
), func
);
1600 OVL_CHAIN (t
) = mapcar (chain
, func
);
1606 int len
= TREE_VEC_LENGTH (t
);
1610 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1617 return copy_node (t
);
1621 case AGGR_INIT_EXPR
:
1623 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1624 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1625 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1630 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1637 case TRUNC_DIV_EXPR
:
1638 case TRUNC_MOD_EXPR
:
1646 case BIT_ANDTC_EXPR
:
1647 case TRUTH_ANDIF_EXPR
:
1648 case TRUTH_ORIF_EXPR
:
1656 case FLOOR_DIV_EXPR
:
1657 case ROUND_DIV_EXPR
:
1659 case FLOOR_MOD_EXPR
:
1660 case ROUND_MOD_EXPR
:
1662 case PREDECREMENT_EXPR
:
1663 case PREINCREMENT_EXPR
:
1664 case POSTDECREMENT_EXPR
:
1665 case POSTINCREMENT_EXPR
:
1668 case TRY_CATCH_EXPR
:
1669 case WITH_CLEANUP_EXPR
:
1671 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1672 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1677 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1678 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1679 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1681 /* tree.def says that operand two is RTL, but
1682 build_call_declarator puts trees in there. */
1683 if (TREE_OPERAND (t
, 2)
1684 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1685 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1687 TREE_OPERAND (t
, 2) = NULL_TREE
;
1695 case TRUTH_NOT_EXPR
:
1698 case CLEANUP_POINT_EXPR
:
1700 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1704 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1705 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1706 case REFERENCE_TYPE
:
1707 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1708 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1710 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1711 mapcar (TYPE_ARG_TYPES (t
), func
));
1712 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1714 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
1715 mapcar (TYPE_DOMAIN (t
), func
));
1716 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1718 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1719 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1721 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
1722 mapcar (TREE_TYPE (t
), func
));
1723 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1725 tmp
= build_cplus_method_type
1726 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
1727 mapcar (TREE_TYPE (t
), func
),
1728 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
1729 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1733 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
1734 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
1739 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
1742 case TEMPLATE_TEMPLATE_PARM
:
1743 return copy_template_template_parm (t
);
1747 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1748 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1749 TREE_OPERAND (t
, 2) = NULL_TREE
;
1753 if (TYPE_PTRMEMFUNC_P (t
))
1754 return build_ptrmemfunc_type
1755 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
1756 /* else fall through */
1758 /* This list is incomplete, but should suffice for now.
1759 It is very important that `sorry' not call
1760 `report_error_function'. That could cause an infinite loop. */
1762 sorry ("initializer contains unrecognized tree code");
1763 return error_mark_node
;
1766 my_friendly_abort (107);
1775 if (TREE_PERMANENT (t
))
1778 /* Support `void f () { extern int i; A<&i> a; }' */
1779 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
1784 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */
1786 make_decl_rtl (t
, NULL_PTR
, 1);
1793 /* Assuming T is a node built bottom-up, make it all exist on
1794 permanent obstack, if it is not permanent already. */
1797 copy_to_permanent (t
)
1800 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
1803 push_obstacks_nochange ();
1804 end_temporary_allocation ();
1806 t
= mapcar (t
, perm_manip
);
1813 #ifdef GATHER_STATISTICS
1814 extern int depth_reached
;
1818 print_lang_statistics ()
1820 extern struct obstack decl_obstack
;
1821 print_obstack_statistics ("class_obstack", &class_obstack
);
1822 print_obstack_statistics ("decl_obstack", &decl_obstack
);
1823 print_search_statistics ();
1824 print_class_statistics ();
1825 #ifdef GATHER_STATISTICS
1826 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1831 /* This is used by the `assert' macro. It is provided in libgcc.a,
1832 which `cc' doesn't know how to link. Note that the C++ front-end
1833 no longer actually uses the `assert' macro (instead, it calls
1834 my_friendly_assert). But all of the back-end files still need this. */
1837 __eprintf (string
, expression
, line
, filename
)
1840 const char *expression
;
1842 const char *filename
;
1850 fprintf (stderr
, string
, expression
, line
, filename
);
1855 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1856 (which is an ARRAY_TYPE). This counts only elements of the top
1860 array_type_nelts_top (type
)
1863 return fold (build (PLUS_EXPR
, sizetype
,
1864 array_type_nelts (type
),
1868 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1869 (which is an ARRAY_TYPE). This one is a recursive count of all
1870 ARRAY_TYPEs that are clumped together. */
1873 array_type_nelts_total (type
)
1876 tree sz
= array_type_nelts_top (type
);
1877 type
= TREE_TYPE (type
);
1878 while (TREE_CODE (type
) == ARRAY_TYPE
)
1880 tree n
= array_type_nelts_top (type
);
1881 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1882 type
= TREE_TYPE (type
);
1892 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1894 else if (TREE_CODE (t
) == TARGET_EXPR
)
1896 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1898 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1899 return build_cplus_new
1900 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1903 TREE_OPERAND (t
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
1904 layout_decl (TREE_OPERAND (t
, 0), 0);
1907 else if (TREE_CODE (t
) == CALL_EXPR
)
1908 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1913 /* Actually, we'll just clean out the target exprs for the moment. */
1916 break_out_target_exprs (t
)
1919 return mapcar (t
, bot_manip
);
1922 /* Obstack used for allocating nodes in template function and variable
1925 /* Similar to `build_nt', except we build
1926 on the permanent_obstack, regardless. */
1929 build_min_nt
VPROTO((enum tree_code code
, ...))
1932 enum tree_code code
;
1934 register struct obstack
*ambient_obstack
= expression_obstack
;
1937 register int length
;
1943 code
= va_arg (p
, enum tree_code
);
1946 expression_obstack
= &permanent_obstack
;
1948 t
= make_node (code
);
1949 length
= tree_code_length
[(int) code
];
1950 TREE_COMPLEXITY (t
) = lineno
;
1952 for (i
= 0; i
< length
; i
++)
1954 tree x
= va_arg (p
, tree
);
1955 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
1959 expression_obstack
= ambient_obstack
;
1963 /* Similar to `build', except we build
1964 on the permanent_obstack, regardless. */
1967 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
1970 enum tree_code code
;
1973 register struct obstack
*ambient_obstack
= expression_obstack
;
1976 register int length
;
1982 code
= va_arg (p
, enum tree_code
);
1983 tt
= va_arg (p
, tree
);
1986 expression_obstack
= &permanent_obstack
;
1988 t
= make_node (code
);
1989 length
= tree_code_length
[(int) code
];
1991 TREE_COMPLEXITY (t
) = lineno
;
1993 for (i
= 0; i
< length
; i
++)
1995 tree x
= va_arg (p
, tree
);
1996 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
2000 expression_obstack
= ambient_obstack
;
2004 /* Same as `tree_cons' but make a permanent object. */
2007 min_tree_cons (purpose
, value
, chain
)
2008 tree purpose
, value
, chain
;
2011 register struct obstack
*ambient_obstack
= current_obstack
;
2012 current_obstack
= &permanent_obstack
;
2014 node
= tree_cons (copy_to_permanent (purpose
),
2015 copy_to_permanent (value
), chain
);
2016 current_obstack
= ambient_obstack
;
2024 if (TREE_CODE (t
) == TYPE_DECL
)
2026 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
2027 return TYPE_STUB_DECL (t
);
2029 my_friendly_abort (42);
2031 /* Stop compiler from complaining control reaches end of non-void function. */
2036 can_free (obstack
, t
)
2037 struct obstack
*obstack
;
2042 if (TREE_CODE (t
) == TREE_VEC
)
2043 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
2045 my_friendly_abort (42);
2047 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2048 & ~ obstack_alignment_mask (obstack))
2049 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
2056 /* Return first vector element whose BINFO_TYPE is ELEM.
2057 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
2060 vec_binfo_member (elem
, vec
)
2066 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
2067 if (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
2068 return TREE_VEC_ELT (vec
, i
);
2073 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2074 the wrong thing for decl_function_context. Hopefully the uses in the
2075 backend won't matter, since we don't need a static chain for local class
2079 hack_decl_function_context (decl
)
2082 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
2083 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
2084 return decl_function_context (decl
);
2087 /* Return truthvalue of whether T1 is the same tree structure as T2.
2088 Return 1 if they are the same.
2089 Return 0 if they are understandably different.
2090 Return -1 if either contains tree structure not understood by
2094 cp_tree_equal (t1
, t2
)
2097 register enum tree_code code1
, code2
;
2102 if (t1
== 0 || t2
== 0)
2105 code1
= TREE_CODE (t1
);
2106 code2
= TREE_CODE (t2
);
2108 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
2110 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
2111 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2113 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
2115 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
2116 || code2
== NON_LVALUE_EXPR
)
2117 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
2125 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
2126 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
2129 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2132 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2133 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2134 TREE_STRING_LENGTH (t1
));
2140 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2143 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2146 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2149 /* Special case: if either target is an unallocated VAR_DECL,
2150 it means that it's going to be unified with whatever the
2151 TARGET_EXPR is really supposed to initialize, so treat it
2152 as being equivalent to anything. */
2153 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
2154 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
2155 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
2156 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
2157 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
2158 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2161 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2164 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2166 case WITH_CLEANUP_EXPR
:
2167 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2170 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2173 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2174 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2183 case TEMPLATE_PARM_INDEX
:
2184 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2185 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
2189 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2191 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2192 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2199 switch (TREE_CODE_CLASS (code1
))
2209 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2211 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2221 /* Similar to make_tree_vec, but build on a temporary obstack. */
2228 register struct obstack
*ambient_obstack
= current_obstack
;
2229 current_obstack
= expression_obstack
;
2230 node
= make_tree_vec (len
);
2231 current_obstack
= ambient_obstack
;
2235 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2238 build_ptr_wrapper (ptr
)
2241 tree t
= make_node (WRAPPER
);
2242 WRAPPER_PTR (t
) = ptr
;
2246 /* Same, but on the expression_obstack. */
2249 build_expr_ptr_wrapper (ptr
)
2253 push_expression_obstack ();
2254 t
= build_ptr_wrapper (ptr
);
2259 /* Build a wrapper around some integer I so we can use it as a tree. */
2262 build_int_wrapper (i
)
2265 tree t
= make_node (WRAPPER
);
2266 WRAPPER_INT (t
) = i
;
2271 build_srcloc (file
, line
)
2275 tree t
= make_node (SRCLOC
);
2276 SRCLOC_FILE (t
) = file
;
2277 SRCLOC_LINE (t
) = line
;
2282 build_srcloc_here ()
2284 return build_srcloc (input_filename
, lineno
);
2288 push_expression_obstack ()
2290 push_obstacks_nochange ();
2291 current_obstack
= expression_obstack
;
2294 /* The type of ARG when used as an lvalue. */
2300 tree type
= TREE_TYPE (arg
);
2301 if (TREE_CODE (arg
) == OVERLOAD
)
2302 type
= unknown_type_node
;
2303 return cp_build_type_variant
2304 (type
, TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
2307 /* The type of ARG for printing error messages; denote lvalues with
2314 tree type
= TREE_TYPE (arg
);
2315 if (TREE_CODE (type
) == ARRAY_TYPE
)
2317 else if (real_lvalue_p (arg
))
2318 type
= build_reference_type (lvalue_type (arg
));
2319 else if (IS_AGGR_TYPE (type
))
2320 type
= lvalue_type (arg
);
2325 /* Does FUNCTION use a variable-length argument list? */
2328 varargs_function_p (function
)
2331 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2332 for (; parm
; parm
= TREE_CHAIN (parm
))
2333 if (TREE_VALUE (parm
) == void_type_node
)
2338 /* Returns 1 if decl is a member of a class. */
2344 tree ctx
= DECL_CONTEXT (decl
);
2345 return (ctx
&& TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't');