Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / cp / tree.c
CommitLineData
003757ed
MD
1/* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1c1138ce 3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
003757ed
MD
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING. If not, write to
20the Free Software Foundation, 59 Temple Place - Suite 330,
21Boston, MA 02111-1307, USA. */
22
23#include "config.h"
24#include "system.h"
25#include "coretypes.h"
26#include "tm.h"
27#include "tree.h"
28#include "cp-tree.h"
29#include "flags.h"
30#include "real.h"
31#include "rtl.h"
32#include "toplev.h"
33#include "insn-config.h"
34#include "integrate.h"
35#include "tree-inline.h"
36#include "target.h"
37
38static tree bot_manip (tree *, int *, void *);
39static tree bot_replace (tree *, int *, void *);
40static tree build_cplus_array_type_1 (tree, tree);
41static int list_hash_eq (const void *, const void *);
42static hashval_t list_hash_pieces (tree, tree, tree);
43static hashval_t list_hash (const void *);
44static cp_lvalue_kind lvalue_p_1 (tree, int);
45static tree no_linkage_helper (tree *, int *, void *);
46static tree mark_local_for_remap_r (tree *, int *, void *);
47static tree cp_unsave_r (tree *, int *, void *);
48static tree build_target_expr (tree, tree);
49static tree count_trees_r (tree *, int *, void *);
50static tree verify_stmt_tree_r (tree *, int *, void *);
51static tree find_tree_r (tree *, int *, void *);
52static tree build_local_temp (tree);
53
54static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
55static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
56static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
57
58/* If REF is an lvalue, returns the kind of lvalue that REF is.
59 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
60 nonzero, rvalues of class type are considered lvalues. */
61
62static cp_lvalue_kind
63lvalue_p_1 (tree ref,
64 int treat_class_rvalues_as_lvalues)
65{
66 cp_lvalue_kind op1_lvalue_kind = clk_none;
67 cp_lvalue_kind op2_lvalue_kind = clk_none;
68
69 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
70 return clk_ordinary;
71
72 if (ref == current_class_ptr)
73 return clk_none;
74
75 switch (TREE_CODE (ref))
76 {
77 /* preincrements and predecrements are valid lvals, provided
78 what they refer to are valid lvals. */
79 case PREINCREMENT_EXPR:
80 case PREDECREMENT_EXPR:
81 case SAVE_EXPR:
82 case UNSAVE_EXPR:
83 case TRY_CATCH_EXPR:
84 case WITH_CLEANUP_EXPR:
85 case REALPART_EXPR:
86 case IMAGPART_EXPR:
87 return lvalue_p_1 (TREE_OPERAND (ref, 0),
88 treat_class_rvalues_as_lvalues);
89
90 case COMPONENT_REF:
91 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
92 treat_class_rvalues_as_lvalues);
93 /* In an expression of the form "X.Y", the packed-ness of the
94 expression does not depend on "X". */
95 op1_lvalue_kind &= ~clk_packed;
96 /* Look at the member designator. */
97 if (!op1_lvalue_kind
98 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
99 situations. */
100 || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
101 ;
102 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
103 {
104 /* Clear the ordinary bit. If this object was a class
105 rvalue we want to preserve that information. */
106 op1_lvalue_kind &= ~clk_ordinary;
107 /* The lvalue is for a bitfield. */
108 op1_lvalue_kind |= clk_bitfield;
109 }
110 else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
111 op1_lvalue_kind |= clk_packed;
112
113 return op1_lvalue_kind;
114
115 case STRING_CST:
116 return clk_ordinary;
117
118 case VAR_DECL:
119 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
120 && DECL_LANG_SPECIFIC (ref)
121 && DECL_IN_AGGR_P (ref))
122 return clk_none;
123 case INDIRECT_REF:
124 case ARRAY_REF:
125 case PARM_DECL:
126 case RESULT_DECL:
127 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
128 return clk_ordinary;
129 break;
130
131 /* A currently unresolved scope ref. */
132 case SCOPE_REF:
133 abort ();
134 case MAX_EXPR:
135 case MIN_EXPR:
136 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
137 treat_class_rvalues_as_lvalues);
138 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
139 treat_class_rvalues_as_lvalues);
140 break;
141
142 case COND_EXPR:
143 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
144 treat_class_rvalues_as_lvalues);
145 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
146 treat_class_rvalues_as_lvalues);
147 break;
148
149 case MODIFY_EXPR:
150 return clk_ordinary;
151
152 case COMPOUND_EXPR:
153 return lvalue_p_1 (TREE_OPERAND (ref, 1),
154 treat_class_rvalues_as_lvalues);
155
156 case TARGET_EXPR:
157 return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
158
159 case CALL_EXPR:
160 case VA_ARG_EXPR:
161 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
162 return clk_none;
163
164 case FUNCTION_DECL:
165 /* All functions (except non-static-member functions) are
166 lvalues. */
167 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
168 ? clk_none : clk_ordinary);
169
170 case NON_DEPENDENT_EXPR:
171 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
172 things like "&E" where "E" is an expression with a
173 non-dependent type work. It is safe to be lenient because an
174 error will be issued when the template is instantiated if "E"
175 is not an lvalue. */
176 return clk_ordinary;
177
178 default:
179 break;
180 }
181
182 /* If one operand is not an lvalue at all, then this expression is
183 not an lvalue. */
184 if (!op1_lvalue_kind || !op2_lvalue_kind)
185 return clk_none;
186
187 /* Otherwise, it's an lvalue, and it has all the odd properties
188 contributed by either operand. */
189 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
190 /* It's not an ordinary lvalue if it involves either a bit-field or
191 a class rvalue. */
192 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
193 op1_lvalue_kind &= ~clk_ordinary;
194 return op1_lvalue_kind;
195}
196
197/* Returns the kind of lvalue that REF is, in the sense of
198 [basic.lval]. This function should really be named lvalue_p; it
199 computes the C++ definition of lvalue. */
200
201cp_lvalue_kind
202real_lvalue_p (tree ref)
203{
204 return lvalue_p_1 (ref,
205 /*treat_class_rvalues_as_lvalues=*/0);
206}
207
208/* This differs from real_lvalue_p in that class rvalues are
209 considered lvalues. */
210
211int
212lvalue_p (tree ref)
213{
214 return
215 (lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);
216}
217
218/* Return nonzero if REF is an lvalue valid for this language;
219 otherwise, print an error message and return zero. */
220
221int
222lvalue_or_else (tree ref, const char* string)
223{
224 if (!lvalue_p (ref))
225 {
226 error ("non-lvalue in %s", string);
227 return 0;
228 }
229 return 1;
230}
231
232/* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
233
234static tree
235build_target_expr (tree decl, tree value)
236{
237 tree t;
238
239 t = build (TARGET_EXPR, TREE_TYPE (decl), decl, value,
240 cxx_maybe_build_cleanup (decl), NULL_TREE);
241 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
242 ignore the TARGET_EXPR. If there really turn out to be no
243 side-effects, then the optimizer should be able to get rid of
244 whatever code is generated anyhow. */
245 TREE_SIDE_EFFECTS (t) = 1;
246
247 return t;
248}
249
250/* Return an undeclared local temporary of type TYPE for use in building a
251 TARGET_EXPR. */
252
253static tree
254build_local_temp (tree type)
255{
256 tree slot = build_decl (VAR_DECL, NULL_TREE, type);
257 DECL_ARTIFICIAL (slot) = 1;
258 DECL_CONTEXT (slot) = current_function_decl;
259 layout_decl (slot, 0);
260 return slot;
261}
262
263/* INIT is a CALL_EXPR which needs info about its target.
264 TYPE is the type that this initialization should appear to have.
265
266 Build an encapsulation of the initialization to perform
267 and return it so that it can be processed by language-independent
268 and language-specific expression expanders. */
269
270tree
271build_cplus_new (tree type, tree init)
272{
273 tree fn;
274 tree slot;
275 tree rval;
276 int is_ctor;
277
278 /* Make sure that we're not trying to create an instance of an
279 abstract class. */
280 abstract_virtuals_error (NULL_TREE, type);
281
282 if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
283 return convert (type, init);
284
285 fn = TREE_OPERAND (init, 0);
286 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
287 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
288 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
289
290 slot = build_local_temp (type);
291
292 /* We split the CALL_EXPR into its function and its arguments here.
293 Then, in expand_expr, we put them back together. The reason for
294 this is that this expression might be a default argument
295 expression. In that case, we need a new temporary every time the
296 expression is used. That's what break_out_target_exprs does; it
297 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
298 temporary slot. Then, expand_expr builds up a call-expression
299 using the new slot. */
300
301 /* If we don't need to use a constructor to create an object of this
302 type, don't mess with AGGR_INIT_EXPR. */
303 if (is_ctor || TREE_ADDRESSABLE (type))
304 {
305 rval = build (AGGR_INIT_EXPR, type, fn, TREE_OPERAND (init, 1), slot);
306 TREE_SIDE_EFFECTS (rval) = 1;
307 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
308 }
309 else
310 rval = init;
311
312 rval = build_target_expr (slot, rval);
313
314 return rval;
315}
316
317/* Build a TARGET_EXPR using INIT to initialize a new temporary of the
318 indicated TYPE. */
319
320tree
321build_target_expr_with_type (tree init, tree type)
322{
323 tree slot;
324
325 if (TREE_CODE (init) == TARGET_EXPR)
326 return init;
327 else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)
328 && TREE_CODE (init) != COND_EXPR
329 && TREE_CODE (init) != CONSTRUCTOR
330 && TREE_CODE (init) != VA_ARG_EXPR)
331 /* We need to build up a copy constructor call. COND_EXPR is a special
332 case because we already have copies on the arms and we don't want
333 another one here. A CONSTRUCTOR is aggregate initialization, which
334 is handled separately. A VA_ARG_EXPR is magic creation of an
335 aggregate; there's no additional work to be done. */
336 return force_rvalue (init);
337
338 slot = build_local_temp (type);
339 return build_target_expr (slot, init);
340}
341
342/* Like the above function, but without the checking. This function should
343 only be used by code which is deliberately trying to subvert the type
344 system, such as call_builtin_trap. */
345
346tree
347force_target_expr (tree type, tree init)
348{
349 tree slot = build_local_temp (type);
350 return build_target_expr (slot, init);
351}
352
353/* Like build_target_expr_with_type, but use the type of INIT. */
354
355tree
356get_target_expr (tree init)
357{
358 return build_target_expr_with_type (init, TREE_TYPE (init));
359}
360
361\f
362static tree
363build_cplus_array_type_1 (tree elt_type, tree index_type)
364{
365 tree t;
366
367 if (elt_type == error_mark_node || index_type == error_mark_node)
368 return error_mark_node;
369
370 if (dependent_type_p (elt_type)
371 || (index_type
372 && value_dependent_expression_p (TYPE_MAX_VALUE (index_type))))
373 {
374 t = make_node (ARRAY_TYPE);
375 TREE_TYPE (t) = elt_type;
376 TYPE_DOMAIN (t) = index_type;
377 }
378 else
379 t = build_array_type (elt_type, index_type);
380
381 /* Push these needs up so that initialization takes place
382 more easily. */
383 TYPE_NEEDS_CONSTRUCTING (t)
384 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
385 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
386 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
387 return t;
388}
389
390tree
391build_cplus_array_type (tree elt_type, tree index_type)
392{
393 tree t;
394 int type_quals = cp_type_quals (elt_type);
395
396 if (type_quals != TYPE_UNQUALIFIED)
397 elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);
398
399 t = build_cplus_array_type_1 (elt_type, index_type);
400
401 if (type_quals != TYPE_UNQUALIFIED)
402 t = cp_build_qualified_type (t, type_quals);
403
404 return t;
405}
406\f
407/* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
408 arrays correctly. In particular, if TYPE is an array of T's, and
409 TYPE_QUALS is non-empty, returns an array of qualified T's.
410
411 FLAGS determines how to deal with illformed qualifications. If
412 tf_ignore_bad_quals is set, then bad qualifications are dropped
413 (this is permitted if TYPE was introduced via a typedef or template
414 type parameter). If bad qualifications are dropped and tf_warning
415 is set, then a warning is issued for non-const qualifications. If
416 tf_ignore_bad_quals is not set and tf_error is not set, we
417 return error_mark_node. Otherwise, we issue an error, and ignore
418 the qualifications.
419
420 Qualification of a reference type is valid when the reference came
421 via a typedef or template type argument. [dcl.ref] No such
422 dispensation is provided for qualifying a function type. [dcl.fct]
423 DR 295 queries this and the proposed resolution brings it into line
424 with qualifying a reference. We implement the DR. We also behave
425 in a similar manner for restricting non-pointer types. */
426
427tree
428cp_build_qualified_type_real (tree type,
429 int type_quals,
430 tsubst_flags_t complain)
431{
432 tree result;
433 int bad_quals = TYPE_UNQUALIFIED;
003757ed
MD
434
435 if (type == error_mark_node)
436 return type;
437
438 if (type_quals == cp_type_quals (type))
439 return type;
440
441 if (TREE_CODE (type) == ARRAY_TYPE)
442 {
443 /* In C++, the qualification really applies to the array element
444 type. Obtain the appropriately qualified element type. */
445 tree t;
446 tree element_type
447 = cp_build_qualified_type_real (TREE_TYPE (type),
448 type_quals,
449 complain);
450
451 if (element_type == error_mark_node)
452 return error_mark_node;
453
454 /* See if we already have an identically qualified type. */
455 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
456 if (cp_type_quals (t) == type_quals
457 && TYPE_NAME (t) == TYPE_NAME (type)
458 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
459 break;
460
461 if (!t)
462 {
463 /* Make a new array type, just like the old one, but with the
464 appropriately qualified element type. */
465 t = build_type_copy (type);
466 TREE_TYPE (t) = element_type;
467 }
468
469 /* Even if we already had this variant, we update
470 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
471 they changed since the variant was originally created.
472
473 This seems hokey; if there is some way to use a previous
474 variant *without* coming through here,
475 TYPE_NEEDS_CONSTRUCTING will never be updated. */
476 TYPE_NEEDS_CONSTRUCTING (t)
477 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
478 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
479 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
480 return t;
481 }
482 else if (TYPE_PTRMEMFUNC_P (type))
483 {
484 /* For a pointer-to-member type, we can't just return a
485 cv-qualified version of the RECORD_TYPE. If we do, we
486 haven't changed the field that contains the actual pointer to
487 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
488 tree t;
489
490 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
491 t = cp_build_qualified_type_real (t, type_quals, complain);
492 return build_ptrmemfunc_type (t);
493 }
494
495 /* A reference, function or method type shall not be cv qualified.
496 [dcl.ref], [dct.fct] */
497 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
498 && (TREE_CODE (type) == REFERENCE_TYPE
499 || TREE_CODE (type) == FUNCTION_TYPE
500 || TREE_CODE (type) == METHOD_TYPE))
501 {
502 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
003757ed
MD
503 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
504 }
505
506 /* A restrict-qualified type must be a pointer (or reference)
507 to object or incomplete type. */
508 if ((type_quals & TYPE_QUAL_RESTRICT)
509 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
510 && TREE_CODE (type) != TYPENAME_TYPE
511 && !POINTER_TYPE_P (type))
512 {
513 bad_quals |= TYPE_QUAL_RESTRICT;
514 type_quals &= ~TYPE_QUAL_RESTRICT;
515 }
516
517 if (bad_quals == TYPE_UNQUALIFIED)
518 /*OK*/;
519 else if (!(complain & (tf_error | tf_ignore_bad_quals)))
520 return error_mark_node;
003757ed
MD
521 else
522 {
523 if (complain & tf_ignore_bad_quals)
524 /* We're not going to warn about constifying things that can't
525 be constified. */
526 bad_quals &= ~TYPE_QUAL_CONST;
003757ed
MD
527 if (bad_quals)
528 {
529 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
530
3a327f56 531 if (!(complain & tf_ignore_bad_quals))
003757ed
MD
532 error ("`%V' qualifiers cannot be applied to `%T'",
533 bad_type, type);
534 }
535 }
536
537 /* Retrieve (or create) the appropriately qualified variant. */
538 result = build_qualified_type (type, type_quals);
539
540 /* If this was a pointer-to-method type, and we just made a copy,
541 then we need to unshare the record that holds the cached
542 pointer-to-member-function type, because these will be distinct
543 between the unqualified and qualified types. */
544 if (result != type
545 && TREE_CODE (type) == POINTER_TYPE
546 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
547 TYPE_LANG_SPECIFIC (result) = NULL;
548
549 return result;
550}
551
552/* Returns the canonical version of TYPE. In other words, if TYPE is
553 a typedef, returns the underlying type. The cv-qualification of
554 the type returned matches the type input; they will always be
555 compatible types. */
556
557tree
558canonical_type_variant (tree t)
559{
560 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));
561}
562\f
563/* Makes new binfos for the indirect bases under BINFO. T is the most
564 derived TYPE. PREV is the previous binfo, whose TREE_CHAIN we make
565 point to this binfo. We return the last BINFO created.
566
567 The CLASSTYPE_VBASECLASSES list of T is constructed in reverse
568 order (pre-order, depth-first, right-to-left). You must nreverse it.
569
570 The BINFO_INHERITANCE of a virtual base class points to the binfo
571 og the most derived type.
572
573 The binfo's TREE_CHAIN is set to inheritance graph order, but bases
574 for non-class types are not included (i.e. those which are
575 dependent bases in non-instantiated templates). */
576
577tree
578copy_base_binfos (tree binfo, tree t, tree prev)
579{
580 tree binfos = BINFO_BASETYPES (binfo);
581 int n, ix;
582
583 if (prev)
584 TREE_CHAIN (prev) = binfo;
585 prev = binfo;
586
587 if (binfos == NULL_TREE)
588 return prev;
589
590 n = TREE_VEC_LENGTH (binfos);
591
592 /* Now copy the structure beneath BINFO. */
593 for (ix = 0; ix != n; ix++)
594 {
595 tree base_binfo = TREE_VEC_ELT (binfos, ix);
596 tree new_binfo = NULL_TREE;
597
598 if (!CLASS_TYPE_P (BINFO_TYPE (base_binfo)))
599 {
600 my_friendly_assert (binfo == TYPE_BINFO (t), 20030204);
601
602 new_binfo = base_binfo;
603 TREE_CHAIN (prev) = new_binfo;
604 prev = new_binfo;
605 BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;
606 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
607 }
608 else if (TREE_VIA_VIRTUAL (base_binfo))
609 {
610 new_binfo = purpose_member (BINFO_TYPE (base_binfo),
611 CLASSTYPE_VBASECLASSES (t));
612 if (new_binfo)
613 new_binfo = TREE_VALUE (new_binfo);
614 }
615
616 if (!new_binfo)
617 {
618 new_binfo = make_binfo (BINFO_OFFSET (base_binfo),
619 base_binfo, NULL_TREE,
620 BINFO_VIRTUALS (base_binfo));
621 prev = copy_base_binfos (new_binfo, t, prev);
622 if (TREE_VIA_VIRTUAL (base_binfo))
623 {
624 CLASSTYPE_VBASECLASSES (t)
625 = tree_cons (BINFO_TYPE (new_binfo), new_binfo,
626 CLASSTYPE_VBASECLASSES (t));
627 TREE_VIA_VIRTUAL (new_binfo) = 1;
628 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
629 }
630 else
631 BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;
632 }
633 TREE_VEC_ELT (binfos, ix) = new_binfo;
634 }
635
636 return prev;
637}
638
639\f
640/* Hashing of lists so that we don't make duplicates.
641 The entry point is `list_hash_canon'. */
642
643/* Now here is the hash table. When recording a list, it is added
644 to the slot whose index is the hash code mod the table size.
645 Note that the hash table is used for several kinds of lists.
646 While all these live in the same table, they are completely independent,
647 and the hash code is computed differently for each of these. */
648
649static GTY ((param_is (union tree_node))) htab_t list_hash_table;
650
651struct list_proxy
652{
653 tree purpose;
654 tree value;
655 tree chain;
656};
657
658/* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
659 for a node we are thinking about adding). */
660
661static int
662list_hash_eq (const void* entry, const void* data)
663{
664 tree t = (tree) entry;
665 struct list_proxy *proxy = (struct list_proxy *) data;
666
667 return (TREE_VALUE (t) == proxy->value
668 && TREE_PURPOSE (t) == proxy->purpose
669 && TREE_CHAIN (t) == proxy->chain);
670}
671
672/* Compute a hash code for a list (chain of TREE_LIST nodes
673 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
674 TREE_COMMON slots), by adding the hash codes of the individual entries. */
675
676static hashval_t
677list_hash_pieces (tree purpose, tree value, tree chain)
678{
679 hashval_t hashcode = 0;
680
681 if (chain)
682 hashcode += TYPE_HASH (chain);
683
684 if (value)
685 hashcode += TYPE_HASH (value);
686 else
687 hashcode += 1007;
688 if (purpose)
689 hashcode += TYPE_HASH (purpose);
690 else
691 hashcode += 1009;
692 return hashcode;
693}
694
695/* Hash an already existing TREE_LIST. */
696
697static hashval_t
698list_hash (const void* p)
699{
700 tree t = (tree) p;
701 return list_hash_pieces (TREE_PURPOSE (t),
702 TREE_VALUE (t),
703 TREE_CHAIN (t));
704}
705
706/* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
707 object for an identical list if one already exists. Otherwise, build a
708 new one, and record it as the canonical object. */
709
710tree
711hash_tree_cons (tree purpose, tree value, tree chain)
712{
713 int hashcode = 0;
714 void **slot;
715 struct list_proxy proxy;
716
717 /* Hash the list node. */
718 hashcode = list_hash_pieces (purpose, value, chain);
719 /* Create a proxy for the TREE_LIST we would like to create. We
720 don't actually create it so as to avoid creating garbage. */
721 proxy.purpose = purpose;
722 proxy.value = value;
723 proxy.chain = chain;
724 /* See if it is already in the table. */
725 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
726 INSERT);
727 /* If not, create a new node. */
728 if (!*slot)
729 *slot = tree_cons (purpose, value, chain);
730 return *slot;
731}
732
733/* Constructor for hashed lists. */
734
735tree
736hash_tree_chain (tree value, tree chain)
737{
738 return hash_tree_cons (NULL_TREE, value, chain);
739}
740
741/* Similar, but used for concatenating two lists. */
742
743tree
744hash_chainon (tree list1, tree list2)
745{
746 if (list2 == 0)
747 return list1;
748 if (list1 == 0)
749 return list2;
750 if (TREE_CHAIN (list1) == NULL_TREE)
751 return hash_tree_chain (TREE_VALUE (list1), list2);
752 return hash_tree_chain (TREE_VALUE (list1),
753 hash_chainon (TREE_CHAIN (list1), list2));
754}
755\f
756/* Build an association between TYPE and some parameters:
757
758 OFFSET is the offset added to `this' to convert it to a pointer
759 of type `TYPE *'
760
761 BINFO is the base binfo to use, if we are deriving from one. This
762 is necessary, as we want specialized parent binfos from base
763 classes, so that the VTABLE_NAMEs of bases are for the most derived
764 type, instead of the simple type.
765
766 VTABLE is the virtual function table with which to initialize
767 sub-objects of type TYPE.
768
769 VIRTUALS are the virtual functions sitting in VTABLE. */
770
771tree
772make_binfo (tree offset, tree binfo, tree vtable, tree virtuals)
773{
774 tree new_binfo = make_tree_vec (BINFO_LANG_ELTS);
775 tree type;
776
777 if (TREE_CODE (binfo) == TREE_VEC)
778 {
779 type = BINFO_TYPE (binfo);
780 BINFO_DEPENDENT_BASE_P (new_binfo) = BINFO_DEPENDENT_BASE_P (binfo);
781 }
782 else
783 {
784 type = binfo;
785 binfo = NULL_TREE;
786 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
787 }
788
789 TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
790 BINFO_OFFSET (new_binfo) = offset;
791 BINFO_VTABLE (new_binfo) = vtable;
792 BINFO_VIRTUALS (new_binfo) = virtuals;
793
794 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo)
795 && BINFO_BASETYPES (binfo) != NULL_TREE)
796 {
797 BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
798 /* We do not need to copy the accesses, as they are read only. */
799 BINFO_BASEACCESSES (new_binfo) = BINFO_BASEACCESSES (binfo);
800 }
801 return new_binfo;
802}
803
804void
805debug_binfo (tree elem)
806{
807 HOST_WIDE_INT n;
808 tree virtuals;
809
810 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
811 "\nvtable type:\n",
812 TYPE_NAME_STRING (BINFO_TYPE (elem)),
813 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
814 debug_tree (BINFO_TYPE (elem));
815 if (BINFO_VTABLE (elem))
816 fprintf (stderr, "vtable decl \"%s\"\n",
817 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
818 else
819 fprintf (stderr, "no vtable decl yet\n");
820 fprintf (stderr, "virtuals:\n");
821 virtuals = BINFO_VIRTUALS (elem);
822 n = 0;
823
824 while (virtuals)
825 {
826 tree fndecl = TREE_VALUE (virtuals);
827 fprintf (stderr, "%s [%ld =? %ld]\n",
828 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
829 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
830 ++n;
831 virtuals = TREE_CHAIN (virtuals);
832 }
833}
834
835int
836count_functions (tree t)
837{
838 int i;
839 if (TREE_CODE (t) == FUNCTION_DECL)
840 return 1;
841 else if (TREE_CODE (t) == OVERLOAD)
842 {
843 for (i = 0; t; t = OVL_CHAIN (t))
844 i++;
845 return i;
846 }
847
848 abort ();
849 return 0;
850}
851
852int
853is_overloaded_fn (tree x)
854{
855 /* A baselink is also considered an overloaded function. */
856 if (TREE_CODE (x) == OFFSET_REF)
857 x = TREE_OPERAND (x, 1);
858 if (BASELINK_P (x))
859 x = BASELINK_FUNCTIONS (x);
860 return (TREE_CODE (x) == FUNCTION_DECL
861 || TREE_CODE (x) == TEMPLATE_ID_EXPR
862 || DECL_FUNCTION_TEMPLATE_P (x)
863 || TREE_CODE (x) == OVERLOAD);
864}
865
866int
867really_overloaded_fn (tree x)
868{
869 /* A baselink is also considered an overloaded function. */
870 if (TREE_CODE (x) == OFFSET_REF)
871 x = TREE_OPERAND (x, 1);
872 if (BASELINK_P (x))
873 x = BASELINK_FUNCTIONS (x);
874
875 return ((TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x))
876 || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
877 || TREE_CODE (x) == TEMPLATE_ID_EXPR);
878}
879
880tree
881get_first_fn (tree from)
882{
883 my_friendly_assert (is_overloaded_fn (from), 9);
884 /* A baselink is also considered an overloaded function. */
885 if (BASELINK_P (from))
886 from = BASELINK_FUNCTIONS (from);
887 return OVL_CURRENT (from);
888}
889
890/* Returns nonzero if T is a ->* or .* expression that refers to a
891 member function. */
892
893int
894bound_pmf_p (tree t)
895{
896 return (TREE_CODE (t) == OFFSET_REF
897 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
898}
899
900/* Return a new OVL node, concatenating it with the old one. */
901
902tree
903ovl_cons (tree decl, tree chain)
904{
905 tree result = make_node (OVERLOAD);
906 TREE_TYPE (result) = unknown_type_node;
907 OVL_FUNCTION (result) = decl;
908 TREE_CHAIN (result) = chain;
909
910 return result;
911}
912
913/* Build a new overloaded function. If this is the first one,
914 just return it; otherwise, ovl_cons the _DECLs */
915
916tree
917build_overload (tree decl, tree chain)
918{
919 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
920 return decl;
921 if (chain && TREE_CODE (chain) != OVERLOAD)
922 chain = ovl_cons (chain, NULL_TREE);
923 return ovl_cons (decl, chain);
924}
925
926\f
927#define PRINT_RING_SIZE 4
928
929const char *
930cxx_printable_name (tree decl, int v)
931{
932 static tree decl_ring[PRINT_RING_SIZE];
933 static char *print_ring[PRINT_RING_SIZE];
934 static int ring_counter;
935 int i;
936
937 /* Only cache functions. */
938 if (v < 2
939 || TREE_CODE (decl) != FUNCTION_DECL
940 || DECL_LANG_SPECIFIC (decl) == 0)
941 return lang_decl_name (decl, v);
942
943 /* See if this print name is lying around. */
944 for (i = 0; i < PRINT_RING_SIZE; i++)
945 if (decl_ring[i] == decl)
946 /* yes, so return it. */
947 return print_ring[i];
948
949 if (++ring_counter == PRINT_RING_SIZE)
950 ring_counter = 0;
951
952 if (current_function_decl != NULL_TREE)
953 {
954 if (decl_ring[ring_counter] == current_function_decl)
955 ring_counter += 1;
956 if (ring_counter == PRINT_RING_SIZE)
957 ring_counter = 0;
958 if (decl_ring[ring_counter] == current_function_decl)
959 abort ();
960 }
961
962 if (print_ring[ring_counter])
963 free (print_ring[ring_counter]);
964
965 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
966 decl_ring[ring_counter] = decl;
967 return print_ring[ring_counter];
968}
969\f
970/* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
971 listed in RAISES. */
972
973tree
974build_exception_variant (tree type, tree raises)
975{
976 tree v = TYPE_MAIN_VARIANT (type);
977 int type_quals = TYPE_QUALS (type);
978
979 for (; v; v = TYPE_NEXT_VARIANT (v))
980 if (TYPE_QUALS (v) == type_quals
981 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1)
982 && (*targetm.comp_type_attributes) (type, v))
983 return v;
984
985 /* Need to build a new variant. */
986 v = build_type_copy (type);
987 TYPE_RAISES_EXCEPTIONS (v) = raises;
988 return v;
989}
990
991/* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
992 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
993 arguments. */
994
995tree
996bind_template_template_parm (tree t, tree newargs)
997{
998 tree decl = TYPE_NAME (t);
999 tree t2;
1000
1001 t2 = make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1002 decl = build_decl (TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1003
1004 /* These nodes have to be created to reflect new TYPE_DECL and template
1005 arguments. */
1006 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1007 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1008 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1009 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t),
1010 newargs, NULL_TREE);
1011
1012 TREE_TYPE (decl) = t2;
1013 TYPE_NAME (t2) = decl;
1014 TYPE_STUB_DECL (t2) = decl;
1015 TYPE_SIZE (t2) = 0;
1016
1017 return t2;
1018}
1019
1020/* Called from count_trees via walk_tree. */
1021
1022static tree
1023count_trees_r (tree* tp ATTRIBUTE_UNUSED ,
1024 int* walk_subtrees ATTRIBUTE_UNUSED ,
1025 void* data)
1026{
1027 ++ *((int*) data);
1028 return NULL_TREE;
1029}
1030
1031/* Debugging function for measuring the rough complexity of a tree
1032 representation. */
1033
1034int
1035count_trees (tree t)
1036{
1037 int n_trees = 0;
1038 walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1039 return n_trees;
1040}
1041
1042/* Called from verify_stmt_tree via walk_tree. */
1043
1044static tree
1045verify_stmt_tree_r (tree* tp,
1046 int* walk_subtrees ATTRIBUTE_UNUSED ,
1047 void* data)
1048{
1049 tree t = *tp;
1050 htab_t *statements = (htab_t *) data;
1051 void **slot;
1052
1053 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1054 return NULL_TREE;
1055
1056 /* If this statement is already present in the hash table, then
1057 there is a circularity in the statement tree. */
1058 if (htab_find (*statements, t))
1059 abort ();
1060
1061 slot = htab_find_slot (*statements, t, INSERT);
1062 *slot = t;
1063
1064 return NULL_TREE;
1065}
1066
1067/* Debugging function to check that the statement T has not been
1068 corrupted. For now, this function simply checks that T contains no
1069 circularities. */
1070
1071void
1072verify_stmt_tree (tree t)
1073{
1074 htab_t statements;
1075 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1076 walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1077 htab_delete (statements);
1078}
1079
1080/* Called from find_tree via walk_tree. */
1081
1082static tree
1083find_tree_r (tree* tp,
1084 int* walk_subtrees ATTRIBUTE_UNUSED ,
1085 void* data)
1086{
1087 if (*tp == (tree) data)
1088 return (tree) data;
1089
1090 return NULL_TREE;
1091}
1092
1093/* Returns X if X appears in the tree structure rooted at T. */
1094
1095tree
1096find_tree (tree t, tree x)
1097{
1098 return walk_tree_without_duplicates (&t, find_tree_r, x);
1099}
1100
1101/* Passed to walk_tree. Checks for the use of types with no linkage. */
1102
1103static tree
1104no_linkage_helper (tree* tp,
1105 int* walk_subtrees ATTRIBUTE_UNUSED ,
1106 void* data ATTRIBUTE_UNUSED )
1107{
1108 tree t = *tp;
1109
1110 if (TYPE_P (t)
1111 && (CLASS_TYPE_P (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1112 && (decl_function_context (TYPE_MAIN_DECL (t))
1113 || TYPE_ANONYMOUS_P (t)))
1114 return t;
1115 return NULL_TREE;
1116}
1117
1118/* Check if the type T depends on a type with no linkage and if so, return
1119 it. */
1120
1121tree
1122no_linkage_check (tree t)
1123{
1124 /* There's no point in checking linkage on template functions; we
1125 can't know their complete types. */
1126 if (processing_template_decl)
1127 return NULL_TREE;
1128
1129 t = walk_tree_without_duplicates (&t, no_linkage_helper, NULL);
1130 if (t != error_mark_node)
1131 return t;
1132 return NULL_TREE;
1133}
1134
1135#ifdef GATHER_STATISTICS
1136extern int depth_reached;
1137#endif
1138
1139void
1140cxx_print_statistics (void)
1141{
1142 print_search_statistics ();
1143 print_class_statistics ();
1144#ifdef GATHER_STATISTICS
1145 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1146 depth_reached);
1147#endif
1148}
1149
1150/* Return, as an INTEGER_CST node, the number of elements for TYPE
1151 (which is an ARRAY_TYPE). This counts only elements of the top
1152 array. */
1153
1154tree
1155array_type_nelts_top (tree type)
1156{
1157 return fold (build (PLUS_EXPR, sizetype,
1158 array_type_nelts (type),
1159 integer_one_node));
1160}
1161
1162/* Return, as an INTEGER_CST node, the number of elements for TYPE
1163 (which is an ARRAY_TYPE). This one is a recursive count of all
1164 ARRAY_TYPEs that are clumped together. */
1165
1166tree
1167array_type_nelts_total (tree type)
1168{
1169 tree sz = array_type_nelts_top (type);
1170 type = TREE_TYPE (type);
1171 while (TREE_CODE (type) == ARRAY_TYPE)
1172 {
1173 tree n = array_type_nelts_top (type);
1174 sz = fold (build (MULT_EXPR, sizetype, sz, n));
1175 type = TREE_TYPE (type);
1176 }
1177 return sz;
1178}
1179
1180/* Called from break_out_target_exprs via mapcar. */
1181
1182static tree
1183bot_manip (tree* tp, int* walk_subtrees, void* data)
1184{
1185 splay_tree target_remap = ((splay_tree) data);
1186 tree t = *tp;
1187
1188 if (TREE_CONSTANT (t))
1189 {
1190 /* There can't be any TARGET_EXPRs or their slot variables below
1191 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1192 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1193 *walk_subtrees = 0;
1194 return NULL_TREE;
1195 }
1196 if (TREE_CODE (t) == TARGET_EXPR)
1197 {
1198 tree u;
1199
1200 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1201 {
1202 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
1203 u = build_cplus_new
1204 (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
1205 }
1206 else
1207 {
1208 u = build_target_expr_with_type
1209 (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t));
1210 }
1211
1212 /* Map the old variable to the new one. */
1213 splay_tree_insert (target_remap,
1214 (splay_tree_key) TREE_OPERAND (t, 0),
1215 (splay_tree_value) TREE_OPERAND (u, 0));
1216
1217 /* Replace the old expression with the new version. */
1218 *tp = u;
1219 /* We don't have to go below this point; the recursive call to
1220 break_out_target_exprs will have handled anything below this
1221 point. */
1222 *walk_subtrees = 0;
1223 return NULL_TREE;
1224 }
1225 else if (TREE_CODE (t) == CALL_EXPR)
1226 mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
1227
1228 /* Make a copy of this node. */
1229 return copy_tree_r (tp, walk_subtrees, NULL);
1230}
1231
1232/* Replace all remapped VAR_DECLs in T with their new equivalents.
1233 DATA is really a splay-tree mapping old variables to new
1234 variables. */
1235
1236static tree
1237bot_replace (tree* t,
1238 int* walk_subtrees ATTRIBUTE_UNUSED ,
1239 void* data)
1240{
1241 splay_tree target_remap = ((splay_tree) data);
1242
1243 if (TREE_CODE (*t) == VAR_DECL)
1244 {
1245 splay_tree_node n = splay_tree_lookup (target_remap,
1246 (splay_tree_key) *t);
1247 if (n)
1248 *t = (tree) n->value;
1249 }
1250
1251 return NULL_TREE;
1252}
1253
1254/* When we parse a default argument expression, we may create
1255 temporary variables via TARGET_EXPRs. When we actually use the
1256 default-argument expression, we make a copy of the expression, but
1257 we must replace the temporaries with appropriate local versions. */
1258
1259tree
1260break_out_target_exprs (tree t)
1261{
1262 static int target_remap_count;
1263 static splay_tree target_remap;
1264
1265 if (!target_remap_count++)
1266 target_remap = splay_tree_new (splay_tree_compare_pointers,
1267 /*splay_tree_delete_key_fn=*/NULL,
1268 /*splay_tree_delete_value_fn=*/NULL);
1269 walk_tree (&t, bot_manip, target_remap, NULL);
1270 walk_tree (&t, bot_replace, target_remap, NULL);
1271
1272 if (!--target_remap_count)
1273 {
1274 splay_tree_delete (target_remap);
1275 target_remap = NULL;
1276 }
1277
1278 return t;
1279}
1280
1281/* Similar to `build_nt', but for template definitions of dependent
1282 expressions */
1283
1284tree
1285build_min_nt (enum tree_code code, ...)
1286{
1287 tree t;
1288 int length;
1289 int i;
1290 va_list p;
1291
1292 va_start (p, code);
1293
1294 t = make_node (code);
1295 length = TREE_CODE_LENGTH (code);
1296 TREE_COMPLEXITY (t) = input_line;
1297
1298 for (i = 0; i < length; i++)
1299 {
1300 tree x = va_arg (p, tree);
1301 TREE_OPERAND (t, i) = x;
1302 }
1303
1304 va_end (p);
1305 return t;
1306}
1307
1308/* Similar to `build', but for template definitions. */
1309
1310tree
1311build_min (enum tree_code code, tree tt, ...)
1312{
1313 tree t;
1314 int length;
1315 int i;
1316 va_list p;
1317
1318 va_start (p, tt);
1319
1320 t = make_node (code);
1321 length = TREE_CODE_LENGTH (code);
1322 TREE_TYPE (t) = tt;
1323 TREE_COMPLEXITY (t) = input_line;
1324
1325 for (i = 0; i < length; i++)
1326 {
1327 tree x = va_arg (p, tree);
1328 TREE_OPERAND (t, i) = x;
1329 if (x && TREE_SIDE_EFFECTS (x))
1330 TREE_SIDE_EFFECTS (t) = 1;
1331 }
1332
1333 va_end (p);
1334 return t;
1335}
1336
1337/* Similar to `build', but for template definitions of non-dependent
1338 expressions. NON_DEP is the non-dependent expression that has been
1339 built. */
1340
1341tree
1342build_min_non_dep (enum tree_code code, tree non_dep, ...)
1343{
1344 tree t;
1345 int length;
1346 int i;
1347 va_list p;
1348
1349 va_start (p, non_dep);
1350
1351 t = make_node (code);
1352 length = TREE_CODE_LENGTH (code);
1353 TREE_TYPE (t) = TREE_TYPE (non_dep);
1354 TREE_COMPLEXITY (t) = input_line;
1355 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1356
1357 for (i = 0; i < length; i++)
1358 {
1359 tree x = va_arg (p, tree);
1360 TREE_OPERAND (t, i) = x;
1361 }
1362
1363 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1364 /* This should not be considered a COMPOUND_EXPR, because it
1365 resolves to an overload. */
1366 COMPOUND_EXPR_OVERLOADED (t) = 1;
1367
1368 va_end (p);
1369 return t;
1370}
1371
1372/* Returns an INTEGER_CST (of type `int') corresponding to I.
1373 Multiple calls with the same value of I may or may not yield the
1374 same node; therefore, callers should never modify the node
1375 returned. */
1376
1377static GTY(()) tree shared_int_cache[256];
1378
1379tree
1380build_shared_int_cst (int i)
1381{
1382 if (i >= 256)
1383 return build_int_2 (i, 0);
1384
1385 if (!shared_int_cache[i])
1386 shared_int_cache[i] = build_int_2 (i, 0);
1387
1388 return shared_int_cache[i];
1389}
1390
1391tree
1392get_type_decl (tree t)
1393{
1394 if (TREE_CODE (t) == TYPE_DECL)
1395 return t;
1396 if (TYPE_P (t))
1397 return TYPE_STUB_DECL (t);
1398 if (t == error_mark_node)
1399 return t;
1400
1401 abort ();
1402
1403 /* Stop compiler from complaining control reaches end of non-void function. */
1404 return 0;
1405}
1406
1407/* Return first vector element whose BINFO_TYPE is ELEM.
1408 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1409
1410tree
1411vec_binfo_member (tree elem, tree vec)
1412{
1413 int i;
1414
1415 if (vec)
1416 for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
1417 if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
1418 return TREE_VEC_ELT (vec, i);
1419
1420 return NULL_TREE;
1421}
1422
1423/* Returns the namespace that contains DECL, whether directly or
1424 indirectly. */
1425
1426tree
1427decl_namespace_context (tree decl)
1428{
1429 while (1)
1430 {
1431 if (TREE_CODE (decl) == NAMESPACE_DECL)
1432 return decl;
1433 else if (TYPE_P (decl))
1434 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1435 else
1436 decl = CP_DECL_CONTEXT (decl);
1437 }
1438}
1439
1440/* Return truthvalue of whether T1 is the same tree structure as T2.
1441 Return 1 if they are the same. Return 0 if they are different. */
1442
1443bool
1444cp_tree_equal (tree t1, tree t2)
1445{
1446 enum tree_code code1, code2;
1447
1448 if (t1 == t2)
1449 return true;
1450 if (!t1 || !t2)
1451 return false;
1452
1453 for (code1 = TREE_CODE (t1);
1454 code1 == NOP_EXPR || code1 == CONVERT_EXPR
1455 || code1 == NON_LVALUE_EXPR;
1456 code1 = TREE_CODE (t1))
1457 t1 = TREE_OPERAND (t1, 0);
1458 for (code2 = TREE_CODE (t2);
1459 code2 == NOP_EXPR || code2 == CONVERT_EXPR
1460 || code1 == NON_LVALUE_EXPR;
1461 code2 = TREE_CODE (t2))
1462 t2 = TREE_OPERAND (t2, 0);
1463
1464 /* They might have become equal now. */
1465 if (t1 == t2)
1466 return true;
1467
1468 if (code1 != code2)
1469 return false;
1470
1471 switch (code1)
1472 {
1473 case INTEGER_CST:
1474 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
1475 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
1476
1477 case REAL_CST:
1478 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
1479
1480 case STRING_CST:
1481 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
1482 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
1483 TREE_STRING_LENGTH (t1));
1484
1485 case CONSTRUCTOR:
1486 /* We need to do this when determining whether or not two
1487 non-type pointer to member function template arguments
1488 are the same. */
1489 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
1490 /* The first operand is RTL. */
1491 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
1492 return false;
1493 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1494
1495 case TREE_LIST:
1496 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
1497 return false;
1498 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
1499 return false;
1500 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
1501
1502 case SAVE_EXPR:
1503 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1504
1505 case CALL_EXPR:
1506 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1507 return false;
1508 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1509
1510 case TARGET_EXPR:
1511 {
1512 tree o1 = TREE_OPERAND (t1, 0);
1513 tree o2 = TREE_OPERAND (t2, 0);
1514
1515 /* Special case: if either target is an unallocated VAR_DECL,
1516 it means that it's going to be unified with whatever the
1517 TARGET_EXPR is really supposed to initialize, so treat it
1518 as being equivalent to anything. */
1519 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
1520 && !DECL_RTL_SET_P (o1))
1521 /*Nop*/;
1522 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
1523 && !DECL_RTL_SET_P (o2))
1524 /*Nop*/;
1525 else if (!cp_tree_equal (o1, o2))
1526 return false;
1527
1528 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1529 }
1530
1531 case WITH_CLEANUP_EXPR:
1532 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1533 return false;
1534 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
1535
1536 case COMPONENT_REF:
1537 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
1538 return false;
1539 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1540
1541 case VAR_DECL:
1542 case PARM_DECL:
1543 case CONST_DECL:
1544 case FUNCTION_DECL:
1545 case TEMPLATE_DECL:
1546 case IDENTIFIER_NODE:
1547 return false;
1548
3a327f56
JS
1549 case BASELINK:
1550 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
1551 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
1552 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
1553 BASELINK_FUNCTIONS (t2)));
1554
003757ed
MD
1555 case TEMPLATE_PARM_INDEX:
1556 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1557 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1558 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1559 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1560
1561 case TEMPLATE_ID_EXPR:
1562 {
1563 unsigned ix;
1564 tree vec1, vec2;
1565
1566 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1567 return false;
1568 vec1 = TREE_OPERAND (t1, 1);
1569 vec2 = TREE_OPERAND (t2, 1);
1570
1571 if (!vec1 || !vec2)
1572 return !vec1 && !vec2;
1573
1574 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1575 return false;
1576
1577 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1578 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1579 TREE_VEC_ELT (vec2, ix)))
1580 return false;
1581
1582 return true;
1583 }
1584
1585 case SIZEOF_EXPR:
1586 case ALIGNOF_EXPR:
1587 {
1588 tree o1 = TREE_OPERAND (t1, 0);
1589 tree o2 = TREE_OPERAND (t2, 0);
1590
1591 if (TREE_CODE (o1) != TREE_CODE (o2))
1592 return false;
1593 if (TYPE_P (o1))
1594 return same_type_p (o1, o2);
1595 else
1596 return cp_tree_equal (o1, o2);
1597 }
1598
1599 case PTRMEM_CST:
1600 /* Two pointer-to-members are the same if they point to the same
1601 field or function in the same class. */
1602 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1603 return false;
1604
1605 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1606
1c1138ce
JS
1607 case OVERLOAD:
1608 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
1609 return false;
1610 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
1611
003757ed
MD
1612 default:
1613 break;
1614 }
1615
1616 switch (TREE_CODE_CLASS (code1))
1617 {
1618 case '1':
1619 case '2':
1620 case '<':
1621 case 'e':
1622 case 'r':
1623 case 's':
1624 {
1625 int i;
1626
1627 for (i = 0; i < TREE_CODE_LENGTH (code1); ++i)
1628 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1629 return false;
1630
1631 return true;
1632 }
1633
1634 case 't':
1635 return same_type_p (t1, t2);
1636 }
1637
1638 my_friendly_assert (0, 20030617);
1639 return false;
1640}
1641
1642/* Build a wrapper around a 'struct z_candidate' so we can use it as a
1643 tree. */
1644
1645tree
1646build_zc_wrapper (struct z_candidate* ptr)
1647{
1648 tree t = make_node (WRAPPER);
1649 WRAPPER_ZC (t) = ptr;
1650 return t;
1651}
1652
1653/* The type of ARG when used as an lvalue. */
1654
1655tree
1656lvalue_type (tree arg)
1657{
1658 tree type = TREE_TYPE (arg);
1659 return type;
1660}
1661
1662/* The type of ARG for printing error messages; denote lvalues with
1663 reference types. */
1664
1665tree
1666error_type (tree arg)
1667{
1668 tree type = TREE_TYPE (arg);
1669
1670 if (TREE_CODE (type) == ARRAY_TYPE)
1671 ;
1672 else if (TREE_CODE (type) == ERROR_MARK)
1673 ;
1674 else if (real_lvalue_p (arg))
1675 type = build_reference_type (lvalue_type (arg));
1676 else if (IS_AGGR_TYPE (type))
1677 type = lvalue_type (arg);
1678
1679 return type;
1680}
1681
1682/* Does FUNCTION use a variable-length argument list? */
1683
1684int
1685varargs_function_p (tree function)
1686{
1687 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1688 for (; parm; parm = TREE_CHAIN (parm))
1689 if (TREE_VALUE (parm) == void_type_node)
1690 return 0;
1691 return 1;
1692}
1693
1694/* Returns 1 if decl is a member of a class. */
1695
1696int
1697member_p (tree decl)
1698{
1699 const tree ctx = DECL_CONTEXT (decl);
1700 return (ctx && TYPE_P (ctx));
1701}
1702
1703/* Create a placeholder for member access where we don't actually have an
1704 object that the access is against. */
1705
1706tree
1707build_dummy_object (tree type)
1708{
1709 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1710 return build_indirect_ref (decl, NULL);
1711}
1712
1713/* We've gotten a reference to a member of TYPE. Return *this if appropriate,
1714 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
1715 binfo path from current_class_type to TYPE, or 0. */
1716
1717tree
1718maybe_dummy_object (tree type, tree* binfop)
1719{
1720 tree decl, context;
1721 tree binfo;
1722
1723 if (current_class_type
1724 && (binfo = lookup_base (current_class_type, type,
1725 ba_ignore | ba_quiet, NULL)))
1726 context = current_class_type;
1727 else
1728 {
1729 /* Reference from a nested class member function. */
1730 context = type;
1731 binfo = TYPE_BINFO (type);
1732 }
1733
1734 if (binfop)
1735 *binfop = binfo;
1736
1737 if (current_class_ref && context == current_class_type
1738 /* Kludge: Make sure that current_class_type is actually
1739 correct. It might not be if we're in the middle of
1740 tsubst_default_argument. */
1741 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1742 current_class_type))
1743 decl = current_class_ref;
1744 else
1745 decl = build_dummy_object (context);
1746
1747 return decl;
1748}
1749
1750/* Returns 1 if OB is a placeholder object, or a pointer to one. */
1751
1752int
1753is_dummy_object (tree ob)
1754{
1755 if (TREE_CODE (ob) == INDIRECT_REF)
1756 ob = TREE_OPERAND (ob, 0);
1757 return (TREE_CODE (ob) == NOP_EXPR
1758 && TREE_OPERAND (ob, 0) == void_zero_node);
1759}
1760
1761/* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
1762
1763int
1764pod_type_p (tree t)
1765{
1766 t = strip_array_types (t);
1767
1768 if (t == error_mark_node)
1769 return 1;
1770 if (INTEGRAL_TYPE_P (t))
1771 return 1; /* integral, character or enumeral type */
1772 if (FLOAT_TYPE_P (t))
1773 return 1;
1774 if (TYPE_PTR_P (t))
1775 return 1; /* pointer to non-member */
1776 if (TYPE_PTR_TO_MEMBER_P (t))
1777 return 1; /* pointer to member */
3a327f56
JS
1778 if (TREE_CODE (t) == VECTOR_TYPE)
1779 return 1; /* vectors are (small) arrays of scalars */
003757ed
MD
1780
1781 if (! CLASS_TYPE_P (t))
1782 return 0; /* other non-class type (reference or function) */
1783 if (CLASSTYPE_NON_POD_P (t))
1784 return 0;
1785 return 1;
1786}
1787
1788/* Returns 1 iff zero initialization of type T means actually storing
1789 zeros in it. */
1790
1791int
1792zero_init_p (tree t)
1793{
1794 t = strip_array_types (t);
1795
1796 if (t == error_mark_node)
1797 return 1;
1798
1799 /* NULL pointers to data members are initialized with -1. */
1800 if (TYPE_PTRMEM_P (t))
1801 return 0;
1802
1803 /* Classes that contain types that can't be zero-initialized, cannot
1804 be zero-initialized themselves. */
1805 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
1806 return 0;
1807
1808 return 1;
1809}
1810
1811/* Table of valid C++ attributes. */
1812const struct attribute_spec cxx_attribute_table[] =
1813{
1814 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1815 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
1816 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
1817 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
1818 { NULL, 0, 0, false, false, false, NULL }
1819};
1820
1821/* Handle a "java_interface" attribute; arguments as in
1822 struct attribute_spec.handler. */
1823static tree
1824handle_java_interface_attribute (tree* node,
1825 tree name,
1826 tree args ATTRIBUTE_UNUSED ,
1827 int flags,
1828 bool* no_add_attrs)
1829{
1830 if (DECL_P (*node)
1831 || !CLASS_TYPE_P (*node)
1832 || !TYPE_FOR_JAVA (*node))
1833 {
1834 error ("`%s' attribute can only be applied to Java class definitions",
1835 IDENTIFIER_POINTER (name));
1836 *no_add_attrs = true;
1837 return NULL_TREE;
1838 }
1839 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
1840 *node = build_type_copy (*node);
1841 TYPE_JAVA_INTERFACE (*node) = 1;
1842
1843 return NULL_TREE;
1844}
1845
1846/* Handle a "com_interface" attribute; arguments as in
1847 struct attribute_spec.handler. */
1848static tree
1849handle_com_interface_attribute (tree* node,
1850 tree name,
1851 tree args ATTRIBUTE_UNUSED ,
1852 int flags ATTRIBUTE_UNUSED ,
1853 bool* no_add_attrs)
1854{
1855 static int warned;
1856
1857 *no_add_attrs = true;
1858
1859 if (DECL_P (*node)
1860 || !CLASS_TYPE_P (*node)
1861 || *node != TYPE_MAIN_VARIANT (*node))
1862 {
1863 warning ("`%s' attribute can only be applied to class definitions",
1864 IDENTIFIER_POINTER (name));
1865 return NULL_TREE;
1866 }
1867
1868 if (!warned++)
1869 warning ("`%s' is obsolete; g++ vtables are now COM-compatible by default",
1870 IDENTIFIER_POINTER (name));
1871
1872 return NULL_TREE;
1873}
1874
1875/* Handle an "init_priority" attribute; arguments as in
1876 struct attribute_spec.handler. */
1877static tree
1878handle_init_priority_attribute (tree* node,
1879 tree name,
1880 tree args,
1881 int flags ATTRIBUTE_UNUSED ,
1882 bool* no_add_attrs)
1883{
1884 tree initp_expr = TREE_VALUE (args);
1885 tree decl = *node;
1886 tree type = TREE_TYPE (decl);
1887 int pri;
1888
1889 STRIP_NOPS (initp_expr);
1890
1891 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
1892 {
1893 error ("requested init_priority is not an integer constant");
1894 *no_add_attrs = true;
1895 return NULL_TREE;
1896 }
1897
1898 pri = TREE_INT_CST_LOW (initp_expr);
1899
1900 type = strip_array_types (type);
1901
1902 if (decl == NULL_TREE
1903 || TREE_CODE (decl) != VAR_DECL
1904 || !TREE_STATIC (decl)
1905 || DECL_EXTERNAL (decl)
1906 || (TREE_CODE (type) != RECORD_TYPE
1907 && TREE_CODE (type) != UNION_TYPE)
1908 /* Static objects in functions are initialized the
1909 first time control passes through that
1910 function. This is not precise enough to pin down an
1911 init_priority value, so don't allow it. */
1912 || current_function_decl)
1913 {
1914 error ("can only use `%s' attribute on file-scope definitions of objects of class type",
1915 IDENTIFIER_POINTER (name));
1916 *no_add_attrs = true;
1917 return NULL_TREE;
1918 }
1919
1920 if (pri > MAX_INIT_PRIORITY || pri <= 0)
1921 {
1922 error ("requested init_priority is out of range");
1923 *no_add_attrs = true;
1924 return NULL_TREE;
1925 }
1926
1927 /* Check for init_priorities that are reserved for
1928 language and runtime support implementations.*/
1929 if (pri <= MAX_RESERVED_INIT_PRIORITY)
1930 {
1931 warning
1932 ("requested init_priority is reserved for internal use");
1933 }
1934
1935 if (SUPPORTS_INIT_PRIORITY)
1936 {
1937 DECL_INIT_PRIORITY (decl) = pri;
1938 return NULL_TREE;
1939 }
1940 else
1941 {
1942 error ("`%s' attribute is not supported on this platform",
1943 IDENTIFIER_POINTER (name));
1944 *no_add_attrs = true;
1945 return NULL_TREE;
1946 }
1947}
1948
1949/* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
1950 thing pointed to by the constant. */
1951
1952tree
1953make_ptrmem_cst (tree type, tree member)
1954{
1955 tree ptrmem_cst = make_node (PTRMEM_CST);
1956 /* If would seem a great convenience if make_node would set
1957 TREE_CONSTANT for things of class `c', but it does not. */
1958 TREE_CONSTANT (ptrmem_cst) = 1;
1959 TREE_TYPE (ptrmem_cst) = type;
1960 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
1961 return ptrmem_cst;
1962}
1963
1964/* Build a variant of TYPE that has the indicated ATTRIBUTES. May
1965 return an existing type of an appropriate type already exists. */
1966
1967tree
1968cp_build_type_attribute_variant (tree type, tree attributes)
1969{
1970 tree new_type;
1971
1972 new_type = build_type_attribute_variant (type, attributes);
1973 if (TREE_CODE (new_type) == FUNCTION_TYPE
1974 && (TYPE_RAISES_EXCEPTIONS (new_type)
1975 != TYPE_RAISES_EXCEPTIONS (type)))
1976 new_type = build_exception_variant (new_type,
1977 TYPE_RAISES_EXCEPTIONS (type));
1978 return new_type;
1979}
1980
1981/* Apply FUNC to all language-specific sub-trees of TP in a pre-order
1982 traversal. Called from walk_tree(). */
1983
1984tree
1985cp_walk_subtrees (tree* tp,
1986 int* walk_subtrees_p,
1987 walk_tree_fn func,
1988 void* data,
1989 void* htab)
1990{
1991 enum tree_code code = TREE_CODE (*tp);
1992 tree result;
1993
1994#define WALK_SUBTREE(NODE) \
1995 do \
1996 { \
1997 result = walk_tree (&(NODE), func, data, htab); \
1998 if (result) \
1999 return result; \
2000 } \
2001 while (0)
2002
2003 /* Not one of the easy cases. We must explicitly go through the
2004 children. */
2005 switch (code)
2006 {
2007 case DEFAULT_ARG:
2008 case TEMPLATE_TEMPLATE_PARM:
2009 case BOUND_TEMPLATE_TEMPLATE_PARM:
2010 case UNBOUND_CLASS_TEMPLATE:
2011 case TEMPLATE_PARM_INDEX:
2012 case TEMPLATE_TYPE_PARM:
2013 case TYPENAME_TYPE:
2014 case TYPEOF_TYPE:
2015 case BASELINK:
2016 /* None of these have subtrees other than those already walked
2017 above. */
2018 *walk_subtrees_p = 0;
2019 break;
2020
2021 case PTRMEM_CST:
2022 WALK_SUBTREE (TREE_TYPE (*tp));
2023 *walk_subtrees_p = 0;
2024 break;
2025
2026 case TREE_LIST:
2027 WALK_SUBTREE (TREE_PURPOSE (*tp));
2028 break;
2029
2030 case OVERLOAD:
2031 WALK_SUBTREE (OVL_FUNCTION (*tp));
2032 WALK_SUBTREE (OVL_CHAIN (*tp));
2033 *walk_subtrees_p = 0;
2034 break;
2035
2036 case RECORD_TYPE:
2037 if (TYPE_PTRMEMFUNC_P (*tp))
2038 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2039 break;
2040
2041 default:
2042 break;
2043 }
2044
2045 /* We didn't find what we were looking for. */
2046 return NULL_TREE;
2047
2048#undef WALK_SUBTREE
2049}
2050
2051/* Decide whether there are language-specific reasons to not inline a
2052 function as a tree. */
2053
2054int
2055cp_cannot_inline_tree_fn (tree* fnp)
2056{
2057 tree fn = *fnp;
2058
2059 /* We can inline a template instantiation only if it's fully
2060 instantiated. */
2061 if (DECL_TEMPLATE_INFO (fn)
2062 && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2063 {
2064 /* Don't instantiate functions that are not going to be
2065 inlined. */
2066 if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2067 (template_for_substitution (fn))))
2068 return 1;
2069
2070 fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0);
2071
2072 if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2073 return 1;
2074 }
2075
2076 if (flag_really_no_inline
2077 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2078 return 1;
2079
2080 /* Don't auto-inline anything that might not be bound within
2081 this unit of translation. */
2082 if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
2083 {
2084 DECL_UNINLINABLE (fn) = 1;
2085 return 1;
2086 }
2087
2088 if (varargs_function_p (fn))
2089 {
2090 DECL_UNINLINABLE (fn) = 1;
2091 return 1;
2092 }
2093
2094 if (! function_attribute_inlinable_p (fn))
2095 {
2096 DECL_UNINLINABLE (fn) = 1;
2097 return 1;
2098 }
2099
2100 return 0;
2101}
2102
2103/* Add any pending functions other than the current function (already
2104 handled by the caller), that thus cannot be inlined, to FNS_P, then
2105 return the latest function added to the array, PREV_FN. */
2106
2107tree
2108cp_add_pending_fn_decls (void* fns_p, tree prev_fn)
2109{
2110 varray_type *fnsp = (varray_type *)fns_p;
2111 struct saved_scope *s;
2112
2113 for (s = scope_chain; s; s = s->prev)
2114 if (s->function_decl && s->function_decl != prev_fn)
2115 {
2116 VARRAY_PUSH_TREE (*fnsp, s->function_decl);
2117 prev_fn = s->function_decl;
2118 }
2119
2120 return prev_fn;
2121}
2122
2123/* Determine whether a tree node is an OVERLOAD node. Used to decide
2124 whether to copy a node or to preserve its chain when inlining a
2125 function. */
2126
2127int
2128cp_is_overload_p (tree t)
2129{
2130 return TREE_CODE (t) == OVERLOAD;
2131}
2132
2133/* Determine whether VAR is a declaration of an automatic variable in
2134 function FN. */
2135
2136int
2137cp_auto_var_in_fn_p (tree var, tree fn)
2138{
2139 return (DECL_P (var) && DECL_CONTEXT (var) == fn
2140 && nonstatic_local_decl_p (var));
2141}
2142
2143/* Tell whether a declaration is needed for the RESULT of a function
2144 FN being inlined into CALLER or if the top node of target_exprs is
2145 to be used. */
2146
2147tree
2148cp_copy_res_decl_for_inlining (tree result,
2149 tree fn,
2150 tree caller,
2151 void* decl_map_,
2152 int* need_decl,
2153 tree return_slot_addr)
2154{
2155 splay_tree decl_map = (splay_tree)decl_map_;
2156 tree var;
2157
2158 /* If FN returns an aggregate then the caller will always pass the
2159 address of the return slot explicitly. If we were just to
2160 create a new VAR_DECL here, then the result of this function
2161 would be copied (bitwise) into the variable initialized by the
2162 TARGET_EXPR. That's incorrect, so we must transform any
2163 references to the RESULT into references to the target. */
2164
2165 /* We should have an explicit return slot iff the return type is
2166 TREE_ADDRESSABLE. See simplify_aggr_init_expr. */
2167 if (TREE_ADDRESSABLE (TREE_TYPE (result))
2168 != (return_slot_addr != NULL_TREE))
2169 abort ();
2170
2171 *need_decl = !return_slot_addr;
2172 if (return_slot_addr)
2173 {
2174 var = build_indirect_ref (return_slot_addr, "");
2175 if (! same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var),
2176 TREE_TYPE (result)))
2177 abort ();
2178 }
2179 /* Otherwise, make an appropriate copy. */
2180 else
2181 var = copy_decl_for_inlining (result, fn, caller);
2182
2183 if (DECL_SAVED_FUNCTION_DATA (fn))
2184 {
2185 tree nrv = DECL_SAVED_FUNCTION_DATA (fn)->x_return_value;
2186 if (nrv)
2187 {
2188 /* We have a named return value; copy the name and source
2189 position so we can get reasonable debugging information, and
2190 register the return variable as its equivalent. */
2191 if (TREE_CODE (var) == VAR_DECL
2192 /* But not if we're initializing a variable from the
2193 enclosing function which already has its own name. */
2194 && DECL_NAME (var) == NULL_TREE)
2195 {
2196 DECL_NAME (var) = DECL_NAME (nrv);
2197 DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (nrv);
2198 DECL_ABSTRACT_ORIGIN (var) = DECL_ORIGIN (nrv);
2199 /* Don't lose initialization info. */
2200 DECL_INITIAL (var) = DECL_INITIAL (nrv);
2201 /* Don't forget that it needs to go in the stack. */
2202 TREE_ADDRESSABLE (var) = TREE_ADDRESSABLE (nrv);
2203 }
2204
2205 splay_tree_insert (decl_map,
2206 (splay_tree_key) nrv,
2207 (splay_tree_value) var);
2208 }
2209 }
2210
2211 return var;
2212}
2213
2214/* Initialize tree.c. */
2215
2216void
2217init_tree (void)
2218{
2219 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2220}
2221
2222/* Called via walk_tree. If *TP points to a DECL_STMT for a local
2223 declaration, copies the declaration and enters it in the splay_tree
2224 pointed to by DATA (which is really a `splay_tree *'). */
2225
2226static tree
2227mark_local_for_remap_r (tree* tp,
2228 int* walk_subtrees ATTRIBUTE_UNUSED ,
2229 void* data)
2230{
2231 tree t = *tp;
2232 splay_tree st = (splay_tree) data;
2233 tree decl;
2234
2235
2236 if (TREE_CODE (t) == DECL_STMT
2237 && nonstatic_local_decl_p (DECL_STMT_DECL (t)))
2238 decl = DECL_STMT_DECL (t);
2239 else if (TREE_CODE (t) == LABEL_STMT)
2240 decl = LABEL_STMT_LABEL (t);
2241 else if (TREE_CODE (t) == TARGET_EXPR
2242 && nonstatic_local_decl_p (TREE_OPERAND (t, 0)))
2243 decl = TREE_OPERAND (t, 0);
2244 else if (TREE_CODE (t) == CASE_LABEL)
2245 decl = CASE_LABEL_DECL (t);
2246 else
2247 decl = NULL_TREE;
2248
2249 if (decl)
2250 {
2251 tree copy;
2252
2253 /* Make a copy. */
2254 copy = copy_decl_for_inlining (decl,
2255 DECL_CONTEXT (decl),
2256 DECL_CONTEXT (decl));
2257
2258 /* Remember the copy. */
2259 splay_tree_insert (st,
2260 (splay_tree_key) decl,
2261 (splay_tree_value) copy);
2262 }
2263
2264 return NULL_TREE;
2265}
2266
2267/* Called via walk_tree when an expression is unsaved. Using the
2268 splay_tree pointed to by ST (which is really a `splay_tree'),
2269 remaps all local declarations to appropriate replacements. */
2270
2271static tree
2272cp_unsave_r (tree* tp,
2273 int* walk_subtrees,
2274 void* data)
2275{
2276 splay_tree st = (splay_tree) data;
2277 splay_tree_node n;
2278
2279 /* Only a local declaration (variable or label). */
2280 if (nonstatic_local_decl_p (*tp))
2281 {
2282 /* Lookup the declaration. */
2283 n = splay_tree_lookup (st, (splay_tree_key) *tp);
2284
2285 /* If it's there, remap it. */
2286 if (n)
2287 *tp = (tree) n->value;
2288 }
2289 else if (TREE_CODE (*tp) == SAVE_EXPR)
2290 remap_save_expr (tp, st, current_function_decl, walk_subtrees);
2291 else
2292 {
2293 copy_tree_r (tp, walk_subtrees, NULL);
2294
2295 /* Do whatever unsaving is required. */
2296 unsave_expr_1 (*tp);
2297 }
2298
2299 /* Keep iterating. */
2300 return NULL_TREE;
2301}
2302
2303/* Called whenever an expression needs to be unsaved. */
2304
2305tree
2306cxx_unsave_expr_now (tree tp)
2307{
2308 splay_tree st;
2309
2310 /* Create a splay-tree to map old local variable declarations to new
2311 ones. */
2312 st = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2313
2314 /* Walk the tree once figuring out what needs to be remapped. */
2315 walk_tree (&tp, mark_local_for_remap_r, st, NULL);
2316
2317 /* Walk the tree again, copying, remapping, and unsaving. */
2318 walk_tree (&tp, cp_unsave_r, st, NULL);
2319
2320 /* Clean up. */
2321 splay_tree_delete (st);
2322
2323 return tp;
2324}
2325
2326/* Returns the kind of special function that DECL (a FUNCTION_DECL)
2327 is. Note that sfk_none is zero, so this function can be used as a
2328 predicate to test whether or not DECL is a special function. */
2329
2330special_function_kind
2331special_function_p (tree decl)
2332{
2333 /* Rather than doing all this stuff with magic names, we should
2334 probably have a field of type `special_function_kind' in
2335 DECL_LANG_SPECIFIC. */
2336 if (DECL_COPY_CONSTRUCTOR_P (decl))
2337 return sfk_copy_constructor;
2338 if (DECL_CONSTRUCTOR_P (decl))
2339 return sfk_constructor;
2340 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2341 return sfk_assignment_operator;
2342 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2343 return sfk_destructor;
2344 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2345 return sfk_complete_destructor;
2346 if (DECL_BASE_DESTRUCTOR_P (decl))
2347 return sfk_base_destructor;
2348 if (DECL_DELETING_DESTRUCTOR_P (decl))
2349 return sfk_deleting_destructor;
2350 if (DECL_CONV_FN_P (decl))
2351 return sfk_conversion;
2352
2353 return sfk_none;
2354}
2355
2356/* Returns true if and only if NODE is a name, i.e., a node created
2357 by the parser when processing an id-expression. */
2358
2359bool
2360name_p (tree node)
2361{
2362 if (TREE_CODE (node) == TEMPLATE_ID_EXPR)
2363 node = TREE_OPERAND (node, 0);
2364 return (/* An ordinary unqualified name. */
2365 TREE_CODE (node) == IDENTIFIER_NODE
2366 /* A destructor name. */
2367 || TREE_CODE (node) == BIT_NOT_EXPR
2368 /* A qualified name. */
2369 || TREE_CODE (node) == SCOPE_REF);
2370}
2371
2372/* Returns nonzero if TYPE is a character type, including wchar_t. */
2373
2374int
2375char_type_p (tree type)
2376{
2377 return (same_type_p (type, char_type_node)
2378 || same_type_p (type, unsigned_char_type_node)
2379 || same_type_p (type, signed_char_type_node)
2380 || same_type_p (type, wchar_type_node));
2381}
2382
2383/* Returns the kind of linkage associated with the indicated DECL. Th
2384 value returned is as specified by the language standard; it is
2385 independent of implementation details regarding template
2386 instantiation, etc. For example, it is possible that a declaration
2387 to which this function assigns external linkage would not show up
2388 as a global symbol when you run `nm' on the resulting object file. */
2389
2390linkage_kind
2391decl_linkage (tree decl)
2392{
2393 /* This function doesn't attempt to calculate the linkage from first
2394 principles as given in [basic.link]. Instead, it makes use of
2395 the fact that we have already set TREE_PUBLIC appropriately, and
2396 then handles a few special cases. Ideally, we would calculate
2397 linkage first, and then transform that into a concrete
2398 implementation. */
2399
2400 /* Things that don't have names have no linkage. */
2401 if (!DECL_NAME (decl))
2402 return lk_none;
2403
2404 /* Things that are TREE_PUBLIC have external linkage. */
2405 if (TREE_PUBLIC (decl))
2406 return lk_external;
2407
2408 /* Some things that are not TREE_PUBLIC have external linkage, too.
2409 For example, on targets that don't have weak symbols, we make all
2410 template instantiations have internal linkage (in the object
2411 file), but the symbols should still be treated as having external
2412 linkage from the point of view of the language. */
2413 if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
2414 return lk_external;
2415
2416 /* Things in local scope do not have linkage, if they don't have
2417 TREE_PUBLIC set. */
2418 if (decl_function_context (decl))
2419 return lk_none;
2420
2421 /* Everything else has internal linkage. */
2422 return lk_internal;
2423}
2424\f
2425/* EXP is an expression that we want to pre-evaluate. Returns via INITP an
2426 expression to perform the pre-evaluation, and returns directly an
2427 expression to use the precalculated result. */
2428
2429tree
2430stabilize_expr (tree exp, tree* initp)
2431{
2432 tree init_expr;
2433
2434 if (!TREE_SIDE_EFFECTS (exp))
2435 {
2436 init_expr = NULL_TREE;
2437 }
2438 else if (!real_lvalue_p (exp)
2439 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2440 {
2441 init_expr = get_target_expr (exp);
2442 exp = TARGET_EXPR_SLOT (init_expr);
2443 }
2444 else
2445 {
2446 exp = build_unary_op (ADDR_EXPR, exp, 1);
2447 init_expr = get_target_expr (exp);
2448 exp = TARGET_EXPR_SLOT (init_expr);
2449 exp = build_indirect_ref (exp, 0);
2450 }
2451
2452 *initp = init_expr;
2453 return exp;
2454}
2455
2456/* Like stabilize_expr, but for a call whose args we want to
2457 pre-evaluate. */
2458
2459void
2460stabilize_call (tree call, tree *initp)
2461{
2462 tree inits = NULL_TREE;
2463 tree t;
2464
2465 if (call == error_mark_node)
2466 return;
2467
2468 if (TREE_CODE (call) != CALL_EXPR
2469 && TREE_CODE (call) != AGGR_INIT_EXPR)
2470 abort ();
2471
2472 for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t))
2473 if (TREE_SIDE_EFFECTS (TREE_VALUE (t)))
2474 {
2475 tree init;
2476 TREE_VALUE (t) = stabilize_expr (TREE_VALUE (t), &init);
2477 if (!init)
2478 /* Nothing. */;
2479 else if (inits)
2480 inits = build (COMPOUND_EXPR, void_type_node, inits, init);
2481 else
2482 inits = init;
2483 }
2484
2485 *initp = inits;
2486}
2487
2488/* Like stabilize_expr, but for an initialization. If we are initializing
2489 an object of class type, we don't want to introduce an extra temporary,
2490 so we look past the TARGET_EXPR and stabilize the arguments of the call
2491 instead. */
2492
2493bool
2494stabilize_init (tree init, tree *initp)
2495{
2496 tree t = init;
2497
2498 if (t == error_mark_node)
2499 return true;
2500
2501 if (TREE_CODE (t) == INIT_EXPR
2502 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2503 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2504 else
2505 {
2506 if (TREE_CODE (t) == INIT_EXPR)
2507 t = TREE_OPERAND (t, 1);
2508 if (TREE_CODE (t) == TARGET_EXPR)
2509 t = TARGET_EXPR_INITIAL (t);
3a327f56
JS
2510 if (TREE_CODE (t) == COMPOUND_EXPR)
2511 t = expr_last (t);
003757ed
MD
2512 if (TREE_CODE (t) == CONSTRUCTOR
2513 && CONSTRUCTOR_ELTS (t) == NULL_TREE)
2514 {
2515 /* Default-initialization. */
2516 *initp = NULL_TREE;
2517 return true;
2518 }
2519
2520 /* If the initializer is a COND_EXPR, we can't preevaluate
2521 anything. */
2522 if (TREE_CODE (t) == COND_EXPR)
2523 return false;
2524
1c1138ce
JS
2525 /* The TARGET_EXPR might be initializing via bitwise copy from
2526 another variable; leave that alone. */
2527 if (TREE_SIDE_EFFECTS (t))
2528 stabilize_call (t, initp);
003757ed
MD
2529 }
2530
2531 return true;
2532}
2533
1c1138ce
JS
2534/* Like "fold", but should be used whenever we might be processing the
2535 body of a template. */
2536
2537tree
2538fold_if_not_in_template (tree expr)
2539{
2540 /* In the body of a template, there is never any need to call
2541 "fold". We will call fold later when actually instantiating the
2542 template. Integral constant expressions in templates will be
2543 evaluated via fold_non_dependent_expr, as necessary. */
2544 return (processing_template_decl ? expr : fold (expr));
2545}
2546
003757ed
MD
2547\f
2548#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2549/* Complain that some language-specific thing hanging off a tree
2550 node has been accessed improperly. */
2551
2552void
2553lang_check_failed (const char* file, int line, const char* function)
2554{
2555 internal_error ("lang_* check: failed in %s, at %s:%d",
2556 function, trim_filename (file), line);
2557}
2558#endif /* ENABLE_TREE_CHECKING */
2559
2560#include "gt-cp-tree.h"