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, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC 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)
11 any later version.
12
13 GCC 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.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, 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
38 static tree bot_manip (tree *, int *, void *);
39 static tree bot_replace (tree *, int *, void *);
40 static tree build_cplus_array_type_1 (tree, tree);
41 static int list_hash_eq (const void *, const void *);
42 static hashval_t list_hash_pieces (tree, tree, tree);
43 static hashval_t list_hash (const void *);
44 static cp_lvalue_kind lvalue_p_1 (tree, int);
45 static tree no_linkage_helper (tree *, int *, void *);
46 static tree mark_local_for_remap_r (tree *, int *, void *);
47 static tree cp_unsave_r (tree *, int *, void *);
48 static tree build_target_expr (tree, tree);
49 static tree count_trees_r (tree *, int *, void *);
50 static tree verify_stmt_tree_r (tree *, int *, void *);
51 static tree find_tree_r (tree *, int *, void *);
52 static tree build_local_temp (tree);
53
54 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
55 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
56 static 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
62 static cp_lvalue_kind
lvalue_p_1(tree ref,int treat_class_rvalues_as_lvalues)63 lvalue_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
201 cp_lvalue_kind
real_lvalue_p(tree ref)202 real_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
211 int
lvalue_p(tree ref)212 lvalue_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
221 int
lvalue_or_else(tree ref,const char * string)222 lvalue_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
234 static tree
build_target_expr(tree decl,tree value)235 build_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
253 static tree
build_local_temp(tree type)254 build_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
270 tree
build_cplus_new(tree type,tree init)271 build_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
320 tree
build_target_expr_with_type(tree init,tree type)321 build_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
346 tree
force_target_expr(tree type,tree init)347 force_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
355 tree
get_target_expr(tree init)356 get_target_expr (tree init)
357 {
358 return build_target_expr_with_type (init, TREE_TYPE (init));
359 }
360
361
362 static tree
build_cplus_array_type_1(tree elt_type,tree index_type)363 build_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
390 tree
build_cplus_array_type(tree elt_type,tree index_type)391 build_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
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
427 tree
cp_build_qualified_type_real(tree type,int type_quals,tsubst_flags_t complain)428 cp_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;
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);
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;
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;
527 if (bad_quals)
528 {
529 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
530
531 if (!(complain & tf_ignore_bad_quals))
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
557 tree
canonical_type_variant(tree t)558 canonical_type_variant (tree t)
559 {
560 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));
561 }
562
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
577 tree
copy_base_binfos(tree binfo,tree t,tree prev)578 copy_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
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
649 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
650
651 struct 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
661 static int
list_hash_eq(const void * entry,const void * data)662 list_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
676 static hashval_t
list_hash_pieces(tree purpose,tree value,tree chain)677 list_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
697 static hashval_t
list_hash(const void * p)698 list_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
710 tree
hash_tree_cons(tree purpose,tree value,tree chain)711 hash_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
735 tree
hash_tree_chain(tree value,tree chain)736 hash_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
743 tree
hash_chainon(tree list1,tree list2)744 hash_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
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
771 tree
make_binfo(tree offset,tree binfo,tree vtable,tree virtuals)772 make_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
804 void
debug_binfo(tree elem)805 debug_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
835 int
count_functions(tree t)836 count_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
852 int
is_overloaded_fn(tree x)853 is_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
866 int
really_overloaded_fn(tree x)867 really_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
880 tree
get_first_fn(tree from)881 get_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
893 int
bound_pmf_p(tree t)894 bound_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
902 tree
ovl_cons(tree decl,tree chain)903 ovl_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
916 tree
build_overload(tree decl,tree chain)917 build_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
927 #define PRINT_RING_SIZE 4
928
929 const char *
cxx_printable_name(tree decl,int v)930 cxx_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
970 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
971 listed in RAISES. */
972
973 tree
build_exception_variant(tree type,tree raises)974 build_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
995 tree
bind_template_template_parm(tree t,tree newargs)996 bind_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
1022 static tree
count_trees_r(tree * tp ATTRIBUTE_UNUSED,int * walk_subtrees ATTRIBUTE_UNUSED,void * data)1023 count_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
1034 int
count_trees(tree t)1035 count_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
1044 static tree
verify_stmt_tree_r(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,void * data)1045 verify_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
1071 void
verify_stmt_tree(tree t)1072 verify_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
1082 static tree
find_tree_r(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,void * data)1083 find_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
1095 tree
find_tree(tree t,tree x)1096 find_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
1103 static tree
no_linkage_helper(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED)1104 no_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
1121 tree
no_linkage_check(tree t)1122 no_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
1136 extern int depth_reached;
1137 #endif
1138
1139 void
cxx_print_statistics(void)1140 cxx_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
1154 tree
array_type_nelts_top(tree type)1155 array_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
1166 tree
array_type_nelts_total(tree type)1167 array_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
1182 static tree
bot_manip(tree * tp,int * walk_subtrees,void * data)1183 bot_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
1236 static tree
bot_replace(tree * t,int * walk_subtrees ATTRIBUTE_UNUSED,void * data)1237 bot_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
1259 tree
break_out_target_exprs(tree t)1260 break_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
1284 tree
build_min_nt(enum tree_code code,...)1285 build_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
1310 tree
build_min(enum tree_code code,tree tt,...)1311 build_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
1341 tree
build_min_non_dep(enum tree_code code,tree non_dep,...)1342 build_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
1377 static GTY(()) tree shared_int_cache[256];
1378
1379 tree
build_shared_int_cst(int i)1380 build_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
1391 tree
get_type_decl(tree t)1392 get_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
1410 tree
vec_binfo_member(tree elem,tree vec)1411 vec_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
1426 tree
decl_namespace_context(tree decl)1427 decl_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
1443 bool
cp_tree_equal(tree t1,tree t2)1444 cp_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
1549 case TEMPLATE_PARM_INDEX:
1550 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1551 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1552 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1553 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1554
1555 case TEMPLATE_ID_EXPR:
1556 {
1557 unsigned ix;
1558 tree vec1, vec2;
1559
1560 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1561 return false;
1562 vec1 = TREE_OPERAND (t1, 1);
1563 vec2 = TREE_OPERAND (t2, 1);
1564
1565 if (!vec1 || !vec2)
1566 return !vec1 && !vec2;
1567
1568 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1569 return false;
1570
1571 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1572 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1573 TREE_VEC_ELT (vec2, ix)))
1574 return false;
1575
1576 return true;
1577 }
1578
1579 case SIZEOF_EXPR:
1580 case ALIGNOF_EXPR:
1581 {
1582 tree o1 = TREE_OPERAND (t1, 0);
1583 tree o2 = TREE_OPERAND (t2, 0);
1584
1585 if (TREE_CODE (o1) != TREE_CODE (o2))
1586 return false;
1587 if (TYPE_P (o1))
1588 return same_type_p (o1, o2);
1589 else
1590 return cp_tree_equal (o1, o2);
1591 }
1592
1593 case PTRMEM_CST:
1594 /* Two pointer-to-members are the same if they point to the same
1595 field or function in the same class. */
1596 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1597 return false;
1598
1599 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1600
1601 default:
1602 break;
1603 }
1604
1605 switch (TREE_CODE_CLASS (code1))
1606 {
1607 case '1':
1608 case '2':
1609 case '<':
1610 case 'e':
1611 case 'r':
1612 case 's':
1613 {
1614 int i;
1615
1616 for (i = 0; i < TREE_CODE_LENGTH (code1); ++i)
1617 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1618 return false;
1619
1620 return true;
1621 }
1622
1623 case 't':
1624 return same_type_p (t1, t2);
1625 }
1626
1627 my_friendly_assert (0, 20030617);
1628 return false;
1629 }
1630
1631 /* Build a wrapper around a 'struct z_candidate' so we can use it as a
1632 tree. */
1633
1634 tree
build_zc_wrapper(struct z_candidate * ptr)1635 build_zc_wrapper (struct z_candidate* ptr)
1636 {
1637 tree t = make_node (WRAPPER);
1638 WRAPPER_ZC (t) = ptr;
1639 return t;
1640 }
1641
1642 /* The type of ARG when used as an lvalue. */
1643
1644 tree
lvalue_type(tree arg)1645 lvalue_type (tree arg)
1646 {
1647 tree type = TREE_TYPE (arg);
1648 return type;
1649 }
1650
1651 /* The type of ARG for printing error messages; denote lvalues with
1652 reference types. */
1653
1654 tree
error_type(tree arg)1655 error_type (tree arg)
1656 {
1657 tree type = TREE_TYPE (arg);
1658
1659 if (TREE_CODE (type) == ARRAY_TYPE)
1660 ;
1661 else if (TREE_CODE (type) == ERROR_MARK)
1662 ;
1663 else if (real_lvalue_p (arg))
1664 type = build_reference_type (lvalue_type (arg));
1665 else if (IS_AGGR_TYPE (type))
1666 type = lvalue_type (arg);
1667
1668 return type;
1669 }
1670
1671 /* Does FUNCTION use a variable-length argument list? */
1672
1673 int
varargs_function_p(tree function)1674 varargs_function_p (tree function)
1675 {
1676 tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1677 for (; parm; parm = TREE_CHAIN (parm))
1678 if (TREE_VALUE (parm) == void_type_node)
1679 return 0;
1680 return 1;
1681 }
1682
1683 /* Returns 1 if decl is a member of a class. */
1684
1685 int
member_p(tree decl)1686 member_p (tree decl)
1687 {
1688 const tree ctx = DECL_CONTEXT (decl);
1689 return (ctx && TYPE_P (ctx));
1690 }
1691
1692 /* Create a placeholder for member access where we don't actually have an
1693 object that the access is against. */
1694
1695 tree
build_dummy_object(tree type)1696 build_dummy_object (tree type)
1697 {
1698 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1699 return build_indirect_ref (decl, NULL);
1700 }
1701
1702 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
1703 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
1704 binfo path from current_class_type to TYPE, or 0. */
1705
1706 tree
maybe_dummy_object(tree type,tree * binfop)1707 maybe_dummy_object (tree type, tree* binfop)
1708 {
1709 tree decl, context;
1710 tree binfo;
1711
1712 if (current_class_type
1713 && (binfo = lookup_base (current_class_type, type,
1714 ba_ignore | ba_quiet, NULL)))
1715 context = current_class_type;
1716 else
1717 {
1718 /* Reference from a nested class member function. */
1719 context = type;
1720 binfo = TYPE_BINFO (type);
1721 }
1722
1723 if (binfop)
1724 *binfop = binfo;
1725
1726 if (current_class_ref && context == current_class_type
1727 /* Kludge: Make sure that current_class_type is actually
1728 correct. It might not be if we're in the middle of
1729 tsubst_default_argument. */
1730 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1731 current_class_type))
1732 decl = current_class_ref;
1733 else
1734 decl = build_dummy_object (context);
1735
1736 return decl;
1737 }
1738
1739 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
1740
1741 int
is_dummy_object(tree ob)1742 is_dummy_object (tree ob)
1743 {
1744 if (TREE_CODE (ob) == INDIRECT_REF)
1745 ob = TREE_OPERAND (ob, 0);
1746 return (TREE_CODE (ob) == NOP_EXPR
1747 && TREE_OPERAND (ob, 0) == void_zero_node);
1748 }
1749
1750 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
1751
1752 int
pod_type_p(tree t)1753 pod_type_p (tree t)
1754 {
1755 t = strip_array_types (t);
1756
1757 if (t == error_mark_node)
1758 return 1;
1759 if (INTEGRAL_TYPE_P (t))
1760 return 1; /* integral, character or enumeral type */
1761 if (FLOAT_TYPE_P (t))
1762 return 1;
1763 if (TYPE_PTR_P (t))
1764 return 1; /* pointer to non-member */
1765 if (TYPE_PTR_TO_MEMBER_P (t))
1766 return 1; /* pointer to member */
1767 if (TREE_CODE (t) == VECTOR_TYPE)
1768 return 1; /* vectors are (small) arrays of scalars */
1769
1770 if (! CLASS_TYPE_P (t))
1771 return 0; /* other non-class type (reference or function) */
1772 if (CLASSTYPE_NON_POD_P (t))
1773 return 0;
1774 return 1;
1775 }
1776
1777 /* Returns 1 iff zero initialization of type T means actually storing
1778 zeros in it. */
1779
1780 int
zero_init_p(tree t)1781 zero_init_p (tree t)
1782 {
1783 t = strip_array_types (t);
1784
1785 if (t == error_mark_node)
1786 return 1;
1787
1788 /* NULL pointers to data members are initialized with -1. */
1789 if (TYPE_PTRMEM_P (t))
1790 return 0;
1791
1792 /* Classes that contain types that can't be zero-initialized, cannot
1793 be zero-initialized themselves. */
1794 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
1795 return 0;
1796
1797 return 1;
1798 }
1799
1800 /* Table of valid C++ attributes. */
1801 const struct attribute_spec cxx_attribute_table[] =
1802 {
1803 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1804 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
1805 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
1806 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
1807 { NULL, 0, 0, false, false, false, NULL }
1808 };
1809
1810 /* Handle a "java_interface" attribute; arguments as in
1811 struct attribute_spec.handler. */
1812 static tree
handle_java_interface_attribute(tree * node,tree name,tree args ATTRIBUTE_UNUSED,int flags,bool * no_add_attrs)1813 handle_java_interface_attribute (tree* node,
1814 tree name,
1815 tree args ATTRIBUTE_UNUSED ,
1816 int flags,
1817 bool* no_add_attrs)
1818 {
1819 if (DECL_P (*node)
1820 || !CLASS_TYPE_P (*node)
1821 || !TYPE_FOR_JAVA (*node))
1822 {
1823 error ("`%s' attribute can only be applied to Java class definitions",
1824 IDENTIFIER_POINTER (name));
1825 *no_add_attrs = true;
1826 return NULL_TREE;
1827 }
1828 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
1829 *node = build_type_copy (*node);
1830 TYPE_JAVA_INTERFACE (*node) = 1;
1831
1832 return NULL_TREE;
1833 }
1834
1835 /* Handle a "com_interface" attribute; arguments as in
1836 struct attribute_spec.handler. */
1837 static tree
handle_com_interface_attribute(tree * node,tree name,tree args ATTRIBUTE_UNUSED,int flags ATTRIBUTE_UNUSED,bool * no_add_attrs)1838 handle_com_interface_attribute (tree* node,
1839 tree name,
1840 tree args ATTRIBUTE_UNUSED ,
1841 int flags ATTRIBUTE_UNUSED ,
1842 bool* no_add_attrs)
1843 {
1844 static int warned;
1845
1846 *no_add_attrs = true;
1847
1848 if (DECL_P (*node)
1849 || !CLASS_TYPE_P (*node)
1850 || *node != TYPE_MAIN_VARIANT (*node))
1851 {
1852 warning ("`%s' attribute can only be applied to class definitions",
1853 IDENTIFIER_POINTER (name));
1854 return NULL_TREE;
1855 }
1856
1857 if (!warned++)
1858 warning ("`%s' is obsolete; g++ vtables are now COM-compatible by default",
1859 IDENTIFIER_POINTER (name));
1860
1861 return NULL_TREE;
1862 }
1863
1864 /* Handle an "init_priority" attribute; arguments as in
1865 struct attribute_spec.handler. */
1866 static tree
handle_init_priority_attribute(tree * node,tree name,tree args,int flags ATTRIBUTE_UNUSED,bool * no_add_attrs)1867 handle_init_priority_attribute (tree* node,
1868 tree name,
1869 tree args,
1870 int flags ATTRIBUTE_UNUSED ,
1871 bool* no_add_attrs)
1872 {
1873 tree initp_expr = TREE_VALUE (args);
1874 tree decl = *node;
1875 tree type = TREE_TYPE (decl);
1876 int pri;
1877
1878 STRIP_NOPS (initp_expr);
1879
1880 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
1881 {
1882 error ("requested init_priority is not an integer constant");
1883 *no_add_attrs = true;
1884 return NULL_TREE;
1885 }
1886
1887 pri = TREE_INT_CST_LOW (initp_expr);
1888
1889 type = strip_array_types (type);
1890
1891 if (decl == NULL_TREE
1892 || TREE_CODE (decl) != VAR_DECL
1893 || !TREE_STATIC (decl)
1894 || DECL_EXTERNAL (decl)
1895 || (TREE_CODE (type) != RECORD_TYPE
1896 && TREE_CODE (type) != UNION_TYPE)
1897 /* Static objects in functions are initialized the
1898 first time control passes through that
1899 function. This is not precise enough to pin down an
1900 init_priority value, so don't allow it. */
1901 || current_function_decl)
1902 {
1903 error ("can only use `%s' attribute on file-scope definitions of objects of class type",
1904 IDENTIFIER_POINTER (name));
1905 *no_add_attrs = true;
1906 return NULL_TREE;
1907 }
1908
1909 if (pri > MAX_INIT_PRIORITY || pri <= 0)
1910 {
1911 error ("requested init_priority is out of range");
1912 *no_add_attrs = true;
1913 return NULL_TREE;
1914 }
1915
1916 /* Check for init_priorities that are reserved for
1917 language and runtime support implementations.*/
1918 if (pri <= MAX_RESERVED_INIT_PRIORITY)
1919 {
1920 warning
1921 ("requested init_priority is reserved for internal use");
1922 }
1923
1924 if (SUPPORTS_INIT_PRIORITY)
1925 {
1926 DECL_INIT_PRIORITY (decl) = pri;
1927 return NULL_TREE;
1928 }
1929 else
1930 {
1931 error ("`%s' attribute is not supported on this platform",
1932 IDENTIFIER_POINTER (name));
1933 *no_add_attrs = true;
1934 return NULL_TREE;
1935 }
1936 }
1937
1938 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
1939 thing pointed to by the constant. */
1940
1941 tree
make_ptrmem_cst(tree type,tree member)1942 make_ptrmem_cst (tree type, tree member)
1943 {
1944 tree ptrmem_cst = make_node (PTRMEM_CST);
1945 /* If would seem a great convenience if make_node would set
1946 TREE_CONSTANT for things of class `c', but it does not. */
1947 TREE_CONSTANT (ptrmem_cst) = 1;
1948 TREE_TYPE (ptrmem_cst) = type;
1949 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
1950 return ptrmem_cst;
1951 }
1952
1953 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
1954 return an existing type of an appropriate type already exists. */
1955
1956 tree
cp_build_type_attribute_variant(tree type,tree attributes)1957 cp_build_type_attribute_variant (tree type, tree attributes)
1958 {
1959 tree new_type;
1960
1961 new_type = build_type_attribute_variant (type, attributes);
1962 if (TREE_CODE (new_type) == FUNCTION_TYPE
1963 && (TYPE_RAISES_EXCEPTIONS (new_type)
1964 != TYPE_RAISES_EXCEPTIONS (type)))
1965 new_type = build_exception_variant (new_type,
1966 TYPE_RAISES_EXCEPTIONS (type));
1967 return new_type;
1968 }
1969
1970 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
1971 traversal. Called from walk_tree(). */
1972
1973 tree
cp_walk_subtrees(tree * tp,int * walk_subtrees_p,walk_tree_fn func,void * data,void * htab)1974 cp_walk_subtrees (tree* tp,
1975 int* walk_subtrees_p,
1976 walk_tree_fn func,
1977 void* data,
1978 void* htab)
1979 {
1980 enum tree_code code = TREE_CODE (*tp);
1981 tree result;
1982
1983 #define WALK_SUBTREE(NODE) \
1984 do \
1985 { \
1986 result = walk_tree (&(NODE), func, data, htab); \
1987 if (result) \
1988 return result; \
1989 } \
1990 while (0)
1991
1992 /* Not one of the easy cases. We must explicitly go through the
1993 children. */
1994 switch (code)
1995 {
1996 case DEFAULT_ARG:
1997 case TEMPLATE_TEMPLATE_PARM:
1998 case BOUND_TEMPLATE_TEMPLATE_PARM:
1999 case UNBOUND_CLASS_TEMPLATE:
2000 case TEMPLATE_PARM_INDEX:
2001 case TEMPLATE_TYPE_PARM:
2002 case TYPENAME_TYPE:
2003 case TYPEOF_TYPE:
2004 case BASELINK:
2005 /* None of these have subtrees other than those already walked
2006 above. */
2007 *walk_subtrees_p = 0;
2008 break;
2009
2010 case PTRMEM_CST:
2011 WALK_SUBTREE (TREE_TYPE (*tp));
2012 *walk_subtrees_p = 0;
2013 break;
2014
2015 case TREE_LIST:
2016 WALK_SUBTREE (TREE_PURPOSE (*tp));
2017 break;
2018
2019 case OVERLOAD:
2020 WALK_SUBTREE (OVL_FUNCTION (*tp));
2021 WALK_SUBTREE (OVL_CHAIN (*tp));
2022 *walk_subtrees_p = 0;
2023 break;
2024
2025 case RECORD_TYPE:
2026 if (TYPE_PTRMEMFUNC_P (*tp))
2027 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2028 break;
2029
2030 default:
2031 break;
2032 }
2033
2034 /* We didn't find what we were looking for. */
2035 return NULL_TREE;
2036
2037 #undef WALK_SUBTREE
2038 }
2039
2040 /* Decide whether there are language-specific reasons to not inline a
2041 function as a tree. */
2042
2043 int
cp_cannot_inline_tree_fn(tree * fnp)2044 cp_cannot_inline_tree_fn (tree* fnp)
2045 {
2046 tree fn = *fnp;
2047
2048 /* We can inline a template instantiation only if it's fully
2049 instantiated. */
2050 if (DECL_TEMPLATE_INFO (fn)
2051 && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2052 {
2053 /* Don't instantiate functions that are not going to be
2054 inlined. */
2055 if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2056 (template_for_substitution (fn))))
2057 return 1;
2058
2059 fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0);
2060
2061 if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2062 return 1;
2063 }
2064
2065 if (flag_really_no_inline
2066 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2067 return 1;
2068
2069 /* Don't auto-inline anything that might not be bound within
2070 this unit of translation. */
2071 if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
2072 {
2073 DECL_UNINLINABLE (fn) = 1;
2074 return 1;
2075 }
2076
2077 if (varargs_function_p (fn))
2078 {
2079 DECL_UNINLINABLE (fn) = 1;
2080 return 1;
2081 }
2082
2083 if (! function_attribute_inlinable_p (fn))
2084 {
2085 DECL_UNINLINABLE (fn) = 1;
2086 return 1;
2087 }
2088
2089 return 0;
2090 }
2091
2092 /* Add any pending functions other than the current function (already
2093 handled by the caller), that thus cannot be inlined, to FNS_P, then
2094 return the latest function added to the array, PREV_FN. */
2095
2096 tree
cp_add_pending_fn_decls(void * fns_p,tree prev_fn)2097 cp_add_pending_fn_decls (void* fns_p, tree prev_fn)
2098 {
2099 varray_type *fnsp = (varray_type *)fns_p;
2100 struct saved_scope *s;
2101
2102 for (s = scope_chain; s; s = s->prev)
2103 if (s->function_decl && s->function_decl != prev_fn)
2104 {
2105 VARRAY_PUSH_TREE (*fnsp, s->function_decl);
2106 prev_fn = s->function_decl;
2107 }
2108
2109 return prev_fn;
2110 }
2111
2112 /* Determine whether a tree node is an OVERLOAD node. Used to decide
2113 whether to copy a node or to preserve its chain when inlining a
2114 function. */
2115
2116 int
cp_is_overload_p(tree t)2117 cp_is_overload_p (tree t)
2118 {
2119 return TREE_CODE (t) == OVERLOAD;
2120 }
2121
2122 /* Determine whether VAR is a declaration of an automatic variable in
2123 function FN. */
2124
2125 int
cp_auto_var_in_fn_p(tree var,tree fn)2126 cp_auto_var_in_fn_p (tree var, tree fn)
2127 {
2128 return (DECL_P (var) && DECL_CONTEXT (var) == fn
2129 && nonstatic_local_decl_p (var));
2130 }
2131
2132 /* Tell whether a declaration is needed for the RESULT of a function
2133 FN being inlined into CALLER or if the top node of target_exprs is
2134 to be used. */
2135
2136 tree
cp_copy_res_decl_for_inlining(tree result,tree fn,tree caller,void * decl_map_,int * need_decl,tree return_slot_addr)2137 cp_copy_res_decl_for_inlining (tree result,
2138 tree fn,
2139 tree caller,
2140 void* decl_map_,
2141 int* need_decl,
2142 tree return_slot_addr)
2143 {
2144 splay_tree decl_map = (splay_tree)decl_map_;
2145 tree var;
2146
2147 /* If FN returns an aggregate then the caller will always pass the
2148 address of the return slot explicitly. If we were just to
2149 create a new VAR_DECL here, then the result of this function
2150 would be copied (bitwise) into the variable initialized by the
2151 TARGET_EXPR. That's incorrect, so we must transform any
2152 references to the RESULT into references to the target. */
2153
2154 /* We should have an explicit return slot iff the return type is
2155 TREE_ADDRESSABLE. See simplify_aggr_init_expr. */
2156 if (TREE_ADDRESSABLE (TREE_TYPE (result))
2157 != (return_slot_addr != NULL_TREE))
2158 abort ();
2159
2160 *need_decl = !return_slot_addr;
2161 if (return_slot_addr)
2162 {
2163 var = build_indirect_ref (return_slot_addr, "");
2164 if (! same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var),
2165 TREE_TYPE (result)))
2166 abort ();
2167 }
2168 /* Otherwise, make an appropriate copy. */
2169 else
2170 var = copy_decl_for_inlining (result, fn, caller);
2171
2172 if (DECL_SAVED_FUNCTION_DATA (fn))
2173 {
2174 tree nrv = DECL_SAVED_FUNCTION_DATA (fn)->x_return_value;
2175 if (nrv)
2176 {
2177 /* We have a named return value; copy the name and source
2178 position so we can get reasonable debugging information, and
2179 register the return variable as its equivalent. */
2180 if (TREE_CODE (var) == VAR_DECL
2181 /* But not if we're initializing a variable from the
2182 enclosing function which already has its own name. */
2183 && DECL_NAME (var) == NULL_TREE)
2184 {
2185 DECL_NAME (var) = DECL_NAME (nrv);
2186 DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (nrv);
2187 DECL_ABSTRACT_ORIGIN (var) = DECL_ORIGIN (nrv);
2188 /* Don't lose initialization info. */
2189 DECL_INITIAL (var) = DECL_INITIAL (nrv);
2190 /* Don't forget that it needs to go in the stack. */
2191 TREE_ADDRESSABLE (var) = TREE_ADDRESSABLE (nrv);
2192 }
2193
2194 splay_tree_insert (decl_map,
2195 (splay_tree_key) nrv,
2196 (splay_tree_value) var);
2197 }
2198 }
2199
2200 return var;
2201 }
2202
2203 /* Initialize tree.c. */
2204
2205 void
init_tree(void)2206 init_tree (void)
2207 {
2208 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2209 }
2210
2211 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2212 declaration, copies the declaration and enters it in the splay_tree
2213 pointed to by DATA (which is really a `splay_tree *'). */
2214
2215 static tree
mark_local_for_remap_r(tree * tp,int * walk_subtrees ATTRIBUTE_UNUSED,void * data)2216 mark_local_for_remap_r (tree* tp,
2217 int* walk_subtrees ATTRIBUTE_UNUSED ,
2218 void* data)
2219 {
2220 tree t = *tp;
2221 splay_tree st = (splay_tree) data;
2222 tree decl;
2223
2224
2225 if (TREE_CODE (t) == DECL_STMT
2226 && nonstatic_local_decl_p (DECL_STMT_DECL (t)))
2227 decl = DECL_STMT_DECL (t);
2228 else if (TREE_CODE (t) == LABEL_STMT)
2229 decl = LABEL_STMT_LABEL (t);
2230 else if (TREE_CODE (t) == TARGET_EXPR
2231 && nonstatic_local_decl_p (TREE_OPERAND (t, 0)))
2232 decl = TREE_OPERAND (t, 0);
2233 else if (TREE_CODE (t) == CASE_LABEL)
2234 decl = CASE_LABEL_DECL (t);
2235 else
2236 decl = NULL_TREE;
2237
2238 if (decl)
2239 {
2240 tree copy;
2241
2242 /* Make a copy. */
2243 copy = copy_decl_for_inlining (decl,
2244 DECL_CONTEXT (decl),
2245 DECL_CONTEXT (decl));
2246
2247 /* Remember the copy. */
2248 splay_tree_insert (st,
2249 (splay_tree_key) decl,
2250 (splay_tree_value) copy);
2251 }
2252
2253 return NULL_TREE;
2254 }
2255
2256 /* Called via walk_tree when an expression is unsaved. Using the
2257 splay_tree pointed to by ST (which is really a `splay_tree'),
2258 remaps all local declarations to appropriate replacements. */
2259
2260 static tree
cp_unsave_r(tree * tp,int * walk_subtrees,void * data)2261 cp_unsave_r (tree* tp,
2262 int* walk_subtrees,
2263 void* data)
2264 {
2265 splay_tree st = (splay_tree) data;
2266 splay_tree_node n;
2267
2268 /* Only a local declaration (variable or label). */
2269 if (nonstatic_local_decl_p (*tp))
2270 {
2271 /* Lookup the declaration. */
2272 n = splay_tree_lookup (st, (splay_tree_key) *tp);
2273
2274 /* If it's there, remap it. */
2275 if (n)
2276 *tp = (tree) n->value;
2277 }
2278 else if (TREE_CODE (*tp) == SAVE_EXPR)
2279 remap_save_expr (tp, st, current_function_decl, walk_subtrees);
2280 else
2281 {
2282 copy_tree_r (tp, walk_subtrees, NULL);
2283
2284 /* Do whatever unsaving is required. */
2285 unsave_expr_1 (*tp);
2286 }
2287
2288 /* Keep iterating. */
2289 return NULL_TREE;
2290 }
2291
2292 /* Called whenever an expression needs to be unsaved. */
2293
2294 tree
cxx_unsave_expr_now(tree tp)2295 cxx_unsave_expr_now (tree tp)
2296 {
2297 splay_tree st;
2298
2299 /* Create a splay-tree to map old local variable declarations to new
2300 ones. */
2301 st = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2302
2303 /* Walk the tree once figuring out what needs to be remapped. */
2304 walk_tree (&tp, mark_local_for_remap_r, st, NULL);
2305
2306 /* Walk the tree again, copying, remapping, and unsaving. */
2307 walk_tree (&tp, cp_unsave_r, st, NULL);
2308
2309 /* Clean up. */
2310 splay_tree_delete (st);
2311
2312 return tp;
2313 }
2314
2315 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2316 is. Note that sfk_none is zero, so this function can be used as a
2317 predicate to test whether or not DECL is a special function. */
2318
2319 special_function_kind
special_function_p(tree decl)2320 special_function_p (tree decl)
2321 {
2322 /* Rather than doing all this stuff with magic names, we should
2323 probably have a field of type `special_function_kind' in
2324 DECL_LANG_SPECIFIC. */
2325 if (DECL_COPY_CONSTRUCTOR_P (decl))
2326 return sfk_copy_constructor;
2327 if (DECL_CONSTRUCTOR_P (decl))
2328 return sfk_constructor;
2329 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2330 return sfk_assignment_operator;
2331 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2332 return sfk_destructor;
2333 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2334 return sfk_complete_destructor;
2335 if (DECL_BASE_DESTRUCTOR_P (decl))
2336 return sfk_base_destructor;
2337 if (DECL_DELETING_DESTRUCTOR_P (decl))
2338 return sfk_deleting_destructor;
2339 if (DECL_CONV_FN_P (decl))
2340 return sfk_conversion;
2341
2342 return sfk_none;
2343 }
2344
2345 /* Returns true if and only if NODE is a name, i.e., a node created
2346 by the parser when processing an id-expression. */
2347
2348 bool
name_p(tree node)2349 name_p (tree node)
2350 {
2351 if (TREE_CODE (node) == TEMPLATE_ID_EXPR)
2352 node = TREE_OPERAND (node, 0);
2353 return (/* An ordinary unqualified name. */
2354 TREE_CODE (node) == IDENTIFIER_NODE
2355 /* A destructor name. */
2356 || TREE_CODE (node) == BIT_NOT_EXPR
2357 /* A qualified name. */
2358 || TREE_CODE (node) == SCOPE_REF);
2359 }
2360
2361 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2362
2363 int
char_type_p(tree type)2364 char_type_p (tree type)
2365 {
2366 return (same_type_p (type, char_type_node)
2367 || same_type_p (type, unsigned_char_type_node)
2368 || same_type_p (type, signed_char_type_node)
2369 || same_type_p (type, wchar_type_node));
2370 }
2371
2372 /* Returns the kind of linkage associated with the indicated DECL. Th
2373 value returned is as specified by the language standard; it is
2374 independent of implementation details regarding template
2375 instantiation, etc. For example, it is possible that a declaration
2376 to which this function assigns external linkage would not show up
2377 as a global symbol when you run `nm' on the resulting object file. */
2378
2379 linkage_kind
decl_linkage(tree decl)2380 decl_linkage (tree decl)
2381 {
2382 /* This function doesn't attempt to calculate the linkage from first
2383 principles as given in [basic.link]. Instead, it makes use of
2384 the fact that we have already set TREE_PUBLIC appropriately, and
2385 then handles a few special cases. Ideally, we would calculate
2386 linkage first, and then transform that into a concrete
2387 implementation. */
2388
2389 /* Things that don't have names have no linkage. */
2390 if (!DECL_NAME (decl))
2391 return lk_none;
2392
2393 /* Things that are TREE_PUBLIC have external linkage. */
2394 if (TREE_PUBLIC (decl))
2395 return lk_external;
2396
2397 /* Some things that are not TREE_PUBLIC have external linkage, too.
2398 For example, on targets that don't have weak symbols, we make all
2399 template instantiations have internal linkage (in the object
2400 file), but the symbols should still be treated as having external
2401 linkage from the point of view of the language. */
2402 if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
2403 return lk_external;
2404
2405 /* Things in local scope do not have linkage, if they don't have
2406 TREE_PUBLIC set. */
2407 if (decl_function_context (decl))
2408 return lk_none;
2409
2410 /* Everything else has internal linkage. */
2411 return lk_internal;
2412 }
2413
2414 /* EXP is an expression that we want to pre-evaluate. Returns via INITP an
2415 expression to perform the pre-evaluation, and returns directly an
2416 expression to use the precalculated result. */
2417
2418 tree
stabilize_expr(tree exp,tree * initp)2419 stabilize_expr (tree exp, tree* initp)
2420 {
2421 tree init_expr;
2422
2423 if (!TREE_SIDE_EFFECTS (exp))
2424 {
2425 init_expr = NULL_TREE;
2426 }
2427 else if (!real_lvalue_p (exp)
2428 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2429 {
2430 init_expr = get_target_expr (exp);
2431 exp = TARGET_EXPR_SLOT (init_expr);
2432 }
2433 else
2434 {
2435 exp = build_unary_op (ADDR_EXPR, exp, 1);
2436 init_expr = get_target_expr (exp);
2437 exp = TARGET_EXPR_SLOT (init_expr);
2438 exp = build_indirect_ref (exp, 0);
2439 }
2440
2441 *initp = init_expr;
2442 return exp;
2443 }
2444
2445 /* Like stabilize_expr, but for a call whose args we want to
2446 pre-evaluate. */
2447
2448 void
stabilize_call(tree call,tree * initp)2449 stabilize_call (tree call, tree *initp)
2450 {
2451 tree inits = NULL_TREE;
2452 tree t;
2453
2454 if (call == error_mark_node)
2455 return;
2456
2457 if (TREE_CODE (call) != CALL_EXPR
2458 && TREE_CODE (call) != AGGR_INIT_EXPR)
2459 abort ();
2460
2461 for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t))
2462 if (TREE_SIDE_EFFECTS (TREE_VALUE (t)))
2463 {
2464 tree init;
2465 TREE_VALUE (t) = stabilize_expr (TREE_VALUE (t), &init);
2466 if (!init)
2467 /* Nothing. */;
2468 else if (inits)
2469 inits = build (COMPOUND_EXPR, void_type_node, inits, init);
2470 else
2471 inits = init;
2472 }
2473
2474 *initp = inits;
2475 }
2476
2477 /* Like stabilize_expr, but for an initialization. If we are initializing
2478 an object of class type, we don't want to introduce an extra temporary,
2479 so we look past the TARGET_EXPR and stabilize the arguments of the call
2480 instead. */
2481
2482 bool
stabilize_init(tree init,tree * initp)2483 stabilize_init (tree init, tree *initp)
2484 {
2485 tree t = init;
2486
2487 if (t == error_mark_node)
2488 return true;
2489
2490 if (TREE_CODE (t) == INIT_EXPR
2491 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2492 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2493 else
2494 {
2495 if (TREE_CODE (t) == INIT_EXPR)
2496 t = TREE_OPERAND (t, 1);
2497 if (TREE_CODE (t) == TARGET_EXPR)
2498 t = TARGET_EXPR_INITIAL (t);
2499 if (TREE_CODE (t) == COMPOUND_EXPR)
2500 t = expr_last (t);
2501 if (TREE_CODE (t) == CONSTRUCTOR
2502 && CONSTRUCTOR_ELTS (t) == NULL_TREE)
2503 {
2504 /* Default-initialization. */
2505 *initp = NULL_TREE;
2506 return true;
2507 }
2508
2509 /* If the initializer is a COND_EXPR, we can't preevaluate
2510 anything. */
2511 if (TREE_CODE (t) == COND_EXPR)
2512 return false;
2513
2514 stabilize_call (t, initp);
2515 }
2516
2517 return true;
2518 }
2519
2520
2521 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2522 /* Complain that some language-specific thing hanging off a tree
2523 node has been accessed improperly. */
2524
2525 void
lang_check_failed(const char * file,int line,const char * function)2526 lang_check_failed (const char* file, int line, const char* function)
2527 {
2528 internal_error ("lang_* check: failed in %s, at %s:%d",
2529 function, trim_filename (file), line);
2530 }
2531 #endif /* ENABLE_TREE_CHECKING */
2532
2533 #include "gt-cp-tree.h"
2534