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. */
31 extern void compiler_error ();
33 static tree get_identifier_list
PROTO((tree
));
34 static tree bot_manip
PROTO((tree
));
35 static tree perm_manip
PROTO((tree
));
36 static tree build_cplus_array_type_1
PROTO((tree
, tree
));
37 static void list_hash_add
PROTO((int, tree
));
38 static int list_hash
PROTO((tree
, tree
, tree
));
39 static tree list_hash_lookup
PROTO((int, int, int, int, tree
, tree
,
41 static void propagate_binfo_offsets
PROTO((tree
, tree
));
42 static int avoid_overlap
PROTO((tree
, tree
));
44 #define CEIL(x,y) (((x) + (y) - 1) / (y))
46 /* Return nonzero if REF is an lvalue valid for this language.
47 Lvalues can be assigned, unless they have TREE_READONLY.
48 Lvalues can have their address taken, unless they have DECL_REGISTER. */
54 if (! language_lvalue_valid (ref
))
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
:
74 return real_lvalue_p (TREE_OPERAND (ref
, 0));
80 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
81 && DECL_LANG_SPECIFIC (ref
)
82 && DECL_IN_AGGR_P (ref
))
89 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
90 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
94 /* A currently unresolved scope ref. */
96 my_friendly_abort (103);
98 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
100 return real_lvalue_p (TREE_OPERAND (ref
, 0))
101 && real_lvalue_p (TREE_OPERAND (ref
, 1));
105 return (real_lvalue_p (TREE_OPERAND (ref
, 1))
106 && real_lvalue_p (TREE_OPERAND (ref
, 2)));
112 return real_lvalue_p (TREE_OPERAND (ref
, 1));
116 return (real_lvalue_p (TREE_OPERAND (ref
, 0))
117 && real_lvalue_p (TREE_OPERAND (ref
, 1)));
126 /* This differs from real_lvalue_p in that class rvalues are considered
132 if (! language_lvalue_valid (ref
))
135 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
138 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
141 switch (TREE_CODE (ref
))
143 /* preincrements and predecrements are valid lvals, provided
144 what they refer to are valid lvals. */
145 case PREINCREMENT_EXPR
:
146 case PREDECREMENT_EXPR
:
153 case WITH_CLEANUP_EXPR
:
154 return lvalue_p (TREE_OPERAND (ref
, 0));
160 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
161 && DECL_LANG_SPECIFIC (ref
)
162 && DECL_IN_AGGR_P (ref
))
169 if (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
170 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
178 if (IS_AGGR_TYPE (TREE_TYPE (ref
)))
182 /* A currently unresolved scope ref. */
184 my_friendly_abort (103);
186 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
188 return lvalue_p (TREE_OPERAND (ref
, 0))
189 && lvalue_p (TREE_OPERAND (ref
, 1));
193 return (lvalue_p (TREE_OPERAND (ref
, 1))
194 && lvalue_p (TREE_OPERAND (ref
, 2)));
200 return lvalue_p (TREE_OPERAND (ref
, 1));
204 return (lvalue_p (TREE_OPERAND (ref
, 0))
205 && lvalue_p (TREE_OPERAND (ref
, 1)));
214 /* Return nonzero if REF is an lvalue valid for this language;
215 otherwise, print an error message and return zero. */
218 lvalue_or_else (ref
, string
)
222 int win
= lvalue_p (ref
);
224 error ("non-lvalue in %s", string
);
228 /* INIT is a CALL_EXPR which needs info about its target.
229 TYPE is the type that this initialization should appear to have.
231 Build an encapsulation of the initialization to perform
232 and return it so that it can be processed by language-independent
233 and language-specific expression expanders. */
236 build_cplus_new (type
, init
)
243 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
246 slot
= build (VAR_DECL
, type
);
247 DECL_ARTIFICIAL (slot
) = 1;
248 layout_decl (slot
, 0);
249 rval
= build (AGGR_INIT_EXPR
, type
,
250 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), slot
);
251 TREE_SIDE_EFFECTS (rval
) = 1;
252 rval
= build (TARGET_EXPR
, type
, slot
, rval
, NULL_TREE
, NULL_TREE
);
253 TREE_SIDE_EFFECTS (rval
) = 1;
258 /* Encapsulate the expression INIT in a TARGET_EXPR. */
261 get_target_expr (init
)
267 slot
= build (VAR_DECL
, TREE_TYPE (init
));
268 DECL_ARTIFICIAL (slot
) = 1;
269 layout_decl (slot
, 0);
270 rval
= build (TARGET_EXPR
, TREE_TYPE (init
), slot
, init
,
271 NULL_TREE
, NULL_TREE
);
272 TREE_SIDE_EFFECTS (rval
) = 1;
277 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
278 these CALL_EXPRs with tree nodes that will perform the cleanups. */
281 break_out_cleanups (exp
)
286 if (TREE_CODE (tmp
) == CALL_EXPR
287 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
288 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
290 while (TREE_CODE (tmp
) == NOP_EXPR
291 || TREE_CODE (tmp
) == CONVERT_EXPR
292 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
294 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
295 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
297 TREE_OPERAND (tmp
, 0)
298 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
299 TREE_OPERAND (tmp
, 0));
303 tmp
= TREE_OPERAND (tmp
, 0);
308 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
309 copies where they are found. Returns a deep copy all nodes transitively
310 containing CALL_EXPRs. */
313 break_out_calls (exp
)
316 register tree t1
, t2
= NULL_TREE
;
317 register enum tree_code code
;
318 register int changed
= 0;
321 if (exp
== NULL_TREE
)
324 code
= TREE_CODE (exp
);
326 if (code
== CALL_EXPR
)
327 return copy_node (exp
);
329 /* Don't try and defeat a save_expr, as it should only be done once. */
330 if (code
== SAVE_EXPR
)
333 switch (TREE_CODE_CLASS (code
))
338 case 'c': /* a constant */
339 case 't': /* a type node */
340 case 'x': /* something random, like an identifier or an ERROR_MARK. */
343 case 'd': /* A decl node */
344 #if 0 /* This is bogus. jason 9/21/94 */
346 t1
= break_out_calls (DECL_INITIAL (exp
));
347 if (t1
!= DECL_INITIAL (exp
))
349 exp
= copy_node (exp
);
350 DECL_INITIAL (exp
) = t1
;
355 case 'b': /* A block node */
357 /* Don't know how to handle these correctly yet. Must do a
358 break_out_calls on all DECL_INITIAL values for local variables,
359 and also break_out_calls on all sub-blocks and sub-statements. */
364 case 'e': /* an expression */
365 case 'r': /* a reference */
366 case 's': /* an expression with side effects */
367 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
369 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
370 if (t1
!= TREE_OPERAND (exp
, i
))
372 exp
= copy_node (exp
);
373 TREE_OPERAND (exp
, i
) = t1
;
378 case '<': /* a comparison expression */
379 case '2': /* a binary arithmetic expression */
380 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
381 if (t2
!= TREE_OPERAND (exp
, 1))
383 case '1': /* a unary arithmetic expression */
384 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
385 if (t1
!= TREE_OPERAND (exp
, 0))
389 if (tree_code_length
[(int) code
] == 1)
390 return build1 (code
, TREE_TYPE (exp
), t1
);
392 return build (code
, TREE_TYPE (exp
), t1
, t2
);
399 extern struct obstack
*current_obstack
;
400 extern struct obstack permanent_obstack
, class_obstack
;
401 extern struct obstack
*saveable_obstack
;
402 extern struct obstack
*expression_obstack
;
404 /* Here is how primitive or already-canonicalized types' hash
405 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
406 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
408 /* Construct, lay out and return the type of methods belonging to class
409 BASETYPE and whose arguments are described by ARGTYPES and whose values
410 are described by RETTYPE. If each type exists already, reuse it. */
413 build_cplus_method_type (basetype
, rettype
, argtypes
)
414 tree basetype
, rettype
, argtypes
;
420 /* Make a node of the sort we want. */
421 t
= make_node (METHOD_TYPE
);
423 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
424 TREE_TYPE (t
) = rettype
;
425 if (IS_SIGNATURE (basetype
))
426 ptype
= build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype
),
427 TYPE_READONLY (basetype
),
428 TYPE_VOLATILE (basetype
));
430 ptype
= build_pointer_type (basetype
);
432 /* The actual arglist for this function includes a "hidden" argument
433 which is "this". Put it into the list of argument types. */
435 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
436 TYPE_ARG_TYPES (t
) = argtypes
;
437 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
439 /* If we already have such a type, use the old one and free this one.
440 Note that it also frees up the above cons cell if found. */
441 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) + type_hash_list (argtypes
);
442 t
= type_hash_canon (hashcode
, t
);
444 if (TYPE_SIZE (t
) == 0)
451 build_cplus_array_type_1 (elt_type
, index_type
)
455 register struct obstack
*ambient_obstack
= current_obstack
;
456 register struct obstack
*ambient_saveable_obstack
= saveable_obstack
;
459 /* We need a new one. If both ELT_TYPE and INDEX_TYPE are permanent,
460 make this permanent too. */
461 if (TREE_PERMANENT (elt_type
)
462 && (index_type
== 0 || TREE_PERMANENT (index_type
)))
464 current_obstack
= &permanent_obstack
;
465 saveable_obstack
= &permanent_obstack
;
468 if (processing_template_decl
469 || uses_template_parms (index_type
))
471 t
= make_node (ARRAY_TYPE
);
472 TREE_TYPE (t
) = elt_type
;
473 TYPE_DOMAIN (t
) = index_type
;
476 t
= build_array_type (elt_type
, index_type
);
478 /* Push these needs up so that initialization takes place
480 TYPE_NEEDS_CONSTRUCTING (t
) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
481 TYPE_NEEDS_DESTRUCTOR (t
) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
482 current_obstack
= ambient_obstack
;
483 saveable_obstack
= ambient_saveable_obstack
;
488 build_cplus_array_type (elt_type
, index_type
)
493 int constp
= TYPE_READONLY (elt_type
);
494 int volatilep
= TYPE_VOLATILE (elt_type
);
495 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
497 t
= build_cplus_array_type_1 (elt_type
, index_type
);
499 if (constp
|| volatilep
)
500 t
= cp_build_type_variant (t
, constp
, volatilep
);
505 /* Make a variant type in the proper way for C/C++, propagating qualifiers
506 down to the element type of an array. */
509 cp_build_type_variant (type
, constp
, volatilep
)
511 int constp
, volatilep
;
513 if (type
== error_mark_node
)
516 if (TREE_CODE (type
) == ARRAY_TYPE
)
518 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
520 push_obstacks (TYPE_OBSTACK (real_main_variant
),
521 TYPE_OBSTACK (real_main_variant
));
522 type
= build_cplus_array_type_1 (cp_build_type_variant
523 (TREE_TYPE (type
), constp
, volatilep
),
526 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
527 make a copy. (TYPE might have come from the hash table and
528 REAL_MAIN_VARIANT might be in some function's obstack.) */
530 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
532 type
= copy_node (type
);
533 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
536 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
540 return build_type_variant (type
, constp
, volatilep
);
543 /* Returns the canonical version of TYPE. In other words, if TYPE is
544 a typedef, returns the underlying type. The cv-qualification of
545 the type returned matches the type input; they will always be
549 canonical_type_variant (t
)
552 int constp
, volatilep
;
553 if (TREE_CODE (t
) == ARRAY_TYPE
)
555 constp
= TYPE_READONLY (TREE_TYPE (t
));
556 volatilep
= TYPE_VOLATILE (TREE_TYPE (t
));
560 constp
= TYPE_READONLY (t
);
561 volatilep
= TYPE_VOLATILE (t
);
563 return cp_build_type_variant (TYPE_MAIN_VARIANT (t
), constp
, volatilep
);
566 /* Add OFFSET to all base types of T.
568 OFFSET, which is a type offset, is number of bytes.
570 Note that we don't have to worry about having two paths to the
571 same base type, since this type owns its association list. */
574 propagate_binfo_offsets (binfo
, offset
)
578 tree binfos
= BINFO_BASETYPES (binfo
);
579 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
581 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
583 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
585 if (TREE_VIA_VIRTUAL (base_binfo
))
590 tree delta
= NULL_TREE
;
592 for (j
= i
+1; j
< n_baselinks
; j
++)
593 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
595 /* The next basetype offset must take into account the space
596 between the classes, not just the size of each class. */
597 delta
= size_binop (MINUS_EXPR
,
598 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
599 BINFO_OFFSET (base_binfo
));
604 if (BINFO_OFFSET_ZEROP (base_binfo
))
605 BINFO_OFFSET (base_binfo
) = offset
;
607 BINFO_OFFSET (base_binfo
)
608 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
610 BINFO_OFFSET (base_binfo
) = offset
;
613 propagate_binfo_offsets (base_binfo
, offset
);
615 /* Go to our next class that counts for offset propagation. */
618 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
623 /* Makes new binfos for the indirect bases under BINFO, and updates
624 BINFO_OFFSET for them and their bases. */
627 unshare_base_binfos (binfo
)
630 tree binfos
= BINFO_BASETYPES (binfo
);
634 if (binfos
== NULL_TREE
)
637 /* Now unshare the structure beneath BINFO. */
638 for (j
= TREE_VEC_LENGTH (binfos
)-1;
641 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
642 new_binfo
= TREE_VEC_ELT (binfos
, j
)
643 = make_binfo (BINFO_OFFSET (base_binfo
),
645 BINFO_VTABLE (base_binfo
),
646 BINFO_VIRTUALS (base_binfo
));
647 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
648 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
649 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
650 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
651 unshare_base_binfos (new_binfo
);
655 /* Finish the work of layout_record, now taking virtual bases into account.
656 Also compute the actual offsets that our base classes will have.
657 This must be performed after the fields are laid out, since virtual
658 baseclasses must lay down at the end of the record.
660 Returns the maximum number of virtual functions any of the
661 baseclasses provide. */
664 layout_basetypes (rec
, max
)
668 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
669 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
673 unsigned int record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
674 unsigned int desired_align
;
676 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
677 register unsigned int const_size
= 0;
678 unsigned int nonvirtual_const_size
;
680 #ifdef STRUCTURE_SIZE_BOUNDARY
681 /* Packed structures don't need to have minimum size. */
682 if (! TYPE_PACKED (rec
))
683 record_align
= MAX (record_align
, STRUCTURE_SIZE_BOUNDARY
);
686 /* Get all the virtual base types that this type uses. The
687 TREE_VALUE slot holds the virtual baseclass type. Note that
688 get_vbase_types makes copies of the virtual base BINFOs, so that
689 the vbase_types are unshared. */
690 CLASSTYPE_VBASECLASSES (rec
) = vbase_types
= get_vbase_types (rec
);
692 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
, 19970302);
693 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
695 nonvirtual_const_size
= const_size
;
699 tree basetype
= BINFO_TYPE (vbase_types
);
702 desired_align
= TYPE_ALIGN (basetype
);
703 record_align
= MAX (record_align
, desired_align
);
706 offset
= integer_zero_node
;
709 /* Give each virtual base type the alignment it wants. */
710 const_size
= CEIL (const_size
, desired_align
) * desired_align
;
711 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
714 if (CLASSTYPE_VSIZE (basetype
) > max
)
715 max
= CLASSTYPE_VSIZE (basetype
);
716 BINFO_OFFSET (vbase_types
) = offset
;
718 /* Every virtual baseclass takes a least a UNIT, so that we can
719 take it's address and get something different for each base. */
720 const_size
+= MAX (BITS_PER_UNIT
,
721 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype
)));
723 vbase_types
= TREE_CHAIN (vbase_types
);
728 /* Because a virtual base might take a single byte above,
729 we have to re-adjust the total size to make sure it is
730 a multiple of the alignment. */
731 /* Give the whole object the alignment it wants. */
732 const_size
= CEIL (const_size
, record_align
) * record_align
;
735 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
736 here, as that is for this class, without any virtual base classes. */
737 TYPE_ALIGN (rec
) = record_align
;
738 if (const_size
!= nonvirtual_const_size
)
740 TYPE_SIZE (rec
) = size_int (const_size
);
741 TYPE_SIZE_UNIT (rec
) = size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (rec
),
742 size_int (BITS_PER_UNIT
));
745 /* Now propagate offset information throughout the lattice. */
746 for (i
= 0; i
< n_baseclasses
; i
++)
748 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
749 register tree basetype
= BINFO_TYPE (base_binfo
);
750 tree field
= TYPE_FIELDS (rec
);
752 if (TREE_VIA_VIRTUAL (base_binfo
))
755 my_friendly_assert (TREE_TYPE (field
) == basetype
, 23897);
757 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
758 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
761 BINFO_OFFSET (base_binfo
)
762 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
)),
764 propagate_binfo_offsets (base_binfo
, BINFO_OFFSET (base_binfo
));
765 TYPE_FIELDS (rec
) = TREE_CHAIN (field
);
768 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
769 vbase_types
= TREE_CHAIN (vbase_types
))
771 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
772 unshare_base_binfos (vbase_types
);
773 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
777 tree basetype
= BINFO_TYPE (vbase_types
);
778 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
779 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
787 /* If the empty base field in DECL overlaps with a base of the same type in
788 NEWDECL, which is either another base field or the first data field of
789 the class, pad the base just before NEWDECL and return 1. Otherwise,
793 avoid_overlap (decl
, newdecl
)
798 if (newdecl
== NULL_TREE
799 || ! types_overlap_p (TREE_TYPE (decl
), TREE_TYPE (newdecl
)))
802 for (field
= decl
; TREE_CHAIN (field
) && TREE_CHAIN (field
) != newdecl
;
803 field
= TREE_CHAIN (field
))
806 DECL_SIZE (field
) = integer_one_node
;
811 /* Returns a list of fields to stand in for the base class subobjects
812 of REC. These fields are later removed by layout_basetypes. */
815 build_base_fields (rec
)
818 /* Chain to hold all the new FIELD_DECLs which stand in for base class
820 tree base_decls
= NULL_TREE
;
821 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
822 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
824 int i
, saw_empty
= 0;
825 unsigned int base_align
= 0;
827 for (i
= 0; i
< n_baseclasses
; ++i
)
829 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
830 register tree basetype
= BINFO_TYPE (base_binfo
);
832 if (TYPE_SIZE (basetype
) == 0)
833 /* This error is now reported in xref_tag, thus giving better
834 location information. */
837 if (TREE_VIA_VIRTUAL (base_binfo
))
840 decl
= build_lang_field_decl (FIELD_DECL
, NULL_TREE
, basetype
);
841 DECL_ARTIFICIAL (decl
) = 1;
842 DECL_FIELD_CONTEXT (decl
) = DECL_CLASS_CONTEXT (decl
) = rec
;
843 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
844 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
845 TREE_CHAIN (decl
) = base_decls
;
850 /* Brain damage for backwards compatibility. For no good reason,
851 the old layout_basetypes made every base at least as large as
852 the alignment for the bases up to that point, gratuitously
853 wasting space. So we do the same thing here. */
854 base_align
= MAX (base_align
, DECL_ALIGN (decl
));
856 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl
)),
859 else if (DECL_SIZE (decl
) == integer_zero_node
)
863 /* Reverse the list of fields so we allocate the bases in the proper
865 base_decls
= nreverse (base_decls
);
867 /* In the presence of empty base classes, we run the risk of allocating
868 two objects of the same class on top of one another. Avoid that. */
869 if (flag_new_abi
&& saw_empty
)
870 for (decl
= base_decls
; decl
; decl
= TREE_CHAIN (decl
))
872 if (DECL_SIZE (decl
) == integer_zero_node
)
874 /* First step through the following bases until we find
875 an overlap or a non-empty base. */
876 for (nextdecl
= TREE_CHAIN (decl
); nextdecl
;
877 nextdecl
= TREE_CHAIN (nextdecl
))
879 if (avoid_overlap (decl
, nextdecl
)
880 || DECL_SIZE (nextdecl
) != integer_zero_node
)
884 /* If we're still looking, also check against the first
886 for (nextdecl
= TYPE_FIELDS (rec
);
887 nextdecl
&& TREE_CODE (nextdecl
) != FIELD_DECL
;
888 nextdecl
= TREE_CHAIN (nextdecl
))
890 avoid_overlap (decl
, nextdecl
);
898 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
901 build_vbase_pointer_fields (rec
)
904 /* Chain to hold all the new FIELD_DECLs which point at virtual
906 tree vbase_decls
= NULL_TREE
;
907 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
908 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
912 /* Handle basetypes almost like fields, but record their
913 offsets differently. */
915 for (i
= 0; i
< n_baseclasses
; i
++)
917 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
918 register tree basetype
= BINFO_TYPE (base_binfo
);
920 if (TYPE_SIZE (basetype
) == 0)
921 /* This error is now reported in xref_tag, thus giving better
922 location information. */
925 /* All basetypes are recorded in the association list of the
928 if (TREE_VIA_VIRTUAL (base_binfo
))
931 char *name
= (char *)alloca (TYPE_NAME_LENGTH (basetype
)
932 + sizeof (VBASE_NAME
) + 1);
934 /* The offset for a virtual base class is only used in computing
935 virtual function tables and for initializing virtual base
936 pointers. It is built once `get_vbase_types' is called. */
938 /* If this basetype can come from another vbase pointer
939 without an additional indirection, we will share
940 that pointer. If an indirection is involved, we
941 make our own pointer. */
942 for (j
= 0; j
< n_baseclasses
; j
++)
944 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
945 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
946 && binfo_member (basetype
,
947 CLASSTYPE_VBASECLASSES (BINFO_TYPE
952 sprintf (name
, VBASE_NAME_FORMAT
, TYPE_NAME_STRING (basetype
));
953 decl
= build_lang_field_decl (FIELD_DECL
, get_identifier (name
),
954 build_pointer_type (basetype
));
955 /* If you change any of the below, take a look at all the
956 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
958 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
959 DECL_VIRTUAL_P (decl
) = 1;
960 DECL_ARTIFICIAL (decl
) = 1;
961 DECL_FIELD_CONTEXT (decl
) = rec
;
962 DECL_CLASS_CONTEXT (decl
) = rec
;
963 DECL_FCONTEXT (decl
) = basetype
;
964 DECL_SAVED_INSNS (decl
) = NULL_RTX
;
965 DECL_FIELD_SIZE (decl
) = 0;
966 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
967 TREE_CHAIN (decl
) = vbase_decls
;
968 BINFO_VPTR_FIELD (base_binfo
) = decl
;
972 /* The space this decl occupies has already been accounted for. */
980 /* Hashing of lists so that we don't make duplicates.
981 The entry point is `list_hash_canon'. */
983 /* Each hash table slot is a bucket containing a chain
984 of these structures. */
988 struct list_hash
*next
; /* Next structure in the bucket. */
989 int hashcode
; /* Hash code of this list. */
990 tree list
; /* The list recorded here. */
993 /* Now here is the hash table. When recording a list, it is added
994 to the slot whose index is the hash code mod the table size.
995 Note that the hash table is used for several kinds of lists.
996 While all these live in the same table, they are completely independent,
997 and the hash code is computed differently for each of these. */
999 #define TYPE_HASH_SIZE 59
1000 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
1002 /* Compute a hash code for a list (chain of TREE_LIST nodes
1003 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1004 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1007 list_hash (purpose
, value
, chain
)
1008 tree purpose
, value
, chain
;
1010 register int hashcode
= 0;
1013 hashcode
+= TYPE_HASH (chain
);
1016 hashcode
+= TYPE_HASH (value
);
1020 hashcode
+= TYPE_HASH (purpose
);
1026 /* Look in the type hash table for a type isomorphic to TYPE.
1027 If one is found, return it. Otherwise return 0. */
1030 list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1031 purpose
, value
, chain
)
1032 int hashcode
, via_public
, via_virtual
, via_protected
;
1033 tree purpose
, value
, chain
;
1035 register struct list_hash
*h
;
1037 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1038 if (h
->hashcode
== hashcode
1039 && TREE_VIA_VIRTUAL (h
->list
) == via_virtual
1040 && TREE_VIA_PUBLIC (h
->list
) == via_public
1041 && TREE_VIA_PROTECTED (h
->list
) == via_protected
1042 && TREE_PURPOSE (h
->list
) == purpose
1043 && TREE_VALUE (h
->list
) == value
1044 && TREE_CHAIN (h
->list
) == chain
)
1049 /* Add an entry to the list-hash-table
1050 for a list TYPE whose hash code is HASHCODE. */
1053 list_hash_add (hashcode
, list
)
1057 register struct list_hash
*h
;
1059 h
= (struct list_hash
*) obstack_alloc (&class_obstack
, sizeof (struct list_hash
));
1060 h
->hashcode
= hashcode
;
1062 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
1063 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1066 /* Given TYPE, and HASHCODE its hash code, return the canonical
1067 object for an identical list if one already exists.
1068 Otherwise, return TYPE, and record it as the canonical object
1069 if it is a permanent object.
1071 To use this function, first create a list of the sort you want.
1072 Then compute its hash code from the fields of the list that
1073 make it different from other similar lists.
1074 Then call this function and use the value.
1075 This function frees the list you pass in if it is a duplicate. */
1077 /* Set to 1 to debug without canonicalization. Never set by program. */
1079 static int debug_no_list_hash
= 0;
1082 hash_tree_cons (via_public
, via_virtual
, via_protected
, purpose
, value
, chain
)
1083 int via_public
, via_virtual
, via_protected
;
1084 tree purpose
, value
, chain
;
1086 struct obstack
*ambient_obstack
= current_obstack
;
1090 if (! debug_no_list_hash
)
1092 hashcode
= list_hash (purpose
, value
, chain
);
1093 t
= list_hash_lookup (hashcode
, via_public
, via_protected
, via_virtual
,
1094 purpose
, value
, chain
);
1099 current_obstack
= &class_obstack
;
1101 t
= tree_cons (purpose
, value
, chain
);
1102 TREE_VIA_PUBLIC (t
) = via_public
;
1103 TREE_VIA_PROTECTED (t
) = via_protected
;
1104 TREE_VIA_VIRTUAL (t
) = via_virtual
;
1106 /* If this is a new list, record it for later reuse. */
1107 if (! debug_no_list_hash
)
1108 list_hash_add (hashcode
, t
);
1110 current_obstack
= ambient_obstack
;
1114 /* Constructor for hashed lists. */
1117 hash_tree_chain (value
, chain
)
1120 return hash_tree_cons (0, 0, 0, NULL_TREE
, value
, chain
);
1123 /* Similar, but used for concatenating two lists. */
1126 hash_chainon (list1
, list2
)
1133 if (TREE_CHAIN (list1
) == NULL_TREE
)
1134 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1135 return hash_tree_chain (TREE_VALUE (list1
),
1136 hash_chainon (TREE_CHAIN (list1
), list2
));
1140 get_identifier_list (value
)
1143 tree list
= IDENTIFIER_AS_LIST (value
);
1144 if (list
!= NULL_TREE
1145 && (TREE_CODE (list
) != TREE_LIST
1146 || TREE_VALUE (list
) != value
))
1148 else if (IDENTIFIER_HAS_TYPE_VALUE (value
)
1149 && TREE_CODE (IDENTIFIER_TYPE_VALUE (value
)) == RECORD_TYPE
1150 && IDENTIFIER_TYPE_VALUE (value
)
1151 == TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (value
)))
1153 tree type
= IDENTIFIER_TYPE_VALUE (value
);
1155 if (TYPE_PTRMEMFUNC_P (type
))
1157 else if (type
== current_class_type
)
1158 /* Don't mess up the constructor name. */
1159 list
= tree_cons (NULL_TREE
, value
, NULL_TREE
);
1162 if (! CLASSTYPE_ID_AS_LIST (type
))
1163 CLASSTYPE_ID_AS_LIST (type
)
1164 = perm_tree_cons (NULL_TREE
, TYPE_IDENTIFIER (type
), NULL_TREE
);
1165 list
= CLASSTYPE_ID_AS_LIST (type
);
1172 get_decl_list (value
)
1175 tree list
= NULL_TREE
;
1177 if (TREE_CODE (value
) == IDENTIFIER_NODE
)
1178 list
= get_identifier_list (value
);
1179 else if (TREE_CODE (value
) == RECORD_TYPE
1180 && TYPE_LANG_SPECIFIC (value
)
1181 && value
== TYPE_MAIN_VARIANT (value
))
1182 list
= CLASSTYPE_AS_LIST (value
);
1184 if (list
!= NULL_TREE
)
1186 my_friendly_assert (TREE_CHAIN (list
) == NULL_TREE
, 301);
1190 return build_decl_list (NULL_TREE
, value
);
1193 /* Build an association between TYPE and some parameters:
1195 OFFSET is the offset added to `this' to convert it to a pointer
1198 BINFO is the base binfo to use, if we are deriving from one. This
1199 is necessary, as we want specialized parent binfos from base
1200 classes, so that the VTABLE_NAMEs of bases are for the most derived
1201 type, instead of the simple type.
1203 VTABLE is the virtual function table with which to initialize
1204 sub-objects of type TYPE.
1206 VIRTUALS are the virtual functions sitting in VTABLE. */
1209 make_binfo (offset
, binfo
, vtable
, virtuals
)
1211 tree vtable
, virtuals
;
1213 tree new_binfo
= make_tree_vec (7);
1216 if (TREE_CODE (binfo
) == TREE_VEC
)
1217 type
= BINFO_TYPE (binfo
);
1221 binfo
= TYPE_BINFO (binfo
);
1224 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1225 BINFO_OFFSET (new_binfo
) = offset
;
1226 BINFO_VTABLE (new_binfo
) = vtable
;
1227 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1228 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1230 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1231 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1235 /* Return the binfo value for ELEM in TYPE. */
1238 binfo_value (elem
, type
)
1242 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1243 compiler_error ("base class `%s' ambiguous in binfo_value",
1244 TYPE_NAME_STRING (elem
));
1246 return TYPE_BINFO (type
);
1247 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1249 return get_binfo (elem
, type
, 0);
1252 /* Return a reversed copy of the BINFO-chain given by PATH. (If the
1253 BINFO_INHERITANCE_CHAIN points from base classes to derived
1254 classes, it will instead point from derived classes to base
1255 classes.) Returns the first node in the reversed chain. */
1261 register tree prev
= NULL_TREE
, cur
;
1262 push_expression_obstack ();
1263 for (cur
= path
; cur
; cur
= BINFO_INHERITANCE_CHAIN (cur
))
1265 tree r
= copy_node (cur
);
1266 BINFO_INHERITANCE_CHAIN (r
) = prev
;
1277 unsigned HOST_WIDE_INT n
;
1280 fprintf (stderr
, "type \"%s\"; offset = %ld\n",
1281 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1282 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1283 fprintf (stderr
, "vtable type:\n");
1284 debug_tree (BINFO_TYPE (elem
));
1285 if (BINFO_VTABLE (elem
))
1286 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1288 fprintf (stderr
, "no vtable decl yet\n");
1289 fprintf (stderr
, "virtuals:\n");
1290 virtuals
= BINFO_VIRTUALS (elem
);
1292 n
= skip_rtti_stuff (&virtuals
);
1296 tree fndecl
= TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
)), 0);
1297 fprintf (stderr
, "%s [%ld =? %ld]\n",
1298 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1299 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1301 virtuals
= TREE_CHAIN (virtuals
);
1305 /* Initialize an CPLUS_BINDING node that does not live on an obstack. */
1309 struct tree_binding
* node
;
1311 static struct tree_binding
* source
;
1314 extern struct obstack permanent_obstack
;
1315 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1316 source
= (struct tree_binding
*)make_node (CPLUS_BINDING
);
1320 TREE_PERMANENT ((tree
)node
) = 0;
1329 if (TREE_CODE (t
) == FUNCTION_DECL
)
1331 else if (TREE_CODE (t
) == OVERLOAD
)
1333 for (i
=0; t
; t
= OVL_CHAIN (t
))
1338 my_friendly_abort (359);
1343 is_overloaded_fn (x
)
1346 /* XXX A baselink is also considered an overloaded function.
1347 As is a placeholder from push_class_decls. */
1348 if (TREE_CODE (x
) == TREE_LIST
)
1350 my_friendly_assert (TREE_CODE (TREE_PURPOSE (x
)) == TREE_VEC
1351 || TREE_CODE (TREE_PURPOSE (x
)) == IDENTIFIER_NODE
,
1355 return (TREE_CODE (x
) == FUNCTION_DECL
1356 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
1357 || DECL_FUNCTION_TEMPLATE_P (x
)
1358 || TREE_CODE (x
) == OVERLOAD
);
1362 really_overloaded_fn (x
)
1365 /* A baselink is also considered an overloaded function.
1366 This might also be an ambiguous class member. */
1367 if (TREE_CODE (x
) == TREE_LIST
)
1369 return (TREE_CODE (x
) == OVERLOAD
1370 && (TREE_CHAIN (x
) != NULL_TREE
1371 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
1378 my_friendly_assert (is_overloaded_fn (from
), 9);
1379 /* A baselink is also considered an overloaded function. */
1380 if (TREE_CODE (from
) == TREE_LIST
)
1381 from
= TREE_VALUE (from
);
1382 return OVL_CURRENT (from
);
1385 /* Return a new OVL node, concatenating it with the old one. */
1388 ovl_cons (decl
, chain
)
1392 tree result
= make_node (OVERLOAD
);
1393 TREE_TYPE (result
) = unknown_type_node
;
1394 OVL_FUNCTION (result
) = decl
;
1395 TREE_CHAIN (result
) = chain
;
1400 /* Same as ovl_cons, but on the scratch_obstack. */
1403 scratch_ovl_cons (value
, chain
)
1407 register struct obstack
*ambient_obstack
= current_obstack
;
1408 extern struct obstack
*expression_obstack
;
1409 current_obstack
= expression_obstack
;
1410 node
= ovl_cons (value
, chain
);
1411 current_obstack
= ambient_obstack
;
1415 /* Build a new overloaded function. If this is the first one,
1416 just return it; otherwise, ovl_cons the _DECLs */
1419 build_overload (decl
, chain
)
1425 if (TREE_CODE (chain
) != OVERLOAD
)
1426 chain
= ovl_cons (chain
, NULL_TREE
);
1427 return ovl_cons (decl
, chain
);
1430 /* True if fn is in ovl. */
1433 ovl_member (fn
, ovl
)
1437 if (ovl
== NULL_TREE
)
1439 if (TREE_CODE (ovl
) != OVERLOAD
)
1440 return decls_match (ovl
, fn
);
1441 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1442 if (decls_match (OVL_FUNCTION (ovl
), fn
))
1448 is_aggr_type_2 (t1
, t2
)
1451 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1453 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1456 #define PRINT_RING_SIZE 4
1459 lang_printable_name (decl
, v
)
1463 static tree decl_ring
[PRINT_RING_SIZE
];
1464 static char *print_ring
[PRINT_RING_SIZE
];
1465 static int ring_counter
;
1468 /* Only cache functions. */
1470 || TREE_CODE (decl
) != FUNCTION_DECL
1471 || DECL_LANG_SPECIFIC (decl
) == 0)
1472 return lang_decl_name (decl
, v
);
1474 /* See if this print name is lying around. */
1475 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1476 if (decl_ring
[i
] == decl
)
1477 /* yes, so return it. */
1478 return print_ring
[i
];
1480 if (++ring_counter
== PRINT_RING_SIZE
)
1483 if (current_function_decl
!= NULL_TREE
)
1485 if (decl_ring
[ring_counter
] == current_function_decl
)
1487 if (ring_counter
== PRINT_RING_SIZE
)
1489 if (decl_ring
[ring_counter
] == current_function_decl
)
1490 my_friendly_abort (106);
1493 if (print_ring
[ring_counter
])
1494 free (print_ring
[ring_counter
]);
1496 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1497 decl_ring
[ring_counter
] = decl
;
1498 return print_ring
[ring_counter
];
1501 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1502 listed in RAISES. */
1505 build_exception_variant (type
, raises
)
1509 tree v
= TYPE_MAIN_VARIANT (type
);
1510 int constp
= TYPE_READONLY (type
);
1511 int volatilep
= TYPE_VOLATILE (type
);
1513 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1515 if (TYPE_READONLY (v
) != constp
1516 || TYPE_VOLATILE (v
) != volatilep
)
1519 /* @@ This should do set equality, not exact match. */
1520 if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v
), raises
))
1521 /* List of exceptions raised matches previously found list.
1523 @@ Nice to free up storage used in consing up the
1524 @@ list of exceptions raised. */
1528 /* Need to build a new variant. */
1529 v
= build_type_copy (type
);
1531 if (raises
&& ! TREE_PERMANENT (raises
))
1533 push_obstacks_nochange ();
1534 end_temporary_allocation ();
1535 raises
= copy_list (raises
);
1539 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1543 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1544 lang_specific field and its corresponding TEMPLATE_DECL node */
1547 copy_template_template_parm (t
)
1550 tree
template = TYPE_NAME (t
);
1551 tree t2
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1552 template = copy_node (template);
1553 copy_lang_decl (template);
1554 TREE_TYPE (template) = t2
;
1555 TYPE_NAME (t2
) = template;
1556 TYPE_STUB_DECL (t2
) = template;
1558 /* No need to copy these */
1559 TYPE_FIELDS (t2
) = TYPE_FIELDS (t
);
1560 CLASSTYPE_TEMPLATE_INFO (t2
) = CLASSTYPE_TEMPLATE_INFO (t
);
1564 /* Walk through the tree structure T, applying func. If func ever returns
1565 non-null, return that value. */
1568 search_tree (t
, func
)
1570 tree (*func
) PROTO((tree
));
1572 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1579 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1582 switch (TREE_CODE (t
))
1587 case IDENTIFIER_NODE
:
1594 case NAMESPACE_DECL
:
1598 TRY (TREE_TYPE (t
));
1602 TRY (TREE_TYPE (t
));
1603 TRY (TREE_CHAIN (t
));
1607 TRY (TREE_PURPOSE (t
));
1608 TRY (TREE_VALUE (t
));
1609 TRY (TREE_CHAIN (t
));
1613 TRY (OVL_FUNCTION (t
));
1614 TRY (OVL_CHAIN (t
));
1619 int len
= TREE_VEC_LENGTH (t
);
1623 TRY (TREE_VEC_ELT (t
, len
));
1635 case AGGR_INIT_EXPR
:
1637 TRY (TREE_OPERAND (t
, 0));
1638 TRY (TREE_OPERAND (t
, 1));
1639 TRY (TREE_OPERAND (t
, 2));
1646 case TRUNC_DIV_EXPR
:
1647 case TRUNC_MOD_EXPR
:
1655 case BIT_ANDTC_EXPR
:
1656 case TRUTH_ANDIF_EXPR
:
1657 case TRUTH_ORIF_EXPR
:
1665 case FLOOR_DIV_EXPR
:
1666 case ROUND_DIV_EXPR
:
1668 case FLOOR_MOD_EXPR
:
1669 case ROUND_MOD_EXPR
:
1671 case PREDECREMENT_EXPR
:
1672 case PREINCREMENT_EXPR
:
1673 case POSTDECREMENT_EXPR
:
1674 case POSTINCREMENT_EXPR
:
1677 case TRY_CATCH_EXPR
:
1678 case WITH_CLEANUP_EXPR
:
1680 TRY (TREE_OPERAND (t
, 0));
1681 TRY (TREE_OPERAND (t
, 1));
1690 case TRUTH_NOT_EXPR
:
1692 case NON_LVALUE_EXPR
:
1694 case CLEANUP_POINT_EXPR
:
1698 TRY (TREE_OPERAND (t
, 0));
1703 case REINTERPRET_CAST_EXPR
:
1704 case CONST_CAST_EXPR
:
1705 case STATIC_CAST_EXPR
:
1706 case DYNAMIC_CAST_EXPR
:
1713 TRY (TREE_REALPART (t
));
1714 TRY (TREE_IMAGPART (t
));
1718 TRY (CONSTRUCTOR_ELTS (t
));
1721 case TEMPLATE_TEMPLATE_PARM
:
1722 case TEMPLATE_PARM_INDEX
:
1723 case TEMPLATE_TYPE_PARM
:
1739 case REFERENCE_TYPE
:
1740 TRY (TREE_TYPE (t
));
1745 TRY (TREE_TYPE (t
));
1746 TRY (TYPE_ARG_TYPES (t
));
1750 TRY (TREE_TYPE (t
));
1751 TRY (TYPE_DOMAIN (t
));
1755 TRY (TYPE_MAX_VALUE (t
));
1759 TRY (TREE_TYPE (t
));
1760 TRY (TYPE_OFFSET_BASETYPE (t
));
1764 if (TYPE_PTRMEMFUNC_P (t
))
1765 TRY (TYPE_PTRMEMFUNC_FN_TYPE (t
));
1768 /* This list is incomplete, but should suffice for now.
1769 It is very important that `sorry' not call
1770 `report_error_function'. That could cause an infinite loop. */
1772 sorry ("initializer contains unrecognized tree code");
1773 return error_mark_node
;
1782 /* Passed to search_tree. Checks for the use of types with no linkage. */
1785 no_linkage_helper (t
)
1789 && (IS_AGGR_TYPE (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1790 && (decl_function_context (TYPE_MAIN_DECL (t
))
1791 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
))))
1796 /* Check if the type T depends on a type with no linkage and if so, return
1800 no_linkage_check (t
)
1803 t
= search_tree (t
, no_linkage_helper
);
1804 if (t
!= error_mark_node
)
1810 /* Subroutine of copy_to_permanent
1812 Assuming T is a node build bottom-up, make it all exist on
1813 permanent obstack, if it is not permanent already. */
1818 tree (*func
) PROTO((tree
));
1825 if (tmp
= func (t
), tmp
!= NULL_TREE
)
1828 switch (TREE_CODE (t
))
1831 return error_mark_node
;
1836 /* Rather than aborting, return error_mark_node. This allows us
1837 to report a sensible error message on code like this:
1839 void g() { int i; f<i>(7); }
1843 void g() { const int i = 7; f<i>(7); }
1845 however, we must actually return the constant initializer. */
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 case AGGR_INIT_EXPR
:
1901 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1902 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1903 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1908 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1915 case TRUNC_DIV_EXPR
:
1916 case TRUNC_MOD_EXPR
:
1924 case BIT_ANDTC_EXPR
:
1925 case TRUTH_ANDIF_EXPR
:
1926 case TRUTH_ORIF_EXPR
:
1934 case FLOOR_DIV_EXPR
:
1935 case ROUND_DIV_EXPR
:
1937 case FLOOR_MOD_EXPR
:
1938 case ROUND_MOD_EXPR
:
1940 case PREDECREMENT_EXPR
:
1941 case PREINCREMENT_EXPR
:
1942 case POSTDECREMENT_EXPR
:
1943 case POSTINCREMENT_EXPR
:
1946 case TRY_CATCH_EXPR
:
1947 case WITH_CLEANUP_EXPR
:
1949 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1950 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1955 TREE_TYPE (t
) = mapcar (TREE_TYPE (t
), func
);
1956 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1957 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
1959 /* tree.def says that operand two is RTL, but
1960 build_call_declarator puts trees in there. */
1961 if (TREE_OPERAND (t
, 2)
1962 && TREE_CODE (TREE_OPERAND (t
, 2)) == TREE_LIST
)
1963 TREE_OPERAND (t
, 2) = mapcar (TREE_OPERAND (t
, 2), func
);
1965 TREE_OPERAND (t
, 2) = NULL_TREE
;
1973 case TRUTH_NOT_EXPR
:
1976 case CLEANUP_POINT_EXPR
:
1978 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
1982 tmp
= build_pointer_type (mapcar (TREE_TYPE (t
), func
));
1983 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1984 case REFERENCE_TYPE
:
1985 tmp
= build_reference_type (mapcar (TREE_TYPE (t
), func
));
1986 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1988 tmp
= build_function_type (mapcar (TREE_TYPE (t
), func
),
1989 mapcar (TYPE_ARG_TYPES (t
), func
));
1990 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1992 tmp
= build_cplus_array_type (mapcar (TREE_TYPE (t
), func
),
1993 mapcar (TYPE_DOMAIN (t
), func
));
1994 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1996 tmp
= build_index_type (mapcar (TYPE_MAX_VALUE (t
), func
));
1997 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1999 tmp
= build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t
), func
),
2000 mapcar (TREE_TYPE (t
), func
));
2001 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
2003 tmp
= build_cplus_method_type
2004 (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))), func
),
2005 mapcar (TREE_TYPE (t
), func
),
2006 mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t
)), func
));
2007 return cp_build_type_variant (tmp
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
2011 TREE_REALPART (t
) = mapcar (TREE_REALPART (t
), func
);
2012 TREE_IMAGPART (t
) = mapcar (TREE_REALPART (t
), func
);
2017 CONSTRUCTOR_ELTS (t
) = mapcar (CONSTRUCTOR_ELTS (t
), func
);
2020 case TEMPLATE_TEMPLATE_PARM
:
2021 return copy_template_template_parm (t
);
2025 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
2026 TREE_OPERAND (t
, 1) = mapcar (TREE_OPERAND (t
, 1), func
);
2027 TREE_OPERAND (t
, 2) = NULL_TREE
;
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) = mapcar (TREE_OPERAND (t
, 2), func
);
2039 TREE_OPERAND (t
, 0) = mapcar (TREE_OPERAND (t
, 0), func
);
2043 if (TYPE_PTRMEMFUNC_P (t
))
2044 return build_ptrmemfunc_type
2045 (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t
), func
));
2046 /* else fall through */
2048 /* This list is incomplete, but should suffice for now.
2049 It is very important that `sorry' not call
2050 `report_error_function'. That could cause an infinite loop. */
2052 sorry ("initializer contains unrecognized tree code");
2053 return error_mark_node
;
2056 my_friendly_abort (107);
2065 if (TREE_PERMANENT (t
))
2068 /* Support `void f () { extern int i; A<&i> a; }' */
2069 if ((TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == FUNCTION_DECL
)
2074 /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again. */
2076 make_decl_rtl (t
, NULL_PTR
, 1);
2083 /* Assuming T is a node built bottom-up, make it all exist on
2084 permanent obstack, if it is not permanent already. */
2087 copy_to_permanent (t
)
2090 if (t
== NULL_TREE
|| TREE_PERMANENT (t
))
2093 push_obstacks_nochange ();
2094 end_temporary_allocation ();
2096 t
= mapcar (t
, perm_manip
);
2103 #ifdef GATHER_STATISTICS
2104 extern int depth_reached
;
2108 print_lang_statistics ()
2110 extern struct obstack decl_obstack
;
2111 print_obstack_statistics ("class_obstack", &class_obstack
);
2112 print_obstack_statistics ("decl_obstack", &decl_obstack
);
2113 print_search_statistics ();
2114 print_class_statistics ();
2115 #ifdef GATHER_STATISTICS
2116 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2121 /* This is used by the `assert' macro. It is provided in libgcc.a,
2122 which `cc' doesn't know how to link. Note that the C++ front-end
2123 no longer actually uses the `assert' macro (instead, it calls
2124 my_friendly_assert). But all of the back-end files still need this. */
2127 __eprintf (string
, expression
, line
, filename
)
2130 const char *expression
;
2132 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 (comptypes (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
)), 1))
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 /* Return truthvalue of whether T1 is the same tree structure as T2.
2378 Return 1 if they are the same.
2379 Return 0 if they are understandably different.
2380 Return -1 if either contains tree structure not understood by
2384 cp_tree_equal (t1
, t2
)
2387 register enum tree_code code1
, code2
;
2392 if (t1
== 0 || t2
== 0)
2395 code1
= TREE_CODE (t1
);
2396 code2
= TREE_CODE (t2
);
2398 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
2400 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
2401 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2403 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
2405 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
2406 || code2
== NON_LVALUE_EXPR
)
2407 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
2415 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
2416 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
2419 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2422 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2423 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2424 TREE_STRING_LENGTH (t1
));
2427 /* We need to do this when determining whether or not two
2428 non-type pointer to member function template arguments
2430 if (!(comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
), 1)
2431 /* The first operand is RTL. */
2432 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
2434 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2437 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
2440 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
2443 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
2446 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2449 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2452 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2455 /* Special case: if either target is an unallocated VAR_DECL,
2456 it means that it's going to be unified with whatever the
2457 TARGET_EXPR is really supposed to initialize, so treat it
2458 as being equivalent to anything. */
2459 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
2460 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
2461 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
2462 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
2463 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
2464 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2467 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2470 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2472 case WITH_CLEANUP_EXPR
:
2473 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2476 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2479 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2480 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2489 case TEMPLATE_PARM_INDEX
:
2490 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2491 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
2495 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2497 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2498 return comptypes (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0), 1);
2505 switch (TREE_CODE_CLASS (code1
))
2515 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2517 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2527 /* Similar to make_tree_vec, but build on a temporary obstack. */
2534 register struct obstack
*ambient_obstack
= current_obstack
;
2535 current_obstack
= expression_obstack
;
2536 node
= make_tree_vec (len
);
2537 current_obstack
= ambient_obstack
;
2541 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2544 build_ptr_wrapper (ptr
)
2547 tree t
= make_node (WRAPPER
);
2548 WRAPPER_PTR (t
) = ptr
;
2552 /* Same, but on the expression_obstack. */
2555 build_expr_ptr_wrapper (ptr
)
2559 push_expression_obstack ();
2560 t
= build_ptr_wrapper (ptr
);
2565 /* Build a wrapper around some integer I so we can use it as a tree. */
2568 build_int_wrapper (i
)
2571 tree t
= make_node (WRAPPER
);
2572 WRAPPER_INT (t
) = i
;
2577 build_srcloc (file
, line
)
2583 /* Make sure that we put these on the permanent obstack; up in
2584 add_pending_template, we pass this return value into perm_tree_cons,
2585 which also puts it on the permanent_obstack. However, this wasn't
2586 explicitly doing the same. */
2587 register struct obstack
*ambient_obstack
= current_obstack
;
2588 current_obstack
= &permanent_obstack
;
2590 t
= make_node (SRCLOC
);
2591 SRCLOC_FILE (t
) = file
;
2592 SRCLOC_LINE (t
) = line
;
2594 current_obstack
= ambient_obstack
;
2600 build_srcloc_here ()
2602 return build_srcloc (input_filename
, lineno
);
2606 push_expression_obstack ()
2608 push_obstacks_nochange ();
2609 current_obstack
= expression_obstack
;
2612 /* The type of ARG when used as an lvalue. */
2618 tree type
= TREE_TYPE (arg
);
2619 if (TREE_CODE (arg
) == OVERLOAD
)
2620 type
= unknown_type_node
;
2621 else if (TREE_CODE (type
) != ARRAY_TYPE
)
2622 type
= cp_build_type_variant
2623 (type
, TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
2627 /* The type of ARG for printing error messages; denote lvalues with
2634 tree type
= TREE_TYPE (arg
);
2635 if (TREE_CODE (type
) == ARRAY_TYPE
)
2637 else if (real_lvalue_p (arg
))
2638 type
= build_reference_type (lvalue_type (arg
));
2639 else if (IS_AGGR_TYPE (type
))
2640 type
= lvalue_type (arg
);
2645 /* Does FUNCTION use a variable-length argument list? */
2648 varargs_function_p (function
)
2651 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2652 for (; parm
; parm
= TREE_CHAIN (parm
))
2653 if (TREE_VALUE (parm
) == void_type_node
)
2658 /* Returns 1 if decl is a member of a class. */
2664 tree ctx
= DECL_CONTEXT (decl
);
2665 return (ctx
&& TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't');