1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
32 #include "insn-config.h"
33 #include "integrate.h"
35 static tree bot_manip
PARAMS ((tree
*, int *, void *));
36 static tree bot_replace
PARAMS ((tree
*, int *, void *));
37 static tree build_cplus_array_type_1
PARAMS ((tree
, tree
));
38 static void list_hash_add
PARAMS ((int, tree
));
39 static int list_hash
PARAMS ((tree
, tree
, tree
));
40 static tree list_hash_lookup
PARAMS ((int, tree
, tree
, tree
));
41 static cp_lvalue_kind lvalue_p_1
PARAMS ((tree
, int));
42 static tree no_linkage_helper
PARAMS ((tree
*, int *, void *));
43 static tree build_srcloc
PARAMS ((const char *, int));
44 static void mark_list_hash
PARAMS ((void *));
45 static int statement_code_p
PARAMS ((enum tree_code
));
46 static tree mark_local_for_remap_r
PARAMS ((tree
*, int *, void *));
47 static tree cp_unsave_r
PARAMS ((tree
*, int *, void *));
48 static void cp_unsave
PARAMS ((tree
*));
49 static tree build_target_expr
PARAMS ((tree
, tree
));
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
53 non-zero, rvalues of class type are considered lvalues. */
56 lvalue_p_1 (ref
, treat_class_rvalues_as_lvalues
)
58 int treat_class_rvalues_as_lvalues
;
60 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
61 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
63 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
66 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
69 switch (TREE_CODE (ref
))
71 /* preincrements and predecrements are valid lvals, provided
72 what they refer to are valid lvals. */
73 case PREINCREMENT_EXPR
:
74 case PREDECREMENT_EXPR
:
78 case WITH_CLEANUP_EXPR
:
82 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
83 treat_class_rvalues_as_lvalues
);
86 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
87 treat_class_rvalues_as_lvalues
);
89 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
91 && TREE_CODE (TREE_OPERAND (ref
, 1)) == FIELD_DECL
92 && DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
94 /* Clear the ordinary bit. If this object was a class
95 rvalue we want to preserve that information. */
96 op1_lvalue_kind
&= ~clk_ordinary
;
97 /* The lvalue is for a btifield. */
98 op1_lvalue_kind
|= clk_bitfield
;
100 return op1_lvalue_kind
;
106 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
107 && DECL_LANG_SPECIFIC (ref
)
108 && DECL_IN_AGGR_P (ref
))
114 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
118 /* A currently unresolved scope ref. */
120 my_friendly_abort (103);
122 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
127 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
128 treat_class_rvalues_as_lvalues
);
129 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
130 treat_class_rvalues_as_lvalues
);
134 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
135 treat_class_rvalues_as_lvalues
);
136 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 2),
137 treat_class_rvalues_as_lvalues
);
144 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
145 treat_class_rvalues_as_lvalues
);
148 return treat_class_rvalues_as_lvalues
? clk_class
: clk_none
;
152 return ((treat_class_rvalues_as_lvalues
153 && IS_AGGR_TYPE (TREE_TYPE (ref
)))
154 ? clk_class
: clk_none
);
157 /* All functions (except non-static-member functions) are
159 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
160 ? clk_none
: clk_ordinary
);
166 /* If one operand is not an lvalue at all, then this expression is
168 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
171 /* Otherwise, it's an lvalue, and it has all the odd properties
172 contributed by either operand. */
173 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
174 /* It's not an ordinary lvalue if it involves either a bit-field or
176 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
177 op1_lvalue_kind
&= ~clk_ordinary
;
178 return op1_lvalue_kind
;
181 /* If REF is an lvalue, returns the kind of lvalue that REF is.
182 Otherwise, returns clk_none. Lvalues can be assigned, unless they
183 have TREE_READONLY, or unless they are FUNCTION_DECLs. Lvalues can
184 have their address taken, unless they have DECL_REGISTER. */
190 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/0);
193 /* This differs from real_lvalue_p in that class rvalues are
194 considered lvalues. */
201 (lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/1) != clk_none
);
204 /* Return nonzero if REF is an lvalue valid for this language;
205 otherwise, print an error message and return zero. */
208 lvalue_or_else (ref
, string
)
212 int win
= lvalue_p (ref
);
214 error ("non-lvalue in %s", string
);
218 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
221 build_target_expr (decl
, value
)
227 t
= build (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
228 maybe_build_cleanup (decl
), NULL_TREE
);
229 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
230 ignore the TARGET_EXPR. If there really turn out to be no
231 side-effects, then the optimizer should be able to get rid of
232 whatever code is generated anyhow. */
233 TREE_SIDE_EFFECTS (t
) = 1;
238 /* INIT is a CALL_EXPR which needs info about its target.
239 TYPE is the type that this initialization should appear to have.
241 Build an encapsulation of the initialization to perform
242 and return it so that it can be processed by language-independent
243 and language-specific expression expanders. */
246 build_cplus_new (type
, init
)
254 /* Make sure that we're not trying to create an instance of an
256 abstract_virtuals_error (NULL_TREE
, type
);
258 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
259 return convert (type
, init
);
261 slot
= build (VAR_DECL
, type
);
262 DECL_ARTIFICIAL (slot
) = 1;
263 DECL_CONTEXT (slot
) = current_function_decl
;
264 layout_decl (slot
, 0);
266 /* We split the CALL_EXPR into its function and its arguments here.
267 Then, in expand_expr, we put them back together. The reason for
268 this is that this expression might be a default argument
269 expression. In that case, we need a new temporary every time the
270 expression is used. That's what break_out_target_exprs does; it
271 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
272 temporary slot. Then, expand_expr builds up a call-expression
273 using the new slot. */
274 fn
= TREE_OPERAND (init
, 0);
275 rval
= build (AGGR_INIT_EXPR
, type
, fn
, TREE_OPERAND (init
, 1), slot
);
276 TREE_SIDE_EFFECTS (rval
) = 1;
277 AGGR_INIT_VIA_CTOR_P (rval
)
278 = (TREE_CODE (fn
) == ADDR_EXPR
279 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
280 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
281 rval
= build_target_expr (slot
, rval
);
286 /* Buidl a TARGET_EXPR using INIT to initialize a new temporary of the
290 build_target_expr_with_type (init
, type
)
297 if (TREE_CODE (init
) == TARGET_EXPR
)
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_HAS_NONTRIVIAL_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_HAS_NONTRIVIAL_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. */
467 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
468 TYPE_ARG_TYPES (t
) = argtypes
;
469 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
471 /* If we already have such a type, use the old one and free this one.
472 Note that it also frees up the above cons cell if found. */
473 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) +
474 type_hash_list (argtypes
);
476 t
= type_hash_canon (hashcode
, t
);
478 if (!COMPLETE_TYPE_P (t
))
485 build_cplus_array_type_1 (elt_type
, index_type
)
491 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
492 return error_mark_node
;
494 if (processing_template_decl
495 || uses_template_parms (elt_type
)
496 || uses_template_parms (index_type
))
498 t
= make_node (ARRAY_TYPE
);
499 TREE_TYPE (t
) = elt_type
;
500 TYPE_DOMAIN (t
) = index_type
;
503 t
= build_array_type (elt_type
, index_type
);
505 /* Push these needs up so that initialization takes place
507 TYPE_NEEDS_CONSTRUCTING (t
)
508 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
509 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
510 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
515 build_cplus_array_type (elt_type
, index_type
)
520 int type_quals
= CP_TYPE_QUALS (elt_type
);
522 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
524 t
= build_cplus_array_type_1 (elt_type
, index_type
);
526 if (type_quals
!= TYPE_UNQUALIFIED
)
527 t
= cp_build_qualified_type (t
, type_quals
);
532 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
533 arrays correctly. In particular, if TYPE is an array of T's, and
534 TYPE_QUALS is non-empty, returns an array of qualified T's. If
535 at attempt is made to qualify a type illegally, and COMPLAIN is
536 non-zero, an error is issued. If COMPLAIN is zero, error_mark_node
540 cp_build_qualified_type_real (type
, type_quals
, complain
)
547 if (type
== error_mark_node
)
550 if (type_quals
== TYPE_QUALS (type
))
553 /* A restrict-qualified pointer type must be a pointer (or reference)
554 to object or incomplete type. */
555 if ((type_quals
& TYPE_QUAL_RESTRICT
)
556 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
557 && (!POINTER_TYPE_P (type
)
558 || TYPE_PTRMEM_P (type
)
559 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
562 cp_error ("`%T' cannot be `restrict'-qualified", type
);
564 return error_mark_node
;
566 type_quals
&= ~TYPE_QUAL_RESTRICT
;
569 if (type_quals
!= TYPE_UNQUALIFIED
570 && TREE_CODE (type
) == FUNCTION_TYPE
)
573 cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type
);
575 return error_mark_node
;
576 type_quals
= TYPE_UNQUALIFIED
;
578 else if (TREE_CODE (type
) == ARRAY_TYPE
)
580 /* In C++, the qualification really applies to the array element
581 type. Obtain the appropriately qualified element type. */
584 = cp_build_qualified_type_real (TREE_TYPE (type
),
588 if (element_type
== error_mark_node
)
589 return error_mark_node
;
591 /* See if we already have an identically qualified type. */
592 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
593 if (CP_TYPE_QUALS (t
) == type_quals
)
596 /* If we didn't already have it, create it now. */
599 /* Make a new array type, just like the old one, but with the
600 appropriately qualified element type. */
601 t
= build_type_copy (type
);
602 TREE_TYPE (t
) = element_type
;
605 /* Even if we already had this variant, we update
606 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
607 they changed since the variant was originally created.
609 This seems hokey; if there is some way to use a previous
610 variant *without* coming through here,
611 TYPE_NEEDS_CONSTRUCTING will never be updated. */
612 TYPE_NEEDS_CONSTRUCTING (t
)
613 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
614 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
615 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
618 else if (TYPE_PTRMEMFUNC_P (type
))
620 /* For a pointer-to-member type, we can't just return a
621 cv-qualified version of the RECORD_TYPE. If we do, we
622 haven't change the field that contains the actual pointer to
623 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
626 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
627 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
628 return build_ptrmemfunc_type (t
);
631 /* Retrieve (or create) the appropriately qualified variant. */
632 result
= build_qualified_type (type
, type_quals
);
634 /* If this was a pointer-to-method type, and we just made a copy,
635 then we need to clear the cached associated
636 pointer-to-member-function type; it is not valid for the new
639 && TREE_CODE (type
) == POINTER_TYPE
640 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
641 TYPE_SET_PTRMEMFUNC_TYPE (result
, NULL_TREE
);
646 /* Returns the canonical version of TYPE. In other words, if TYPE is
647 a typedef, returns the underlying type. The cv-qualification of
648 the type returned matches the type input; they will always be
652 canonical_type_variant (t
)
655 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), CP_TYPE_QUALS (t
));
658 /* Makes new binfos for the indirect bases under BINFO, and updates
659 BINFO_OFFSET for them and their bases. */
662 unshare_base_binfos (binfo
)
665 tree binfos
= BINFO_BASETYPES (binfo
);
669 if (binfos
== NULL_TREE
)
672 /* Now unshare the structure beneath BINFO. */
673 for (j
= TREE_VEC_LENGTH (binfos
)-1;
676 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
677 new_binfo
= TREE_VEC_ELT (binfos
, j
)
678 = make_binfo (BINFO_OFFSET (base_binfo
),
680 BINFO_VTABLE (base_binfo
),
681 BINFO_VIRTUALS (base_binfo
));
682 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
683 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
684 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
685 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
686 unshare_base_binfos (new_binfo
);
691 /* Hashing of lists so that we don't make duplicates.
692 The entry point is `list_hash_canon'. */
694 /* Each hash table slot is a bucket containing a chain
695 of these structures. */
699 struct list_hash
*next
; /* Next structure in the bucket. */
700 int hashcode
; /* Hash code of this list. */
701 tree list
; /* The list recorded here. */
704 /* Now here is the hash table. When recording a list, it is added
705 to the slot whose index is the hash code mod the table size.
706 Note that the hash table is used for several kinds of lists.
707 While all these live in the same table, they are completely independent,
708 and the hash code is computed differently for each of these. */
710 #define TYPE_HASH_SIZE 59
711 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
713 /* Compute a hash code for a list (chain of TREE_LIST nodes
714 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
715 TREE_COMMON slots), by adding the hash codes of the individual entries. */
718 list_hash (purpose
, value
, chain
)
719 tree purpose
, value
, chain
;
721 register int hashcode
= 0;
724 hashcode
+= TYPE_HASH (chain
);
727 hashcode
+= TYPE_HASH (value
);
731 hashcode
+= TYPE_HASH (purpose
);
737 /* Look in the type hash table for a type isomorphic to TYPE.
738 If one is found, return it. Otherwise return 0. */
741 list_hash_lookup (hashcode
, purpose
, value
, chain
)
743 tree purpose
, value
, chain
;
745 register struct list_hash
*h
;
747 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
748 if (h
->hashcode
== hashcode
749 && TREE_PURPOSE (h
->list
) == purpose
750 && TREE_VALUE (h
->list
) == value
751 && TREE_CHAIN (h
->list
) == chain
)
756 /* Add an entry to the list-hash-table
757 for a list TYPE whose hash code is HASHCODE. */
760 list_hash_add (hashcode
, list
)
764 register struct list_hash
*h
;
766 h
= (struct list_hash
*) obstack_alloc (&permanent_obstack
, sizeof (struct list_hash
));
767 h
->hashcode
= hashcode
;
769 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
770 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
773 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
774 object for an identical list if one already exists. Otherwise, build a
775 new one, and record it as the canonical object. */
777 /* Set to 1 to debug without canonicalization. Never set by program. */
779 static int debug_no_list_hash
= 0;
782 hash_tree_cons (purpose
, value
, chain
)
783 tree purpose
, value
, chain
;
788 if (! debug_no_list_hash
)
790 hashcode
= list_hash (purpose
, value
, chain
);
791 t
= list_hash_lookup (hashcode
, purpose
, value
, chain
);
796 t
= tree_cons (purpose
, value
, chain
);
798 /* If this is a new list, record it for later reuse. */
799 if (! debug_no_list_hash
)
800 list_hash_add (hashcode
, t
);
805 /* Constructor for hashed lists. */
808 hash_tree_chain (value
, chain
)
811 return hash_tree_cons (NULL_TREE
, value
, chain
);
814 /* Similar, but used for concatenating two lists. */
817 hash_chainon (list1
, list2
)
824 if (TREE_CHAIN (list1
) == NULL_TREE
)
825 return hash_tree_chain (TREE_VALUE (list1
), list2
);
826 return hash_tree_chain (TREE_VALUE (list1
),
827 hash_chainon (TREE_CHAIN (list1
), list2
));
830 /* Build an association between TYPE and some parameters:
832 OFFSET is the offset added to `this' to convert it to a pointer
835 BINFO is the base binfo to use, if we are deriving from one. This
836 is necessary, as we want specialized parent binfos from base
837 classes, so that the VTABLE_NAMEs of bases are for the most derived
838 type, instead of the simple type.
840 VTABLE is the virtual function table with which to initialize
841 sub-objects of type TYPE.
843 VIRTUALS are the virtual functions sitting in VTABLE. */
846 make_binfo (offset
, binfo
, vtable
, virtuals
)
848 tree vtable
, virtuals
;
850 tree new_binfo
= make_tree_vec (8);
853 if (TREE_CODE (binfo
) == TREE_VEC
)
854 type
= BINFO_TYPE (binfo
);
858 binfo
= CLASS_TYPE_P (type
) ? TYPE_BINFO (binfo
) : NULL_TREE
;
861 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
862 BINFO_OFFSET (new_binfo
) = offset
;
863 BINFO_VTABLE (new_binfo
) = vtable
;
864 BINFO_VIRTUALS (new_binfo
) = virtuals
;
866 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
867 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
871 /* Return the binfo value for ELEM in TYPE. */
874 binfo_value (elem
, type
)
878 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
879 compiler_error ("base class `%s' ambiguous in binfo_value",
880 TYPE_NAME_STRING (elem
));
882 return TYPE_BINFO (type
);
883 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
885 return get_binfo (elem
, type
, 0);
888 /* Return a TREE_LIST whose TREE_VALUE nodes along the
889 BINFO_INHERITANCE_CHAIN for BINFO, but in the opposite order. In
890 other words, while the BINFO_INHERITANCE_CHAIN goes from base
891 classes to derived classes, the reversed path goes from derived
892 classes to base classes. */
900 reversed_path
= NULL_TREE
;
903 reversed_path
= tree_cons (NULL_TREE
, binfo
, reversed_path
);
904 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
907 return reversed_path
;
917 fprintf (stderr
, "type \"%s\", offset = ",
918 TYPE_NAME_STRING (BINFO_TYPE (elem
)));
919 fprintf (stderr
, HOST_WIDE_INT_PRINT_DEC
,
920 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
921 fprintf (stderr
, "\nvtable type:\n");
922 debug_tree (BINFO_TYPE (elem
));
923 if (BINFO_VTABLE (elem
))
924 fprintf (stderr
, "vtable decl \"%s\"\n",
925 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
927 fprintf (stderr
, "no vtable decl yet\n");
928 fprintf (stderr
, "virtuals:\n");
929 virtuals
= BINFO_VIRTUALS (elem
);
930 n
= first_vfun_index (BINFO_TYPE (elem
));
934 tree fndecl
= TREE_VALUE (virtuals
);
935 fprintf (stderr
, "%s [%ld =? %ld]\n",
936 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
937 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
939 virtuals
= TREE_CHAIN (virtuals
);
948 if (TREE_CODE (t
) == FUNCTION_DECL
)
950 else if (TREE_CODE (t
) == OVERLOAD
)
952 for (i
=0; t
; t
= OVL_CHAIN (t
))
957 my_friendly_abort (359);
965 /* A baselink is also considered an overloaded function. */
966 if (TREE_CODE (x
) == OFFSET_REF
)
967 x
= TREE_OPERAND (x
, 1);
970 return (TREE_CODE (x
) == FUNCTION_DECL
971 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
972 || DECL_FUNCTION_TEMPLATE_P (x
)
973 || TREE_CODE (x
) == OVERLOAD
);
977 really_overloaded_fn (x
)
980 /* A baselink is also considered an overloaded function. */
981 if (TREE_CODE (x
) == OFFSET_REF
)
982 x
= TREE_OPERAND (x
, 1);
985 return (TREE_CODE (x
) == OVERLOAD
986 && (TREE_CHAIN (x
) != NULL_TREE
987 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
994 my_friendly_assert (is_overloaded_fn (from
), 9);
995 /* A baselink is also considered an overloaded function. */
996 if (BASELINK_P (from
))
997 from
= TREE_VALUE (from
);
998 return OVL_CURRENT (from
);
1001 /* Returns nonzero if T is a ->* or .* expression that refers to a
1008 return (TREE_CODE (t
) == OFFSET_REF
1009 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t
, 1))));
1012 /* Return a new OVL node, concatenating it with the old one. */
1015 ovl_cons (decl
, chain
)
1019 tree result
= make_node (OVERLOAD
);
1020 TREE_TYPE (result
) = unknown_type_node
;
1021 OVL_FUNCTION (result
) = decl
;
1022 TREE_CHAIN (result
) = chain
;
1027 /* Build a new overloaded function. If this is the first one,
1028 just return it; otherwise, ovl_cons the _DECLs */
1031 build_overload (decl
, chain
)
1035 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1037 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1038 chain
= ovl_cons (chain
, NULL_TREE
);
1039 return ovl_cons (decl
, chain
);
1042 /* True if fn is in ovl. */
1045 ovl_member (fn
, ovl
)
1049 if (ovl
== NULL_TREE
)
1051 if (TREE_CODE (ovl
) != OVERLOAD
)
1053 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1054 if (OVL_FUNCTION (ovl
) == fn
)
1060 is_aggr_type_2 (t1
, t2
)
1063 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1065 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1068 /* Returns non-zero if CODE is the code for a statement. */
1071 statement_code_p (code
)
1072 enum tree_code code
;
1092 case START_CATCH_STMT
:
1095 case CTOR_INITIALIZER
:
1107 #define PRINT_RING_SIZE 4
1110 lang_printable_name (decl
, v
)
1114 static tree decl_ring
[PRINT_RING_SIZE
];
1115 static char *print_ring
[PRINT_RING_SIZE
];
1116 static int ring_counter
;
1119 /* Only cache functions. */
1121 || TREE_CODE (decl
) != FUNCTION_DECL
1122 || DECL_LANG_SPECIFIC (decl
) == 0)
1123 return lang_decl_name (decl
, v
);
1125 /* See if this print name is lying around. */
1126 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1127 if (decl_ring
[i
] == decl
)
1128 /* yes, so return it. */
1129 return print_ring
[i
];
1131 if (++ring_counter
== PRINT_RING_SIZE
)
1134 if (current_function_decl
!= NULL_TREE
)
1136 if (decl_ring
[ring_counter
] == current_function_decl
)
1138 if (ring_counter
== PRINT_RING_SIZE
)
1140 if (decl_ring
[ring_counter
] == current_function_decl
)
1141 my_friendly_abort (106);
1144 if (print_ring
[ring_counter
])
1145 free (print_ring
[ring_counter
]);
1147 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1148 decl_ring
[ring_counter
] = decl
;
1149 return print_ring
[ring_counter
];
1152 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1153 listed in RAISES. */
1156 build_exception_variant (type
, raises
)
1160 tree v
= TYPE_MAIN_VARIANT (type
);
1161 int type_quals
= TYPE_QUALS (type
);
1163 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1164 if (TYPE_QUALS (v
) == type_quals
1165 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), 1))
1168 /* Need to build a new variant. */
1169 v
= build_type_copy (type
);
1170 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1174 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1175 lang_specific field and its corresponding TEMPLATE_DECL node */
1178 copy_template_template_parm (t
)
1181 tree
template = TYPE_NAME (t
);
1184 t2
= make_aggr_type (TEMPLATE_TEMPLATE_PARM
);
1185 template = copy_decl (template);
1187 TREE_TYPE (template) = t2
;
1188 TYPE_NAME (t2
) = template;
1189 TYPE_STUB_DECL (t2
) = template;
1191 /* No need to copy these */
1192 TYPE_FIELDS (t2
) = TYPE_FIELDS (t
);
1193 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1194 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
1198 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1199 FUNC is called with the DATA and the address of each sub-tree. If
1200 FUNC returns a non-NULL value, the traversal is aborted, and the
1201 value returned by FUNC is returned. */
1204 walk_tree (tp
, func
, data
)
1209 enum tree_code code
;
1213 #define WALK_SUBTREE(NODE) \
1216 result = walk_tree (&(NODE), func, data); \
1222 /* Skip empty subtrees. */
1226 /* Call the function. */
1228 result
= (*func
) (tp
, &walk_subtrees
, data
);
1230 /* If we found something, return it. */
1234 /* Even if we didn't, FUNC may have decided that there was nothing
1235 interesting below this point in the tree. */
1239 code
= TREE_CODE (*tp
);
1241 /* Handle common cases up front. */
1242 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1243 || TREE_CODE_CLASS (code
) == 'r'
1244 || TREE_CODE_CLASS (code
) == 's')
1248 /* Set lineno here so we get the right instantiation context
1249 if we call instantiate_decl from inlinable_function_p. */
1250 if (statement_code_p (code
) && !STMT_LINENO_FOR_FN_P (*tp
))
1251 lineno
= STMT_LINENO (*tp
);
1253 /* Walk over all the sub-trees of this operand. */
1254 len
= first_rtl_op (code
);
1255 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
1256 But, we only want to walk once. */
1257 if (code
== TARGET_EXPR
1258 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
1260 /* Go through the subtrees. We need to do this in forward order so
1261 that the scope of a FOR_EXPR is handled properly. */
1262 for (i
= 0; i
< len
; ++i
)
1263 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
1265 /* For statements, we also walk the chain so that we cover the
1266 entire statement tree. */
1267 if (statement_code_p (code
))
1269 if (code
== DECL_STMT
1270 && DECL_STMT_DECL (*tp
)
1271 && DECL_P (DECL_STMT_DECL (*tp
)))
1273 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
1274 into declarations that are just mentioned, rather than
1275 declared; they don't really belong to this part of the tree.
1276 And, we can see cycles: the initializer for a declaration can
1277 refer to the declaration itself. */
1278 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
1279 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
1280 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp
)));
1283 WALK_SUBTREE (TREE_CHAIN (*tp
));
1286 /* We didn't find what we were looking for. */
1289 else if (TREE_CODE_CLASS (code
) == 'd')
1291 WALK_SUBTREE (TREE_TYPE (*tp
));
1293 /* We didn't find what we were looking for. */
1297 /* Not one of the easy cases. We must explicitly go through the
1302 case IDENTIFIER_NODE
:
1307 case TEMPLATE_TEMPLATE_PARM
:
1308 case TEMPLATE_PARM_INDEX
:
1309 case TEMPLATE_TYPE_PARM
:
1319 /* None of thse have subtrees other than those already walked
1324 WALK_SUBTREE (TREE_TYPE (*tp
));
1328 case REFERENCE_TYPE
:
1329 WALK_SUBTREE (TREE_TYPE (*tp
));
1333 WALK_SUBTREE (TREE_PURPOSE (*tp
));
1334 WALK_SUBTREE (TREE_VALUE (*tp
));
1335 WALK_SUBTREE (TREE_CHAIN (*tp
));
1339 WALK_SUBTREE (OVL_FUNCTION (*tp
));
1340 WALK_SUBTREE (OVL_CHAIN (*tp
));
1345 int len
= TREE_VEC_LENGTH (*tp
);
1347 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
1352 WALK_SUBTREE (TREE_REALPART (*tp
));
1353 WALK_SUBTREE (TREE_IMAGPART (*tp
));
1357 WALK_SUBTREE (CONSTRUCTOR_ELTS (*tp
));
1361 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp
));
1365 WALK_SUBTREE (TREE_TYPE (*tp
));
1366 WALK_SUBTREE (TYPE_ARG_TYPES (*tp
));
1370 WALK_SUBTREE (TREE_TYPE (*tp
));
1371 WALK_SUBTREE (TYPE_DOMAIN (*tp
));
1375 WALK_SUBTREE (TYPE_MIN_VALUE (*tp
));
1376 WALK_SUBTREE (TYPE_MAX_VALUE (*tp
));
1380 WALK_SUBTREE (TREE_TYPE (*tp
));
1381 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (*tp
));
1385 if (TYPE_PTRMEMFUNC_P (*tp
))
1386 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
1390 my_friendly_abort (19990803);
1393 /* We didn't find what we were looking for. */
1399 /* Passed to walk_tree. Checks for the use of types with no linkage. */
1402 no_linkage_helper (tp
, walk_subtrees
, data
)
1404 int *walk_subtrees ATTRIBUTE_UNUSED
;
1405 void *data ATTRIBUTE_UNUSED
;
1410 && (IS_AGGR_TYPE (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1411 && (decl_function_context (TYPE_MAIN_DECL (t
))
1412 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
))))
1417 /* Check if the type T depends on a type with no linkage and if so, return
1421 no_linkage_check (t
)
1424 /* There's no point in checking linkage on template functions; we
1425 can't know their complete types. */
1426 if (processing_template_decl
)
1429 t
= walk_tree (&t
, no_linkage_helper
, NULL
);
1430 if (t
!= error_mark_node
)
1435 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1438 copy_tree_r (tp
, walk_subtrees
, data
)
1441 void *data ATTRIBUTE_UNUSED
;
1443 enum tree_code code
= TREE_CODE (*tp
);
1445 /* We make copies of most nodes. */
1446 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1447 || TREE_CODE_CLASS (code
) == 'r'
1448 || TREE_CODE_CLASS (code
) == 'c'
1449 || TREE_CODE_CLASS (code
) == 's'
1450 || code
== TREE_LIST
1452 || code
== OVERLOAD
)
1454 /* Because the chain gets clobbered when we make a copy, we save it
1456 tree chain
= TREE_CHAIN (*tp
);
1458 /* Copy the node. */
1459 *tp
= copy_node (*tp
);
1461 /* Now, restore the chain, if appropriate. That will cause
1462 walk_tree to walk into the chain as well. */
1463 if (code
== PARM_DECL
|| code
== TREE_LIST
|| code
== OVERLOAD
1464 || statement_code_p (code
))
1465 TREE_CHAIN (*tp
) = chain
;
1467 /* For now, we don't update BLOCKs when we make copies. So, we
1468 have to nullify all scope-statements. */
1469 if (TREE_CODE (*tp
) == SCOPE_STMT
)
1470 SCOPE_STMT_BLOCK (*tp
) = NULL_TREE
;
1472 else if (code
== TEMPLATE_TEMPLATE_PARM
)
1473 /* These must be copied specially. */
1474 *tp
= copy_template_template_parm (*tp
);
1475 else if (TREE_CODE_CLASS (code
) == 't')
1476 /* There's no need to copy types, or anything beneath them. */
1482 #ifdef GATHER_STATISTICS
1483 extern int depth_reached
;
1487 print_lang_statistics ()
1489 print_search_statistics ();
1490 print_class_statistics ();
1491 #ifdef GATHER_STATISTICS
1492 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1497 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1498 (which is an ARRAY_TYPE). This counts only elements of the top
1502 array_type_nelts_top (type
)
1505 return fold (build (PLUS_EXPR
, sizetype
,
1506 array_type_nelts (type
),
1510 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1511 (which is an ARRAY_TYPE). This one is a recursive count of all
1512 ARRAY_TYPEs that are clumped together. */
1515 array_type_nelts_total (type
)
1518 tree sz
= array_type_nelts_top (type
);
1519 type
= TREE_TYPE (type
);
1520 while (TREE_CODE (type
) == ARRAY_TYPE
)
1522 tree n
= array_type_nelts_top (type
);
1523 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1524 type
= TREE_TYPE (type
);
1529 /* Called from break_out_target_exprs via mapcar. */
1532 bot_manip (tp
, walk_subtrees
, data
)
1537 splay_tree target_remap
= ((splay_tree
) data
);
1540 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1542 /* There can't be any TARGET_EXPRs below this point. */
1546 else if (TREE_CODE (t
) == TARGET_EXPR
)
1550 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1552 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1554 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1561 var
= build (VAR_DECL
, TREE_TYPE (t
));
1562 DECL_CONTEXT (var
) = current_function_decl
;
1563 layout_decl (var
, 0);
1564 TREE_OPERAND (u
, 0) = var
;
1567 /* Map the old variable to the new one. */
1568 splay_tree_insert (target_remap
,
1569 (splay_tree_key
) TREE_OPERAND (t
, 0),
1570 (splay_tree_value
) TREE_OPERAND (u
, 0));
1572 /* Replace the old expression with the new version. */
1574 /* We don't have to go below this point; the recursive call to
1575 break_out_target_exprs will have handled anything below this
1580 else if (TREE_CODE (t
) == CALL_EXPR
)
1581 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1583 /* Make a copy of this node. */
1584 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1587 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1588 DATA is really a splay-tree mapping old variables to new
1592 bot_replace (t
, walk_subtrees
, data
)
1594 int *walk_subtrees ATTRIBUTE_UNUSED
;
1597 splay_tree target_remap
= ((splay_tree
) data
);
1599 if (TREE_CODE (*t
) == VAR_DECL
)
1601 splay_tree_node n
= splay_tree_lookup (target_remap
,
1602 (splay_tree_key
) *t
);
1604 *t
= (tree
) n
->value
;
1610 /* When we parse a default argument expression, we may create
1611 temporary variables via TARGET_EXPRs. When we actually use the
1612 default-argument expression, we make a copy of the expression, but
1613 we must replace the temporaries with appropriate local versions. */
1616 break_out_target_exprs (t
)
1619 static int target_remap_count
;
1620 static splay_tree target_remap
;
1622 if (!target_remap_count
++)
1623 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
1624 /*splay_tree_delete_key_fn=*/NULL
,
1625 /*splay_tree_delete_value_fn=*/NULL
);
1626 walk_tree (&t
, bot_manip
, target_remap
);
1627 walk_tree (&t
, bot_replace
, target_remap
);
1629 if (!--target_remap_count
)
1631 splay_tree_delete (target_remap
);
1632 target_remap
= NULL
;
1638 /* Obstack used for allocating nodes in template function and variable
1641 /* Similar to `build_nt', except that we set TREE_COMPLEXITY to be the
1642 current line number. */
1645 build_min_nt
VPARAMS ((enum tree_code code
, ...))
1647 #ifndef ANSI_PROTOTYPES
1648 enum tree_code code
;
1652 register int length
;
1657 #ifndef ANSI_PROTOTYPES
1658 code
= va_arg (p
, enum tree_code
);
1661 t
= make_node (code
);
1662 length
= tree_code_length
[(int) code
];
1663 TREE_COMPLEXITY (t
) = lineno
;
1665 for (i
= 0; i
< length
; i
++)
1667 tree x
= va_arg (p
, tree
);
1668 TREE_OPERAND (t
, i
) = x
;
1675 /* Similar to `build', except we set TREE_COMPLEXITY to the current
1679 build_min
VPARAMS ((enum tree_code code
, tree tt
, ...))
1681 #ifndef ANSI_PROTOTYPES
1682 enum tree_code code
;
1687 register int length
;
1692 #ifndef ANSI_PROTOTYPES
1693 code
= va_arg (p
, enum tree_code
);
1694 tt
= va_arg (p
, tree
);
1697 t
= make_node (code
);
1698 length
= tree_code_length
[(int) code
];
1700 TREE_COMPLEXITY (t
) = lineno
;
1702 for (i
= 0; i
< length
; i
++)
1704 tree x
= va_arg (p
, tree
);
1705 TREE_OPERAND (t
, i
) = x
;
1712 /* Returns an INTEGER_CST (of type `int') corresponding to I.
1713 Multiple calls with the same value of I may or may not yield the
1714 same node; therefore, callers should never modify the node
1718 build_shared_int_cst (i
)
1721 static tree cache
[256];
1724 return build_int_2 (i
, 0);
1727 cache
[i
] = build_int_2 (i
, 0);
1736 if (TREE_CODE (t
) == TYPE_DECL
)
1739 return TYPE_STUB_DECL (t
);
1741 my_friendly_abort (42);
1743 /* Stop compiler from complaining control reaches end of non-void function. */
1748 can_free (obstack
, t
)
1749 struct obstack
*obstack
;
1754 if (TREE_CODE (t
) == TREE_VEC
)
1755 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1757 my_friendly_abort (42);
1759 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1760 & ~ obstack_alignment_mask (obstack))
1761 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1768 /* Return first vector element whose BINFO_TYPE is ELEM.
1769 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1772 vec_binfo_member (elem
, vec
)
1778 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1779 if (same_type_p (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
))))
1780 return TREE_VEC_ELT (vec
, i
);
1785 /* Returns the namespace that contains DECL, whether directly or
1789 decl_namespace_context (decl
)
1794 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1796 else if (TYPE_P (decl
))
1797 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
1799 decl
= CP_DECL_CONTEXT (decl
);
1803 /* Return truthvalue of whether T1 is the same tree structure as T2.
1804 Return 1 if they are the same.
1805 Return 0 if they are understandably different.
1806 Return -1 if either contains tree structure not understood by
1810 cp_tree_equal (t1
, t2
)
1813 register enum tree_code code1
, code2
;
1818 if (t1
== 0 || t2
== 0)
1821 code1
= TREE_CODE (t1
);
1822 code2
= TREE_CODE (t2
);
1824 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1826 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1827 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1829 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1831 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1832 || code2
== NON_LVALUE_EXPR
)
1833 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1841 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1842 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1845 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1848 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1849 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1850 TREE_STRING_LENGTH (t1
));
1853 /* We need to do this when determining whether or not two
1854 non-type pointer to member function template arguments
1856 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1857 /* The first operand is RTL. */
1858 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
1860 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1863 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1866 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
1869 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1872 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1875 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1878 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1881 /* Special case: if either target is an unallocated VAR_DECL,
1882 it means that it's going to be unified with whatever the
1883 TARGET_EXPR is really supposed to initialize, so treat it
1884 as being equivalent to anything. */
1885 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1886 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1887 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
1888 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1889 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1890 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
1893 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1896 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1898 case WITH_CLEANUP_EXPR
:
1899 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1902 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
1905 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
1906 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1915 case TEMPLATE_PARM_INDEX
:
1916 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
1917 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
1921 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
1923 if (TYPE_P (TREE_OPERAND (t1
, 0)))
1924 return same_type_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1928 /* Two pointer-to-members are the same if they point to the same
1929 field or function in the same class. */
1930 return (PTRMEM_CST_MEMBER (t1
) == PTRMEM_CST_MEMBER (t2
)
1931 && same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
)));
1937 switch (TREE_CODE_CLASS (code1
))
1947 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
1949 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
1959 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
1962 build_ptr_wrapper (ptr
)
1965 tree t
= make_node (WRAPPER
);
1966 WRAPPER_PTR (t
) = ptr
;
1970 /* Same, but on the expression_obstack. */
1973 build_expr_ptr_wrapper (ptr
)
1976 return build_ptr_wrapper (ptr
);
1979 /* Build a wrapper around some integer I so we can use it as a tree. */
1982 build_int_wrapper (i
)
1985 tree t
= make_node (WRAPPER
);
1986 WRAPPER_INT (t
) = i
;
1991 build_srcloc (file
, line
)
1997 t
= make_node (SRCLOC
);
1998 SRCLOC_FILE (t
) = file
;
1999 SRCLOC_LINE (t
) = line
;
2005 build_srcloc_here ()
2007 return build_srcloc (input_filename
, lineno
);
2010 /* The type of ARG when used as an lvalue. */
2016 tree type
= TREE_TYPE (arg
);
2017 if (TREE_CODE (arg
) == OVERLOAD
)
2018 type
= unknown_type_node
;
2022 /* The type of ARG for printing error messages; denote lvalues with
2029 tree type
= TREE_TYPE (arg
);
2030 if (TREE_CODE (type
) == ARRAY_TYPE
)
2032 else if (real_lvalue_p (arg
))
2033 type
= build_reference_type (lvalue_type (arg
));
2034 else if (IS_AGGR_TYPE (type
))
2035 type
= lvalue_type (arg
);
2040 /* Does FUNCTION use a variable-length argument list? */
2043 varargs_function_p (function
)
2046 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2047 for (; parm
; parm
= TREE_CHAIN (parm
))
2048 if (TREE_VALUE (parm
) == void_type_node
)
2053 /* Returns 1 if decl is a member of a class. */
2059 const tree ctx
= DECL_CONTEXT (decl
);
2060 return (ctx
&& TYPE_P (ctx
));
2063 /* Create a placeholder for member access where we don't actually have an
2064 object that the access is against. */
2067 build_dummy_object (type
)
2070 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
2071 return build_indirect_ref (decl
, NULL_PTR
);
2074 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2075 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2076 binfo path from current_class_type to TYPE, or 0. */
2079 maybe_dummy_object (type
, binfop
)
2085 if (current_class_type
2086 && get_base_distance (type
, current_class_type
, 0, binfop
) != -1)
2087 context
= current_class_type
;
2090 /* Reference from a nested class member function. */
2093 *binfop
= TYPE_BINFO (type
);
2096 if (current_class_ref
&& context
== current_class_type
)
2097 decl
= current_class_ref
;
2099 decl
= build_dummy_object (context
);
2104 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2107 is_dummy_object (ob
)
2110 if (TREE_CODE (ob
) == INDIRECT_REF
)
2111 ob
= TREE_OPERAND (ob
, 0);
2112 return (TREE_CODE (ob
) == NOP_EXPR
2113 && TREE_OPERAND (ob
, 0) == void_zero_node
);
2116 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2122 while (TREE_CODE (t
) == ARRAY_TYPE
)
2125 if (INTEGRAL_TYPE_P (t
))
2126 return 1; /* integral, character or enumeral type */
2127 if (FLOAT_TYPE_P (t
))
2130 return 1; /* pointer to non-member */
2131 if (TYPE_PTRMEM_P (t
))
2132 return 1; /* pointer to member object */
2133 if (TYPE_PTRMEMFUNC_P (t
))
2134 return 1; /* pointer to member function */
2136 if (! CLASS_TYPE_P (t
))
2137 return 0; /* other non-class type (reference or function) */
2138 if (CLASSTYPE_NON_POD_P (t
))
2143 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2144 attribute for either declaration DECL or type TYPE and 0 otherwise.
2145 Plugged into valid_lang_attribute. */
2148 cp_valid_lang_attribute (attr_name
, attr_args
, decl
, type
)
2150 tree attr_args ATTRIBUTE_UNUSED
;
2151 tree decl ATTRIBUTE_UNUSED
;
2152 tree type ATTRIBUTE_UNUSED
;
2154 if (is_attribute_p ("com_interface", attr_name
))
2156 if (! flag_vtable_thunks
)
2158 error ("`com_interface' only supported with -fvtable-thunks");
2162 if (attr_args
!= NULL_TREE
2163 || decl
!= NULL_TREE
2164 || ! CLASS_TYPE_P (type
)
2165 || type
!= TYPE_MAIN_VARIANT (type
))
2167 warning ("`com_interface' attribute can only be applied to class definitions");
2171 CLASSTYPE_COM_INTERFACE (type
) = 1;
2174 else if (is_attribute_p ("init_priority", attr_name
))
2176 tree initp_expr
= (attr_args
? TREE_VALUE (attr_args
): NULL_TREE
);
2180 STRIP_NOPS (initp_expr
);
2182 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
2184 error ("requested init_priority is not an integer constant");
2188 pri
= TREE_INT_CST_LOW (initp_expr
);
2190 while (TREE_CODE (type
) == ARRAY_TYPE
)
2191 type
= TREE_TYPE (type
);
2193 if (decl
== NULL_TREE
2194 || TREE_CODE (decl
) != VAR_DECL
2195 || ! TREE_STATIC (decl
)
2196 || DECL_EXTERNAL (decl
)
2197 || (TREE_CODE (type
) != RECORD_TYPE
2198 && TREE_CODE (type
) != UNION_TYPE
)
2199 /* Static objects in functions are initialized the
2200 first time control passes through that
2201 function. This is not precise enough to pin down an
2202 init_priority value, so don't allow it. */
2203 || current_function_decl
)
2205 error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2209 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
2211 error ("requested init_priority is out of range");
2215 /* Check for init_priorities that are reserved for
2216 language and runtime support implementations.*/
2217 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
2220 ("requested init_priority is reserved for internal use");
2223 DECL_INIT_PRIORITY (decl
) = pri
;
2230 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2231 thing pointed to by the constant. */
2234 make_ptrmem_cst (type
, member
)
2238 tree ptrmem_cst
= make_node (PTRMEM_CST
);
2239 /* If would seem a great convenience if make_node would set
2240 TREE_CONSTANT for things of class `c', but it does not. */
2241 TREE_CONSTANT (ptrmem_cst
) = 1;
2242 TREE_TYPE (ptrmem_cst
) = type
;
2243 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
2247 /* Mark ARG (which is really a list_hash_table **) for GC. */
2250 mark_list_hash (arg
)
2253 struct list_hash
*lh
;
2255 for (lh
= * ((struct list_hash
**) arg
); lh
; lh
= lh
->next
)
2256 ggc_mark_tree (lh
->list
);
2259 /* Initialize tree.c. */
2264 make_lang_type_fn
= cp_make_lang_type
;
2265 lang_unsave
= cp_unsave
;
2266 ggc_add_root (list_hash_table
,
2267 sizeof (list_hash_table
) / sizeof (struct list_hash
*),
2268 sizeof (struct list_hash
*),
2272 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2273 information indicating to what new SAVE_EXPR this one should be
2274 mapped, use that one. Otherwise, create a new node and enter it in
2275 ST. FN is the function into which the copy will be placed. */
2278 remap_save_expr (tp
, st
, fn
, walk_subtrees
)
2286 /* See if we already encountered this SAVE_EXPR. */
2287 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2289 /* If we didn't already remap this SAVE_EXPR, do so now. */
2292 tree t
= copy_node (*tp
);
2294 /* The SAVE_EXPR is now part of the function into which we
2295 are inlining this body. */
2296 SAVE_EXPR_CONTEXT (t
) = fn
;
2297 /* And we haven't evaluated it yet. */
2298 SAVE_EXPR_RTL (t
) = NULL_RTX
;
2299 /* Remember this SAVE_EXPR. */
2300 n
= splay_tree_insert (st
,
2301 (splay_tree_key
) *tp
,
2302 (splay_tree_value
) t
);
2305 /* We've already walked into this SAVE_EXPR, so we needn't do it
2309 /* Replace this SAVE_EXPR with the copy. */
2310 *tp
= (tree
) n
->value
;
2313 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2314 declaration, copies the declaration and enters it in the splay_tree
2315 pointed to by DATA (which is really a `splay_tree *'). */
2318 mark_local_for_remap_r (tp
, walk_subtrees
, data
)
2320 int *walk_subtrees ATTRIBUTE_UNUSED
;
2324 splay_tree st
= (splay_tree
) data
;
2328 if (TREE_CODE (t
) == DECL_STMT
2329 && nonstatic_local_decl_p (DECL_STMT_DECL (t
)))
2330 decl
= DECL_STMT_DECL (t
);
2331 else if (TREE_CODE (t
) == LABEL_STMT
)
2332 decl
= LABEL_STMT_LABEL (t
);
2333 else if (TREE_CODE (t
) == TARGET_EXPR
2334 && nonstatic_local_decl_p (TREE_OPERAND (t
, 0)))
2335 decl
= TREE_OPERAND (t
, 0);
2344 copy
= copy_decl_for_inlining (decl
,
2345 DECL_CONTEXT (decl
),
2346 DECL_CONTEXT (decl
));
2348 /* Remember the copy. */
2349 splay_tree_insert (st
,
2350 (splay_tree_key
) decl
,
2351 (splay_tree_value
) copy
);
2357 /* Called via walk_tree when an expression is unsaved. Using the
2358 splay_tree pointed to by ST (which is really a `splay_tree'),
2359 remaps all local declarations to appropriate replacements. */
2362 cp_unsave_r (tp
, walk_subtrees
, data
)
2367 splay_tree st
= (splay_tree
) data
;
2370 /* Only a local declaration (variable or label). */
2371 if (nonstatic_local_decl_p (*tp
))
2373 /* Lookup the declaration. */
2374 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2376 /* If it's there, remap it. */
2378 *tp
= (tree
) n
->value
;
2380 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2381 remap_save_expr (tp
, st
, current_function_decl
, walk_subtrees
);
2384 copy_tree_r (tp
, walk_subtrees
, NULL
);
2386 /* Do whatever unsaving is required. */
2387 unsave_expr_1 (*tp
);
2390 /* Keep iterating. */
2394 /* Called by unsave_expr_now whenever an expression (*TP) needs to be
2403 /* Create a splay-tree to map old local variable declarations to new
2405 st
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2407 /* Walk the tree once figuring out what needs to be remapped. */
2408 walk_tree (tp
, mark_local_for_remap_r
, st
);
2410 /* Walk the tree again, copying, remapping, and unsaving. */
2411 walk_tree (tp
, cp_unsave_r
, st
);
2414 splay_tree_delete (st
);
2417 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2418 is. Note that this sfk_none is zero, so this function can be used
2419 as a predicate to test whether or not DECL is a special function. */
2421 special_function_kind
2422 special_function_p (decl
)
2425 /* Rather than doing all this stuff with magic names, we should
2426 probably have a field of type `special_function_kind' in
2427 DECL_LANG_SPECIFIC. */
2428 if (DECL_COPY_CONSTRUCTOR_P (decl
))
2429 return sfk_copy_constructor
;
2430 if (DECL_CONSTRUCTOR_P (decl
))
2431 return sfk_constructor
;
2432 if (DECL_NAME (decl
) == ansi_opname
[(int) MODIFY_EXPR
])
2433 return sfk_assignment_operator
;
2434 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2435 return sfk_destructor
;
2436 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
2437 return sfk_complete_destructor
;
2438 if (DECL_BASE_DESTRUCTOR_P (decl
))
2439 return sfk_base_destructor
;
2440 if (DECL_DELETING_DESTRUCTOR_P (decl
))
2441 return sfk_deleting_destructor
;
2442 if (DECL_CONV_FN_P (decl
))
2443 return sfk_conversion
;