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 #include "insn-config.h"
32 #include "integrate.h"
34 static tree bot_manip
PROTO((tree
*, int *, void *));
35 static tree bot_replace
PROTO((tree
*, int *, void *));
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, tree
, tree
, tree
));
40 static void propagate_binfo_offsets
PROTO((tree
, tree
));
41 static int avoid_overlap
PROTO((tree
, tree
));
42 static cp_lvalue_kind lvalue_p_1
PROTO((tree
, int));
43 static tree no_linkage_helper
PROTO((tree
*, int *, void *));
44 static tree build_srcloc
PROTO((char *, int));
45 static void mark_list_hash
PROTO ((void *));
46 static int statement_code_p
PROTO((enum tree_code
));
47 static tree mark_local_for_remap_r
PROTO((tree
*, int *, void *));
48 static tree cp_unsave_r
PROTO ((tree
*, int *, void *));
49 static void cp_unsave
PROTO((tree
*));
50 static tree build_target_expr
PROTO((tree
, tree
));
52 #define CEIL(x,y) (((x) + (y) - 1) / (y))
54 /* If REF is an lvalue, returns the kind of lvalue that REF is.
55 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
56 non-zero, rvalues of class type are considered lvalues. */
59 lvalue_p_1 (ref
, treat_class_rvalues_as_lvalues
)
61 int treat_class_rvalues_as_lvalues
;
63 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
64 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
66 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
69 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
72 switch (TREE_CODE (ref
))
74 /* preincrements and predecrements are valid lvals, provided
75 what they refer to are valid lvals. */
76 case PREINCREMENT_EXPR
:
77 case PREDECREMENT_EXPR
:
81 case WITH_CLEANUP_EXPR
:
85 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
86 treat_class_rvalues_as_lvalues
);
89 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
90 treat_class_rvalues_as_lvalues
);
92 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
94 && TREE_CODE (TREE_OPERAND (ref
, 1)) == FIELD_DECL
95 && DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
97 /* Clear the ordinary bit. If this object was a class
98 rvalue we want to preserve that information. */
99 op1_lvalue_kind
&= ~clk_ordinary
;
100 /* The lvalue is for a btifield. */
101 op1_lvalue_kind
|= clk_bitfield
;
103 return op1_lvalue_kind
;
109 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
110 && DECL_LANG_SPECIFIC (ref
)
111 && DECL_IN_AGGR_P (ref
))
117 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
121 /* A currently unresolved scope ref. */
123 my_friendly_abort (103);
125 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
130 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
131 treat_class_rvalues_as_lvalues
);
132 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
133 treat_class_rvalues_as_lvalues
);
137 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
138 treat_class_rvalues_as_lvalues
);
139 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 2),
140 treat_class_rvalues_as_lvalues
);
147 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
148 treat_class_rvalues_as_lvalues
);
151 return treat_class_rvalues_as_lvalues
? clk_class
: clk_none
;
155 return ((treat_class_rvalues_as_lvalues
156 && IS_AGGR_TYPE (TREE_TYPE (ref
)))
157 ? clk_class
: clk_none
);
160 /* All functions (except non-static-member functions) are
162 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
163 ? clk_none
: clk_ordinary
);
169 /* If one operand is not an lvalue at all, then this expression is
171 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
174 /* Otherwise, it's an lvalue, and it has all the odd properties
175 contributed by either operand. */
176 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
177 /* It's not an ordinary lvalue if it involves either a bit-field or
179 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
180 op1_lvalue_kind
&= ~clk_ordinary
;
181 return op1_lvalue_kind
;
184 /* If REF is an lvalue, returns the kind of lvalue that REF is.
185 Otherwise, returns clk_none. Lvalues can be assigned, unless they
186 have TREE_READONLY, or unless they are FUNCTION_DECLs. Lvalues can
187 have their address taken, unless they have DECL_REGISTER. */
193 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/0);
196 /* This differs from real_lvalue_p in that class rvalues are
197 considered lvalues. */
204 (lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/1) != clk_none
);
207 /* Return nonzero if REF is an lvalue valid for this language;
208 otherwise, print an error message and return zero. */
211 lvalue_or_else (ref
, string
)
215 int win
= lvalue_p (ref
);
217 error ("non-lvalue in %s", string
);
221 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
224 build_target_expr (decl
, value
)
230 t
= build (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
231 maybe_build_cleanup (decl
), NULL_TREE
);
232 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
233 ignore the TARGET_EXPR. If there really turn out to be no
234 side-effects, then the optimizer should be able to get rid of
235 whatever code is generated anyhow. */
236 TREE_SIDE_EFFECTS (t
) = 1;
241 /* INIT is a CALL_EXPR which needs info about its target.
242 TYPE is the type that this initialization should appear to have.
244 Build an encapsulation of the initialization to perform
245 and return it so that it can be processed by language-independent
246 and language-specific expression expanders. */
249 build_cplus_new (type
, init
)
257 /* Make sure that we're not trying to create an instance of an
259 abstract_virtuals_error (NULL_TREE
, type
);
261 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
262 return convert (type
, init
);
264 slot
= build (VAR_DECL
, type
);
265 DECL_ARTIFICIAL (slot
) = 1;
266 DECL_CONTEXT (slot
) = current_function_decl
;
267 layout_decl (slot
, 0);
269 /* We split the CALL_EXPR into its function and its arguments here.
270 Then, in expand_expr, we put them back together. The reason for
271 this is that this expression might be a default argument
272 expression. In that case, we need a new temporary every time the
273 expression is used. That's what break_out_target_exprs does; it
274 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
275 temporary slot. Then, expand_expr builds up a call-expression
276 using the new slot. */
277 fn
= TREE_OPERAND (init
, 0);
278 rval
= build (AGGR_INIT_EXPR
, type
, fn
, TREE_OPERAND (init
, 1), slot
);
279 TREE_SIDE_EFFECTS (rval
) = 1;
280 AGGR_INIT_VIA_CTOR_P (rval
)
281 = (TREE_CODE (fn
) == ADDR_EXPR
282 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
283 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
284 rval
= build_target_expr (slot
, rval
);
289 /* Buidl a TARGET_EXPR using INIT to initialize a new temporary of the
293 build_target_expr_with_type (init
, type
)
300 slot
= build (VAR_DECL
, type
);
301 DECL_ARTIFICIAL (slot
) = 1;
302 DECL_CONTEXT (slot
) = current_function_decl
;
303 layout_decl (slot
, 0);
304 rval
= build_target_expr (slot
, init
);
309 /* Like build_target_expr_with_type, but use the type of INIT. */
312 get_target_expr (init
)
315 return build_target_expr_with_type (init
, TREE_TYPE (init
));
318 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
319 these CALL_EXPRs with tree nodes that will perform the cleanups. */
322 break_out_cleanups (exp
)
327 if (TREE_CODE (tmp
) == CALL_EXPR
328 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp
)))
329 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
331 while (TREE_CODE (tmp
) == NOP_EXPR
332 || TREE_CODE (tmp
) == CONVERT_EXPR
333 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
335 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
336 && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
338 TREE_OPERAND (tmp
, 0)
339 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
340 TREE_OPERAND (tmp
, 0));
344 tmp
= TREE_OPERAND (tmp
, 0);
349 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
350 copies where they are found. Returns a deep copy all nodes transitively
351 containing CALL_EXPRs. */
354 break_out_calls (exp
)
357 register tree t1
, t2
= NULL_TREE
;
358 register enum tree_code code
;
359 register int changed
= 0;
362 if (exp
== NULL_TREE
)
365 code
= TREE_CODE (exp
);
367 if (code
== CALL_EXPR
)
368 return copy_node (exp
);
370 /* Don't try and defeat a save_expr, as it should only be done once. */
371 if (code
== SAVE_EXPR
)
374 switch (TREE_CODE_CLASS (code
))
379 case 'c': /* a constant */
380 case 't': /* a type node */
381 case 'x': /* something random, like an identifier or an ERROR_MARK. */
384 case 'd': /* A decl node */
385 #if 0 /* This is bogus. jason 9/21/94 */
387 t1
= break_out_calls (DECL_INITIAL (exp
));
388 if (t1
!= DECL_INITIAL (exp
))
390 exp
= copy_node (exp
);
391 DECL_INITIAL (exp
) = t1
;
396 case 'b': /* A block node */
398 /* Don't know how to handle these correctly yet. Must do a
399 break_out_calls on all DECL_INITIAL values for local variables,
400 and also break_out_calls on all sub-blocks and sub-statements. */
405 case 'e': /* an expression */
406 case 'r': /* a reference */
407 case 's': /* an expression with side effects */
408 for (i
= tree_code_length
[(int) code
] - 1; i
>= 0; i
--)
410 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
411 if (t1
!= TREE_OPERAND (exp
, i
))
413 exp
= copy_node (exp
);
414 TREE_OPERAND (exp
, i
) = t1
;
419 case '<': /* a comparison expression */
420 case '2': /* a binary arithmetic expression */
421 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
422 if (t2
!= TREE_OPERAND (exp
, 1))
424 case '1': /* a unary arithmetic expression */
425 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
426 if (t1
!= TREE_OPERAND (exp
, 0))
430 if (tree_code_length
[(int) code
] == 1)
431 return build1 (code
, TREE_TYPE (exp
), t1
);
433 return build (code
, TREE_TYPE (exp
), t1
, t2
);
440 extern struct obstack permanent_obstack
;
442 /* Here is how primitive or already-canonicalized types' hash
443 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
444 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
446 /* Construct, lay out and return the type of methods belonging to class
447 BASETYPE and whose arguments are described by ARGTYPES and whose values
448 are described by RETTYPE. If each type exists already, reuse it. */
451 build_cplus_method_type (basetype
, rettype
, argtypes
)
452 tree basetype
, rettype
, argtypes
;
458 /* Make a node of the sort we want. */
459 t
= make_node (METHOD_TYPE
);
461 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
462 TREE_TYPE (t
) = rettype
;
463 ptype
= build_pointer_type (basetype
);
465 /* The actual arglist for this function includes a "hidden" argument
466 which is "this". Put it into the list of argument types. Make
467 sure that the new argument list is allocated on the same obstack
469 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
470 TYPE_ARG_TYPES (t
) = argtypes
;
471 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
473 /* If we already have such a type, use the old one and free this one.
474 Note that it also frees up the above cons cell if found. */
475 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) +
476 type_hash_list (argtypes
);
478 t
= type_hash_canon (hashcode
, t
);
480 if (TYPE_SIZE (t
) == 0)
487 build_cplus_array_type_1 (elt_type
, index_type
)
493 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
494 return error_mark_node
;
496 if (processing_template_decl
497 || uses_template_parms (elt_type
)
498 || uses_template_parms (index_type
))
500 t
= make_node (ARRAY_TYPE
);
501 TREE_TYPE (t
) = elt_type
;
502 TYPE_DOMAIN (t
) = index_type
;
505 t
= build_array_type (elt_type
, index_type
);
507 /* Push these needs up so that initialization takes place
509 TYPE_NEEDS_CONSTRUCTING (t
)
510 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
511 TYPE_NEEDS_DESTRUCTOR (t
)
512 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
517 build_cplus_array_type (elt_type
, index_type
)
522 int type_quals
= CP_TYPE_QUALS (elt_type
);
524 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
526 t
= build_cplus_array_type_1 (elt_type
, index_type
);
528 if (type_quals
!= TYPE_UNQUALIFIED
)
529 t
= cp_build_qualified_type (t
, type_quals
);
534 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
535 arrays correctly. In particular, if TYPE is an array of T's, and
536 TYPE_QUALS is non-empty, returns an array of qualified T's. If
537 at attempt is made to qualify a type illegally, and COMPLAIN is
538 non-zero, an error is issued. If COMPLAIN is zero, error_mark_node
542 cp_build_qualified_type_real (type
, type_quals
, complain
)
549 if (type
== error_mark_node
)
552 if (type_quals
== TYPE_QUALS (type
))
555 /* A restrict-qualified pointer type must be a pointer (or reference)
556 to object or incomplete type. */
557 if ((type_quals
& TYPE_QUAL_RESTRICT
)
558 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
559 && (!POINTER_TYPE_P (type
)
560 || TYPE_PTRMEM_P (type
)
561 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
564 cp_error ("`%T' cannot be `restrict'-qualified", type
);
566 return error_mark_node
;
568 type_quals
&= ~TYPE_QUAL_RESTRICT
;
571 if (type_quals
!= TYPE_UNQUALIFIED
572 && TREE_CODE (type
) == FUNCTION_TYPE
)
575 cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type
);
577 return error_mark_node
;
578 type_quals
= TYPE_UNQUALIFIED
;
580 else if (TREE_CODE (type
) == ARRAY_TYPE
)
582 /* In C++, the qualification really applies to the array element
583 type. Obtain the appropriately qualified element type. */
586 = cp_build_qualified_type_real (TREE_TYPE (type
),
590 if (element_type
== error_mark_node
)
591 return error_mark_node
;
593 /* See if we already have an identically qualified type. */
594 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
595 if (CP_TYPE_QUALS (t
) == type_quals
)
598 /* If we didn't already have it, create it now. */
601 /* Make a new array type, just like the old one, but with the
602 appropriately qualified element type. */
603 t
= build_type_copy (type
);
604 TREE_TYPE (t
) = element_type
;
607 /* Even if we already had this variant, we update
608 TYPE_NEEDS_CONSTRUCTING and TYPE_NEEDS_DESTRUCTOR in case
609 they changed since the variant was originally created.
611 This seems hokey; if there is some way to use a previous
612 variant *without* coming through here,
613 TYPE_NEEDS_CONSTRUCTING will never be updated. */
614 TYPE_NEEDS_CONSTRUCTING (t
)
615 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
616 TYPE_NEEDS_DESTRUCTOR (t
)
617 = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
620 else if (TYPE_PTRMEMFUNC_P (type
))
622 /* For a pointer-to-member type, we can't just return a
623 cv-qualified version of the RECORD_TYPE. If we do, we
624 haven't change the field that contains the actual pointer to
625 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
628 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
629 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
630 return build_ptrmemfunc_type (t
);
633 /* Retrieve (or create) the appropriately qualified variant. */
634 result
= build_qualified_type (type
, type_quals
);
636 /* If this was a pointer-to-method type, and we just made a copy,
637 then we need to clear the cached associated
638 pointer-to-member-function type; it is not valid for the new
641 && TREE_CODE (type
) == POINTER_TYPE
642 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
643 TYPE_SET_PTRMEMFUNC_TYPE (result
, NULL_TREE
);
648 /* Returns the canonical version of TYPE. In other words, if TYPE is
649 a typedef, returns the underlying type. The cv-qualification of
650 the type returned matches the type input; they will always be
654 canonical_type_variant (t
)
657 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), CP_TYPE_QUALS (t
));
660 /* Add OFFSET to all base types of T.
662 OFFSET, which is a type offset, is number of bytes.
664 Note that we don't have to worry about having two paths to the
665 same base type, since this type owns its association list. */
668 propagate_binfo_offsets (binfo
, offset
)
672 tree binfos
= BINFO_BASETYPES (binfo
);
673 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
675 for (i
= 0; i
< n_baselinks
; /* note increment is done in the loop. */)
677 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
679 if (TREE_VIA_VIRTUAL (base_binfo
))
684 tree delta
= NULL_TREE
;
686 for (j
= i
+1; j
< n_baselinks
; j
++)
687 if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos
, j
)))
689 /* The next basetype offset must take into account the space
690 between the classes, not just the size of each class. */
691 delta
= size_binop (MINUS_EXPR
,
692 BINFO_OFFSET (TREE_VEC_ELT (binfos
, j
)),
693 BINFO_OFFSET (base_binfo
));
698 if (BINFO_OFFSET_ZEROP (base_binfo
))
699 BINFO_OFFSET (base_binfo
) = offset
;
701 BINFO_OFFSET (base_binfo
)
702 = size_binop (PLUS_EXPR
, BINFO_OFFSET (base_binfo
), offset
);
704 BINFO_OFFSET (base_binfo
) = offset
;
707 propagate_binfo_offsets (base_binfo
, offset
);
709 /* Go to our next class that counts for offset propagation. */
712 offset
= size_binop (PLUS_EXPR
, offset
, delta
);
717 /* Makes new binfos for the indirect bases under BINFO, and updates
718 BINFO_OFFSET for them and their bases. */
721 unshare_base_binfos (binfo
)
724 tree binfos
= BINFO_BASETYPES (binfo
);
728 if (binfos
== NULL_TREE
)
731 /* Now unshare the structure beneath BINFO. */
732 for (j
= TREE_VEC_LENGTH (binfos
)-1;
735 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
736 new_binfo
= TREE_VEC_ELT (binfos
, j
)
737 = make_binfo (BINFO_OFFSET (base_binfo
),
739 BINFO_VTABLE (base_binfo
),
740 BINFO_VIRTUALS (base_binfo
));
741 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
742 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
743 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
744 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
745 unshare_base_binfos (new_binfo
);
749 /* Finish the work of layout_record, now taking virtual bases into account.
750 Also compute the actual offsets that our base classes will have.
751 This must be performed after the fields are laid out, since virtual
752 baseclasses must lay down at the end of the record.
754 Returns the maximum number of virtual functions any of the
755 baseclasses provide. */
758 layout_basetypes (rec
, max
)
762 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
763 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
767 unsigned int record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (rec
));
768 unsigned int desired_align
;
770 /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer. */
771 register unsigned int const_size
= 0;
772 unsigned int nonvirtual_const_size
;
774 #ifdef STRUCTURE_SIZE_BOUNDARY
775 /* Packed structures don't need to have minimum size. */
776 if (! TYPE_PACKED (rec
))
777 record_align
= MAX (record_align
, STRUCTURE_SIZE_BOUNDARY
);
780 /* Get all the virtual base types that this type uses. The
781 TREE_VALUE slot holds the virtual baseclass type. Note that
782 get_vbase_types makes copies of the virtual base BINFOs, so that
783 the vbase_types are unshared. */
784 vbase_types
= CLASSTYPE_VBASECLASSES (rec
);
786 my_friendly_assert (TREE_CODE (TYPE_SIZE (rec
)) == INTEGER_CST
, 19970302);
787 const_size
= TREE_INT_CST_LOW (TYPE_SIZE (rec
));
789 nonvirtual_const_size
= const_size
;
793 tree basetype
= BINFO_TYPE (vbase_types
);
796 desired_align
= TYPE_ALIGN (basetype
);
797 record_align
= MAX (record_align
, desired_align
);
800 offset
= integer_zero_node
;
803 /* Give each virtual base type the alignment it wants. */
804 const_size
= CEIL (const_size
, desired_align
) * desired_align
;
805 offset
= size_int (CEIL (const_size
, BITS_PER_UNIT
));
808 if (CLASSTYPE_VSIZE (basetype
) > max
)
809 max
= CLASSTYPE_VSIZE (basetype
);
810 BINFO_OFFSET (vbase_types
) = offset
;
812 /* Every virtual baseclass takes a least a UNIT, so that we can
813 take it's address and get something different for each base. */
814 const_size
+= MAX (BITS_PER_UNIT
,
815 TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype
)));
817 vbase_types
= TREE_CHAIN (vbase_types
);
822 /* Because a virtual base might take a single byte above,
823 we have to re-adjust the total size to make sure it is
824 a multiple of the alignment. */
825 /* Give the whole object the alignment it wants. */
826 const_size
= CEIL (const_size
, record_align
) * record_align
;
829 /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
830 here, as that is for this class, without any virtual base classes. */
831 TYPE_ALIGN (rec
) = record_align
;
832 if (const_size
!= nonvirtual_const_size
)
834 TYPE_SIZE (rec
) = size_int (const_size
);
835 TYPE_SIZE_UNIT (rec
) = size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (rec
),
836 size_int (BITS_PER_UNIT
));
839 /* Now propagate offset information throughout the lattice. */
840 for (i
= 0; i
< n_baseclasses
; i
++)
842 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
843 register tree basetype
= BINFO_TYPE (base_binfo
);
844 tree field
= TYPE_FIELDS (rec
);
846 if (TREE_VIA_VIRTUAL (base_binfo
))
849 my_friendly_assert (TREE_TYPE (field
) == basetype
, 23897);
851 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
852 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
855 BINFO_OFFSET (base_binfo
)
856 = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
)),
858 propagate_binfo_offsets (base_binfo
, BINFO_OFFSET (base_binfo
));
859 TYPE_FIELDS (rec
) = TREE_CHAIN (field
);
862 for (vbase_types
= CLASSTYPE_VBASECLASSES (rec
); vbase_types
;
863 vbase_types
= TREE_CHAIN (vbase_types
))
865 BINFO_INHERITANCE_CHAIN (vbase_types
) = TYPE_BINFO (rec
);
866 unshare_base_binfos (vbase_types
);
867 propagate_binfo_offsets (vbase_types
, BINFO_OFFSET (vbase_types
));
871 tree basetype
= BINFO_TYPE (vbase_types
);
872 if (get_base_distance (basetype
, rec
, 0, (tree
*)0) == -2)
873 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
881 /* If the empty base field in DECL overlaps with a base of the same type in
882 NEWDECL, which is either another base field or the first data field of
883 the class, pad the base just before NEWDECL and return 1. Otherwise,
887 avoid_overlap (decl
, newdecl
)
892 if (newdecl
== NULL_TREE
893 || ! types_overlap_p (TREE_TYPE (decl
), TREE_TYPE (newdecl
)))
896 for (field
= decl
; TREE_CHAIN (field
) && TREE_CHAIN (field
) != newdecl
;
897 field
= TREE_CHAIN (field
))
900 DECL_SIZE (field
) = integer_one_node
;
905 /* Returns a list of fields to stand in for the base class subobjects
906 of REC. These fields are later removed by layout_basetypes. */
909 build_base_fields (rec
)
912 /* Chain to hold all the new FIELD_DECLs which stand in for base class
914 tree base_decls
= NULL_TREE
;
915 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
916 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
918 int i
, saw_empty
= 0;
919 unsigned int base_align
= 0;
921 for (i
= 0; i
< n_baseclasses
; ++i
)
923 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
924 register tree basetype
= BINFO_TYPE (base_binfo
);
926 if (TYPE_SIZE (basetype
) == 0)
927 /* This error is now reported in xref_tag, thus giving better
928 location information. */
931 if (TREE_VIA_VIRTUAL (base_binfo
))
934 decl
= build_lang_decl (FIELD_DECL
, NULL_TREE
, basetype
);
935 DECL_ARTIFICIAL (decl
) = 1;
936 DECL_FIELD_CONTEXT (decl
) = DECL_CLASS_CONTEXT (decl
) = rec
;
937 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
938 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
939 TREE_CHAIN (decl
) = base_decls
;
944 /* Brain damage for backwards compatibility. For no good reason,
945 the old layout_basetypes made every base at least as large as
946 the alignment for the bases up to that point, gratuitously
947 wasting space. So we do the same thing here. */
948 base_align
= MAX (base_align
, DECL_ALIGN (decl
));
950 = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl
)),
953 else if (DECL_SIZE (decl
) == integer_zero_node
)
957 /* Reverse the list of fields so we allocate the bases in the proper
959 base_decls
= nreverse (base_decls
);
961 /* In the presence of empty base classes, we run the risk of allocating
962 two objects of the same class on top of one another. Avoid that. */
963 if (flag_new_abi
&& saw_empty
)
964 for (decl
= base_decls
; decl
; decl
= TREE_CHAIN (decl
))
966 if (DECL_SIZE (decl
) == integer_zero_node
)
968 /* First step through the following bases until we find
969 an overlap or a non-empty base. */
970 for (nextdecl
= TREE_CHAIN (decl
); nextdecl
;
971 nextdecl
= TREE_CHAIN (nextdecl
))
973 if (avoid_overlap (decl
, nextdecl
)
974 || DECL_SIZE (nextdecl
) != integer_zero_node
)
978 /* If we're still looking, also check against the first
980 for (nextdecl
= TYPE_FIELDS (rec
);
981 nextdecl
&& TREE_CODE (nextdecl
) != FIELD_DECL
;
982 nextdecl
= TREE_CHAIN (nextdecl
))
984 avoid_overlap (decl
, nextdecl
);
992 /* Returns list of virtual base class pointers in a FIELD_DECL chain. */
995 build_vbase_pointer_fields (rec
)
998 /* Chain to hold all the new FIELD_DECLs which point at virtual
1000 tree vbase_decls
= NULL_TREE
;
1001 tree binfos
= TYPE_BINFO_BASETYPES (rec
);
1002 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1006 /* Handle basetypes almost like fields, but record their
1007 offsets differently. */
1009 for (i
= 0; i
< n_baseclasses
; i
++)
1011 register tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1012 register tree basetype
= BINFO_TYPE (base_binfo
);
1014 if (TYPE_SIZE (basetype
) == 0)
1015 /* This error is now reported in xref_tag, thus giving better
1016 location information. */
1019 /* All basetypes are recorded in the association list of the
1022 if (TREE_VIA_VIRTUAL (base_binfo
))
1027 /* The offset for a virtual base class is only used in computing
1028 virtual function tables and for initializing virtual base
1029 pointers. It is built once `get_vbase_types' is called. */
1031 /* If this basetype can come from another vbase pointer
1032 without an additional indirection, we will share
1033 that pointer. If an indirection is involved, we
1034 make our own pointer. */
1035 for (j
= 0; j
< n_baseclasses
; j
++)
1037 tree other_base_binfo
= TREE_VEC_ELT (binfos
, j
);
1038 if (! TREE_VIA_VIRTUAL (other_base_binfo
)
1039 && binfo_member (basetype
,
1040 CLASSTYPE_VBASECLASSES (BINFO_TYPE
1045 FORMAT_VBASE_NAME (name
, basetype
);
1046 decl
= build_lang_decl (FIELD_DECL
, get_identifier (name
),
1047 build_pointer_type (basetype
));
1048 /* If you change any of the below, take a look at all the
1049 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
1051 DECL_ASSEMBLER_NAME (decl
) = get_identifier (VTABLE_BASE
);
1052 DECL_VIRTUAL_P (decl
) = 1;
1053 DECL_ARTIFICIAL (decl
) = 1;
1054 DECL_FIELD_CONTEXT (decl
) = rec
;
1055 DECL_CLASS_CONTEXT (decl
) = rec
;
1056 DECL_FCONTEXT (decl
) = basetype
;
1057 DECL_SAVED_INSNS (decl
) = 0;
1058 DECL_FIELD_SIZE (decl
) = 0;
1059 DECL_ALIGN (decl
) = TYPE_ALIGN (ptr_type_node
);
1060 TREE_CHAIN (decl
) = vbase_decls
;
1061 BINFO_VPTR_FIELD (base_binfo
) = decl
;
1065 /* The space this decl occupies has already been accounted for. */
1073 /* Hashing of lists so that we don't make duplicates.
1074 The entry point is `list_hash_canon'. */
1076 /* Each hash table slot is a bucket containing a chain
1077 of these structures. */
1081 struct list_hash
*next
; /* Next structure in the bucket. */
1082 int hashcode
; /* Hash code of this list. */
1083 tree list
; /* The list recorded here. */
1086 /* Now here is the hash table. When recording a list, it is added
1087 to the slot whose index is the hash code mod the table size.
1088 Note that the hash table is used for several kinds of lists.
1089 While all these live in the same table, they are completely independent,
1090 and the hash code is computed differently for each of these. */
1092 #define TYPE_HASH_SIZE 59
1093 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
1095 /* Compute a hash code for a list (chain of TREE_LIST nodes
1096 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1097 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1100 list_hash (purpose
, value
, chain
)
1101 tree purpose
, value
, chain
;
1103 register int hashcode
= 0;
1106 hashcode
+= TYPE_HASH (chain
);
1109 hashcode
+= TYPE_HASH (value
);
1113 hashcode
+= TYPE_HASH (purpose
);
1119 /* Look in the type hash table for a type isomorphic to TYPE.
1120 If one is found, return it. Otherwise return 0. */
1123 list_hash_lookup (hashcode
, purpose
, value
, chain
)
1125 tree purpose
, value
, chain
;
1127 register struct list_hash
*h
;
1129 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
1130 if (h
->hashcode
== hashcode
1131 && TREE_PURPOSE (h
->list
) == purpose
1132 && TREE_VALUE (h
->list
) == value
1133 && TREE_CHAIN (h
->list
) == chain
)
1138 /* Add an entry to the list-hash-table
1139 for a list TYPE whose hash code is HASHCODE. */
1142 list_hash_add (hashcode
, list
)
1146 register struct list_hash
*h
;
1148 h
= (struct list_hash
*) obstack_alloc (&permanent_obstack
, sizeof (struct list_hash
));
1149 h
->hashcode
= hashcode
;
1151 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
1152 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
1155 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1156 object for an identical list if one already exists. Otherwise, build a
1157 new one, and record it as the canonical object. */
1159 /* Set to 1 to debug without canonicalization. Never set by program. */
1161 static int debug_no_list_hash
= 0;
1164 hash_tree_cons (purpose
, value
, chain
)
1165 tree purpose
, value
, chain
;
1170 if (! debug_no_list_hash
)
1172 hashcode
= list_hash (purpose
, value
, chain
);
1173 t
= list_hash_lookup (hashcode
, purpose
, value
, chain
);
1178 t
= tree_cons (purpose
, value
, chain
);
1180 /* If this is a new list, record it for later reuse. */
1181 if (! debug_no_list_hash
)
1182 list_hash_add (hashcode
, t
);
1187 /* Constructor for hashed lists. */
1190 hash_tree_chain (value
, chain
)
1193 return hash_tree_cons (NULL_TREE
, value
, chain
);
1196 /* Similar, but used for concatenating two lists. */
1199 hash_chainon (list1
, list2
)
1206 if (TREE_CHAIN (list1
) == NULL_TREE
)
1207 return hash_tree_chain (TREE_VALUE (list1
), list2
);
1208 return hash_tree_chain (TREE_VALUE (list1
),
1209 hash_chainon (TREE_CHAIN (list1
), list2
));
1212 /* Build an association between TYPE and some parameters:
1214 OFFSET is the offset added to `this' to convert it to a pointer
1217 BINFO is the base binfo to use, if we are deriving from one. This
1218 is necessary, as we want specialized parent binfos from base
1219 classes, so that the VTABLE_NAMEs of bases are for the most derived
1220 type, instead of the simple type.
1222 VTABLE is the virtual function table with which to initialize
1223 sub-objects of type TYPE.
1225 VIRTUALS are the virtual functions sitting in VTABLE. */
1228 make_binfo (offset
, binfo
, vtable
, virtuals
)
1230 tree vtable
, virtuals
;
1232 tree new_binfo
= make_tree_vec (7);
1235 if (TREE_CODE (binfo
) == TREE_VEC
)
1236 type
= BINFO_TYPE (binfo
);
1240 binfo
= CLASS_TYPE_P (type
) ? TYPE_BINFO (binfo
) : NULL_TREE
;
1243 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
1244 BINFO_OFFSET (new_binfo
) = offset
;
1245 BINFO_VTABLE (new_binfo
) = vtable
;
1246 BINFO_VIRTUALS (new_binfo
) = virtuals
;
1247 BINFO_VPTR_FIELD (new_binfo
) = NULL_TREE
;
1249 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
1250 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
1254 /* Return the binfo value for ELEM in TYPE. */
1257 binfo_value (elem
, type
)
1261 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
1262 compiler_error ("base class `%s' ambiguous in binfo_value",
1263 TYPE_NAME_STRING (elem
));
1265 return TYPE_BINFO (type
);
1266 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
1268 return get_binfo (elem
, type
, 0);
1271 /* Return a reversed copy of the BINFO-chain given by PATH. (If the
1272 BINFO_INHERITANCE_CHAIN points from base classes to derived
1273 classes, it will instead point from derived classes to base
1274 classes.) Returns the first node in the reversed chain. */
1280 register tree prev
= NULL_TREE
, cur
;
1281 for (cur
= path
; cur
; cur
= BINFO_INHERITANCE_CHAIN (cur
))
1283 tree r
= copy_node (cur
);
1284 BINFO_INHERITANCE_CHAIN (r
) = prev
;
1294 unsigned HOST_WIDE_INT n
;
1297 fprintf (stderr
, "type \"%s\"; offset = %ld\n",
1298 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1299 (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1300 fprintf (stderr
, "vtable type:\n");
1301 debug_tree (BINFO_TYPE (elem
));
1302 if (BINFO_VTABLE (elem
))
1303 fprintf (stderr
, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem
))));
1305 fprintf (stderr
, "no vtable decl yet\n");
1306 fprintf (stderr
, "virtuals:\n");
1307 virtuals
= BINFO_VIRTUALS (elem
);
1309 n
= skip_rtti_stuff (&virtuals
, BINFO_TYPE (elem
));
1313 tree fndecl
= TREE_VALUE (virtuals
);
1314 fprintf (stderr
, "%s [%ld =? %ld]\n",
1315 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1316 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1318 virtuals
= TREE_CHAIN (virtuals
);
1327 if (TREE_CODE (t
) == FUNCTION_DECL
)
1329 else if (TREE_CODE (t
) == OVERLOAD
)
1331 for (i
=0; t
; t
= OVL_CHAIN (t
))
1336 my_friendly_abort (359);
1341 is_overloaded_fn (x
)
1344 /* A baselink is also considered an overloaded function. */
1345 if (TREE_CODE (x
) == OFFSET_REF
)
1346 x
= TREE_OPERAND (x
, 1);
1349 return (TREE_CODE (x
) == FUNCTION_DECL
1350 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
1351 || DECL_FUNCTION_TEMPLATE_P (x
)
1352 || TREE_CODE (x
) == OVERLOAD
);
1356 really_overloaded_fn (x
)
1359 /* A baselink is also considered an overloaded function. */
1360 if (TREE_CODE (x
) == OFFSET_REF
)
1361 x
= TREE_OPERAND (x
, 1);
1364 return (TREE_CODE (x
) == OVERLOAD
1365 && (TREE_CHAIN (x
) != NULL_TREE
1366 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
1373 my_friendly_assert (is_overloaded_fn (from
), 9);
1374 /* A baselink is also considered an overloaded function. */
1375 if (BASELINK_P (from
))
1376 from
= TREE_VALUE (from
);
1377 return OVL_CURRENT (from
);
1380 /* Returns nonzero if T is a ->* or .* expression that refers to a
1387 return (TREE_CODE (t
) == OFFSET_REF
1388 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t
, 1))));
1391 /* Return a new OVL node, concatenating it with the old one. */
1394 ovl_cons (decl
, chain
)
1398 tree result
= make_node (OVERLOAD
);
1399 TREE_TYPE (result
) = unknown_type_node
;
1400 OVL_FUNCTION (result
) = decl
;
1401 TREE_CHAIN (result
) = chain
;
1406 /* Build a new overloaded function. If this is the first one,
1407 just return it; otherwise, ovl_cons the _DECLs */
1410 build_overload (decl
, chain
)
1414 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1416 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1417 chain
= ovl_cons (chain
, NULL_TREE
);
1418 return ovl_cons (decl
, chain
);
1421 /* True if fn is in ovl. */
1424 ovl_member (fn
, ovl
)
1428 if (ovl
== NULL_TREE
)
1430 if (TREE_CODE (ovl
) != OVERLOAD
)
1432 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1433 if (OVL_FUNCTION (ovl
) == fn
)
1439 is_aggr_type_2 (t1
, t2
)
1442 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1444 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1447 /* Returns non-zero if CODE is the code for a statement. */
1450 statement_code_p (code
)
1451 enum tree_code code
;
1471 case START_CATCH_STMT
:
1474 case CTOR_INITIALIZER
:
1486 #define PRINT_RING_SIZE 4
1489 lang_printable_name (decl
, v
)
1493 static tree decl_ring
[PRINT_RING_SIZE
];
1494 static char *print_ring
[PRINT_RING_SIZE
];
1495 static int ring_counter
;
1498 /* Only cache functions. */
1500 || TREE_CODE (decl
) != FUNCTION_DECL
1501 || DECL_LANG_SPECIFIC (decl
) == 0)
1502 return lang_decl_name (decl
, v
);
1504 /* See if this print name is lying around. */
1505 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1506 if (decl_ring
[i
] == decl
)
1507 /* yes, so return it. */
1508 return print_ring
[i
];
1510 if (++ring_counter
== PRINT_RING_SIZE
)
1513 if (current_function_decl
!= NULL_TREE
)
1515 if (decl_ring
[ring_counter
] == current_function_decl
)
1517 if (ring_counter
== PRINT_RING_SIZE
)
1519 if (decl_ring
[ring_counter
] == current_function_decl
)
1520 my_friendly_abort (106);
1523 if (print_ring
[ring_counter
])
1524 free (print_ring
[ring_counter
]);
1526 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1527 decl_ring
[ring_counter
] = decl
;
1528 return print_ring
[ring_counter
];
1531 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1532 listed in RAISES. */
1535 build_exception_variant (type
, raises
)
1539 tree v
= TYPE_MAIN_VARIANT (type
);
1540 int type_quals
= TYPE_QUALS (type
);
1542 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1543 if (TYPE_QUALS (v
) == type_quals
1544 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), 1))
1547 /* Need to build a new variant. */
1548 v
= build_type_copy (type
);
1549 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1553 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1554 lang_specific field and its corresponding TEMPLATE_DECL node */
1557 copy_template_template_parm (t
)
1560 tree
template = TYPE_NAME (t
);
1563 t2
= make_aggr_type (TEMPLATE_TEMPLATE_PARM
);
1564 template = copy_node (template);
1565 copy_lang_decl (template);
1567 TREE_TYPE (template) = t2
;
1568 TYPE_NAME (t2
) = template;
1569 TYPE_STUB_DECL (t2
) = template;
1571 /* No need to copy these */
1572 TYPE_FIELDS (t2
) = TYPE_FIELDS (t
);
1573 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1574 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
1578 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1579 FUNC is called with the DATA and the address of each sub-tree. If
1580 FUNC returns a non-NULL value, the traversal is aborted, and the
1581 value returned by FUNC is returned. */
1584 walk_tree (tp
, func
, data
)
1589 enum tree_code code
;
1593 #define WALK_SUBTREE(NODE) \
1596 result = walk_tree (&(NODE), func, data); \
1602 /* Skip empty subtrees. */
1606 /* Call the function. */
1608 result
= (*func
) (tp
, &walk_subtrees
, data
);
1610 /* If we found something, return it. */
1614 /* Even if we didn't, FUNC may have decided that there was nothing
1615 interesting below this point in the tree. */
1619 code
= TREE_CODE (*tp
);
1621 /* Handle common cases up front. */
1622 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1623 || TREE_CODE_CLASS (code
) == 'r'
1624 || TREE_CODE_CLASS (code
) == 's')
1628 /* Walk over all the sub-trees of this operand. */
1629 len
= first_rtl_op (code
);
1630 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
1631 But, we only want to walk once. */
1632 if (code
== TARGET_EXPR
1633 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
1635 /* Go through the subtrees. We need to do this in forward order so
1636 that the scope of a FOR_EXPR is handled properly. */
1637 for (i
= 0; i
< len
; ++i
)
1638 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
1640 /* For statements, we also walk the chain so that we cover the
1641 entire statement tree. */
1642 if (statement_code_p (code
))
1644 if (code
== DECL_STMT
1645 && DECL_STMT_DECL (*tp
)
1646 && TREE_CODE_CLASS (TREE_CODE (DECL_STMT_DECL (*tp
))) == 'd')
1648 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
1649 into declarations that are just mentioned, rather than
1650 declared; they don't really belong to this part of the tree.
1651 And, we can see cycles: the initializer for a declaration can
1652 refer to the declaration itself. */
1653 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
1654 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
1657 WALK_SUBTREE (TREE_CHAIN (*tp
));
1660 /* We didn't find what we were looking for. */
1663 else if (TREE_CODE_CLASS (code
) == 'd')
1665 WALK_SUBTREE (TREE_TYPE (*tp
));
1667 /* We didn't find what we were looking for. */
1671 /* Not one of the easy cases. We must explicitly go through the
1676 case IDENTIFIER_NODE
:
1681 case TEMPLATE_TEMPLATE_PARM
:
1682 case TEMPLATE_PARM_INDEX
:
1683 case TEMPLATE_TYPE_PARM
:
1693 /* None of thse have subtrees other than those already walked
1698 WALK_SUBTREE (TREE_TYPE (*tp
));
1702 case REFERENCE_TYPE
:
1703 WALK_SUBTREE (TREE_TYPE (*tp
));
1707 WALK_SUBTREE (TREE_PURPOSE (*tp
));
1708 WALK_SUBTREE (TREE_VALUE (*tp
));
1709 WALK_SUBTREE (TREE_CHAIN (*tp
));
1713 WALK_SUBTREE (OVL_FUNCTION (*tp
));
1714 WALK_SUBTREE (OVL_CHAIN (*tp
));
1719 int len
= TREE_VEC_LENGTH (*tp
);
1721 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
1726 WALK_SUBTREE (TREE_REALPART (*tp
));
1727 WALK_SUBTREE (TREE_IMAGPART (*tp
));
1731 WALK_SUBTREE (CONSTRUCTOR_ELTS (*tp
));
1735 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp
));
1739 WALK_SUBTREE (TREE_TYPE (*tp
));
1740 WALK_SUBTREE (TYPE_ARG_TYPES (*tp
));
1744 WALK_SUBTREE (TREE_TYPE (*tp
));
1745 WALK_SUBTREE (TYPE_DOMAIN (*tp
));
1749 WALK_SUBTREE (TYPE_MIN_VALUE (*tp
));
1750 WALK_SUBTREE (TYPE_MAX_VALUE (*tp
));
1754 WALK_SUBTREE (TREE_TYPE (*tp
));
1755 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (*tp
));
1759 if (TYPE_PTRMEMFUNC_P (*tp
))
1760 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
1764 my_friendly_abort (19990803);
1767 /* We didn't find what we were looking for. */
1773 /* Passed to walk_tree. Checks for the use of types with no linkage. */
1776 no_linkage_helper (tp
, walk_subtrees
, data
)
1778 int *walk_subtrees ATTRIBUTE_UNUSED
;
1779 void *data ATTRIBUTE_UNUSED
;
1784 && (IS_AGGR_TYPE (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1785 && (decl_function_context (TYPE_MAIN_DECL (t
))
1786 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
))))
1791 /* Check if the type T depends on a type with no linkage and if so, return
1795 no_linkage_check (t
)
1798 /* There's no point in checking linkage on template functions; we
1799 can't know their complete types. */
1800 if (processing_template_decl
)
1803 t
= walk_tree (&t
, no_linkage_helper
, NULL
);
1804 if (t
!= error_mark_node
)
1809 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1812 copy_tree_r (tp
, walk_subtrees
, data
)
1815 void *data ATTRIBUTE_UNUSED
;
1817 enum tree_code code
= TREE_CODE (*tp
);
1819 /* We make copies of most nodes. */
1820 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1821 || TREE_CODE_CLASS (code
) == 'r'
1822 || TREE_CODE_CLASS (code
) == 'c'
1823 || TREE_CODE_CLASS (code
) == 's'
1824 || code
== PARM_DECL
1825 || code
== TREE_LIST
1827 || code
== OVERLOAD
)
1829 /* Because the chain gets clobbered when we make a copy, we save it
1831 tree chain
= TREE_CHAIN (*tp
);
1833 /* Copy the node. */
1834 *tp
= copy_node (*tp
);
1836 /* Now, restore the chain, if appropriate. That will cause
1837 walk_tree to walk into the chain as well. */
1838 if (code
== PARM_DECL
|| code
== TREE_LIST
|| code
== OVERLOAD
1839 || statement_code_p (code
))
1840 TREE_CHAIN (*tp
) = chain
;
1842 /* For now, we don't update BLOCKs when we make copies. So, we
1843 have to nullify all scope-statements. */
1844 if (TREE_CODE (*tp
) == SCOPE_STMT
)
1845 SCOPE_STMT_BLOCK (*tp
) = NULL_TREE
;
1847 else if (code
== TEMPLATE_TEMPLATE_PARM
)
1848 /* These must be copied specially. */
1849 *tp
= copy_template_template_parm (*tp
);
1850 else if (TREE_CODE_CLASS (code
) == 't')
1851 /* There's no need to copy types, or anything beneath them. */
1857 #ifdef GATHER_STATISTICS
1858 extern int depth_reached
;
1862 print_lang_statistics ()
1864 print_search_statistics ();
1865 print_class_statistics ();
1866 #ifdef GATHER_STATISTICS
1867 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1872 /* This is used by the `assert' macro. It is provided in libgcc.a,
1873 which `cc' doesn't know how to link. Note that the C++ front-end
1874 no longer actually uses the `assert' macro (instead, it calls
1875 my_friendly_assert). But all of the back-end files still need this. */
1878 __eprintf (string
, expression
, line
, filename
)
1880 const char *expression
;
1882 const char *filename
;
1884 fprintf (stderr
, string
, expression
, line
, filename
);
1889 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1890 (which is an ARRAY_TYPE). This counts only elements of the top
1894 array_type_nelts_top (type
)
1897 return fold (build (PLUS_EXPR
, sizetype
,
1898 array_type_nelts (type
),
1902 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1903 (which is an ARRAY_TYPE). This one is a recursive count of all
1904 ARRAY_TYPEs that are clumped together. */
1907 array_type_nelts_total (type
)
1910 tree sz
= array_type_nelts_top (type
);
1911 type
= TREE_TYPE (type
);
1912 while (TREE_CODE (type
) == ARRAY_TYPE
)
1914 tree n
= array_type_nelts_top (type
);
1915 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1916 type
= TREE_TYPE (type
);
1921 /* Called from break_out_target_exprs via mapcar. */
1924 bot_manip (tp
, walk_subtrees
, data
)
1929 splay_tree target_remap
= ((splay_tree
) data
);
1932 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1934 /* There can't be any TARGET_EXPRs below this point. */
1938 else if (TREE_CODE (t
) == TARGET_EXPR
)
1942 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1944 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1946 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1951 TREE_OPERAND (u
, 0) = build (VAR_DECL
, TREE_TYPE (t
));
1952 layout_decl (TREE_OPERAND (u
, 0), 0);
1955 /* Map the old variable to the new one. */
1956 splay_tree_insert (target_remap
,
1957 (splay_tree_key
) TREE_OPERAND (t
, 0),
1958 (splay_tree_value
) TREE_OPERAND (u
, 0));
1960 /* Replace the old expression with the new version. */
1962 /* We don't have to go below this point; the recursive call to
1963 break_out_target_exprs will have handled anything below this
1968 else if (TREE_CODE (t
) == CALL_EXPR
)
1969 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1971 /* Make a copy of this node. */
1972 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1975 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1976 DATA is really a splay-tree mapping old variables to new
1980 bot_replace (t
, walk_subtrees
, data
)
1982 int *walk_subtrees ATTRIBUTE_UNUSED
;
1985 splay_tree target_remap
= ((splay_tree
) data
);
1987 if (TREE_CODE (*t
) == VAR_DECL
)
1989 splay_tree_node n
= splay_tree_lookup (target_remap
,
1990 (splay_tree_key
) *t
);
1992 *t
= (tree
) n
->value
;
1998 /* When we parse a default argument expression, we may create
1999 temporary variables via TARGET_EXPRs. When we actually use the
2000 default-argument expression, we make a copy of the expression, but
2001 we must replace the temporaries with appropriate local versions. */
2004 break_out_target_exprs (t
)
2007 static int target_remap_count
;
2008 static splay_tree target_remap
;
2010 if (!target_remap_count
++)
2011 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
2012 /*splay_tree_delete_key_fn=*/NULL
,
2013 /*splay_tree_delete_value_fn=*/NULL
);
2014 walk_tree (&t
, bot_manip
, target_remap
);
2015 walk_tree (&t
, bot_replace
, target_remap
);
2017 if (!--target_remap_count
)
2019 splay_tree_delete (target_remap
);
2020 target_remap
= NULL
;
2026 /* Obstack used for allocating nodes in template function and variable
2029 /* Similar to `build_nt', except that we set TREE_COMPLEXITY to be the
2030 current line number. */
2033 build_min_nt
VPROTO((enum tree_code code
, ...))
2035 #ifndef ANSI_PROTOTYPES
2036 enum tree_code code
;
2040 register int length
;
2045 #ifndef ANSI_PROTOTYPES
2046 code
= va_arg (p
, enum tree_code
);
2049 t
= make_node (code
);
2050 length
= tree_code_length
[(int) code
];
2051 TREE_COMPLEXITY (t
) = lineno
;
2053 for (i
= 0; i
< length
; i
++)
2055 tree x
= va_arg (p
, tree
);
2056 TREE_OPERAND (t
, i
) = x
;
2063 /* Similar to `build', except we set TREE_COMPLEXITY to the current
2067 build_min
VPROTO((enum tree_code code
, tree tt
, ...))
2069 #ifndef ANSI_PROTOTYPES
2070 enum tree_code code
;
2075 register int length
;
2080 #ifndef ANSI_PROTOTYPES
2081 code
= va_arg (p
, enum tree_code
);
2082 tt
= va_arg (p
, tree
);
2085 t
= make_node (code
);
2086 length
= tree_code_length
[(int) code
];
2088 TREE_COMPLEXITY (t
) = lineno
;
2090 for (i
= 0; i
< length
; i
++)
2092 tree x
= va_arg (p
, tree
);
2093 TREE_OPERAND (t
, i
) = x
;
2104 if (TREE_CODE (t
) == TYPE_DECL
)
2106 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
2107 return TYPE_STUB_DECL (t
);
2109 my_friendly_abort (42);
2111 /* Stop compiler from complaining control reaches end of non-void function. */
2116 can_free (obstack
, t
)
2117 struct obstack
*obstack
;
2122 if (TREE_CODE (t
) == TREE_VEC
)
2123 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
2125 my_friendly_abort (42);
2127 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2128 & ~ obstack_alignment_mask (obstack))
2129 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
2136 /* Return first vector element whose BINFO_TYPE is ELEM.
2137 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
2140 vec_binfo_member (elem
, vec
)
2146 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
2147 if (same_type_p (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
))))
2148 return TREE_VEC_ELT (vec
, i
);
2153 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2154 the wrong thing for decl_function_context. Hopefully the uses in the
2155 backend won't matter, since we don't need a static chain for local class
2159 hack_decl_function_context (decl
)
2162 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FUNCTION_MEMBER_P (decl
))
2163 return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl
)));
2164 return decl_function_context (decl
);
2167 /* Returns the namespace that contains DECL, whether directly or
2171 decl_namespace_context (decl
)
2176 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2178 else if (TYPE_P (decl
))
2179 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
2181 decl
= CP_DECL_CONTEXT (decl
);
2185 /* Return truthvalue of whether T1 is the same tree structure as T2.
2186 Return 1 if they are the same.
2187 Return 0 if they are understandably different.
2188 Return -1 if either contains tree structure not understood by
2192 cp_tree_equal (t1
, t2
)
2195 register enum tree_code code1
, code2
;
2200 if (t1
== 0 || t2
== 0)
2203 code1
= TREE_CODE (t1
);
2204 code2
= TREE_CODE (t2
);
2206 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
2208 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
2209 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2211 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
2213 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
2214 || code2
== NON_LVALUE_EXPR
)
2215 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
2223 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
2224 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
2227 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2230 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2231 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2232 TREE_STRING_LENGTH (t1
));
2235 /* We need to do this when determining whether or not two
2236 non-type pointer to member function template arguments
2238 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2239 /* The first operand is RTL. */
2240 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
2242 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2245 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
2248 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
2251 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
2254 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2257 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2260 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2263 /* Special case: if either target is an unallocated VAR_DECL,
2264 it means that it's going to be unified with whatever the
2265 TARGET_EXPR is really supposed to initialize, so treat it
2266 as being equivalent to anything. */
2267 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
2268 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
2269 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
2270 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
2271 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
2272 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
2275 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2278 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
2280 case WITH_CLEANUP_EXPR
:
2281 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2284 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
2287 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
2288 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2297 case TEMPLATE_PARM_INDEX
:
2298 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
2299 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
2303 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
2305 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1
, 0))) == 't')
2306 return same_type_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2310 /* Two pointer-to-members are the same if they point to the same
2311 field or function in the same class. */
2312 return (PTRMEM_CST_MEMBER (t1
) == PTRMEM_CST_MEMBER (t2
)
2313 && same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
)));
2319 switch (TREE_CODE_CLASS (code1
))
2329 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
2331 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2341 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2344 build_ptr_wrapper (ptr
)
2347 tree t
= make_node (WRAPPER
);
2348 WRAPPER_PTR (t
) = ptr
;
2352 /* Same, but on the expression_obstack. */
2355 build_expr_ptr_wrapper (ptr
)
2358 return build_ptr_wrapper (ptr
);
2361 /* Build a wrapper around some integer I so we can use it as a tree. */
2364 build_int_wrapper (i
)
2367 tree t
= make_node (WRAPPER
);
2368 WRAPPER_INT (t
) = i
;
2373 build_srcloc (file
, line
)
2379 t
= make_node (SRCLOC
);
2380 SRCLOC_FILE (t
) = file
;
2381 SRCLOC_LINE (t
) = line
;
2387 build_srcloc_here ()
2389 return build_srcloc (input_filename
, lineno
);
2392 /* The type of ARG when used as an lvalue. */
2398 tree type
= TREE_TYPE (arg
);
2399 if (TREE_CODE (arg
) == OVERLOAD
)
2400 type
= unknown_type_node
;
2404 /* The type of ARG for printing error messages; denote lvalues with
2411 tree type
= TREE_TYPE (arg
);
2412 if (TREE_CODE (type
) == ARRAY_TYPE
)
2414 else if (real_lvalue_p (arg
))
2415 type
= build_reference_type (lvalue_type (arg
));
2416 else if (IS_AGGR_TYPE (type
))
2417 type
= lvalue_type (arg
);
2422 /* Does FUNCTION use a variable-length argument list? */
2425 varargs_function_p (function
)
2428 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2429 for (; parm
; parm
= TREE_CHAIN (parm
))
2430 if (TREE_VALUE (parm
) == void_type_node
)
2435 /* Returns 1 if decl is a member of a class. */
2441 tree ctx
= DECL_CONTEXT (decl
);
2442 return (ctx
&& TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't');
2445 /* Create a placeholder for member access where we don't actually have an
2446 object that the access is against. */
2449 build_dummy_object (type
)
2452 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
2453 return build_indirect_ref (decl
, NULL_PTR
);
2456 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2457 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2458 binfo path from current_class_type to TYPE, or 0. */
2461 maybe_dummy_object (type
, binfop
)
2467 if (current_class_type
2468 && get_base_distance (type
, current_class_type
, 0, binfop
) != -1)
2469 context
= current_class_type
;
2472 /* Reference from a nested class member function. */
2475 *binfop
= TYPE_BINFO (type
);
2478 if (current_class_ref
&& context
== current_class_type
)
2479 decl
= current_class_ref
;
2481 decl
= build_dummy_object (context
);
2486 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2489 is_dummy_object (ob
)
2492 if (TREE_CODE (ob
) == INDIRECT_REF
)
2493 ob
= TREE_OPERAND (ob
, 0);
2494 return (TREE_CODE (ob
) == NOP_EXPR
2495 && TREE_OPERAND (ob
, 0) == void_zero_node
);
2498 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2504 while (TREE_CODE (t
) == ARRAY_TYPE
)
2507 if (INTEGRAL_TYPE_P (t
))
2508 return 1; /* integral, character or enumeral type */
2509 if (FLOAT_TYPE_P (t
))
2512 return 1; /* pointer to non-member */
2513 if (TYPE_PTRMEM_P (t
))
2514 return 1; /* pointer to member object */
2515 if (TYPE_PTRMEMFUNC_P (t
))
2516 return 1; /* pointer to member function */
2518 if (! CLASS_TYPE_P (t
))
2519 return 0; /* other non-class type (reference or function) */
2520 if (CLASSTYPE_NON_POD_P (t
))
2525 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2526 attribute for either declaration DECL or type TYPE and 0 otherwise.
2527 Plugged into valid_lang_attribute. */
2530 cp_valid_lang_attribute (attr_name
, attr_args
, decl
, type
)
2532 tree attr_args ATTRIBUTE_UNUSED
;
2533 tree decl ATTRIBUTE_UNUSED
;
2534 tree type ATTRIBUTE_UNUSED
;
2536 if (is_attribute_p ("com_interface", attr_name
))
2538 if (! flag_vtable_thunks
)
2540 error ("`com_interface' only supported with -fvtable-thunks");
2544 if (attr_args
!= NULL_TREE
2545 || decl
!= NULL_TREE
2546 || ! CLASS_TYPE_P (type
)
2547 || type
!= TYPE_MAIN_VARIANT (type
))
2549 warning ("`com_interface' attribute can only be applied to class definitions");
2553 CLASSTYPE_COM_INTERFACE (type
) = 1;
2556 else if (is_attribute_p ("init_priority", attr_name
))
2558 tree initp_expr
= (attr_args
? TREE_VALUE (attr_args
): NULL_TREE
);
2562 STRIP_NOPS (initp_expr
);
2564 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
2566 error ("requested init_priority is not an integer constant");
2570 pri
= TREE_INT_CST_LOW (initp_expr
);
2572 while (TREE_CODE (type
) == ARRAY_TYPE
)
2573 type
= TREE_TYPE (type
);
2575 if (decl
== NULL_TREE
2576 || TREE_CODE (decl
) != VAR_DECL
2577 || ! TREE_STATIC (decl
)
2578 || DECL_EXTERNAL (decl
)
2579 || (TREE_CODE (type
) != RECORD_TYPE
2580 && TREE_CODE (type
) != UNION_TYPE
)
2581 /* Static objects in functions are initialized the
2582 first time control passes through that
2583 function. This is not precise enough to pin down an
2584 init_priority value, so don't allow it. */
2585 || current_function_decl
)
2587 error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2591 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
2593 error ("requested init_priority is out of range");
2597 /* Check for init_priorities that are reserved for
2598 language and runtime support implementations.*/
2599 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
2602 ("requested init_priority is reserved for internal use");
2605 DECL_INIT_PRIORITY (decl
) = pri
;
2612 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2613 thing pointed to by the constant. */
2616 make_ptrmem_cst (type
, member
)
2620 tree ptrmem_cst
= make_node (PTRMEM_CST
);
2621 /* If would seem a great convenience if make_node would set
2622 TREE_CONSTANT for things of class `c', but it does not. */
2623 TREE_CONSTANT (ptrmem_cst
) = 1;
2624 TREE_TYPE (ptrmem_cst
) = type
;
2625 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
2629 /* Mark ARG (which is really a list_hash_table **) for GC. */
2632 mark_list_hash (arg
)
2635 struct list_hash
*lh
;
2637 for (lh
= * ((struct list_hash
**) arg
); lh
; lh
= lh
->next
)
2638 ggc_mark_tree (lh
->list
);
2641 /* Initialize tree.c. */
2646 make_lang_type_fn
= cp_make_lang_type
;
2647 lang_unsave
= cp_unsave
;
2648 ggc_add_root (list_hash_table
,
2649 sizeof (list_hash_table
) / sizeof (struct list_hash
*),
2650 sizeof (struct list_hash
*),
2654 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2655 information indicating to what new SAVE_EXPR this one should be
2656 mapped, use that one. Otherwise, create a new node and enter it in
2657 ST. FN is the function into which the copy will be placed. */
2660 remap_save_expr (tp
, st
, fn
, walk_subtrees
)
2668 /* See if we already encountered this SAVE_EXPR. */
2669 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2671 /* If we didn't already remap this SAVE_EXPR, do so now. */
2674 tree t
= copy_node (*tp
);
2676 /* The SAVE_EXPR is now part of the function into which we
2677 are inlining this body. */
2678 SAVE_EXPR_CONTEXT (t
) = fn
;
2679 /* And we haven't evaluated it yet. */
2680 SAVE_EXPR_RTL (t
) = NULL_RTX
;
2681 /* Remember this SAVE_EXPR. */
2682 n
= splay_tree_insert (st
,
2683 (splay_tree_key
) *tp
,
2684 (splay_tree_value
) t
);
2687 /* We've already walked into this SAVE_EXPR, so we needn't do it
2691 /* Replace this SAVE_EXPR with the copy. */
2692 *tp
= (tree
) n
->value
;
2695 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2696 declaration, copies the declaration and enters it in the splay_tree
2697 pointed to by DATA (which is really a `splay_tree *'). */
2700 mark_local_for_remap_r (tp
, walk_subtrees
, data
)
2702 int *walk_subtrees ATTRIBUTE_UNUSED
;
2706 splay_tree st
= (splay_tree
) data
;
2708 if ((TREE_CODE (t
) == DECL_STMT
2709 && nonstatic_local_decl_p (DECL_STMT_DECL (t
)))
2710 || TREE_CODE (t
) == LABEL_STMT
)
2715 /* Figure out what's being declared. */
2716 decl
= (TREE_CODE (t
) == DECL_STMT
2717 ? DECL_STMT_DECL (t
) : LABEL_STMT_LABEL (t
));
2720 copy
= copy_decl_for_inlining (decl
,
2721 DECL_CONTEXT (decl
),
2722 DECL_CONTEXT (decl
));
2724 /* Remember the copy. */
2725 splay_tree_insert (st
,
2726 (splay_tree_key
) decl
,
2727 (splay_tree_value
) copy
);
2733 /* Called via walk_tree when an expression is unsaved. Using the
2734 splay_tree pointed to by ST (which is really a `splay_tree *'),
2735 remaps all local declarations to appropriate replacements. */
2738 cp_unsave_r (tp
, walk_subtrees
, data
)
2743 splay_tree st
= (splay_tree
) data
;
2746 /* Only a local declaration (variable or label). */
2747 if (nonstatic_local_decl_p (*tp
))
2749 /* Lookup the declaration. */
2750 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2752 /* If it's there, remap it. */
2754 *tp
= (tree
) n
->value
;
2756 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2757 remap_save_expr (tp
, st
, current_function_decl
, walk_subtrees
);
2760 copy_tree_r (tp
, walk_subtrees
, NULL
);
2762 /* Do whatever unsaving is required. */
2763 unsave_expr_1 (*tp
);
2766 /* Keep iterating. */
2770 /* Called by unsave_expr_now whenever an expression (*TP) needs to be
2779 /* Create a splay-tree to map old local variable declarations to new
2781 st
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2783 /* Walk the tree once figuring out what needs to be remapped. */
2784 walk_tree (tp
, mark_local_for_remap_r
, st
);
2786 /* Walk the tree again, copying, remapping, and unsaving. */
2787 walk_tree (tp
, cp_unsave_r
, st
);
2790 splay_tree_delete (st
);