1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92-98, 1999 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. */
31 static tree get_identifier_list
PROTO((tree
));
32 static tree bot_manip
PROTO((tree
));
33 static tree perm_manip
PROTO((tree
));
34 static tree build_cplus_array_type_1
PROTO((tree
, tree
));
35 static void list_hash_add
PROTO((int, tree
));
36 static int list_hash
PROTO((tree
, tree
, tree
));
37 static tree list_hash_lookup
PROTO((int, int, int, int, tree
, tree
,
39 static void propagate_binfo_offsets
PROTO((tree
, tree
));
40 static int avoid_overlap
PROTO((tree
, tree
));
41 static int lvalue_p_1
PROTO((tree
, int));
42 static int equal_functions
PROTO((tree
, tree
));
43 static tree no_linkage_helper
PROTO((tree
));
44 static tree build_srcloc
PROTO((char *, int));
46 #define CEIL(x,y) (((x) + (y) - 1) / (y))
48 /* Returns non-zero if REF is an lvalue. If
49 TREAT_CLASS_RVALUES_AS_LVALUES is non-zero, rvalues of class type
50 are considered lvalues. */
53 lvalue_p_1 (ref
, treat_class_rvalues_as_lvalues
)
55 int treat_class_rvalues_as_lvalues
;
57 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
60 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
63 switch (TREE_CODE (ref
))
65 /* preincrements and predecrements are valid lvals, provided
66 what they refer to are valid lvals. */
67 case PREINCREMENT_EXPR
:
68 case PREDECREMENT_EXPR
:
73 case WITH_CLEANUP_EXPR
:
76 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
77 treat_class_rvalues_as_lvalues
);
83 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
84 && DECL_LANG_SPECIFIC (ref
)
85 && DECL_IN_AGGR_P (ref
))
91 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
95 /* A currently unresolved scope ref. */
97 my_friendly_abort (103);
99 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
101 return (lvalue_p_1 (TREE_OPERAND (ref
, 0),
102 treat_class_rvalues_as_lvalues
)
103 && lvalue_p_1 (TREE_OPERAND (ref
, 1),
104 treat_class_rvalues_as_lvalues
));
108 return (lvalue_p_1 (TREE_OPERAND (ref
, 1),
109 treat_class_rvalues_as_lvalues
)
110 && lvalue_p_1 (TREE_OPERAND (ref
, 2),
111 treat_class_rvalues_as_lvalues
));
117 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
118 treat_class_rvalues_as_lvalues
);
122 return (lvalue_p_1 (TREE_OPERAND (ref
, 0),
123 treat_class_rvalues_as_lvalues
)
124 && lvalue_p_1 (TREE_OPERAND (ref
, 1),
125 treat_class_rvalues_as_lvalues
));
128 return treat_class_rvalues_as_lvalues
;
131 return (treat_class_rvalues_as_lvalues
132 && IS_AGGR_TYPE (TREE_TYPE (ref
)));
135 /* All functions (except non-static-member functions) are
137 return !DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
);
146 /* Return nonzero if REF is an lvalue valid for this language.
147 Lvalues can be assigned, unless they have TREE_READONLY, or unless
148 they are FUNCTION_DECLs. Lvalues can have their address taken,
149 unless they have DECL_REGISTER. */
155 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/0);
158 /* This differs from real_lvalue_p in that class rvalues are considered
165 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/1);
168 /* Return nonzero if REF is an lvalue valid for this language;
169 otherwise, print an error message and return zero. */
172 lvalue_or_else (ref
, string
)
176 int win
= lvalue_p (ref
);
178 error ("non-lvalue in %s", string
);
182 /* INIT is a CALL_EXPR which needs info about its target.
183 TYPE is the type that this initialization should appear to have.
185 Build an encapsulation of the initialization to perform
186 and return it so that it can be processed by language-independent
187 and language-specific expression expanders. */
190 build_cplus_new (type
, init
)
197 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
200 slot
= build (VAR_DECL
, type
);
201 DECL_ARTIFICIAL (slot
) = 1;
202 layout_decl (slot
, 0);
203 rval
= build (AGGR_INIT_EXPR
, type
,
204 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
205 TREE_SIDE_EFFECTS (rval
) = 1;
206 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
207 TREE_SIDE_EFFECTS (rval
) = 1;
212 /* Encapsulate the expression INIT in a TARGET_EXPR. */
215 get_target_expr (init
)
221 slot
= build (VAR_DECL
, TREE_TYPE (init
));
222 DECL_ARTIFICIAL (slot
) = 1;
223 layout_decl (slot
, 0);
224 rval
= build (TARGET_EXPR
, TREE_TYPE (init
), slot
, init
,
225 NULL_TREE
, NULL_TREE
);
226 TREE_SIDE_EFFECTS (rval
) = 1;
231 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
232 these CALL_EXPRs with tree nodes that will perform the cleanups. */
235 break_out_cleanups (exp
)
240 if (TREE_CODE (tmp
) == CALL_EXPR
241 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
242 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
244 while (TREE_CODE (tmp
) == NOP_EXPR
245 || TREE_CODE (tmp
) == CONVERT_EXPR
246 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
248 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
249 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
251 TREE_OPERAND (tmp
, 0)
252 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
253 TREE_OPERAND (tmp
, 0));
257 tmp
= TREE_OPERAND (tmp
, 0);
262 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
263 copies where they are found. Returns a deep copy all nodes transitively
264 containing CALL_EXPRs. */
267 break_out_calls (exp
)
270 register tree t1
, t2
= NULL_TREE
;
271 register enum tree_code code
;
272 register int changed
= 0;
275 if (exp
== NULL_TREE
)
278 code
= TREE_CODE (exp
);
280 if (code
== CALL_EXPR
)
281 return copy_node (exp
);
283 /* Don't try and defeat a save_expr, as it should only be done once. */
284 if (code
== SAVE_EXPR
)
287 switch (TREE_CODE_CLASS (code
))
292 case 'c': /* a constant */
293 case 't': /* a type node */
294 case 'x': /* something random, like an identifier or an ERROR_MARK. */
297 case 'd': /* A decl node */
298 #if 0 /* This is bogus. jason 9/21/94 */
300 t1
= break_out_calls (DECL_INITIAL (exp
));
301 if (t1
!= DECL_INITIAL (exp
))
303 exp
= copy_node (exp
);
304 DECL_INITIAL (exp
) = t1
;
309 case 'b': /* A block node */
311 /* Don't know how to handle these correctly yet. Must do a
312 break_out_calls on all DECL_INITIAL values for local variables,
313 and also break_out_calls on all sub-blocks and sub-statements. */
318 case 'e': /* an expression */
319 case 'r': /* a reference */
320 case 's': /* an expression with side effects */
321 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
323 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
324 if (t1
!= TREE_OPERAND (exp
, i
))
326 exp
= copy_node (exp
);
327 TREE_OPERAND (exp
, i
) = t1
;
332 case '<': /* a comparison expression */
333 case '2': /* a binary arithmetic expression */
334 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
335 if (t2
!= TREE_OPERAND (exp
, 1))
337 case '1': /* a unary arithmetic expression */
338 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
339 if (t1
!= TREE_OPERAND (exp
, 0))
343 if (tree_code_length
[(int) code
] == 1)
344 return build1 (code
, TREE_TYPE (exp
), t1
);
346 return build (code
, TREE_TYPE (exp
), t1
, t2
);
353 extern struct obstack
*current_obstack
;
354 extern struct obstack permanent_obstack
, class_obstack
;
355 extern struct obstack
*saveable_obstack
;
356 extern struct obstack
*expression_obstack
;
358 /* Here is how primitive or already-canonicalized types' hash
359 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
360 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
362 /* Construct, lay out and return the type of methods belonging to class
363 BASETYPE and whose arguments are described by ARGTYPES and whose values
364 are described by RETTYPE. If each type exists already, reuse it. */
367 build_cplus_method_type (basetype
, rettype
, argtypes
)
368 tree basetype
, rettype
, argtypes
;
374 /* Make a node of the sort we want. */
375 t
= make_node (METHOD_TYPE
);
377 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
378 TREE_TYPE (t
) = rettype
;
379 if (IS_SIGNATURE (basetype
))
380 ptype
= build_signature_pointer_type (basetype
);
382 ptype
= build_pointer_type (basetype
);
384 /* The actual arglist for this function includes a "hidden" argument
385 which is "this". Put it into the list of argument types. */
387 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
388 TYPE_ARG_TYPES (t
) = argtypes
;
389 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
391 /* If we already have such a type, use the old one and free this one.
392 Note that it also frees up the above cons cell if found. */
393 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
394 t
= type_hash_canon (hashcode
, t
);
396 if (TYPE_SIZE (t
) == 0)
403 build_cplus_array_type_1 (elt_type
, index_type
)
407 register struct obstack
*ambient_obstack
= current_obstack
;
408 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
411 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
412 make this permanent too. */
413 if (TREE_PERMANENT (elt_type
)
414 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
416 current_obstack
= &permanent_obstack
;
417 saveable_obstack
= &permanent_obstack
;
420 if (processing_template_decl
421 || uses_template_parms (elt_type
)
422 || uses_template_parms (index_type
))
424 t
= make_node (ARRAY_TYPE
);
425 TREE_TYPE (t
) = elt_type
;
426 TYPE_DOMAIN (t
) = index_type
;
429 t
= build_array_type (elt_type
, index_type
);
431 /* Push these needs up so that initialization takes place
433 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
434 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
435 current_obstack
= ambient_obstack
;
436 saveable_obstack
= ambient_saveable_obstack
;
441 build_cplus_array_type (elt_type
, index_type
)
446 int type_quals
= CP_TYPE_QUALS (elt_type
);
448 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
450 t
= build_cplus_array_type_1 (elt_type
, index_type
);
452 if (type_quals
!= TYPE_UNQUALIFIED
)
453 t
= cp_build_qualified_type (t
, type_quals
);
458 /* Make a variant type in the proper way for C/C++, propagating qualifiers
459 down to the element type of an array. */
462 cp_build_qualified_type (type
, type_quals
)
466 if (type
== error_mark_node
)
469 /* A restrict-qualified pointer type must be a pointer (or reference)
470 to object or incomplete type. */
471 if ((type_quals
& TYPE_QUAL_RESTRICT
)
472 && (!POINTER_TYPE_P (type
)
473 || TYPE_PTRMEM_P (type
)
474 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
476 cp_error ("`%T' cannot be `restrict'-qualified", type
);
477 type_quals
&= ~TYPE_QUAL_RESTRICT
;
480 if (TREE_CODE (type
) == ARRAY_TYPE
)
482 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
484 push_obstacks (TYPE_OBSTACK (real_main_variant
),
485 TYPE_OBSTACK (real_main_variant
));
486 type
= build_cplus_array_type_1 (cp_build_qualified_type
487 (TREE_TYPE (type
), type_quals
),
490 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
491 make a copy. (TYPE might have come from the hash table and
492 REAL_MAIN_VARIANT might be in some function's obstack.) */
494 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
496 type
= copy_node (type
);
497 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
500 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
504 return build_qualified_type (type
, type_quals
);
507 /* Returns the canonical version of TYPE. In other words, if TYPE is
508 a typedef, returns the underlying type. The cv-qualification of
509 the type returned matches the type input; they will always be
513 canonical_type_variant (t
)
516 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), CP_TYPE_QUALS (t
));
519 /* Add OFFSET to all base types of T.
521 OFFSET, which is a type offset, is number of bytes.
523 Note that we don't have to worry about having two paths to the
524 same base type, since this type owns its association list. */
527 propagate_binfo_offsets (binfo
, offset
)
531 tree binfos
= BINFO_BASETYPES (binfo
);
532 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
534 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
536 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
538 if (TREE_VIA_VIRTUAL (base_binfo
))
543 tree delta
= NULL_TREE
;
545 for (j
= i
+1; j
< n_baselinks
; j
++)
546 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
548 /* The next basetype offset must take into account the space
549 between the classes, not just the size of each class. */
550 delta
= size_binop (MINUS_EXPR
,
551 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
552 BINFO_OFFSET (base_binfo
));
557 if (BINFO_OFFSET_ZEROP (base_binfo
))
558 BINFO_OFFSET (base_binfo
) = offset
;
560 BINFO_OFFSET (base_binfo
)
561 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
563 BINFO_OFFSET (base_binfo
) = offset
;
566 propagate_binfo_offsets (base_binfo
, offset
);
568 /* Go to our next class that counts for offset propagation. */
571 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
576 /* Makes new binfos for the indirect bases under BINFO, and updates
577 BINFO_OFFSET for them and their bases. */
580 unshare_base_binfos (binfo
)
583 tree binfos
= BINFO_BASETYPES (binfo
);
587 if (binfos
== NULL_TREE
)
590 /* Now unshare the structure beneath BINFO. */
591 for (j
= TREE_VEC_LENGTH (binfos
)-1;
594 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
595 new_binfo
= TREE_VEC_ELT (binfos
, j
)
596 = make_binfo (BINFO_OFFSET (base_binfo
),
598 BINFO_VTABLE (base_binfo
),
599 BINFO_VIRTUALS (base_binfo
));
600 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
601 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
602 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
603 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
604 unshare_base_binfos (new_binfo
);
608 /* Finish the work of layout_record, now taking virtual bases into account.
609 Also compute the actual offsets that our base classes will have.
610 This must be performed after the fields are laid out, since virtual
611 baseclasses must lay down at the end of the record.
613 Returns the maximum number of virtual functions any of the
614 baseclasses provide. */
617 layout_basetypes (rec
, max
)
621 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
622 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
626 unsigned int record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
627 unsigned int desired_align
;
629 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
630 register unsigned int const_size
= 0;
631 unsigned int nonvirtual_const_size
;
633 #ifdef STRUCTURE_SIZE_BOUNDARY
634 /* Packed structures don't need to have minimum size. */
635 if (! TYPE_PACKED (rec
))
636 record_align
= MAX (record_align
, STRUCTURE_SIZE_BOUNDARY
);
639 /* Get all the virtual base types that this type uses. The
640 TREE_VALUE slot holds the virtual baseclass type. Note that
641 get_vbase_types makes copies of the virtual base BINFOs, so that
642 the vbase_types are unshared. */
643 vbase_types
= CLASSTYPE_VBASECLASSES (rec
);
645 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
, 19970302);
646 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
648 nonvirtual_const_size
= const_size
;
652 tree basetype
= BINFO_TYPE (vbase_types
);
655 desired_align
= TYPE_ALIGN (basetype
);
656 record_align
= MAX (record_align
, desired_align
);
659 offset
= integer_zero_node
;
662 /* Give each virtual base type the alignment it wants. */
663 const_size
= CEIL (const_size
, desired_align
) * desired_align
;
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 /* Every virtual baseclass takes a least a UNIT, so that we can
672 take it's address and get something different for each base. */
673 const_size
+= MAX (BITS_PER_UNIT
,
674 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype
)));
676 vbase_types
= TREE_CHAIN (vbase_types
);
681 /* Because a virtual base might take a single byte above,
682 we have to re-adjust the total size to make sure it is
683 a multiple of the alignment. */
684 /* Give the whole object the alignment it wants. */
685 const_size
= CEIL (const_size
, record_align
) * record_align
;
688 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
689 here, as that is for this class, without any virtual base classes. */
690 TYPE_ALIGN (rec
) = record_align
;
691 if (const_size
!= nonvirtual_const_size
)
693 TYPE_SIZE (rec
) = size_int (const_size
);
694 TYPE_SIZE_UNIT (rec
) = size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (rec
),
695 size_int (BITS_PER_UNIT
));
698 /* Now propagate offset information throughout the lattice. */
699 for (i
= 0; i
< n_baseclasses
; i
++)
701 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
702 register tree basetype
= BINFO_TYPE (base_binfo
);
703 tree field
= TYPE_FIELDS (rec
);
705 if (TREE_VIA_VIRTUAL (base_binfo
))
708 my_friendly_assert (TREE_TYPE (field
) == basetype
, 23897);
710 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
711 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
714 BINFO_OFFSET (base_binfo
)
715 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
)),
717 propagate_binfo_offsets (base_binfo
, BINFO_OFFSET (base_binfo
));
718 TYPE_FIELDS (rec
) = TREE_CHAIN (field
);
721 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
722 vbase_types
= TREE_CHAIN (vbase_types
))
724 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
725 unshare_base_binfos (vbase_types
);
726 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
730 tree basetype
= BINFO_TYPE (vbase_types
);
731 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
732 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
740 /* If the empty base field in DECL overlaps with a base of the same type in
741 NEWDECL, which is either another base field or the first data field of
742 the class, pad the base just before NEWDECL and return 1. Otherwise,
746 avoid_overlap (decl
, newdecl
)
751 if (newdecl
== NULL_TREE
752 || ! types_overlap_p (TREE_TYPE (decl
), TREE_TYPE (newdecl
)))
755 for (field
= decl
; TREE_CHAIN (field
) && TREE_CHAIN (field
) != newdecl
;
756 field
= TREE_CHAIN (field
))
759 DECL_SIZE (field
) = integer_one_node
;
764 /* Returns a list of fields to stand in for the base class subobjects
765 of REC. These fields are later removed by layout_basetypes. */
768 build_base_fields (rec
)
771 /* Chain to hold all the new FIELD_DECLs which stand in for base class
773 tree base_decls
= NULL_TREE
;
774 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
775 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
777 int i
, saw_empty
= 0;
778 unsigned int base_align
= 0;
780 for (i
= 0; i
< n_baseclasses
; ++i
)
782 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
783 register tree basetype
= BINFO_TYPE (base_binfo
);
785 if (TYPE_SIZE (basetype
) == 0)
786 /* This error is now reported in xref_tag, thus giving better
787 location information. */
790 if (TREE_VIA_VIRTUAL (base_binfo
))
793 decl
= build_lang_field_decl (FIELD_DECL
, NULL_TREE
, basetype
);
794 DECL_ARTIFICIAL (decl
) = 1;
795 DECL_FIELD_CONTEXT (decl
) = DECL_CLASS_CONTEXT (decl
) = rec
;
796 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
797 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
798 TREE_CHAIN (decl
) = base_decls
;
803 /* Brain damage for backwards compatibility. For no good reason,
804 the old layout_basetypes made every base at least as large as
805 the alignment for the bases up to that point, gratuitously
806 wasting space. So we do the same thing here. */
807 base_align
= MAX (base_align
, DECL_ALIGN (decl
));
809 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl
)),
812 else if (DECL_SIZE (decl
) == integer_zero_node
)
816 /* Reverse the list of fields so we allocate the bases in the proper
818 base_decls
= nreverse (base_decls
);
820 /* In the presence of empty base classes, we run the risk of allocating
821 two objects of the same class on top of one another. Avoid that. */
822 if (flag_new_abi
&& saw_empty
)
823 for (decl
= base_decls
; decl
; decl
= TREE_CHAIN (decl
))
825 if (DECL_SIZE (decl
) == integer_zero_node
)
827 /* First step through the following bases until we find
828 an overlap or a non-empty base. */
829 for (nextdecl
= TREE_CHAIN (decl
); nextdecl
;
830 nextdecl
= TREE_CHAIN (nextdecl
))
832 if (avoid_overlap (decl
, nextdecl
)
833 || DECL_SIZE (nextdecl
) != integer_zero_node
)
837 /* If we're still looking, also check against the first
839 for (nextdecl
= TYPE_FIELDS (rec
);
840 nextdecl
&& TREE_CODE (nextdecl
) != FIELD_DECL
;
841 nextdecl
= TREE_CHAIN (nextdecl
))
843 avoid_overlap (decl
, nextdecl
);
851 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
854 build_vbase_pointer_fields (rec
)
857 /* Chain to hold all the new FIELD_DECLs which point at virtual
859 tree vbase_decls
= NULL_TREE
;
860 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
861 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
865 /* Handle basetypes almost like fields, but record their
866 offsets differently. */
868 for (i
= 0; i
< n_baseclasses
; i
++)
870 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
871 register tree basetype
= BINFO_TYPE (base_binfo
);
873 if (TYPE_SIZE (basetype
) == 0)
874 /* This error is now reported in xref_tag, thus giving better
875 location information. */
878 /* All basetypes are recorded in the association list of the
881 if (TREE_VIA_VIRTUAL (base_binfo
))
886 /* The offset for a virtual base class is only used in computing
887 virtual function tables and for initializing virtual base
888 pointers. It is built once `get_vbase_types' is called. */
890 /* If this basetype can come from another vbase pointer
891 without an additional indirection, we will share
892 that pointer. If an indirection is involved, we
893 make our own pointer. */
894 for (j
= 0; j
< n_baseclasses
; j
++)
896 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
897 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
898 && binfo_member (basetype
,
899 CLASSTYPE_VBASECLASSES (BINFO_TYPE
904 FORMAT_VBASE_NAME (name
, basetype
);
905 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
906 build_pointer_type (basetype
));
907 /* If you change any of the below, take a look at all the
908 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
910 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
911 DECL_VIRTUAL_P (decl
) = 1;
912 DECL_ARTIFICIAL (decl
) = 1;
913 DECL_FIELD_CONTEXT (decl
) = rec
;
914 DECL_CLASS_CONTEXT (decl
) = rec
;
915 DECL_FCONTEXT (decl
) = basetype
;
916 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
917 DECL_FIELD_SIZE (decl
) = 0;
918 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
919 TREE_CHAIN (decl
) = vbase_decls
;
920 BINFO_VPTR_FIELD (base_binfo
) = decl
;
924 /* The space this decl occupies has already been accounted for. */
932 /* Hashing of lists so that we don't make duplicates.
933 The entry point is `list_hash_canon'. */
935 /* Each hash table slot is a bucket containing a chain
936 of these structures. */
940 struct list_hash
*next
; /* Next structure in the bucket. */
941 int hashcode
; /* Hash code of this list. */
942 tree list
; /* The list recorded here. */
945 /* Now here is the hash table. When recording a list, it is added
946 to the slot whose index is the hash code mod the table size.
947 Note that the hash table is used for several kinds of lists.
948 While all these live in the same table, they are completely independent,
949 and the hash code is computed differently for each of these. */
951 #define TYPE_HASH_SIZE 59
952 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
954 /* Compute a hash code for a list (chain of TREE_LIST nodes
955 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
956 TREE_COMMON slots), by adding the hash codes of the individual entries. */
959 list_hash (purpose
, value
, chain
)
960 tree purpose
, value
, chain
;
962 register int hashcode
= 0;
965 hashcode
+= TYPE_HASH (chain
);
968 hashcode
+= TYPE_HASH (value
);
972 hashcode
+= TYPE_HASH (purpose
);
978 /* Look in the type hash table for a type isomorphic to TYPE.
979 If one is found, return it. Otherwise return 0. */
982 list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
983 purpose
, value
, chain
)
984 int hashcode
, via_public
, via_virtual
, via_protected
;
985 tree purpose
, value
, chain
;
987 register struct list_hash
*h
;
989 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
990 if (h
->hashcode
== hashcode
991 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
992 && TREE_VIA_PUBLIC (h
->list
) == via_public
993 && TREE_VIA_PROTECTED (h
->list
) == via_protected
994 && TREE_PURPOSE (h
->list
) == purpose
995 && TREE_VALUE (h
->list
) == value
996 && TREE_CHAIN (h
->list
) == chain
)
1001 /* Add an entry to the list-hash-table
1002 for a list TYPE whose hash code is HASHCODE. */
1005 list_hash_add (hashcode
, list
)
1009 register struct list_hash
*h
;
1011 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
1012 h
->hashcode
= hashcode
;
1014 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
1015 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1018 /* Given TYPE, and HASHCODE its hash code, return the canonical
1019 object for an identical list if one already exists.
1020 Otherwise, return TYPE, and record it as the canonical object
1021 if it is a permanent object.
1023 To use this function, first create a list of the sort you want.
1024 Then compute its hash code from the fields of the list that
1025 make it different from other similar lists.
1026 Then call this function and use the value.
1027 This function frees the list you pass in if it is a duplicate. */
1029 /* Set to 1 to debug without canonicalization. Never set by program. */
1031 static int debug_no_list_hash
= 0;
1034 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1035 int via_public
, via_virtual
, via_protected
;
1036 tree purpose
, value
, chain
;
1038 struct obstack
*ambient_obstack
= current_obstack
;
1042 if (! debug_no_list_hash
)
1044 hashcode
= list_hash (purpose
, value
, chain
);
1045 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1046 purpose
, value
, chain
);
1051 current_obstack
= &class_obstack
;
1053 t
= tree_cons (purpose
, value
, chain
);
1054 TREE_VIA_PUBLIC (t
) = via_public
;
1055 TREE_VIA_PROTECTED (t
) = via_protected
;
1056 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1058 /* If this is a new list, record it for later reuse. */
1059 if (! debug_no_list_hash
)
1060 list_hash_add (hashcode
, t
);
1062 current_obstack
= ambient_obstack
;
1066 /* Constructor for hashed lists. */
1069 hash_tree_chain (value
, chain
)
1072 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1075 /* Similar, but used for concatenating two lists. */
1078 hash_chainon (list1
, list2
)
1085 if (TREE_CHAIN (list1
) == NULL_TREE
)
1086 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1087 return hash_tree_chain (TREE_VALUE (list1
),
1088 hash_chainon (TREE_CHAIN (list1
), list2
));
1092 get_identifier_list (value
)
1095 tree list
= IDENTIFIER_AS_LIST (value
);
1096 if (list
!= NULL_TREE
1097 && (TREE_CODE (list
) != TREE_LIST
1098 || TREE_VALUE (list
) != value
))
1100 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1101 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1102 && IDENTIFIER_TYPE_VALUE (value
)
1103 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1105 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1107 if (TYPE_PTRMEMFUNC_P (type
))
1109 else if (type
== current_class_type
)
1110 /* Don't mess up the constructor name. */
1111 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1114 if (! CLASSTYPE_ID_AS_LIST (type
))
1115 CLASSTYPE_ID_AS_LIST (type
)
1116 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1117 list
= CLASSTYPE_ID_AS_LIST (type
);
1124 get_decl_list (value
)
1127 tree list
= NULL_TREE
;
1129 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1130 list
= get_identifier_list (value
);
1131 else if (TREE_CODE (value
) == RECORD_TYPE
1132 && TYPE_LANG_SPECIFIC (value
)
1133 && value
== TYPE_MAIN_VARIANT (value
))
1134 list
= CLASSTYPE_AS_LIST (value
);
1136 if (list
!= NULL_TREE
)
1138 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1142 return build_decl_list (NULL_TREE
, value
);
1145 /* Build an association between TYPE and some parameters:
1147 OFFSET is the offset added to `this' to convert it to a pointer
1150 BINFO is the base binfo to use, if we are deriving from one. This
1151 is necessary, as we want specialized parent binfos from base
1152 classes, so that the VTABLE_NAMEs of bases are for the most derived
1153 type, instead of the simple type.
1155 VTABLE is the virtual function table with which to initialize
1156 sub-objects of type TYPE.
1158 VIRTUALS are the virtual functions sitting in VTABLE. */
1161 make_binfo (offset
, binfo
, vtable
, virtuals
)
1163 tree vtable
, virtuals
;
1165 tree new_binfo
= make_tree_vec (7);
1168 if (TREE_CODE (binfo
) == TREE_VEC
)
1169 type
= BINFO_TYPE (binfo
);
1173 binfo
= CLASS_TYPE_P (type
) ? TYPE_BINFO (binfo
) : NULL_TREE
;
1176 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1177 BINFO_OFFSET (new_binfo
) = offset
;
1178 BINFO_VTABLE (new_binfo
) = vtable
;
1179 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1180 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1182 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1183 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1187 /* Return the binfo value for ELEM in TYPE. */
1190 binfo_value (elem
, type
)
1194 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1195 compiler_error ("base class `%s' ambiguous in binfo_value",
1196 TYPE_NAME_STRING (elem
));
1198 return TYPE_BINFO (type
);
1199 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1201 return get_binfo (elem
, type
, 0);
1204 /* Return a reversed copy of the BINFO-chain given by PATH. (If the
1205 BINFO_INHERITANCE_CHAIN points from base classes to derived
1206 classes, it will instead point from derived classes to base
1207 classes.) Returns the first node in the reversed chain. */
1213 register tree prev
= NULL_TREE
, cur
;
1214 push_expression_obstack ();
1215 for (cur
= path
; cur
; cur
= BINFO_INHERITANCE_CHAIN (cur
))
1217 tree r
= copy_node (cur
);
1218 BINFO_INHERITANCE_CHAIN (r
) = prev
;
1229 unsigned HOST_WIDE_INT n
;
1232 fprintf (stderr
, "type \"%s\"; offset = %ld\n",
1233 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1234 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1235 fprintf (stderr
, "vtable type:\n");
1236 debug_tree (BINFO_TYPE (elem
));
1237 if (BINFO_VTABLE (elem
))
1238 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1240 fprintf (stderr
, "no vtable decl yet\n");
1241 fprintf (stderr
, "virtuals:\n");
1242 virtuals
= BINFO_VIRTUALS (elem
);
1244 n
= skip_rtti_stuff (&virtuals
);
1248 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1249 fprintf (stderr
, "%s [%ld =? %ld]\n",
1250 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1251 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1253 virtuals
= TREE_CHAIN (virtuals
);
1257 /* Initialize an CPLUS_BINDING node that does not live on an obstack. */
1261 struct tree_binding
* node
;
1263 static struct tree_binding
* source
;
1266 extern struct obstack permanent_obstack
;
1267 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1268 source
= (struct tree_binding
*)make_node (CPLUS_BINDING
);
1272 TREE_PERMANENT ((tree
)node
) = 0;
1281 if (TREE_CODE (t
) == FUNCTION_DECL
)
1283 else if (TREE_CODE (t
) == OVERLOAD
)
1285 for (i
=0; t
; t
= OVL_CHAIN (t
))
1290 my_friendly_abort (359);
1295 is_overloaded_fn (x
)
1298 /* XXX A baselink is also considered an overloaded function.
1299 As is a placeholder from push_class_decls.
1300 As is an expression like X::f. */
1301 if (TREE_CODE (x
) == TREE_LIST
)
1303 if (TREE_PURPOSE (x
) == error_mark_node
)
1306 my_friendly_assert (TREE_CODE (x
) == TREE_LIST
, 981121);
1308 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x
)) == TREE_VEC
1309 || TREE_CODE (TREE_PURPOSE (x
)) == IDENTIFIER_NODE
,
1313 return (TREE_CODE (x
) == FUNCTION_DECL
1314 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
1315 || DECL_FUNCTION_TEMPLATE_P (x
)
1316 || TREE_CODE (x
) == OVERLOAD
);
1320 really_overloaded_fn (x
)
1323 /* A baselink is also considered an overloaded function.
1324 This might also be an ambiguous class member. */
1325 if (TREE_CODE (x
) == TREE_LIST
)
1327 return (TREE_CODE (x
) == OVERLOAD
1328 && (TREE_CHAIN (x
) != NULL_TREE
1329 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
1336 my_friendly_assert (is_overloaded_fn (from
), 9);
1337 /* A baselink is also considered an overloaded function. */
1338 if (TREE_CODE (from
) == TREE_LIST
)
1339 from
= TREE_VALUE (from
);
1340 return OVL_CURRENT (from
);
1343 /* Returns nonzero if T is a ->* or .* expression that refers to a
1350 return (TREE_CODE (t
) == OFFSET_REF
1351 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t
, 1))));
1354 /* Return a new OVL node, concatenating it with the old one. */
1357 ovl_cons (decl
, chain
)
1361 tree result
= make_node (OVERLOAD
);
1362 TREE_TYPE (result
) = unknown_type_node
;
1363 OVL_FUNCTION (result
) = decl
;
1364 TREE_CHAIN (result
) = chain
;
1369 /* Same as ovl_cons, but on the scratch_obstack. */
1372 scratch_ovl_cons (value
, chain
)
1376 register struct obstack
*ambient_obstack
= current_obstack
;
1377 extern struct obstack
*expression_obstack
;
1378 current_obstack
= expression_obstack
;
1379 node
= ovl_cons (value
, chain
);
1380 current_obstack
= ambient_obstack
;
1384 /* Build a new overloaded function. If this is the first one,
1385 just return it; otherwise, ovl_cons the _DECLs */
1388 build_overload (decl
, chain
)
1392 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1394 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1395 chain
= ovl_cons (chain
, NULL_TREE
);
1396 return ovl_cons (decl
, chain
);
1399 /* Returns true iff functions are equivalent. Equivalent functions are
1400 not identical only if one is a function-local extern function.
1401 This assumes that function-locals don't have TREE_PERMANENT. */
1404 equal_functions (fn1
, fn2
)
1408 if (!TREE_PERMANENT (fn1
) || !TREE_PERMANENT (fn2
))
1409 return decls_match (fn1
, fn2
);
1413 /* True if fn is in ovl. */
1416 ovl_member (fn
, ovl
)
1420 if (ovl
== NULL_TREE
)
1422 if (TREE_CODE (ovl
) != OVERLOAD
)
1423 return equal_functions (ovl
, fn
);
1424 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1425 if (equal_functions (OVL_FUNCTION (ovl
), fn
))
1431 is_aggr_type_2 (t1
, t2
)
1434 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1436 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1439 #define PRINT_RING_SIZE 4
1442 lang_printable_name (decl
, v
)
1446 static tree decl_ring
[PRINT_RING_SIZE
];
1447 static char *print_ring
[PRINT_RING_SIZE
];
1448 static int ring_counter
;
1451 /* Only cache functions. */
1453 || TREE_CODE (decl
) != FUNCTION_DECL
1454 || DECL_LANG_SPECIFIC (decl
) == 0)
1455 return lang_decl_name (decl
, v
);
1457 /* See if this print name is lying around. */
1458 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1459 if (decl_ring
[i
] == decl
)
1460 /* yes, so return it. */
1461 return print_ring
[i
];
1463 if (++ring_counter
== PRINT_RING_SIZE
)
1466 if (current_function_decl
!= NULL_TREE
)
1468 if (decl_ring
[ring_counter
] == current_function_decl
)
1470 if (ring_counter
== PRINT_RING_SIZE
)
1472 if (decl_ring
[ring_counter
] == current_function_decl
)
1473 my_friendly_abort (106);
1476 if (print_ring
[ring_counter
])
1477 free (print_ring
[ring_counter
]);
1479 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1480 decl_ring
[ring_counter
] = decl
;
1481 return print_ring
[ring_counter
];
1484 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1485 listed in RAISES. */
1488 build_exception_variant (type
, raises
)
1492 tree v
= TYPE_MAIN_VARIANT (type
);
1493 int type_quals
= TYPE_QUALS (type
);
1495 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1500 if (TYPE_QUALS (v
) != type_quals
)
1503 for (t
= TYPE_RAISES_EXCEPTIONS (v
), u
= raises
;
1504 t
!= NULL_TREE
&& u
!= NULL_TREE
;
1505 t
= TREE_CHAIN (t
), u
= TREE_CHAIN (v
))
1506 if (((TREE_VALUE (t
) != NULL_TREE
)
1507 != (TREE_VALUE (u
) != NULL_TREE
))
1508 || !same_type_p (TREE_VALUE (t
), TREE_VALUE (u
)))
1512 /* There's a memory leak here; RAISES is not freed. */
1516 /* Need to build a new variant. */
1517 v
= build_type_copy (type
);
1519 if (raises
&& ! TREE_PERMANENT (raises
))
1520 raises
= copy_to_permanent (raises
);
1522 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1526 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1527 lang_specific field and its corresponding TEMPLATE_DECL node */
1530 copy_template_template_parm (t
)
1533 tree
template = TYPE_NAME (t
);
1536 /* Make sure these end up on the permanent_obstack. */
1537 push_obstacks_nochange ();
1538 end_temporary_allocation ();
1540 t2
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1541 template = copy_node (template);
1542 copy_lang_decl (template);
1546 TREE_TYPE (template) = t2
;
1547 TYPE_NAME (t2
) = template;
1548 TYPE_STUB_DECL (t2
) = template;
1550 /* No need to copy these */
1551 TYPE_FIELDS (t2
) = TYPE_FIELDS (t
);
1552 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1553 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
1557 /* Walk through the tree structure T, applying func. If func ever returns
1558 non-null, return that value. */
1561 search_tree (t
, func
)
1563 tree (*func
) PROTO((tree
));
1565 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1572 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1575 switch (TREE_CODE (t
))
1580 case IDENTIFIER_NODE
:
1587 case NAMESPACE_DECL
:
1591 TRY (TREE_TYPE (t
));
1595 TRY (TREE_TYPE (t
));
1596 TRY (TREE_CHAIN (t
));
1600 TRY (TREE_PURPOSE (t
));
1601 TRY (TREE_VALUE (t
));
1602 TRY (TREE_CHAIN (t
));
1606 TRY (OVL_FUNCTION (t
));
1607 TRY (OVL_CHAIN (t
));
1612 int len
= TREE_VEC_LENGTH (t
);
1616 TRY (TREE_VEC_ELT (t
, len
));
1627 TRY (TREE_TYPE (t
));
1632 case AGGR_INIT_EXPR
:
1634 TRY (TREE_OPERAND (t
, 0));
1635 TRY (TREE_OPERAND (t
, 1));
1636 TRY (TREE_OPERAND (t
, 2));
1643 case TRUNC_DIV_EXPR
:
1644 case TRUNC_MOD_EXPR
:
1652 case BIT_ANDTC_EXPR
:
1653 case TRUTH_ANDIF_EXPR
:
1654 case TRUTH_ORIF_EXPR
:
1662 case FLOOR_DIV_EXPR
:
1663 case ROUND_DIV_EXPR
:
1665 case FLOOR_MOD_EXPR
:
1666 case ROUND_MOD_EXPR
:
1668 case PREDECREMENT_EXPR
:
1669 case PREINCREMENT_EXPR
:
1670 case POSTDECREMENT_EXPR
:
1671 case POSTINCREMENT_EXPR
:
1674 case TRY_CATCH_EXPR
:
1675 case WITH_CLEANUP_EXPR
:
1677 TRY (TREE_OPERAND (t
, 0));
1678 TRY (TREE_OPERAND (t
, 1));
1687 case TRUTH_NOT_EXPR
:
1689 case NON_LVALUE_EXPR
:
1691 case CLEANUP_POINT_EXPR
:
1695 TRY (TREE_OPERAND (t
, 0));
1700 case REINTERPRET_CAST_EXPR
:
1701 case CONST_CAST_EXPR
:
1702 case STATIC_CAST_EXPR
:
1703 case DYNAMIC_CAST_EXPR
:
1710 TRY (TREE_REALPART (t
));
1711 TRY (TREE_IMAGPART (t
));
1715 TRY (CONSTRUCTOR_ELTS (t
));
1718 case TEMPLATE_TEMPLATE_PARM
:
1719 case TEMPLATE_PARM_INDEX
:
1720 case TEMPLATE_TYPE_PARM
:
1737 case REFERENCE_TYPE
:
1738 TRY (TREE_TYPE (t
));
1743 TRY (TREE_TYPE (t
));
1744 TRY (TYPE_ARG_TYPES (t
));
1748 TRY (TREE_TYPE (t
));
1749 TRY (TYPE_DOMAIN (t
));
1753 TRY (TYPE_MAX_VALUE (t
));
1757 TRY (TREE_TYPE (t
));
1758 TRY (TYPE_OFFSET_BASETYPE (t
));
1762 if (TYPE_PTRMEMFUNC_P (t
))
1763 TRY (TYPE_PTRMEMFUNC_FN_TYPE (t
));
1766 /* This list is incomplete, but should suffice for now.
1767 It is very important that `sorry' not call
1768 `report_error_function'. That could cause an infinite loop. */
1770 sorry ("initializer contains unrecognized tree code");
1771 return error_mark_node
;
1780 /* Passed to search_tree. Checks for the use of types with no linkage. */
1783 no_linkage_helper (t
)
1787 && (IS_AGGR_TYPE (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1788 && (decl_function_context (TYPE_MAIN_DECL (t
))
1789 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
))))
1794 /* Check if the type T depends on a type with no linkage and if so, return
1798 no_linkage_check (t
)
1801 t
= search_tree (t
, no_linkage_helper
);
1802 if (t
!= error_mark_node
)
1808 /* Subroutine of copy_to_permanent
1810 Assuming T is a node build bottom-up, make it all exist on
1811 permanent obstack, if it is not permanent already. */
1816 tree (*func
) PROTO((tree
));
1823 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1826 switch (TREE_CODE (t
))
1829 return error_mark_node
;
1834 /* Rather than aborting, return error_mark_node. This allows us
1835 to report a sensible error message on code like this:
1837 void g() { int i; f<i>(7); }
1841 void g() { const int i = 7; f<i>(7); }
1843 however, we must actually return the constant initializer. */
1844 if (TREE_READONLY_DECL_P (t
))
1846 tmp
= decl_constant_value (t
);
1848 return mapcar (tmp
, func
);
1850 return error_mark_node
;
1854 tree chain
= TREE_CHAIN (t
);
1856 TREE_CHAIN (t
) = mapcar (chain
, func
);
1857 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1858 DECL_INITIAL (t
) = mapcar (DECL_INITIAL (t
), func
);
1859 DECL_SIZE (t
) = mapcar (DECL_SIZE (t
), func
);
1865 tree chain
= TREE_CHAIN (t
);
1867 TREE_PURPOSE (t
) = mapcar (TREE_PURPOSE (t
), func
);
1868 TREE_VALUE (t
) = mapcar (TREE_VALUE (t
), func
);
1869 TREE_CHAIN (t
) = mapcar (chain
, func
);
1875 tree chain
= OVL_CHAIN (t
);
1877 OVL_FUNCTION (t
) = mapcar (OVL_FUNCTION (t
), func
);
1878 OVL_CHAIN (t
) = mapcar (chain
, func
);
1884 int len
= TREE_VEC_LENGTH (t
);
1888 TREE_VEC_ELT (t
, len
) = mapcar (TREE_VEC_ELT (t
, len
), func
);
1895 return copy_node (t
);
1899 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1900 PTRMEM_CST_MEMBER (t
) = mapcar (PTRMEM_CST_MEMBER (t
), func
);
1905 case AGGR_INIT_EXPR
:
1907 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1908 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1909 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1914 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1921 case TRUNC_DIV_EXPR
:
1922 case TRUNC_MOD_EXPR
:
1930 case BIT_ANDTC_EXPR
:
1931 case TRUTH_ANDIF_EXPR
:
1932 case TRUTH_ORIF_EXPR
:
1940 case FLOOR_DIV_EXPR
:
1941 case ROUND_DIV_EXPR
:
1943 case FLOOR_MOD_EXPR
:
1944 case ROUND_MOD_EXPR
:
1946 case PREDECREMENT_EXPR
:
1947 case PREINCREMENT_EXPR
:
1948 case POSTDECREMENT_EXPR
:
1949 case POSTINCREMENT_EXPR
:
1952 case TRY_CATCH_EXPR
:
1953 case WITH_CLEANUP_EXPR
:
1955 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1956 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1961 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1962 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1963 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1965 /* tree.def says that operand two is RTL, but
1966 make_call_declarator puts trees in there. */
1967 if (TREE_OPERAND (t
, 2)
1968 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1969 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1971 TREE_OPERAND (t
, 2) = NULL_TREE
;
1979 case TRUTH_NOT_EXPR
:
1982 case CLEANUP_POINT_EXPR
:
1984 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1985 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1989 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1990 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
1991 case REFERENCE_TYPE
:
1992 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1993 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
1995 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1996 mapcar (TYPE_ARG_TYPES (t
), func
));
1997 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
1999 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
2000 mapcar (TYPE_DOMAIN (t
), func
));
2001 return cp_build_qualified_type (tmp
, CP_TYPE_QUALS (t
));
2003 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
2004 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
2006 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
2007 mapcar (TREE_TYPE (t
), func
));
2008 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
2010 tmp
= build_cplus_method_type
2011 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
2012 mapcar (TREE_TYPE (t
), func
),
2013 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
2014 return cp_build_qualified_type (tmp
, TYPE_QUALS (t
));
2018 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
2019 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
2024 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
2027 case TEMPLATE_TEMPLATE_PARM
:
2028 return copy_template_template_parm (t
);
2032 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
2033 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
2034 TREE_OPERAND (t
, 2) = NULL_TREE
;
2039 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
2040 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
2041 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
2046 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
2050 if (TYPE_PTRMEMFUNC_P (t
))
2051 return build_ptrmemfunc_type
2052 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
2053 /* else fall through */
2055 /* This list is incomplete, but should suffice for now.
2056 It is very important that `sorry' not call
2057 `report_error_function'. That could cause an infinite loop. */
2059 sorry ("initializer contains unrecognized tree code");
2060 return error_mark_node
;
2063 my_friendly_abort (107);
2072 if (TREE_PERMANENT (t
))
2075 /* Support `void f () { extern int i; A<&i> a; }' */
2076 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
2081 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */
2083 make_decl_rtl (t
, NULL_PTR
, 1);
2090 /* Assuming T is a node built bottom-up, make it all exist on
2091 permanent obstack, if it is not permanent already. */
2094 copy_to_permanent (t
)
2097 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
2100 push_obstacks_nochange ();
2101 end_temporary_allocation ();
2103 t
= mapcar (t
, perm_manip
);
2110 #ifdef GATHER_STATISTICS
2111 extern int depth_reached
;
2115 print_lang_statistics ()
2117 extern struct obstack decl_obstack
;
2118 print_obstack_statistics ("class_obstack", &class_obstack
);
2119 print_obstack_statistics ("decl_obstack", &decl_obstack
);
2120 print_search_statistics ();
2121 print_class_statistics ();
2122 #ifdef GATHER_STATISTICS
2123 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2128 /* This is used by the `assert' macro. It is provided in libgcc.a,
2129 which `cc' doesn't know how to link. Note that the C++ front-end
2130 no longer actually uses the `assert' macro (instead, it calls
2131 my_friendly_assert). But all of the back-end files still need this. */
2134 __eprintf (string
, expression
, line
, filename
)
2136 const char *expression
;
2138 const char *filename
;
2140 fprintf (stderr
, string
, expression
, line
, filename
);
2145 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2146 (which is an ARRAY_TYPE). This counts only elements of the top
2150 array_type_nelts_top (type
)
2153 return fold (build (PLUS_EXPR
, sizetype
,
2154 array_type_nelts (type
),
2158 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2159 (which is an ARRAY_TYPE). This one is a recursive count of all
2160 ARRAY_TYPEs that are clumped together. */
2163 array_type_nelts_total (type
)
2166 tree sz
= array_type_nelts_top (type
);
2167 type
= TREE_TYPE (type
);
2168 while (TREE_CODE (type
) == ARRAY_TYPE
)
2170 tree n
= array_type_nelts_top (type
);
2171 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
2172 type
= TREE_TYPE (type
);
2182 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
2184 else if (TREE_CODE (t
) == TARGET_EXPR
)
2186 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2188 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
2189 return build_cplus_new
2190 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
2193 TREE_OPERAND (t
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
2194 layout_decl (TREE_OPERAND (t
, 0), 0);
2197 else if (TREE_CODE (t
) == CALL_EXPR
)
2198 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
2203 /* Actually, we'll just clean out the target exprs for the moment. */
2206 break_out_target_exprs (t
)
2209 return mapcar (t
, bot_manip
);
2212 /* Obstack used for allocating nodes in template function and variable
2215 /* Similar to `build_nt', except we build
2216 on the permanent_obstack, regardless. */
2219 build_min_nt
VPROTO((enum tree_code code
, ...))
2222 enum tree_code code
;
2224 register struct obstack
*ambient_obstack
= expression_obstack
;
2227 register int length
;
2233 code
= va_arg (p
, enum tree_code
);
2236 expression_obstack
= &permanent_obstack
;
2238 t
= make_node (code
);
2239 length
= tree_code_length
[(int) code
];
2240 TREE_COMPLEXITY (t
) = lineno
;
2242 for (i
= 0; i
< length
; i
++)
2244 tree x
= va_arg (p
, tree
);
2245 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
2249 expression_obstack
= ambient_obstack
;
2253 /* Similar to `build', except we build
2254 on the permanent_obstack, regardless. */
2257 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
2260 enum tree_code code
;
2263 register struct obstack
*ambient_obstack
= expression_obstack
;
2266 register int length
;
2272 code
= va_arg (p
, enum tree_code
);
2273 tt
= va_arg (p
, tree
);
2276 expression_obstack
= &permanent_obstack
;
2278 t
= make_node (code
);
2279 length
= tree_code_length
[(int) code
];
2280 TREE_TYPE (t
) = copy_to_permanent (tt
);
2281 TREE_COMPLEXITY (t
) = lineno
;
2283 for (i
= 0; i
< length
; i
++)
2285 tree x
= va_arg (p
, tree
);
2286 TREE_OPERAND (t
, i
) = copy_to_permanent (x
);
2290 expression_obstack
= ambient_obstack
;
2294 /* Same as `tree_cons' but make a permanent object. */
2297 min_tree_cons (purpose
, value
, chain
)
2298 tree purpose
, value
, chain
;
2301 register struct obstack
*ambient_obstack
= current_obstack
;
2302 current_obstack
= &permanent_obstack
;
2304 node
= tree_cons (copy_to_permanent (purpose
),
2305 copy_to_permanent (value
), chain
);
2306 current_obstack
= ambient_obstack
;
2314 if (TREE_CODE (t
) == TYPE_DECL
)
2316 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
2317 return TYPE_STUB_DECL (t
);
2319 my_friendly_abort (42);
2321 /* Stop compiler from complaining control reaches end of non-void function. */
2326 can_free (obstack
, t
)
2327 struct obstack
*obstack
;
2332 if (TREE_CODE (t
) == TREE_VEC
)
2333 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
2335 my_friendly_abort (42);
2337 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2338 & ~ obstack_alignment_mask (obstack))
2339 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
2346 /* Return first vector element whose BINFO_TYPE is ELEM.
2347 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
2350 vec_binfo_member (elem
, vec
)
2356 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
2357 if (same_type_p (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
))))
2358 return TREE_VEC_ELT (vec
, i
);
2363 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2364 the wrong thing for decl_function_context. Hopefully the uses in the
2365 backend won't matter, since we don't need a static chain for local class
2369 hack_decl_function_context (decl
)
2372 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
2373 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
2374 return decl_function_context (decl
);
2377 /* Returns the namespace that contains DECL, whether directly or
2381 decl_namespace_context (decl
)
2386 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2388 else if (TYPE_P (decl
))
2389 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
2391 decl
= CP_DECL_CONTEXT (decl
);
2395 /* Return truthvalue of whether T1 is the same tree structure as T2.
2396 Return 1 if they are the same.
2397 Return 0 if they are understandably different.
2398 Return -1 if either contains tree structure not understood by
2402 cp_tree_equal (t1
, t2
)
2405 register enum tree_code code1
, code2
;
2410 if (t1
== 0 || t2
== 0)
2413 code1
= TREE_CODE (t1
);
2414 code2
= TREE_CODE (t2
);
2416 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
2418 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
2419 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2421 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
2423 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
2424 || code2
== NON_LVALUE_EXPR
)
2425 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
2433 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
2434 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
2437 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2440 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2441 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2442 TREE_STRING_LENGTH (t1
));
2445 /* We need to do this when determining whether or not two
2446 non-type pointer to member function template arguments
2448 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2449 /* The first operand is RTL. */
2450 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
2452 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2455 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
2458 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
2461 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
2464 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2467 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2470 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2473 /* Special case: if either target is an unallocated VAR_DECL,
2474 it means that it's going to be unified with whatever the
2475 TARGET_EXPR is really supposed to initialize, so treat it
2476 as being equivalent to anything. */
2477 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
2478 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
2479 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
2480 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
2481 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
2482 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2485 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2488 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2490 case WITH_CLEANUP_EXPR
:
2491 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2494 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2497 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2498 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2507 case TEMPLATE_PARM_INDEX
:
2508 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2509 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
2513 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2515 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2516 return same_type_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2520 /* Two pointer-to-members are the same if they point to the same
2521 field or function in the same class. */
2522 return (PTRMEM_CST_MEMBER (t1
) == PTRMEM_CST_MEMBER (t2
)
2523 && same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
)));
2529 switch (TREE_CODE_CLASS (code1
))
2539 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2541 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2551 /* Similar to make_tree_vec, but build on the momentary_obstack.
2552 Thus, these vectors are really and truly temporary. */
2559 push_expression_obstack ();
2560 node
= make_tree_vec (len
);
2565 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2568 build_ptr_wrapper (ptr
)
2571 tree t
= make_node (WRAPPER
);
2572 WRAPPER_PTR (t
) = ptr
;
2576 /* Same, but on the expression_obstack. */
2579 build_expr_ptr_wrapper (ptr
)
2583 push_expression_obstack ();
2584 t
= build_ptr_wrapper (ptr
);
2589 /* Build a wrapper around some integer I so we can use it as a tree. */
2592 build_int_wrapper (i
)
2595 tree t
= make_node (WRAPPER
);
2596 WRAPPER_INT (t
) = i
;
2601 build_srcloc (file
, line
)
2607 /* Make sure that we put these on the permanent obstack; up in
2608 add_pending_template, we pass this return value into perm_tree_cons,
2609 which also puts it on the permanent_obstack. However, this wasn't
2610 explicitly doing the same. */
2611 register struct obstack
*ambient_obstack
= current_obstack
;
2612 current_obstack
= &permanent_obstack
;
2614 t
= make_node (SRCLOC
);
2615 SRCLOC_FILE (t
) = file
;
2616 SRCLOC_LINE (t
) = line
;
2618 current_obstack
= ambient_obstack
;
2624 build_srcloc_here ()
2626 return build_srcloc (input_filename
, lineno
);
2630 push_expression_obstack ()
2632 push_obstacks_nochange ();
2633 current_obstack
= expression_obstack
;
2636 /* The type of ARG when used as an lvalue. */
2642 tree type
= TREE_TYPE (arg
);
2643 if (TREE_CODE (arg
) == OVERLOAD
)
2644 type
= unknown_type_node
;
2648 /* The type of ARG for printing error messages; denote lvalues with
2655 tree type
= TREE_TYPE (arg
);
2656 if (TREE_CODE (type
) == ARRAY_TYPE
)
2658 else if (real_lvalue_p (arg
))
2659 type
= build_reference_type (lvalue_type (arg
));
2660 else if (IS_AGGR_TYPE (type
))
2661 type
= lvalue_type (arg
);
2666 /* Does FUNCTION use a variable-length argument list? */
2669 varargs_function_p (function
)
2672 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2673 for (; parm
; parm
= TREE_CHAIN (parm
))
2674 if (TREE_VALUE (parm
) == void_type_node
)
2679 /* Returns 1 if decl is a member of a class. */
2685 tree ctx
= DECL_CONTEXT (decl
);
2686 return (ctx
&& TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't');
2689 /* Create a placeholder for member access where we don't actually have an
2690 object that the access is against. */
2693 build_dummy_object (type
)
2696 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
2697 return build_indirect_ref (decl
, NULL_PTR
);
2700 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2701 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2702 binfo path from current_class_type to TYPE, or 0. */
2705 maybe_dummy_object (type
, binfop
)
2711 if (current_class_type
2712 && get_base_distance (type
, current_class_type
, 0, binfop
) != -1)
2713 context
= current_class_type
;
2716 /* Reference from a nested class member function. */
2719 *binfop
= TYPE_BINFO (type
);
2722 if (current_class_ref
&& context
== current_class_type
)
2723 decl
= current_class_ref
;
2725 decl
= build_dummy_object (context
);
2730 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2733 is_dummy_object (ob
)
2736 if (TREE_CODE (ob
) == INDIRECT_REF
)
2737 ob
= TREE_OPERAND (ob
, 0);
2738 return (TREE_CODE (ob
) == NOP_EXPR
2739 && TREE_OPERAND (ob
, 0) == void_zero_node
);
2742 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2750 while (TREE_CODE (t
) == ARRAY_TYPE
)
2753 if (! IS_AGGR_TYPE (t
))
2756 if (CLASSTYPE_NON_AGGREGATE (t
)
2757 || TYPE_HAS_COMPLEX_ASSIGN_REF (t
)
2758 || TYPE_HAS_DESTRUCTOR (t
))
2761 for (f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
2763 if (TREE_CODE (f
) != FIELD_DECL
)
2766 if (TREE_CODE (TREE_TYPE (f
)) == REFERENCE_TYPE
2767 || TYPE_PTRMEMFUNC_P (TREE_TYPE (f
))
2768 || TYPE_PTRMEM_P (TREE_TYPE (f
)))