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
));
50 static tree count_trees_r
PARAMS ((tree
*, int *, void *));
52 /* If REF is an lvalue, returns the kind of lvalue that REF is.
53 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
54 non-zero, rvalues of class type are considered lvalues. */
57 lvalue_p_1 (ref
, treat_class_rvalues_as_lvalues
)
59 int treat_class_rvalues_as_lvalues
;
61 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
62 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
64 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
67 if (ref
== current_class_ptr
&& flag_this_is_variable
<= 0)
70 switch (TREE_CODE (ref
))
72 /* preincrements and predecrements are valid lvals, provided
73 what they refer to are valid lvals. */
74 case PREINCREMENT_EXPR
:
75 case PREDECREMENT_EXPR
:
79 case WITH_CLEANUP_EXPR
:
83 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
84 treat_class_rvalues_as_lvalues
);
87 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
88 treat_class_rvalues_as_lvalues
);
90 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
92 && TREE_CODE (TREE_OPERAND (ref
, 1)) == FIELD_DECL
93 && DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
95 /* Clear the ordinary bit. If this object was a class
96 rvalue we want to preserve that information. */
97 op1_lvalue_kind
&= ~clk_ordinary
;
98 /* The lvalue is for a btifield. */
99 op1_lvalue_kind
|= clk_bitfield
;
101 return op1_lvalue_kind
;
107 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
108 && DECL_LANG_SPECIFIC (ref
)
109 && DECL_IN_AGGR_P (ref
))
115 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
119 /* A currently unresolved scope ref. */
121 my_friendly_abort (103);
123 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
128 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
129 treat_class_rvalues_as_lvalues
);
130 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
131 treat_class_rvalues_as_lvalues
);
135 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
136 treat_class_rvalues_as_lvalues
);
137 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 2),
138 treat_class_rvalues_as_lvalues
);
145 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
146 treat_class_rvalues_as_lvalues
);
149 return treat_class_rvalues_as_lvalues
? clk_class
: clk_none
;
153 return ((treat_class_rvalues_as_lvalues
154 && IS_AGGR_TYPE (TREE_TYPE (ref
)))
155 ? clk_class
: clk_none
);
158 /* All functions (except non-static-member functions) are
160 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
161 ? clk_none
: clk_ordinary
);
167 /* If one operand is not an lvalue at all, then this expression is
169 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
172 /* Otherwise, it's an lvalue, and it has all the odd properties
173 contributed by either operand. */
174 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
175 /* It's not an ordinary lvalue if it involves either a bit-field or
177 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
178 op1_lvalue_kind
&= ~clk_ordinary
;
179 return op1_lvalue_kind
;
182 /* If REF is an lvalue, returns the kind of lvalue that REF is.
183 Otherwise, returns clk_none. Lvalues can be assigned, unless they
184 have TREE_READONLY, or unless they are FUNCTION_DECLs. Lvalues can
185 have their address taken, unless they have DECL_REGISTER. */
191 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/0);
194 /* This differs from real_lvalue_p in that class rvalues are
195 considered lvalues. */
202 (lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/1) != clk_none
);
205 /* Return nonzero if REF is an lvalue valid for this language;
206 otherwise, print an error message and return zero. */
209 lvalue_or_else (ref
, string
)
213 int win
= lvalue_p (ref
);
215 error ("non-lvalue in %s", string
);
219 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
222 build_target_expr (decl
, value
)
228 t
= build (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
229 maybe_build_cleanup (decl
), NULL_TREE
);
230 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
231 ignore the TARGET_EXPR. If there really turn out to be no
232 side-effects, then the optimizer should be able to get rid of
233 whatever code is generated anyhow. */
234 TREE_SIDE_EFFECTS (t
) = 1;
239 /* INIT is a CALL_EXPR which needs info about its target.
240 TYPE is the type that this initialization should appear to have.
242 Build an encapsulation of the initialization to perform
243 and return it so that it can be processed by language-independent
244 and language-specific expression expanders. */
247 build_cplus_new (type
, init
)
255 /* Make sure that we're not trying to create an instance of an
257 abstract_virtuals_error (NULL_TREE
, type
);
259 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
260 return convert (type
, init
);
262 slot
= build (VAR_DECL
, type
);
263 DECL_ARTIFICIAL (slot
) = 1;
264 DECL_CONTEXT (slot
) = current_function_decl
;
265 layout_decl (slot
, 0);
267 /* We split the CALL_EXPR into its function and its arguments here.
268 Then, in expand_expr, we put them back together. The reason for
269 this is that this expression might be a default argument
270 expression. In that case, we need a new temporary every time the
271 expression is used. That's what break_out_target_exprs does; it
272 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
273 temporary slot. Then, expand_expr builds up a call-expression
274 using the new slot. */
275 fn
= TREE_OPERAND (init
, 0);
276 rval
= build (AGGR_INIT_EXPR
, type
, fn
, TREE_OPERAND (init
, 1), slot
);
277 TREE_SIDE_EFFECTS (rval
) = 1;
278 AGGR_INIT_VIA_CTOR_P (rval
)
279 = (TREE_CODE (fn
) == ADDR_EXPR
280 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
281 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
282 rval
= build_target_expr (slot
, rval
);
287 /* Buidl a TARGET_EXPR using INIT to initialize a new temporary of the
291 build_target_expr_with_type (init
, type
)
298 if (TREE_CODE (init
) == TARGET_EXPR
)
301 slot
= build (VAR_DECL
, type
);
302 DECL_ARTIFICIAL (slot
) = 1;
303 DECL_CONTEXT (slot
) = current_function_decl
;
304 layout_decl (slot
, 0);
305 rval
= build_target_expr (slot
, init
);
310 /* Like build_target_expr_with_type, but use the type of INIT. */
313 get_target_expr (init
)
316 return build_target_expr_with_type (init
, TREE_TYPE (init
));
319 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
320 these CALL_EXPRs with tree nodes that will perform the cleanups. */
323 break_out_cleanups (exp
)
328 if (TREE_CODE (tmp
) == CALL_EXPR
329 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (tmp
)))
330 return build_cplus_new (TREE_TYPE (tmp
), tmp
);
332 while (TREE_CODE (tmp
) == NOP_EXPR
333 || TREE_CODE (tmp
) == CONVERT_EXPR
334 || TREE_CODE (tmp
) == NON_LVALUE_EXPR
)
336 if (TREE_CODE (TREE_OPERAND (tmp
, 0)) == CALL_EXPR
337 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp
, 0))))
339 TREE_OPERAND (tmp
, 0)
340 = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp
, 0)),
341 TREE_OPERAND (tmp
, 0));
345 tmp
= TREE_OPERAND (tmp
, 0);
350 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
351 copies where they are found. Returns a deep copy all nodes transitively
352 containing CALL_EXPRs. */
355 break_out_calls (exp
)
358 register tree t1
, t2
= NULL_TREE
;
359 register enum tree_code code
;
360 register int changed
= 0;
363 if (exp
== NULL_TREE
)
366 code
= TREE_CODE (exp
);
368 if (code
== CALL_EXPR
)
369 return copy_node (exp
);
371 /* Don't try and defeat a save_expr, as it should only be done once. */
372 if (code
== SAVE_EXPR
)
375 switch (TREE_CODE_CLASS (code
))
380 case 'c': /* a constant */
381 case 't': /* a type node */
382 case 'x': /* something random, like an identifier or an ERROR_MARK. */
385 case 'd': /* A decl node */
386 #if 0 /* This is bogus. jason 9/21/94 */
388 t1
= break_out_calls (DECL_INITIAL (exp
));
389 if (t1
!= DECL_INITIAL (exp
))
391 exp
= copy_node (exp
);
392 DECL_INITIAL (exp
) = t1
;
397 case 'b': /* A block node */
399 /* Don't know how to handle these correctly yet. Must do a
400 break_out_calls on all DECL_INITIAL values for local variables,
401 and also break_out_calls on all sub-blocks and sub-statements. */
406 case 'e': /* an expression */
407 case 'r': /* a reference */
408 case 's': /* an expression with side effects */
409 for (i
= TREE_CODE_LENGTH (code
) - 1; i
>= 0; i
--)
411 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
412 if (t1
!= TREE_OPERAND (exp
, i
))
414 exp
= copy_node (exp
);
415 TREE_OPERAND (exp
, i
) = t1
;
420 case '<': /* a comparison expression */
421 case '2': /* a binary arithmetic expression */
422 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
423 if (t2
!= TREE_OPERAND (exp
, 1))
425 case '1': /* a unary arithmetic expression */
426 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
427 if (t1
!= TREE_OPERAND (exp
, 0))
431 if (TREE_CODE_LENGTH (code
) == 1)
432 return build1 (code
, TREE_TYPE (exp
), t1
);
434 return build (code
, TREE_TYPE (exp
), t1
, t2
);
441 extern struct obstack permanent_obstack
;
443 /* Here is how primitive or already-canonicalized types' hash
444 codes are made. MUST BE CONSISTENT WITH tree.c !!! */
445 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
447 /* Construct, lay out and return the type of methods belonging to class
448 BASETYPE and whose arguments are described by ARGTYPES and whose values
449 are described by RETTYPE. If each type exists already, reuse it. */
452 build_cplus_method_type (basetype
, rettype
, argtypes
)
453 tree basetype
, rettype
, argtypes
;
459 /* Make a node of the sort we want. */
460 t
= make_node (METHOD_TYPE
);
462 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
463 TREE_TYPE (t
) = rettype
;
464 ptype
= build_pointer_type (basetype
);
466 /* The actual arglist for this function includes a "hidden" argument
467 which is "this". Put it into the list of argument types. */
468 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
469 TYPE_ARG_TYPES (t
) = argtypes
;
470 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
472 /* If we already have such a type, use the old one and free this one.
473 Note that it also frees up the above cons cell if found. */
474 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) +
475 type_hash_list (argtypes
);
477 t
= type_hash_canon (hashcode
, t
);
479 if (!COMPLETE_TYPE_P (t
))
486 build_cplus_array_type_1 (elt_type
, index_type
)
492 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
493 return error_mark_node
;
495 if (processing_template_decl
496 || uses_template_parms (elt_type
)
497 || uses_template_parms (index_type
))
499 t
= make_node (ARRAY_TYPE
);
500 TREE_TYPE (t
) = elt_type
;
501 TYPE_DOMAIN (t
) = index_type
;
504 t
= build_array_type (elt_type
, index_type
);
506 /* Push these needs up so that initialization takes place
508 TYPE_NEEDS_CONSTRUCTING (t
)
509 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
510 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
511 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
516 build_cplus_array_type (elt_type
, index_type
)
521 int type_quals
= CP_TYPE_QUALS (elt_type
);
523 elt_type
= TYPE_MAIN_VARIANT (elt_type
);
525 t
= build_cplus_array_type_1 (elt_type
, index_type
);
527 if (type_quals
!= TYPE_UNQUALIFIED
)
528 t
= cp_build_qualified_type (t
, type_quals
);
533 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
534 arrays correctly. In particular, if TYPE is an array of T's, and
535 TYPE_QUALS is non-empty, returns an array of qualified T's. If
536 at attempt is made to qualify a type illegally, and COMPLAIN is
537 non-zero, an error is issued. If COMPLAIN is zero, error_mark_node
541 cp_build_qualified_type_real (type
, type_quals
, complain
)
548 if (type
== error_mark_node
)
551 if (type_quals
== TYPE_QUALS (type
))
554 /* A restrict-qualified pointer type must be a pointer (or reference)
555 to object or incomplete type. */
556 if ((type_quals
& TYPE_QUAL_RESTRICT
)
557 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
558 && (!POINTER_TYPE_P (type
)
559 || TYPE_PTRMEM_P (type
)
560 || TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
))
563 cp_error ("`%T' cannot be `restrict'-qualified", type
);
565 return error_mark_node
;
567 type_quals
&= ~TYPE_QUAL_RESTRICT
;
570 if (type_quals
!= TYPE_UNQUALIFIED
571 && TREE_CODE (type
) == FUNCTION_TYPE
)
574 cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type
);
576 return error_mark_node
;
577 type_quals
= TYPE_UNQUALIFIED
;
579 else if (TREE_CODE (type
) == ARRAY_TYPE
)
581 /* In C++, the qualification really applies to the array element
582 type. Obtain the appropriately qualified element type. */
585 = cp_build_qualified_type_real (TREE_TYPE (type
),
589 if (element_type
== error_mark_node
)
590 return error_mark_node
;
592 /* See if we already have an identically qualified type. */
593 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
594 if (CP_TYPE_QUALS (t
) == type_quals
)
597 /* If we didn't already have it, create it now. */
600 /* Make a new array type, just like the old one, but with the
601 appropriately qualified element type. */
602 t
= build_type_copy (type
);
603 TREE_TYPE (t
) = element_type
;
606 /* Even if we already had this variant, we update
607 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
608 they changed since the variant was originally created.
610 This seems hokey; if there is some way to use a previous
611 variant *without* coming through here,
612 TYPE_NEEDS_CONSTRUCTING will never be updated. */
613 TYPE_NEEDS_CONSTRUCTING (t
)
614 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
615 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
616 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
619 else if (TYPE_PTRMEMFUNC_P (type
))
621 /* For a pointer-to-member type, we can't just return a
622 cv-qualified version of the RECORD_TYPE. If we do, we
623 haven't change the field that contains the actual pointer to
624 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
627 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
628 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
629 return build_ptrmemfunc_type (t
);
632 /* Retrieve (or create) the appropriately qualified variant. */
633 result
= build_qualified_type (type
, type_quals
);
635 /* If this was a pointer-to-method type, and we just made a copy,
636 then we need to clear the cached associated
637 pointer-to-member-function type; it is not valid for the new
640 && TREE_CODE (type
) == POINTER_TYPE
641 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
642 TYPE_SET_PTRMEMFUNC_TYPE (result
, NULL_TREE
);
647 /* Returns the canonical version of TYPE. In other words, if TYPE is
648 a typedef, returns the underlying type. The cv-qualification of
649 the type returned matches the type input; they will always be
653 canonical_type_variant (t
)
656 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), CP_TYPE_QUALS (t
));
659 /* Makes new binfos for the indirect bases under BINFO, and updates
660 BINFO_OFFSET for them and their bases. */
663 unshare_base_binfos (binfo
)
666 tree binfos
= BINFO_BASETYPES (binfo
);
670 if (binfos
== NULL_TREE
)
673 /* Now unshare the structure beneath BINFO. */
674 for (j
= TREE_VEC_LENGTH (binfos
)-1;
677 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
678 new_binfo
= TREE_VEC_ELT (binfos
, j
)
679 = make_binfo (BINFO_OFFSET (base_binfo
),
681 BINFO_VTABLE (base_binfo
),
682 BINFO_VIRTUALS (base_binfo
));
683 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
684 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
685 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
686 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
687 unshare_base_binfos (new_binfo
);
692 /* Hashing of lists so that we don't make duplicates.
693 The entry point is `list_hash_canon'. */
695 /* Each hash table slot is a bucket containing a chain
696 of these structures. */
700 struct list_hash
*next
; /* Next structure in the bucket. */
701 int hashcode
; /* Hash code of this list. */
702 tree list
; /* The list recorded here. */
705 /* Now here is the hash table. When recording a list, it is added
706 to the slot whose index is the hash code mod the table size.
707 Note that the hash table is used for several kinds of lists.
708 While all these live in the same table, they are completely independent,
709 and the hash code is computed differently for each of these. */
711 #define TYPE_HASH_SIZE 59
712 static struct list_hash
*list_hash_table
[TYPE_HASH_SIZE
];
714 /* Compute a hash code for a list (chain of TREE_LIST nodes
715 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
716 TREE_COMMON slots), by adding the hash codes of the individual entries. */
719 list_hash (purpose
, value
, chain
)
720 tree purpose
, value
, chain
;
722 register int hashcode
= 0;
725 hashcode
+= TYPE_HASH (chain
);
728 hashcode
+= TYPE_HASH (value
);
732 hashcode
+= TYPE_HASH (purpose
);
738 /* Look in the type hash table for a type isomorphic to TYPE.
739 If one is found, return it. Otherwise return 0. */
742 list_hash_lookup (hashcode
, purpose
, value
, chain
)
744 tree purpose
, value
, chain
;
746 register struct list_hash
*h
;
748 for (h
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
749 if (h
->hashcode
== hashcode
750 && TREE_PURPOSE (h
->list
) == purpose
751 && TREE_VALUE (h
->list
) == value
752 && TREE_CHAIN (h
->list
) == chain
)
757 /* Add an entry to the list-hash-table
758 for a list TYPE whose hash code is HASHCODE. */
761 list_hash_add (hashcode
, list
)
765 register struct list_hash
*h
;
767 h
= (struct list_hash
*) obstack_alloc (&permanent_obstack
, sizeof (struct list_hash
));
768 h
->hashcode
= hashcode
;
770 h
->next
= list_hash_table
[hashcode
% TYPE_HASH_SIZE
];
771 list_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
774 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
775 object for an identical list if one already exists. Otherwise, build a
776 new one, and record it as the canonical object. */
778 /* Set to 1 to debug without canonicalization. Never set by program. */
780 static int debug_no_list_hash
= 0;
783 hash_tree_cons (purpose
, value
, chain
)
784 tree purpose
, value
, chain
;
789 if (! debug_no_list_hash
)
791 hashcode
= list_hash (purpose
, value
, chain
);
792 t
= list_hash_lookup (hashcode
, purpose
, value
, chain
);
797 t
= tree_cons (purpose
, value
, chain
);
799 /* If this is a new list, record it for later reuse. */
800 if (! debug_no_list_hash
)
801 list_hash_add (hashcode
, t
);
806 /* Constructor for hashed lists. */
809 hash_tree_chain (value
, chain
)
812 return hash_tree_cons (NULL_TREE
, value
, chain
);
815 /* Similar, but used for concatenating two lists. */
818 hash_chainon (list1
, list2
)
825 if (TREE_CHAIN (list1
) == NULL_TREE
)
826 return hash_tree_chain (TREE_VALUE (list1
), list2
);
827 return hash_tree_chain (TREE_VALUE (list1
),
828 hash_chainon (TREE_CHAIN (list1
), list2
));
831 /* Build an association between TYPE and some parameters:
833 OFFSET is the offset added to `this' to convert it to a pointer
836 BINFO is the base binfo to use, if we are deriving from one. This
837 is necessary, as we want specialized parent binfos from base
838 classes, so that the VTABLE_NAMEs of bases are for the most derived
839 type, instead of the simple type.
841 VTABLE is the virtual function table with which to initialize
842 sub-objects of type TYPE.
844 VIRTUALS are the virtual functions sitting in VTABLE. */
847 make_binfo (offset
, binfo
, vtable
, virtuals
)
849 tree vtable
, virtuals
;
851 tree new_binfo
= make_tree_vec (10);
854 if (TREE_CODE (binfo
) == TREE_VEC
)
855 type
= BINFO_TYPE (binfo
);
859 binfo
= CLASS_TYPE_P (type
) ? TYPE_BINFO (binfo
) : NULL_TREE
;
862 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
863 BINFO_OFFSET (new_binfo
) = offset
;
864 BINFO_VTABLE (new_binfo
) = vtable
;
865 BINFO_VIRTUALS (new_binfo
) = virtuals
;
867 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
868 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
872 /* Return the binfo value for ELEM in TYPE. */
875 binfo_value (elem
, type
)
879 if (get_base_distance (elem
, type
, 0, (tree
*)0) == -2)
880 compiler_error ("base class `%s' ambiguous in binfo_value",
881 TYPE_NAME_STRING (elem
));
883 return TYPE_BINFO (type
);
884 if (TREE_CODE (elem
) == RECORD_TYPE
&& TYPE_BINFO (elem
) == type
)
886 return get_binfo (elem
, type
, 0);
889 /* Return a TREE_LIST whose TREE_VALUE nodes along the
890 BINFO_INHERITANCE_CHAIN for BINFO, but in the opposite order. In
891 other words, while the BINFO_INHERITANCE_CHAIN goes from base
892 classes to derived classes, the reversed path goes from derived
893 classes to base classes. */
901 reversed_path
= NULL_TREE
;
904 reversed_path
= tree_cons (NULL_TREE
, binfo
, reversed_path
);
905 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
908 return reversed_path
;
918 fprintf (stderr
, "type \"%s\", offset = ",
919 TYPE_NAME_STRING (BINFO_TYPE (elem
)));
920 fprintf (stderr
, HOST_WIDE_INT_PRINT_DEC
,
921 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
922 fprintf (stderr
, "\nvtable type:\n");
923 debug_tree (BINFO_TYPE (elem
));
924 if (BINFO_VTABLE (elem
))
925 fprintf (stderr
, "vtable decl \"%s\"\n",
926 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
928 fprintf (stderr
, "no vtable decl yet\n");
929 fprintf (stderr
, "virtuals:\n");
930 virtuals
= BINFO_VIRTUALS (elem
);
931 n
= first_vfun_index (BINFO_TYPE (elem
));
935 tree fndecl
= TREE_VALUE (virtuals
);
936 fprintf (stderr
, "%s [%ld =? %ld]\n",
937 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
938 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
940 virtuals
= TREE_CHAIN (virtuals
);
949 if (TREE_CODE (t
) == FUNCTION_DECL
)
951 else if (TREE_CODE (t
) == OVERLOAD
)
953 for (i
=0; t
; t
= OVL_CHAIN (t
))
958 my_friendly_abort (359);
966 /* A baselink is also considered an overloaded function. */
967 if (TREE_CODE (x
) == OFFSET_REF
)
968 x
= TREE_OPERAND (x
, 1);
971 return (TREE_CODE (x
) == FUNCTION_DECL
972 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
973 || DECL_FUNCTION_TEMPLATE_P (x
)
974 || TREE_CODE (x
) == OVERLOAD
);
978 really_overloaded_fn (x
)
981 /* A baselink is also considered an overloaded function. */
982 if (TREE_CODE (x
) == OFFSET_REF
)
983 x
= TREE_OPERAND (x
, 1);
986 return (TREE_CODE (x
) == OVERLOAD
987 && (TREE_CHAIN (x
) != NULL_TREE
988 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
995 my_friendly_assert (is_overloaded_fn (from
), 9);
996 /* A baselink is also considered an overloaded function. */
997 if (BASELINK_P (from
))
998 from
= TREE_VALUE (from
);
999 return OVL_CURRENT (from
);
1002 /* Returns nonzero if T is a ->* or .* expression that refers to a
1009 return (TREE_CODE (t
) == OFFSET_REF
1010 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t
, 1))));
1013 /* Return a new OVL node, concatenating it with the old one. */
1016 ovl_cons (decl
, chain
)
1020 tree result
= make_node (OVERLOAD
);
1021 TREE_TYPE (result
) = unknown_type_node
;
1022 OVL_FUNCTION (result
) = decl
;
1023 TREE_CHAIN (result
) = chain
;
1028 /* Build a new overloaded function. If this is the first one,
1029 just return it; otherwise, ovl_cons the _DECLs */
1032 build_overload (decl
, chain
)
1036 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1038 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1039 chain
= ovl_cons (chain
, NULL_TREE
);
1040 return ovl_cons (decl
, chain
);
1043 /* True if fn is in ovl. */
1046 ovl_member (fn
, ovl
)
1050 if (ovl
== NULL_TREE
)
1052 if (TREE_CODE (ovl
) != OVERLOAD
)
1054 for (; ovl
; ovl
= OVL_CHAIN (ovl
))
1055 if (OVL_FUNCTION (ovl
) == fn
)
1061 is_aggr_type_2 (t1
, t2
)
1064 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1066 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1069 /* Returns non-zero if CODE is the code for a statement. */
1072 statement_code_p (code
)
1073 enum tree_code code
;
1093 case START_CATCH_STMT
:
1096 case CTOR_INITIALIZER
:
1108 #define PRINT_RING_SIZE 4
1111 lang_printable_name (decl
, v
)
1115 static tree decl_ring
[PRINT_RING_SIZE
];
1116 static char *print_ring
[PRINT_RING_SIZE
];
1117 static int ring_counter
;
1120 /* Only cache functions. */
1122 || TREE_CODE (decl
) != FUNCTION_DECL
1123 || DECL_LANG_SPECIFIC (decl
) == 0)
1124 return lang_decl_name (decl
, v
);
1126 /* See if this print name is lying around. */
1127 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1128 if (decl_ring
[i
] == decl
)
1129 /* yes, so return it. */
1130 return print_ring
[i
];
1132 if (++ring_counter
== PRINT_RING_SIZE
)
1135 if (current_function_decl
!= NULL_TREE
)
1137 if (decl_ring
[ring_counter
] == current_function_decl
)
1139 if (ring_counter
== PRINT_RING_SIZE
)
1141 if (decl_ring
[ring_counter
] == current_function_decl
)
1142 my_friendly_abort (106);
1145 if (print_ring
[ring_counter
])
1146 free (print_ring
[ring_counter
]);
1148 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1149 decl_ring
[ring_counter
] = decl
;
1150 return print_ring
[ring_counter
];
1153 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1154 listed in RAISES. */
1157 build_exception_variant (type
, raises
)
1161 tree v
= TYPE_MAIN_VARIANT (type
);
1162 int type_quals
= TYPE_QUALS (type
);
1164 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1165 if (TYPE_QUALS (v
) == type_quals
1166 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), 1))
1169 /* Need to build a new variant. */
1170 v
= build_type_copy (type
);
1171 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1175 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1176 lang_specific field and its corresponding *_DECL node.
1177 If NEWARGS is not NULL_TREE, this parameter is bound with new set of
1181 copy_template_template_parm (t
, newargs
)
1185 tree decl
= TYPE_NAME (t
);
1188 t2
= make_aggr_type (TEMPLATE_TEMPLATE_PARM
);
1189 if (newargs
== NULL_TREE
)
1191 decl
= copy_decl (decl
);
1193 /* No need to copy these. */
1194 TEMPLATE_TYPE_PARM_INDEX (t2
) = TEMPLATE_TYPE_PARM_INDEX (t
);
1195 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1196 = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
1200 decl
= build_decl (TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1202 /* These nodes have to be created to reflect new TYPE_DECL and template
1204 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
1205 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
1206 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1207 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
),
1208 newargs
, NULL_TREE
);
1211 TREE_TYPE (decl
) = t2
;
1212 TYPE_NAME (t2
) = decl
;
1213 TYPE_STUB_DECL (t2
) = decl
;
1218 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1219 FUNC is called with the DATA and the address of each sub-tree. If
1220 FUNC returns a non-NULL value, the traversal is aborted, and the
1221 value returned by FUNC is returned. */
1224 walk_tree (tp
, func
, data
)
1229 enum tree_code code
;
1233 #define WALK_SUBTREE(NODE) \
1236 result = walk_tree (&(NODE), func, data); \
1242 /* Skip empty subtrees. */
1246 /* Call the function. */
1248 result
= (*func
) (tp
, &walk_subtrees
, data
);
1250 /* If we found something, return it. */
1254 /* Even if we didn't, FUNC may have decided that there was nothing
1255 interesting below this point in the tree. */
1259 code
= TREE_CODE (*tp
);
1261 /* Handle common cases up front. */
1262 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1263 || TREE_CODE_CLASS (code
) == 'r'
1264 || TREE_CODE_CLASS (code
) == 's')
1268 /* Set lineno here so we get the right instantiation context
1269 if we call instantiate_decl from inlinable_function_p. */
1270 if (statement_code_p (code
) && !STMT_LINENO_FOR_FN_P (*tp
))
1271 lineno
= STMT_LINENO (*tp
);
1273 /* Walk over all the sub-trees of this operand. */
1274 len
= first_rtl_op (code
);
1275 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
1276 But, we only want to walk once. */
1277 if (code
== TARGET_EXPR
1278 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
1280 /* Go through the subtrees. We need to do this in forward order so
1281 that the scope of a FOR_EXPR is handled properly. */
1282 for (i
= 0; i
< len
; ++i
)
1283 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
1285 /* For statements, we also walk the chain so that we cover the
1286 entire statement tree. */
1287 if (statement_code_p (code
))
1289 if (code
== DECL_STMT
1290 && DECL_STMT_DECL (*tp
)
1291 && DECL_P (DECL_STMT_DECL (*tp
)))
1293 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
1294 into declarations that are just mentioned, rather than
1295 declared; they don't really belong to this part of the tree.
1296 And, we can see cycles: the initializer for a declaration can
1297 refer to the declaration itself. */
1298 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
1299 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
1300 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp
)));
1303 WALK_SUBTREE (TREE_CHAIN (*tp
));
1306 /* We didn't find what we were looking for. */
1309 else if (TREE_CODE_CLASS (code
) == 'd')
1311 WALK_SUBTREE (TREE_TYPE (*tp
));
1313 /* We didn't find what we were looking for. */
1317 /* Not one of the easy cases. We must explicitly go through the
1322 case IDENTIFIER_NODE
:
1327 case TEMPLATE_TEMPLATE_PARM
:
1328 case TEMPLATE_PARM_INDEX
:
1329 case TEMPLATE_TYPE_PARM
:
1339 /* None of thse have subtrees other than those already walked
1344 WALK_SUBTREE (TREE_TYPE (*tp
));
1348 case REFERENCE_TYPE
:
1349 WALK_SUBTREE (TREE_TYPE (*tp
));
1353 WALK_SUBTREE (TREE_PURPOSE (*tp
));
1354 WALK_SUBTREE (TREE_VALUE (*tp
));
1355 WALK_SUBTREE (TREE_CHAIN (*tp
));
1359 WALK_SUBTREE (OVL_FUNCTION (*tp
));
1360 WALK_SUBTREE (OVL_CHAIN (*tp
));
1365 int len
= TREE_VEC_LENGTH (*tp
);
1367 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
1372 WALK_SUBTREE (TREE_REALPART (*tp
));
1373 WALK_SUBTREE (TREE_IMAGPART (*tp
));
1377 WALK_SUBTREE (CONSTRUCTOR_ELTS (*tp
));
1381 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp
));
1385 WALK_SUBTREE (TREE_TYPE (*tp
));
1386 WALK_SUBTREE (TYPE_ARG_TYPES (*tp
));
1390 WALK_SUBTREE (TREE_TYPE (*tp
));
1391 WALK_SUBTREE (TYPE_DOMAIN (*tp
));
1395 WALK_SUBTREE (TYPE_MIN_VALUE (*tp
));
1396 WALK_SUBTREE (TYPE_MAX_VALUE (*tp
));
1400 WALK_SUBTREE (TREE_TYPE (*tp
));
1401 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (*tp
));
1405 if (TYPE_PTRMEMFUNC_P (*tp
))
1406 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
1410 my_friendly_abort (19990803);
1413 /* We didn't find what we were looking for. */
1419 /* Called from count_trees via walk_tree. */
1422 count_trees_r (tp
, walk_subtrees
, data
)
1423 tree
*tp ATTRIBUTE_UNUSED
;
1424 int *walk_subtrees ATTRIBUTE_UNUSED
;
1431 /* Debugging function for measuring the rough complexity of a tree
1439 walk_tree (&t
, count_trees_r
, &n_trees
);
1443 /* Passed to walk_tree. Checks for the use of types with no linkage. */
1446 no_linkage_helper (tp
, walk_subtrees
, data
)
1448 int *walk_subtrees ATTRIBUTE_UNUSED
;
1449 void *data ATTRIBUTE_UNUSED
;
1454 && (IS_AGGR_TYPE (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1455 && (decl_function_context (TYPE_MAIN_DECL (t
))
1456 || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
))))
1461 /* Check if the type T depends on a type with no linkage and if so, return
1465 no_linkage_check (t
)
1468 /* There's no point in checking linkage on template functions; we
1469 can't know their complete types. */
1470 if (processing_template_decl
)
1473 t
= walk_tree (&t
, no_linkage_helper
, NULL
);
1474 if (t
!= error_mark_node
)
1479 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1482 copy_tree_r (tp
, walk_subtrees
, data
)
1485 void *data ATTRIBUTE_UNUSED
;
1487 enum tree_code code
= TREE_CODE (*tp
);
1489 /* We make copies of most nodes. */
1490 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1491 || TREE_CODE_CLASS (code
) == 'r'
1492 || TREE_CODE_CLASS (code
) == 'c'
1493 || TREE_CODE_CLASS (code
) == 's'
1494 || code
== TREE_LIST
1496 || code
== OVERLOAD
)
1498 /* Because the chain gets clobbered when we make a copy, we save it
1500 tree chain
= TREE_CHAIN (*tp
);
1502 /* Copy the node. */
1503 *tp
= copy_node (*tp
);
1505 /* Now, restore the chain, if appropriate. That will cause
1506 walk_tree to walk into the chain as well. */
1507 if (code
== PARM_DECL
|| code
== TREE_LIST
|| code
== OVERLOAD
1508 || statement_code_p (code
))
1509 TREE_CHAIN (*tp
) = chain
;
1511 /* For now, we don't update BLOCKs when we make copies. So, we
1512 have to nullify all scope-statements. */
1513 if (TREE_CODE (*tp
) == SCOPE_STMT
)
1514 SCOPE_STMT_BLOCK (*tp
) = NULL_TREE
;
1516 else if (code
== TEMPLATE_TEMPLATE_PARM
)
1517 /* These must be copied specially. */
1518 *tp
= copy_template_template_parm (*tp
, NULL_TREE
);
1519 else if (TREE_CODE_CLASS (code
) == 't')
1520 /* There's no need to copy types, or anything beneath them. */
1526 #ifdef GATHER_STATISTICS
1527 extern int depth_reached
;
1531 print_lang_statistics ()
1533 print_search_statistics ();
1534 print_class_statistics ();
1535 #ifdef GATHER_STATISTICS
1536 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1541 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1542 (which is an ARRAY_TYPE). This counts only elements of the top
1546 array_type_nelts_top (type
)
1549 return fold (build (PLUS_EXPR
, sizetype
,
1550 array_type_nelts (type
),
1554 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1555 (which is an ARRAY_TYPE). This one is a recursive count of all
1556 ARRAY_TYPEs that are clumped together. */
1559 array_type_nelts_total (type
)
1562 tree sz
= array_type_nelts_top (type
);
1563 type
= TREE_TYPE (type
);
1564 while (TREE_CODE (type
) == ARRAY_TYPE
)
1566 tree n
= array_type_nelts_top (type
);
1567 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1568 type
= TREE_TYPE (type
);
1573 /* Called from break_out_target_exprs via mapcar. */
1576 bot_manip (tp
, walk_subtrees
, data
)
1581 splay_tree target_remap
= ((splay_tree
) data
);
1584 if (TREE_CODE (t
) != TREE_LIST
&& ! TREE_SIDE_EFFECTS (t
))
1586 /* There can't be any TARGET_EXPRs below this point. */
1590 else if (TREE_CODE (t
) == TARGET_EXPR
)
1594 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1596 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1598 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1605 var
= build (VAR_DECL
, TREE_TYPE (t
));
1606 DECL_CONTEXT (var
) = current_function_decl
;
1607 layout_decl (var
, 0);
1608 TREE_OPERAND (u
, 0) = var
;
1611 /* Map the old variable to the new one. */
1612 splay_tree_insert (target_remap
,
1613 (splay_tree_key
) TREE_OPERAND (t
, 0),
1614 (splay_tree_value
) TREE_OPERAND (u
, 0));
1616 /* Replace the old expression with the new version. */
1618 /* We don't have to go below this point; the recursive call to
1619 break_out_target_exprs will have handled anything below this
1624 else if (TREE_CODE (t
) == CALL_EXPR
)
1625 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1627 /* Make a copy of this node. */
1628 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1631 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1632 DATA is really a splay-tree mapping old variables to new
1636 bot_replace (t
, walk_subtrees
, data
)
1638 int *walk_subtrees ATTRIBUTE_UNUSED
;
1641 splay_tree target_remap
= ((splay_tree
) data
);
1643 if (TREE_CODE (*t
) == VAR_DECL
)
1645 splay_tree_node n
= splay_tree_lookup (target_remap
,
1646 (splay_tree_key
) *t
);
1648 *t
= (tree
) n
->value
;
1654 /* When we parse a default argument expression, we may create
1655 temporary variables via TARGET_EXPRs. When we actually use the
1656 default-argument expression, we make a copy of the expression, but
1657 we must replace the temporaries with appropriate local versions. */
1660 break_out_target_exprs (t
)
1663 static int target_remap_count
;
1664 static splay_tree target_remap
;
1666 if (!target_remap_count
++)
1667 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
1668 /*splay_tree_delete_key_fn=*/NULL
,
1669 /*splay_tree_delete_value_fn=*/NULL
);
1670 walk_tree (&t
, bot_manip
, target_remap
);
1671 walk_tree (&t
, bot_replace
, target_remap
);
1673 if (!--target_remap_count
)
1675 splay_tree_delete (target_remap
);
1676 target_remap
= NULL
;
1682 /* Obstack used for allocating nodes in template function and variable
1685 /* Similar to `build_nt', except that we set TREE_COMPLEXITY to be the
1686 current line number. */
1689 build_min_nt
VPARAMS ((enum tree_code code
, ...))
1691 #ifndef ANSI_PROTOTYPES
1692 enum tree_code code
;
1696 register int length
;
1701 #ifndef ANSI_PROTOTYPES
1702 code
= va_arg (p
, enum tree_code
);
1705 t
= make_node (code
);
1706 length
= TREE_CODE_LENGTH (code
);
1707 TREE_COMPLEXITY (t
) = lineno
;
1709 for (i
= 0; i
< length
; i
++)
1711 tree x
= va_arg (p
, tree
);
1712 TREE_OPERAND (t
, i
) = x
;
1719 /* Similar to `build', except we set TREE_COMPLEXITY to the current
1723 build_min
VPARAMS ((enum tree_code code
, tree tt
, ...))
1725 #ifndef ANSI_PROTOTYPES
1726 enum tree_code code
;
1731 register int length
;
1736 #ifndef ANSI_PROTOTYPES
1737 code
= va_arg (p
, enum tree_code
);
1738 tt
= va_arg (p
, tree
);
1741 t
= make_node (code
);
1742 length
= TREE_CODE_LENGTH (code
);
1744 TREE_COMPLEXITY (t
) = lineno
;
1746 for (i
= 0; i
< length
; i
++)
1748 tree x
= va_arg (p
, tree
);
1749 TREE_OPERAND (t
, i
) = x
;
1756 /* Returns an INTEGER_CST (of type `int') corresponding to I.
1757 Multiple calls with the same value of I may or may not yield the
1758 same node; therefore, callers should never modify the node
1762 build_shared_int_cst (i
)
1765 static tree cache
[256];
1768 return build_int_2 (i
, 0);
1771 cache
[i
] = build_int_2 (i
, 0);
1780 if (TREE_CODE (t
) == TYPE_DECL
)
1783 return TYPE_STUB_DECL (t
);
1785 my_friendly_abort (42);
1787 /* Stop compiler from complaining control reaches end of non-void function. */
1792 can_free (obstack
, t
)
1793 struct obstack
*obstack
;
1798 if (TREE_CODE (t
) == TREE_VEC
)
1799 size
= (TREE_VEC_LENGTH (t
)-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1801 my_friendly_abort (42);
1803 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
1804 & ~ obstack_alignment_mask (obstack))
1805 if ((char *)t
+ ROUND (size
) == obstack_next_free (obstack
))
1812 /* Return first vector element whose BINFO_TYPE is ELEM.
1813 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1816 vec_binfo_member (elem
, vec
)
1822 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1823 if (same_type_p (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
))))
1824 return TREE_VEC_ELT (vec
, i
);
1829 /* Returns the namespace that contains DECL, whether directly or
1833 decl_namespace_context (decl
)
1838 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1840 else if (TYPE_P (decl
))
1841 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
1843 decl
= CP_DECL_CONTEXT (decl
);
1847 /* Return truthvalue of whether T1 is the same tree structure as T2.
1848 Return 1 if they are the same.
1849 Return 0 if they are understandably different.
1850 Return -1 if either contains tree structure not understood by
1854 cp_tree_equal (t1
, t2
)
1857 register enum tree_code code1
, code2
;
1862 if (t1
== 0 || t2
== 0)
1865 code1
= TREE_CODE (t1
);
1866 code2
= TREE_CODE (t2
);
1868 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1870 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1871 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1873 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1875 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1876 || code2
== NON_LVALUE_EXPR
)
1877 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1885 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1886 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1889 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1892 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1893 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1894 TREE_STRING_LENGTH (t1
));
1897 /* We need to do this when determining whether or not two
1898 non-type pointer to member function template arguments
1900 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1901 /* The first operand is RTL. */
1902 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
1904 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1907 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1910 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
1913 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1916 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1919 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1922 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1925 /* Special case: if either target is an unallocated VAR_DECL,
1926 it means that it's going to be unified with whatever the
1927 TARGET_EXPR is really supposed to initialize, so treat it
1928 as being equivalent to anything. */
1929 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1930 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1931 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
1932 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1933 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1934 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
1937 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1940 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1942 case WITH_CLEANUP_EXPR
:
1943 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1946 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
1949 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
1950 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1959 case TEMPLATE_PARM_INDEX
:
1960 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
1961 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
1965 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
1967 if (TYPE_P (TREE_OPERAND (t1
, 0)))
1968 return same_type_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1972 /* Two pointer-to-members are the same if they point to the same
1973 field or function in the same class. */
1974 return (PTRMEM_CST_MEMBER (t1
) == PTRMEM_CST_MEMBER (t2
)
1975 && same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
)));
1981 switch (TREE_CODE_CLASS (code1
))
1991 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); ++i
)
1993 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
2003 /* Build a wrapper around some pointer PTR so we can use it as a tree. */
2006 build_ptr_wrapper (ptr
)
2009 tree t
= make_node (WRAPPER
);
2010 WRAPPER_PTR (t
) = ptr
;
2014 /* Same, but on the expression_obstack. */
2017 build_expr_ptr_wrapper (ptr
)
2020 return build_ptr_wrapper (ptr
);
2023 /* Build a wrapper around some integer I so we can use it as a tree. */
2026 build_int_wrapper (i
)
2029 tree t
= make_node (WRAPPER
);
2030 WRAPPER_INT (t
) = i
;
2035 build_srcloc (file
, line
)
2041 t
= make_node (SRCLOC
);
2042 SRCLOC_FILE (t
) = file
;
2043 SRCLOC_LINE (t
) = line
;
2049 build_srcloc_here ()
2051 return build_srcloc (input_filename
, lineno
);
2054 /* The type of ARG when used as an lvalue. */
2060 tree type
= TREE_TYPE (arg
);
2061 if (TREE_CODE (arg
) == OVERLOAD
)
2062 type
= unknown_type_node
;
2066 /* The type of ARG for printing error messages; denote lvalues with
2073 tree type
= TREE_TYPE (arg
);
2074 if (TREE_CODE (type
) == ARRAY_TYPE
)
2076 else if (real_lvalue_p (arg
))
2077 type
= build_reference_type (lvalue_type (arg
));
2078 else if (IS_AGGR_TYPE (type
))
2079 type
= lvalue_type (arg
);
2084 /* Does FUNCTION use a variable-length argument list? */
2087 varargs_function_p (function
)
2090 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
2091 for (; parm
; parm
= TREE_CHAIN (parm
))
2092 if (TREE_VALUE (parm
) == void_type_node
)
2097 /* Returns 1 if decl is a member of a class. */
2103 const tree ctx
= DECL_CONTEXT (decl
);
2104 return (ctx
&& TYPE_P (ctx
));
2107 /* Create a placeholder for member access where we don't actually have an
2108 object that the access is against. */
2111 build_dummy_object (type
)
2114 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
2115 return build_indirect_ref (decl
, NULL_PTR
);
2118 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2119 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2120 binfo path from current_class_type to TYPE, or 0. */
2123 maybe_dummy_object (type
, binfop
)
2129 if (current_class_type
2130 && get_base_distance (type
, current_class_type
, 0, binfop
) != -1)
2131 context
= current_class_type
;
2134 /* Reference from a nested class member function. */
2137 *binfop
= TYPE_BINFO (type
);
2140 if (current_class_ref
&& context
== current_class_type
)
2141 decl
= current_class_ref
;
2143 decl
= build_dummy_object (context
);
2148 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2151 is_dummy_object (ob
)
2154 if (TREE_CODE (ob
) == INDIRECT_REF
)
2155 ob
= TREE_OPERAND (ob
, 0);
2156 return (TREE_CODE (ob
) == NOP_EXPR
2157 && TREE_OPERAND (ob
, 0) == void_zero_node
);
2160 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2166 while (TREE_CODE (t
) == ARRAY_TYPE
)
2169 if (INTEGRAL_TYPE_P (t
))
2170 return 1; /* integral, character or enumeral type */
2171 if (FLOAT_TYPE_P (t
))
2174 return 1; /* pointer to non-member */
2175 if (TYPE_PTRMEM_P (t
))
2176 return 1; /* pointer to member object */
2177 if (TYPE_PTRMEMFUNC_P (t
))
2178 return 1; /* pointer to member function */
2180 if (! CLASS_TYPE_P (t
))
2181 return 0; /* other non-class type (reference or function) */
2182 if (CLASSTYPE_NON_POD_P (t
))
2187 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2188 attribute for either declaration DECL or type TYPE and 0 otherwise.
2189 Plugged into valid_lang_attribute. */
2192 cp_valid_lang_attribute (attr_name
, attr_args
, decl
, type
)
2194 tree attr_args ATTRIBUTE_UNUSED
;
2195 tree decl ATTRIBUTE_UNUSED
;
2196 tree type ATTRIBUTE_UNUSED
;
2198 if (is_attribute_p ("com_interface", attr_name
))
2200 if (! flag_vtable_thunks
)
2202 error ("`com_interface' only supported with -fvtable-thunks");
2206 if (attr_args
!= NULL_TREE
2207 || decl
!= NULL_TREE
2208 || ! CLASS_TYPE_P (type
)
2209 || type
!= TYPE_MAIN_VARIANT (type
))
2211 warning ("`com_interface' attribute can only be applied to class definitions");
2215 CLASSTYPE_COM_INTERFACE (type
) = 1;
2218 else if (is_attribute_p ("init_priority", attr_name
))
2220 tree initp_expr
= (attr_args
? TREE_VALUE (attr_args
): NULL_TREE
);
2224 STRIP_NOPS (initp_expr
);
2226 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
2228 error ("requested init_priority is not an integer constant");
2232 pri
= TREE_INT_CST_LOW (initp_expr
);
2234 while (TREE_CODE (type
) == ARRAY_TYPE
)
2235 type
= TREE_TYPE (type
);
2237 if (decl
== NULL_TREE
2238 || TREE_CODE (decl
) != VAR_DECL
2239 || ! TREE_STATIC (decl
)
2240 || DECL_EXTERNAL (decl
)
2241 || (TREE_CODE (type
) != RECORD_TYPE
2242 && TREE_CODE (type
) != UNION_TYPE
)
2243 /* Static objects in functions are initialized the
2244 first time control passes through that
2245 function. This is not precise enough to pin down an
2246 init_priority value, so don't allow it. */
2247 || current_function_decl
)
2249 error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2253 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
2255 error ("requested init_priority is out of range");
2259 /* Check for init_priorities that are reserved for
2260 language and runtime support implementations.*/
2261 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
2264 ("requested init_priority is reserved for internal use");
2267 DECL_INIT_PRIORITY (decl
) = pri
;
2274 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2275 thing pointed to by the constant. */
2278 make_ptrmem_cst (type
, member
)
2282 tree ptrmem_cst
= make_node (PTRMEM_CST
);
2283 /* If would seem a great convenience if make_node would set
2284 TREE_CONSTANT for things of class `c', but it does not. */
2285 TREE_CONSTANT (ptrmem_cst
) = 1;
2286 TREE_TYPE (ptrmem_cst
) = type
;
2287 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
2291 /* Mark ARG (which is really a list_hash_table **) for GC. */
2294 mark_list_hash (arg
)
2297 struct list_hash
*lh
;
2299 for (lh
= * ((struct list_hash
**) arg
); lh
; lh
= lh
->next
)
2300 ggc_mark_tree (lh
->list
);
2303 /* Initialize tree.c. */
2308 make_lang_type_fn
= cp_make_lang_type
;
2309 lang_unsave
= cp_unsave
;
2310 ggc_add_root (list_hash_table
,
2311 sizeof (list_hash_table
) / sizeof (struct list_hash
*),
2312 sizeof (struct list_hash
*),
2316 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2317 information indicating to what new SAVE_EXPR this one should be
2318 mapped, use that one. Otherwise, create a new node and enter it in
2319 ST. FN is the function into which the copy will be placed. */
2322 remap_save_expr (tp
, st
, fn
, walk_subtrees
)
2330 /* See if we already encountered this SAVE_EXPR. */
2331 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2333 /* If we didn't already remap this SAVE_EXPR, do so now. */
2336 tree t
= copy_node (*tp
);
2338 /* The SAVE_EXPR is now part of the function into which we
2339 are inlining this body. */
2340 SAVE_EXPR_CONTEXT (t
) = fn
;
2341 /* And we haven't evaluated it yet. */
2342 SAVE_EXPR_RTL (t
) = NULL_RTX
;
2343 /* Remember this SAVE_EXPR. */
2344 n
= splay_tree_insert (st
,
2345 (splay_tree_key
) *tp
,
2346 (splay_tree_value
) t
);
2349 /* We've already walked into this SAVE_EXPR, so we needn't do it
2353 /* Replace this SAVE_EXPR with the copy. */
2354 *tp
= (tree
) n
->value
;
2357 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2358 declaration, copies the declaration and enters it in the splay_tree
2359 pointed to by DATA (which is really a `splay_tree *'). */
2362 mark_local_for_remap_r (tp
, walk_subtrees
, data
)
2364 int *walk_subtrees ATTRIBUTE_UNUSED
;
2368 splay_tree st
= (splay_tree
) data
;
2372 if (TREE_CODE (t
) == DECL_STMT
2373 && nonstatic_local_decl_p (DECL_STMT_DECL (t
)))
2374 decl
= DECL_STMT_DECL (t
);
2375 else if (TREE_CODE (t
) == LABEL_STMT
)
2376 decl
= LABEL_STMT_LABEL (t
);
2377 else if (TREE_CODE (t
) == TARGET_EXPR
2378 && nonstatic_local_decl_p (TREE_OPERAND (t
, 0)))
2379 decl
= TREE_OPERAND (t
, 0);
2388 copy
= copy_decl_for_inlining (decl
,
2389 DECL_CONTEXT (decl
),
2390 DECL_CONTEXT (decl
));
2392 /* Remember the copy. */
2393 splay_tree_insert (st
,
2394 (splay_tree_key
) decl
,
2395 (splay_tree_value
) copy
);
2401 /* Called via walk_tree when an expression is unsaved. Using the
2402 splay_tree pointed to by ST (which is really a `splay_tree'),
2403 remaps all local declarations to appropriate replacements. */
2406 cp_unsave_r (tp
, walk_subtrees
, data
)
2411 splay_tree st
= (splay_tree
) data
;
2414 /* Only a local declaration (variable or label). */
2415 if (nonstatic_local_decl_p (*tp
))
2417 /* Lookup the declaration. */
2418 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2420 /* If it's there, remap it. */
2422 *tp
= (tree
) n
->value
;
2424 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2425 remap_save_expr (tp
, st
, current_function_decl
, walk_subtrees
);
2428 copy_tree_r (tp
, walk_subtrees
, NULL
);
2430 /* Do whatever unsaving is required. */
2431 unsave_expr_1 (*tp
);
2434 /* Keep iterating. */
2438 /* Called by unsave_expr_now whenever an expression (*TP) needs to be
2447 /* Create a splay-tree to map old local variable declarations to new
2449 st
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2451 /* Walk the tree once figuring out what needs to be remapped. */
2452 walk_tree (tp
, mark_local_for_remap_r
, st
);
2454 /* Walk the tree again, copying, remapping, and unsaving. */
2455 walk_tree (tp
, cp_unsave_r
, st
);
2458 splay_tree_delete (st
);
2461 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2462 is. Note that this sfk_none is zero, so this function can be used
2463 as a predicate to test whether or not DECL is a special function. */
2465 special_function_kind
2466 special_function_p (decl
)
2469 /* Rather than doing all this stuff with magic names, we should
2470 probably have a field of type `special_function_kind' in
2471 DECL_LANG_SPECIFIC. */
2472 if (DECL_COPY_CONSTRUCTOR_P (decl
))
2473 return sfk_copy_constructor
;
2474 if (DECL_CONSTRUCTOR_P (decl
))
2475 return sfk_constructor
;
2476 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
2477 return sfk_assignment_operator
;
2478 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2479 return sfk_destructor
;
2480 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
2481 return sfk_complete_destructor
;
2482 if (DECL_BASE_DESTRUCTOR_P (decl
))
2483 return sfk_base_destructor
;
2484 if (DECL_DELETING_DESTRUCTOR_P (decl
))
2485 return sfk_deleting_destructor
;
2486 if (DECL_CONV_FN_P (decl
))
2487 return sfk_conversion
;