1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tree.h"
25 #include "cp-tree.h"
26 #include "gimple-expr.h"
27 #include "cgraph.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
32 #include "debug.h"
33 #include "convert.h"
34 #include "gimplify.h"
35 #include "stringpool.h"
36 #include "attribs.h"
37 #include "flags.h"
38 #include "selftest.h"
39
40 static tree bot_manip (tree *, int *, void *);
41 static tree bot_replace (tree *, int *, void *);
42 static hashval_t list_hash_pieces (tree, tree, tree);
43 static tree build_target_expr (tree, tree, tsubst_flags_t);
44 static tree count_trees_r (tree *, int *, void *);
45 static tree verify_stmt_tree_r (tree *, int *, void *);
46 static tree build_local_temp (tree);
47
48 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
50
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52 Otherwise, returns clk_none. */
53
54 cp_lvalue_kind
lvalue_kind(const_tree ref)55 lvalue_kind (const_tree ref)
56 {
57 cp_lvalue_kind op1_lvalue_kind = clk_none;
58 cp_lvalue_kind op2_lvalue_kind = clk_none;
59
60 /* Expressions of reference type are sometimes wrapped in
61 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
62 representation, not part of the language, so we have to look
63 through them. */
64 if (REFERENCE_REF_P (ref))
65 return lvalue_kind (TREE_OPERAND (ref, 0));
66
67 if (TREE_TYPE (ref)
68 && TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
69 {
70 /* unnamed rvalue references are rvalues */
71 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
72 && TREE_CODE (ref) != PARM_DECL
73 && !VAR_P (ref)
74 && TREE_CODE (ref) != COMPONENT_REF
75 /* Functions are always lvalues. */
76 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
77 return clk_rvalueref;
78
79 /* lvalue references and named rvalue references are lvalues. */
80 return clk_ordinary;
81 }
82
83 if (ref == current_class_ptr)
84 return clk_none;
85
86 switch (TREE_CODE (ref))
87 {
88 case SAVE_EXPR:
89 return clk_none;
90 /* preincrements and predecrements are valid lvals, provided
91 what they refer to are valid lvals. */
92 case PREINCREMENT_EXPR:
93 case PREDECREMENT_EXPR:
94 case TRY_CATCH_EXPR:
95 case REALPART_EXPR:
96 case IMAGPART_EXPR:
97 return lvalue_kind (TREE_OPERAND (ref, 0));
98
99 case MEMBER_REF:
100 case DOTSTAR_EXPR:
101 if (TREE_CODE (ref) == MEMBER_REF)
102 op1_lvalue_kind = clk_ordinary;
103 else
104 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
105 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1))))
106 op1_lvalue_kind = clk_none;
107 return op1_lvalue_kind;
108
109 case COMPONENT_REF:
110 if (BASELINK_P (TREE_OPERAND (ref, 1)))
111 {
112 tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1));
113
114 /* For static member function recurse on the BASELINK, we can get
115 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
116 OVERLOAD, the overload is resolved first if possible through
117 resolve_address_of_overloaded_function. */
118 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn))
119 return lvalue_kind (TREE_OPERAND (ref, 1));
120 }
121 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
122 /* Look at the member designator. */
123 if (!op1_lvalue_kind)
124 ;
125 else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
126 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
127 situations. If we're seeing a COMPONENT_REF, it's a non-static
128 member, so it isn't an lvalue. */
129 op1_lvalue_kind = clk_none;
130 else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
131 /* This can be IDENTIFIER_NODE in a template. */;
132 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
133 {
134 /* Clear the ordinary bit. If this object was a class
135 rvalue we want to preserve that information. */
136 op1_lvalue_kind &= ~clk_ordinary;
137 /* The lvalue is for a bitfield. */
138 op1_lvalue_kind |= clk_bitfield;
139 }
140 else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
141 op1_lvalue_kind |= clk_packed;
142
143 return op1_lvalue_kind;
144
145 case STRING_CST:
146 case COMPOUND_LITERAL_EXPR:
147 return clk_ordinary;
148
149 case CONST_DECL:
150 /* CONST_DECL without TREE_STATIC are enumeration values and
151 thus not lvalues. With TREE_STATIC they are used by ObjC++
152 in objc_build_string_object and need to be considered as
153 lvalues. */
154 if (! TREE_STATIC (ref))
155 return clk_none;
156 /* FALLTHRU */
157 case VAR_DECL:
158 if (VAR_P (ref) && DECL_HAS_VALUE_EXPR_P (ref))
159 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref)));
160
161 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
162 && DECL_LANG_SPECIFIC (ref)
163 && DECL_IN_AGGR_P (ref))
164 return clk_none;
165 /* FALLTHRU */
166 case INDIRECT_REF:
167 case ARROW_EXPR:
168 case ARRAY_REF:
169 case PARM_DECL:
170 case RESULT_DECL:
171 case PLACEHOLDER_EXPR:
172 return clk_ordinary;
173
174 /* A scope ref in a template, left as SCOPE_REF to support later
175 access checking. */
176 case SCOPE_REF:
177 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
178 {
179 tree op = TREE_OPERAND (ref, 1);
180 if (TREE_CODE (op) == FIELD_DECL)
181 return (DECL_C_BIT_FIELD (op) ? clk_bitfield : clk_ordinary);
182 else
183 return lvalue_kind (op);
184 }
185
186 case MAX_EXPR:
187 case MIN_EXPR:
188 /* Disallow <? and >? as lvalues if either argument side-effects. */
189 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
190 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
191 return clk_none;
192 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
193 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
194 break;
195
196 case COND_EXPR:
197 if (processing_template_decl)
198 {
199 /* Within templates, a REFERENCE_TYPE will indicate whether
200 the COND_EXPR result is an ordinary lvalue or rvalueref.
201 Since REFERENCE_TYPEs are handled above, if we reach this
202 point, we know we got a plain rvalue. Unless we have a
203 type-dependent expr, that is, but we shouldn't be testing
204 lvalueness if we can't even tell the types yet! */
205 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
206 if (CLASS_TYPE_P (TREE_TYPE (ref))
207 || TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
208 return clk_class;
209 else
210 return clk_none;
211 }
212 op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)
213 ? TREE_OPERAND (ref, 1)
214 : TREE_OPERAND (ref, 0));
215 op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2));
216 break;
217
218 case MODOP_EXPR:
219 /* We expect to see unlowered MODOP_EXPRs only during
220 template processing. */
221 gcc_assert (processing_template_decl);
222 return clk_ordinary;
223
224 case MODIFY_EXPR:
225 case TYPEID_EXPR:
226 return clk_ordinary;
227
228 case COMPOUND_EXPR:
229 return lvalue_kind (TREE_OPERAND (ref, 1));
230
231 case TARGET_EXPR:
232 return clk_class;
233
234 case VA_ARG_EXPR:
235 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
236
237 case CALL_EXPR:
238 /* We can see calls outside of TARGET_EXPR in templates. */
239 if (CLASS_TYPE_P (TREE_TYPE (ref)))
240 return clk_class;
241 return clk_none;
242
243 case FUNCTION_DECL:
244 /* All functions (except non-static-member functions) are
245 lvalues. */
246 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
247 ? clk_none : clk_ordinary);
248
249 case BASELINK:
250 /* We now represent a reference to a single static member function
251 with a BASELINK. */
252 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
253 its argument unmodified and we assign it to a const_tree. */
254 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
255
256 case NON_DEPENDENT_EXPR:
257 case PAREN_EXPR:
258 return lvalue_kind (TREE_OPERAND (ref, 0));
259
260 case VIEW_CONVERT_EXPR:
261 if (location_wrapper_p (ref))
262 return lvalue_kind (TREE_OPERAND (ref, 0));
263 /* Fallthrough. */
264
265 default:
266 if (!TREE_TYPE (ref))
267 return clk_none;
268 if (CLASS_TYPE_P (TREE_TYPE (ref))
269 || TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
270 return clk_class;
271 break;
272 }
273
274 /* If one operand is not an lvalue at all, then this expression is
275 not an lvalue. */
276 if (!op1_lvalue_kind || !op2_lvalue_kind)
277 return clk_none;
278
279 /* Otherwise, it's an lvalue, and it has all the odd properties
280 contributed by either operand. */
281 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
282 /* It's not an ordinary lvalue if it involves any other kind. */
283 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
284 op1_lvalue_kind &= ~clk_ordinary;
285 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
286 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
287 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
288 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
289 op1_lvalue_kind = clk_none;
290 return op1_lvalue_kind;
291 }
292
293 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
294
295 cp_lvalue_kind
real_lvalue_p(const_tree ref)296 real_lvalue_p (const_tree ref)
297 {
298 cp_lvalue_kind kind = lvalue_kind (ref);
299 if (kind & (clk_rvalueref|clk_class))
300 return clk_none;
301 else
302 return kind;
303 }
304
305 /* c-common wants us to return bool. */
306
307 bool
lvalue_p(const_tree t)308 lvalue_p (const_tree t)
309 {
310 return real_lvalue_p (t);
311 }
312
313 /* This differs from lvalue_p in that xvalues are included. */
314
315 bool
glvalue_p(const_tree ref)316 glvalue_p (const_tree ref)
317 {
318 cp_lvalue_kind kind = lvalue_kind (ref);
319 if (kind & clk_class)
320 return false;
321 else
322 return (kind != clk_none);
323 }
324
325 /* This differs from glvalue_p in that class prvalues are included. */
326
327 bool
obvalue_p(const_tree ref)328 obvalue_p (const_tree ref)
329 {
330 return (lvalue_kind (ref) != clk_none);
331 }
332
333 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
334 reference), false otherwise. */
335
336 bool
xvalue_p(const_tree ref)337 xvalue_p (const_tree ref)
338 {
339 return (lvalue_kind (ref) == clk_rvalueref);
340 }
341
342 /* True if REF is a bit-field. */
343
344 bool
bitfield_p(const_tree ref)345 bitfield_p (const_tree ref)
346 {
347 return (lvalue_kind (ref) & clk_bitfield);
348 }
349
350 /* C++-specific version of stabilize_reference. */
351
352 tree
cp_stabilize_reference(tree ref)353 cp_stabilize_reference (tree ref)
354 {
355 switch (TREE_CODE (ref))
356 {
357 case NON_DEPENDENT_EXPR:
358 /* We aren't actually evaluating this. */
359 return ref;
360
361 /* We need to treat specially anything stabilize_reference doesn't
362 handle specifically. */
363 case VAR_DECL:
364 case PARM_DECL:
365 case RESULT_DECL:
366 CASE_CONVERT:
367 case FLOAT_EXPR:
368 case FIX_TRUNC_EXPR:
369 case INDIRECT_REF:
370 case COMPONENT_REF:
371 case BIT_FIELD_REF:
372 case ARRAY_REF:
373 case ARRAY_RANGE_REF:
374 case ERROR_MARK:
375 break;
376 default:
377 cp_lvalue_kind kind = lvalue_kind (ref);
378 if ((kind & ~clk_class) != clk_none)
379 {
380 tree type = unlowered_expr_type (ref);
381 bool rval = !!(kind & clk_rvalueref);
382 type = cp_build_reference_type (type, rval);
383 /* This inhibits warnings in, eg, cxx_mark_addressable
384 (c++/60955). */
385 warning_sentinel s (extra_warnings);
386 ref = build_static_cast (type, ref, tf_error);
387 }
388 }
389
390 return stabilize_reference (ref);
391 }
392
393 /* Test whether DECL is a builtin that may appear in a
394 constant-expression. */
395
396 bool
builtin_valid_in_constant_expr_p(const_tree decl)397 builtin_valid_in_constant_expr_p (const_tree decl)
398 {
399 if (!(TREE_CODE (decl) == FUNCTION_DECL
400 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL))
401 /* Not a built-in. */
402 return false;
403 switch (DECL_FUNCTION_CODE (decl))
404 {
405 /* These always have constant results like the corresponding
406 macros/symbol. */
407 case BUILT_IN_FILE:
408 case BUILT_IN_FUNCTION:
409 case BUILT_IN_LINE:
410
411 /* The following built-ins are valid in constant expressions
412 when their arguments are. */
413 case BUILT_IN_ADD_OVERFLOW_P:
414 case BUILT_IN_SUB_OVERFLOW_P:
415 case BUILT_IN_MUL_OVERFLOW_P:
416
417 /* These have constant results even if their operands are
418 non-constant. */
419 case BUILT_IN_CONSTANT_P:
420 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
421 return true;
422 default:
423 return false;
424 }
425 }
426
427 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
428
429 static tree
build_target_expr(tree decl,tree value,tsubst_flags_t complain)430 build_target_expr (tree decl, tree value, tsubst_flags_t complain)
431 {
432 tree t;
433 tree type = TREE_TYPE (decl);
434
435 value = mark_rvalue_use (value);
436
437 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value))
438 || TREE_TYPE (decl) == TREE_TYPE (value)
439 /* On ARM ctors return 'this'. */
440 || (TYPE_PTR_P (TREE_TYPE (value))
441 && TREE_CODE (value) == CALL_EXPR)
442 || useless_type_conversion_p (TREE_TYPE (decl),
443 TREE_TYPE (value)));
444
445 if (complain & tf_no_cleanup)
446 /* The caller is building a new-expr and does not need a cleanup. */
447 t = NULL_TREE;
448 else
449 {
450 t = cxx_maybe_build_cleanup (decl, complain);
451 if (t == error_mark_node)
452 return error_mark_node;
453 }
454 t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
455 if (EXPR_HAS_LOCATION (value))
456 SET_EXPR_LOCATION (t, EXPR_LOCATION (value));
457 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
458 ignore the TARGET_EXPR. If there really turn out to be no
459 side-effects, then the optimizer should be able to get rid of
460 whatever code is generated anyhow. */
461 TREE_SIDE_EFFECTS (t) = 1;
462
463 return t;
464 }
465
466 /* Return an undeclared local temporary of type TYPE for use in building a
467 TARGET_EXPR. */
468
469 static tree
build_local_temp(tree type)470 build_local_temp (tree type)
471 {
472 tree slot = build_decl (input_location,
473 VAR_DECL, NULL_TREE, type);
474 DECL_ARTIFICIAL (slot) = 1;
475 DECL_IGNORED_P (slot) = 1;
476 DECL_CONTEXT (slot) = current_function_decl;
477 layout_decl (slot, 0);
478 return slot;
479 }
480
481 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
482
483 static void
process_aggr_init_operands(tree t)484 process_aggr_init_operands (tree t)
485 {
486 bool side_effects;
487
488 side_effects = TREE_SIDE_EFFECTS (t);
489 if (!side_effects)
490 {
491 int i, n;
492 n = TREE_OPERAND_LENGTH (t);
493 for (i = 1; i < n; i++)
494 {
495 tree op = TREE_OPERAND (t, i);
496 if (op && TREE_SIDE_EFFECTS (op))
497 {
498 side_effects = 1;
499 break;
500 }
501 }
502 }
503 TREE_SIDE_EFFECTS (t) = side_effects;
504 }
505
506 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
507 FN, and SLOT. NARGS is the number of call arguments which are specified
508 as a tree array ARGS. */
509
510 static tree
build_aggr_init_array(tree return_type,tree fn,tree slot,int nargs,tree * args)511 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
512 tree *args)
513 {
514 tree t;
515 int i;
516
517 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
518 TREE_TYPE (t) = return_type;
519 AGGR_INIT_EXPR_FN (t) = fn;
520 AGGR_INIT_EXPR_SLOT (t) = slot;
521 for (i = 0; i < nargs; i++)
522 AGGR_INIT_EXPR_ARG (t, i) = args[i];
523 process_aggr_init_operands (t);
524 return t;
525 }
526
527 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
528 target. TYPE is the type to be initialized.
529
530 Build an AGGR_INIT_EXPR to represent the initialization. This function
531 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
532 to initialize another object, whereas a TARGET_EXPR can either
533 initialize another object or create its own temporary object, and as a
534 result building up a TARGET_EXPR requires that the type's destructor be
535 callable. */
536
537 tree
build_aggr_init_expr(tree type,tree init)538 build_aggr_init_expr (tree type, tree init)
539 {
540 tree fn;
541 tree slot;
542 tree rval;
543 int is_ctor;
544
545 /* Don't build AGGR_INIT_EXPR in a template. */
546 if (processing_template_decl)
547 return init;
548
549 fn = cp_get_callee (init);
550 if (fn == NULL_TREE)
551 return convert (type, init);
552
553 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
554 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
555 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
556
557 /* We split the CALL_EXPR into its function and its arguments here.
558 Then, in expand_expr, we put them back together. The reason for
559 this is that this expression might be a default argument
560 expression. In that case, we need a new temporary every time the
561 expression is used. That's what break_out_target_exprs does; it
562 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
563 temporary slot. Then, expand_expr builds up a call-expression
564 using the new slot. */
565
566 /* If we don't need to use a constructor to create an object of this
567 type, don't mess with AGGR_INIT_EXPR. */
568 if (is_ctor || TREE_ADDRESSABLE (type))
569 {
570 slot = build_local_temp (type);
571
572 if (TREE_CODE (init) == CALL_EXPR)
573 {
574 rval = build_aggr_init_array (void_type_node, fn, slot,
575 call_expr_nargs (init),
576 CALL_EXPR_ARGP (init));
577 AGGR_INIT_FROM_THUNK_P (rval)
578 = CALL_FROM_THUNK_P (init);
579 }
580 else
581 {
582 rval = build_aggr_init_array (void_type_node, fn, slot,
583 aggr_init_expr_nargs (init),
584 AGGR_INIT_EXPR_ARGP (init));
585 AGGR_INIT_FROM_THUNK_P (rval)
586 = AGGR_INIT_FROM_THUNK_P (init);
587 }
588 TREE_SIDE_EFFECTS (rval) = 1;
589 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
590 TREE_NOTHROW (rval) = TREE_NOTHROW (init);
591 CALL_EXPR_OPERATOR_SYNTAX (rval) = CALL_EXPR_OPERATOR_SYNTAX (init);
592 CALL_EXPR_ORDERED_ARGS (rval) = CALL_EXPR_ORDERED_ARGS (init);
593 CALL_EXPR_REVERSE_ARGS (rval) = CALL_EXPR_REVERSE_ARGS (init);
594 }
595 else
596 rval = init;
597
598 return rval;
599 }
600
601 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
602 target. TYPE is the type that this initialization should appear to
603 have.
604
605 Build an encapsulation of the initialization to perform
606 and return it so that it can be processed by language-independent
607 and language-specific expression expanders. */
608
609 tree
build_cplus_new(tree type,tree init,tsubst_flags_t complain)610 build_cplus_new (tree type, tree init, tsubst_flags_t complain)
611 {
612 tree rval = build_aggr_init_expr (type, init);
613 tree slot;
614
615 if (!complete_type_or_maybe_complain (type, init, complain))
616 return error_mark_node;
617
618 /* Make sure that we're not trying to create an instance of an
619 abstract class. */
620 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
621 return error_mark_node;
622
623 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
624 slot = AGGR_INIT_EXPR_SLOT (rval);
625 else if (TREE_CODE (rval) == CALL_EXPR
626 || TREE_CODE (rval) == CONSTRUCTOR)
627 slot = build_local_temp (type);
628 else
629 return rval;
630
631 rval = build_target_expr (slot, rval, complain);
632
633 if (rval != error_mark_node)
634 TARGET_EXPR_IMPLICIT_P (rval) = 1;
635
636 return rval;
637 }
638
639 /* Subroutine of build_vec_init_expr: Build up a single element
640 intialization as a proxy for the full array initialization to get things
641 marked as used and any appropriate diagnostics.
642
643 Since we're deferring building the actual constructor calls until
644 gimplification time, we need to build one now and throw it away so
645 that the relevant constructor gets mark_used before cgraph decides
646 what functions are needed. Here we assume that init is either
647 NULL_TREE, void_type_node (indicating value-initialization), or
648 another array to copy. */
649
650 static tree
build_vec_init_elt(tree type,tree init,tsubst_flags_t complain)651 build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
652 {
653 tree inner_type = strip_array_types (type);
654 vec<tree, va_gc> *argvec;
655
656 if (integer_zerop (array_type_nelts_total (type))
657 || !CLASS_TYPE_P (inner_type))
658 /* No interesting initialization to do. */
659 return integer_zero_node;
660 else if (init == void_type_node)
661 return build_value_init (inner_type, complain);
662
663 gcc_assert (init == NULL_TREE
664 || (same_type_ignoring_top_level_qualifiers_p
665 (type, TREE_TYPE (init))));
666
667 argvec = make_tree_vector ();
668 if (init)
669 {
670 tree init_type = strip_array_types (TREE_TYPE (init));
671 tree dummy = build_dummy_object (init_type);
672 if (!lvalue_p (init))
673 dummy = move (dummy);
674 argvec->quick_push (dummy);
675 }
676 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
677 &argvec, inner_type, LOOKUP_NORMAL,
678 complain);
679 release_tree_vector (argvec);
680
681 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
682 we don't want one here because we aren't creating a temporary. */
683 if (TREE_CODE (init) == TARGET_EXPR)
684 init = TARGET_EXPR_INITIAL (init);
685
686 return init;
687 }
688
689 /* Return a TARGET_EXPR which expresses the initialization of an array to
690 be named later, either default-initialization or copy-initialization
691 from another array of the same type. */
692
693 tree
build_vec_init_expr(tree type,tree init,tsubst_flags_t complain)694 build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
695 {
696 tree slot;
697 bool value_init = false;
698 tree elt_init = build_vec_init_elt (type, init, complain);
699
700 if (init == void_type_node)
701 {
702 value_init = true;
703 init = NULL_TREE;
704 }
705
706 slot = build_local_temp (type);
707 init = build2 (VEC_INIT_EXPR, type, slot, init);
708 TREE_SIDE_EFFECTS (init) = true;
709 SET_EXPR_LOCATION (init, input_location);
710
711 if (cxx_dialect >= cxx11
712 && potential_constant_expression (elt_init))
713 VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
714 VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
715
716 return init;
717 }
718
719 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
720 that requires a constant expression. */
721
722 void
diagnose_non_constexpr_vec_init(tree expr)723 diagnose_non_constexpr_vec_init (tree expr)
724 {
725 tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
726 tree init, elt_init;
727 if (VEC_INIT_EXPR_VALUE_INIT (expr))
728 init = void_type_node;
729 else
730 init = VEC_INIT_EXPR_INIT (expr);
731
732 elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
733 require_potential_constant_expression (elt_init);
734 }
735
736 tree
build_array_copy(tree init)737 build_array_copy (tree init)
738 {
739 return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error);
740 }
741
742 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
743 indicated TYPE. */
744
745 tree
build_target_expr_with_type(tree init,tree type,tsubst_flags_t complain)746 build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
747 {
748 gcc_assert (!VOID_TYPE_P (type));
749
750 if (TREE_CODE (init) == TARGET_EXPR
751 || init == error_mark_node)
752 return init;
753 else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
754 && !VOID_TYPE_P (TREE_TYPE (init))
755 && TREE_CODE (init) != COND_EXPR
756 && TREE_CODE (init) != CONSTRUCTOR
757 && TREE_CODE (init) != VA_ARG_EXPR)
758 /* We need to build up a copy constructor call. A void initializer
759 means we're being called from bot_manip. COND_EXPR is a special
760 case because we already have copies on the arms and we don't want
761 another one here. A CONSTRUCTOR is aggregate initialization, which
762 is handled separately. A VA_ARG_EXPR is magic creation of an
763 aggregate; there's no additional work to be done. */
764 return force_rvalue (init, complain);
765
766 return force_target_expr (type, init, complain);
767 }
768
769 /* Like the above function, but without the checking. This function should
770 only be used by code which is deliberately trying to subvert the type
771 system, such as call_builtin_trap. Or build_over_call, to avoid
772 infinite recursion. */
773
774 tree
force_target_expr(tree type,tree init,tsubst_flags_t complain)775 force_target_expr (tree type, tree init, tsubst_flags_t complain)
776 {
777 tree slot;
778
779 gcc_assert (!VOID_TYPE_P (type));
780
781 slot = build_local_temp (type);
782 return build_target_expr (slot, init, complain);
783 }
784
785 /* Like build_target_expr_with_type, but use the type of INIT. */
786
787 tree
get_target_expr_sfinae(tree init,tsubst_flags_t complain)788 get_target_expr_sfinae (tree init, tsubst_flags_t complain)
789 {
790 if (TREE_CODE (init) == AGGR_INIT_EXPR)
791 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
792 else if (TREE_CODE (init) == VEC_INIT_EXPR)
793 return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
794 else
795 {
796 init = convert_bitfield_to_declared_type (init);
797 return build_target_expr_with_type (init, TREE_TYPE (init), complain);
798 }
799 }
800
801 tree
get_target_expr(tree init)802 get_target_expr (tree init)
803 {
804 return get_target_expr_sfinae (init, tf_warning_or_error);
805 }
806
807 /* If EXPR is a bitfield reference, convert it to the declared type of
808 the bitfield, and return the resulting expression. Otherwise,
809 return EXPR itself. */
810
811 tree
convert_bitfield_to_declared_type(tree expr)812 convert_bitfield_to_declared_type (tree expr)
813 {
814 tree bitfield_type;
815
816 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
817 if (bitfield_type)
818 expr = convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type),
819 expr);
820 return expr;
821 }
822
823 /* EXPR is being used in an rvalue context. Return a version of EXPR
824 that is marked as an rvalue. */
825
826 tree
rvalue(tree expr)827 rvalue (tree expr)
828 {
829 tree type;
830
831 if (error_operand_p (expr))
832 return expr;
833
834 expr = mark_rvalue_use (expr);
835
836 /* [basic.lval]
837
838 Non-class rvalues always have cv-unqualified types. */
839 type = TREE_TYPE (expr);
840 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
841 type = cv_unqualified (type);
842
843 /* We need to do this for rvalue refs as well to get the right answer
844 from decltype; see c++/36628. */
845 if (!processing_template_decl && glvalue_p (expr))
846 expr = build1 (NON_LVALUE_EXPR, type, expr);
847 else if (type != TREE_TYPE (expr))
848 expr = build_nop (type, expr);
849
850 return expr;
851 }
852
853
854 struct cplus_array_info
855 {
856 tree type;
857 tree domain;
858 };
859
860 struct cplus_array_hasher : ggc_ptr_hash<tree_node>
861 {
862 typedef cplus_array_info *compare_type;
863
864 static hashval_t hash (tree t);
865 static bool equal (tree, cplus_array_info *);
866 };
867
868 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
869
870 hashval_t
hash(tree t)871 cplus_array_hasher::hash (tree t)
872 {
873 hashval_t hash;
874
875 hash = TYPE_UID (TREE_TYPE (t));
876 if (TYPE_DOMAIN (t))
877 hash ^= TYPE_UID (TYPE_DOMAIN (t));
878 return hash;
879 }
880
881 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
882 of type `cplus_array_info*'. */
883
884 bool
equal(tree t1,cplus_array_info * t2)885 cplus_array_hasher::equal (tree t1, cplus_array_info *t2)
886 {
887 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
888 }
889
890 /* Hash table containing dependent array types, which are unsuitable for
891 the language-independent type hash table. */
892 static GTY (()) hash_table<cplus_array_hasher> *cplus_array_htab;
893
894 /* Build an ARRAY_TYPE without laying it out. */
895
896 static tree
build_min_array_type(tree elt_type,tree index_type)897 build_min_array_type (tree elt_type, tree index_type)
898 {
899 tree t = cxx_make_type (ARRAY_TYPE);
900 TREE_TYPE (t) = elt_type;
901 TYPE_DOMAIN (t) = index_type;
902 return t;
903 }
904
905 /* Set TYPE_CANONICAL like build_array_type_1, but using
906 build_cplus_array_type. */
907
908 static void
set_array_type_canon(tree t,tree elt_type,tree index_type)909 set_array_type_canon (tree t, tree elt_type, tree index_type)
910 {
911 /* Set the canonical type for this new node. */
912 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
913 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
914 SET_TYPE_STRUCTURAL_EQUALITY (t);
915 else if (TYPE_CANONICAL (elt_type) != elt_type
916 || (index_type && TYPE_CANONICAL (index_type) != index_type))
917 TYPE_CANONICAL (t)
918 = build_cplus_array_type (TYPE_CANONICAL (elt_type),
919 index_type
920 ? TYPE_CANONICAL (index_type) : index_type);
921 else
922 TYPE_CANONICAL (t) = t;
923 }
924
925 /* Like build_array_type, but handle special C++ semantics: an array of a
926 variant element type is a variant of the array of the main variant of
927 the element type. */
928
929 tree
build_cplus_array_type(tree elt_type,tree index_type)930 build_cplus_array_type (tree elt_type, tree index_type)
931 {
932 tree t;
933
934 if (elt_type == error_mark_node || index_type == error_mark_node)
935 return error_mark_node;
936
937 bool dependent = (uses_template_parms (elt_type)
938 || (index_type && uses_template_parms (index_type)));
939
940 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
941 /* Start with an array of the TYPE_MAIN_VARIANT. */
942 t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
943 index_type);
944 else if (dependent)
945 {
946 /* Since type_hash_canon calls layout_type, we need to use our own
947 hash table. */
948 cplus_array_info cai;
949 hashval_t hash;
950
951 if (cplus_array_htab == NULL)
952 cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61);
953
954 hash = TYPE_UID (elt_type);
955 if (index_type)
956 hash ^= TYPE_UID (index_type);
957 cai.type = elt_type;
958 cai.domain = index_type;
959
960 tree *e = cplus_array_htab->find_slot_with_hash (&cai, hash, INSERT);
961 if (*e)
962 /* We have found the type: we're done. */
963 return (tree) *e;
964 else
965 {
966 /* Build a new array type. */
967 t = build_min_array_type (elt_type, index_type);
968
969 /* Store it in the hash table. */
970 *e = t;
971
972 /* Set the canonical type for this new node. */
973 set_array_type_canon (t, elt_type, index_type);
974 }
975 }
976 else
977 {
978 bool typeless_storage
979 = (elt_type == unsigned_char_type_node
980 || elt_type == signed_char_type_node
981 || elt_type == char_type_node
982 || (TREE_CODE (elt_type) == ENUMERAL_TYPE
983 && TYPE_CONTEXT (elt_type) == std_node
984 && !strcmp ("byte", TYPE_NAME_STRING (elt_type))));
985 t = build_array_type (elt_type, index_type, typeless_storage);
986 }
987
988 /* Now check whether we already have this array variant. */
989 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
990 {
991 tree m = t;
992 for (t = m; t; t = TYPE_NEXT_VARIANT (t))
993 if (TREE_TYPE (t) == elt_type
994 && TYPE_NAME (t) == NULL_TREE
995 && TYPE_ATTRIBUTES (t) == NULL_TREE)
996 break;
997 if (!t)
998 {
999 t = build_min_array_type (elt_type, index_type);
1000 set_array_type_canon (t, elt_type, index_type);
1001 if (!dependent)
1002 {
1003 layout_type (t);
1004 /* Make sure sizes are shared with the main variant.
1005 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1006 as it will overwrite alignment etc. of all variants. */
1007 TYPE_SIZE (t) = TYPE_SIZE (m);
1008 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (m);
1009 TYPE_TYPELESS_STORAGE (t) = TYPE_TYPELESS_STORAGE (m);
1010 }
1011
1012 TYPE_MAIN_VARIANT (t) = m;
1013 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
1014 TYPE_NEXT_VARIANT (m) = t;
1015 }
1016 }
1017
1018 /* Avoid spurious warnings with VLAs (c++/54583). */
1019 if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t)))
1020 TREE_NO_WARNING (TYPE_SIZE (t)) = 1;
1021
1022 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1023 place more easily. */
1024 bool needs_ctor = (TYPE_NEEDS_CONSTRUCTING (t)
1025 = TYPE_NEEDS_CONSTRUCTING (elt_type));
1026 bool needs_dtor = (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1027 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type));
1028
1029 if (!dependent && t == TYPE_MAIN_VARIANT (t)
1030 && !COMPLETE_TYPE_P (t) && COMPLETE_TYPE_P (elt_type))
1031 {
1032 /* The element type has been completed since the last time we saw
1033 this array type; update the layout and 'tor flags for any variants
1034 that need it. */
1035 layout_type (t);
1036 for (tree v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
1037 {
1038 TYPE_NEEDS_CONSTRUCTING (v) = needs_ctor;
1039 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v) = needs_dtor;
1040 }
1041 }
1042
1043 return t;
1044 }
1045
1046 /* Return an ARRAY_TYPE with element type ELT and length N. */
1047
1048 tree
build_array_of_n_type(tree elt,int n)1049 build_array_of_n_type (tree elt, int n)
1050 {
1051 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
1052 }
1053
1054 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1055 for C++14 but then removed. This should only be used for N3639
1056 specifically; code wondering more generally if something is a VLA should use
1057 vla_type_p. */
1058
1059 bool
array_of_runtime_bound_p(tree t)1060 array_of_runtime_bound_p (tree t)
1061 {
1062 if (!t || TREE_CODE (t) != ARRAY_TYPE)
1063 return false;
1064 if (variably_modified_type_p (TREE_TYPE (t), NULL_TREE))
1065 return false;
1066 tree dom = TYPE_DOMAIN (t);
1067 if (!dom)
1068 return false;
1069 tree max = TYPE_MAX_VALUE (dom);
1070 return (!potential_rvalue_constant_expression (max)
1071 || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)));
1072 }
1073
1074 /* True iff T is a variable length array. */
1075
1076 bool
vla_type_p(tree t)1077 vla_type_p (tree t)
1078 {
1079 for (; t && TREE_CODE (t) == ARRAY_TYPE;
1080 t = TREE_TYPE (t))
1081 if (tree dom = TYPE_DOMAIN (t))
1082 {
1083 tree max = TYPE_MAX_VALUE (dom);
1084 if (!potential_rvalue_constant_expression (max)
1085 || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)))
1086 return true;
1087 }
1088 return false;
1089 }
1090
1091 /* Return a reference type node referring to TO_TYPE. If RVAL is
1092 true, return an rvalue reference type, otherwise return an lvalue
1093 reference type. If a type node exists, reuse it, otherwise create
1094 a new one. */
1095 tree
cp_build_reference_type(tree to_type,bool rval)1096 cp_build_reference_type (tree to_type, bool rval)
1097 {
1098 tree lvalue_ref, t;
1099
1100 if (to_type == error_mark_node)
1101 return error_mark_node;
1102
1103 if (TREE_CODE (to_type) == REFERENCE_TYPE)
1104 {
1105 rval = rval && TYPE_REF_IS_RVALUE (to_type);
1106 to_type = TREE_TYPE (to_type);
1107 }
1108
1109 lvalue_ref = build_reference_type (to_type);
1110 if (!rval)
1111 return lvalue_ref;
1112
1113 /* This code to create rvalue reference types is based on and tied
1114 to the code creating lvalue reference types in the middle-end
1115 functions build_reference_type_for_mode and build_reference_type.
1116
1117 It works by putting the rvalue reference type nodes after the
1118 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1119 they will effectively be ignored by the middle end. */
1120
1121 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
1122 if (TYPE_REF_IS_RVALUE (t))
1123 return t;
1124
1125 t = build_distinct_type_copy (lvalue_ref);
1126
1127 TYPE_REF_IS_RVALUE (t) = true;
1128 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
1129 TYPE_NEXT_REF_TO (lvalue_ref) = t;
1130
1131 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
1132 SET_TYPE_STRUCTURAL_EQUALITY (t);
1133 else if (TYPE_CANONICAL (to_type) != to_type)
1134 TYPE_CANONICAL (t)
1135 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
1136 else
1137 TYPE_CANONICAL (t) = t;
1138
1139 layout_type (t);
1140
1141 return t;
1142
1143 }
1144
1145 /* Returns EXPR cast to rvalue reference type, like std::move. */
1146
1147 tree
move(tree expr)1148 move (tree expr)
1149 {
1150 tree type = TREE_TYPE (expr);
1151 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
1152 type = cp_build_reference_type (type, /*rval*/true);
1153 return build_static_cast (type, expr, tf_warning_or_error);
1154 }
1155
1156 /* Used by the C++ front end to build qualified array types. However,
1157 the C version of this function does not properly maintain canonical
1158 types (which are not used in C). */
1159 tree
c_build_qualified_type(tree type,int type_quals,tree,size_t)1160 c_build_qualified_type (tree type, int type_quals, tree /* orig_qual_type */,
1161 size_t /* orig_qual_indirect */)
1162 {
1163 return cp_build_qualified_type (type, type_quals);
1164 }
1165
1166
1167 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1168 arrays correctly. In particular, if TYPE is an array of T's, and
1169 TYPE_QUALS is non-empty, returns an array of qualified T's.
1170
1171 FLAGS determines how to deal with ill-formed qualifications. If
1172 tf_ignore_bad_quals is set, then bad qualifications are dropped
1173 (this is permitted if TYPE was introduced via a typedef or template
1174 type parameter). If bad qualifications are dropped and tf_warning
1175 is set, then a warning is issued for non-const qualifications. If
1176 tf_ignore_bad_quals is not set and tf_error is not set, we
1177 return error_mark_node. Otherwise, we issue an error, and ignore
1178 the qualifications.
1179
1180 Qualification of a reference type is valid when the reference came
1181 via a typedef or template type argument. [dcl.ref] No such
1182 dispensation is provided for qualifying a function type. [dcl.fct]
1183 DR 295 queries this and the proposed resolution brings it into line
1184 with qualifying a reference. We implement the DR. We also behave
1185 in a similar manner for restricting non-pointer types. */
1186
1187 tree
cp_build_qualified_type_real(tree type,int type_quals,tsubst_flags_t complain)1188 cp_build_qualified_type_real (tree type,
1189 int type_quals,
1190 tsubst_flags_t complain)
1191 {
1192 tree result;
1193 int bad_quals = TYPE_UNQUALIFIED;
1194
1195 if (type == error_mark_node)
1196 return type;
1197
1198 if (type_quals == cp_type_quals (type))
1199 return type;
1200
1201 if (TREE_CODE (type) == ARRAY_TYPE)
1202 {
1203 /* In C++, the qualification really applies to the array element
1204 type. Obtain the appropriately qualified element type. */
1205 tree t;
1206 tree element_type
1207 = cp_build_qualified_type_real (TREE_TYPE (type),
1208 type_quals,
1209 complain);
1210
1211 if (element_type == error_mark_node)
1212 return error_mark_node;
1213
1214 /* See if we already have an identically qualified type. Tests
1215 should be equivalent to those in check_qualified_type. */
1216 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
1217 if (TREE_TYPE (t) == element_type
1218 && TYPE_NAME (t) == TYPE_NAME (type)
1219 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
1220 && attribute_list_equal (TYPE_ATTRIBUTES (t),
1221 TYPE_ATTRIBUTES (type)))
1222 break;
1223
1224 if (!t)
1225 {
1226 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
1227
1228 /* Keep the typedef name. */
1229 if (TYPE_NAME (t) != TYPE_NAME (type))
1230 {
1231 t = build_variant_type_copy (t);
1232 TYPE_NAME (t) = TYPE_NAME (type);
1233 SET_TYPE_ALIGN (t, TYPE_ALIGN (type));
1234 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (type);
1235 }
1236 }
1237
1238 /* Even if we already had this variant, we update
1239 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1240 they changed since the variant was originally created.
1241
1242 This seems hokey; if there is some way to use a previous
1243 variant *without* coming through here,
1244 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1245 TYPE_NEEDS_CONSTRUCTING (t)
1246 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
1247 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1248 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
1249 return t;
1250 }
1251 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
1252 {
1253 tree t = PACK_EXPANSION_PATTERN (type);
1254
1255 t = cp_build_qualified_type_real (t, type_quals, complain);
1256 return make_pack_expansion (t, complain);
1257 }
1258
1259 /* A reference or method type shall not be cv-qualified.
1260 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1261 (in CD1) we always ignore extra cv-quals on functions. */
1262 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1263 && (TREE_CODE (type) == REFERENCE_TYPE
1264 || TREE_CODE (type) == FUNCTION_TYPE
1265 || TREE_CODE (type) == METHOD_TYPE))
1266 {
1267 if (TREE_CODE (type) == REFERENCE_TYPE)
1268 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1269 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1270 }
1271
1272 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1273 if (TREE_CODE (type) == FUNCTION_TYPE)
1274 type_quals |= type_memfn_quals (type);
1275
1276 /* A restrict-qualified type must be a pointer (or reference)
1277 to object or incomplete type. */
1278 if ((type_quals & TYPE_QUAL_RESTRICT)
1279 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1280 && TREE_CODE (type) != TYPENAME_TYPE
1281 && !POINTER_TYPE_P (type))
1282 {
1283 bad_quals |= TYPE_QUAL_RESTRICT;
1284 type_quals &= ~TYPE_QUAL_RESTRICT;
1285 }
1286
1287 if (bad_quals == TYPE_UNQUALIFIED
1288 || (complain & tf_ignore_bad_quals))
1289 /*OK*/;
1290 else if (!(complain & tf_error))
1291 return error_mark_node;
1292 else
1293 {
1294 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1295 error ("%qV qualifiers cannot be applied to %qT",
1296 bad_type, type);
1297 }
1298
1299 /* Retrieve (or create) the appropriately qualified variant. */
1300 result = build_qualified_type (type, type_quals);
1301
1302 /* Preserve exception specs and ref-qualifier since build_qualified_type
1303 doesn't know about them. */
1304 if (TREE_CODE (result) == FUNCTION_TYPE
1305 || TREE_CODE (result) == METHOD_TYPE)
1306 {
1307 result = build_exception_variant (result, TYPE_RAISES_EXCEPTIONS (type));
1308 result = build_ref_qualified_type (result, type_memfn_rqual (type));
1309 }
1310
1311 return result;
1312 }
1313
1314 /* Return TYPE with const and volatile removed. */
1315
1316 tree
cv_unqualified(tree type)1317 cv_unqualified (tree type)
1318 {
1319 int quals;
1320
1321 if (type == error_mark_node)
1322 return type;
1323
1324 quals = cp_type_quals (type);
1325 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1326 return cp_build_qualified_type (type, quals);
1327 }
1328
1329 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1330 from ATTRIBS that affect type identity, and no others. If any are not
1331 applied, set *remove_attributes to true. */
1332
1333 static tree
apply_identity_attributes(tree result,tree attribs,bool * remove_attributes)1334 apply_identity_attributes (tree result, tree attribs, bool *remove_attributes)
1335 {
1336 tree first_ident = NULL_TREE;
1337 tree new_attribs = NULL_TREE;
1338 tree *p = &new_attribs;
1339
1340 if (OVERLOAD_TYPE_P (result))
1341 {
1342 /* On classes and enums all attributes are ingrained. */
1343 gcc_assert (attribs == TYPE_ATTRIBUTES (result));
1344 return result;
1345 }
1346
1347 for (tree a = attribs; a; a = TREE_CHAIN (a))
1348 {
1349 const attribute_spec *as
1350 = lookup_attribute_spec (get_attribute_name (a));
1351 if (as && as->affects_type_identity)
1352 {
1353 if (!first_ident)
1354 first_ident = a;
1355 else if (first_ident == error_mark_node)
1356 {
1357 *p = tree_cons (TREE_PURPOSE (a), TREE_VALUE (a), NULL_TREE);
1358 p = &TREE_CHAIN (*p);
1359 }
1360 }
1361 else if (first_ident)
1362 {
1363 for (tree a2 = first_ident; a2; a2 = TREE_CHAIN (a2))
1364 {
1365 *p = tree_cons (TREE_PURPOSE (a2), TREE_VALUE (a2), NULL_TREE);
1366 p = &TREE_CHAIN (*p);
1367 }
1368 first_ident = error_mark_node;
1369 }
1370 }
1371 if (first_ident != error_mark_node)
1372 new_attribs = first_ident;
1373
1374 if (first_ident == attribs)
1375 /* All attributes affected type identity. */;
1376 else
1377 *remove_attributes = true;
1378
1379 return cp_build_type_attribute_variant (result, new_attribs);
1380 }
1381
1382 /* Builds a qualified variant of T that is not a typedef variant.
1383 E.g. consider the following declarations:
1384 typedef const int ConstInt;
1385 typedef ConstInt* PtrConstInt;
1386 If T is PtrConstInt, this function returns a type representing
1387 const int*.
1388 In other words, if T is a typedef, the function returns the underlying type.
1389 The cv-qualification and attributes of the type returned match the
1390 input type.
1391 They will always be compatible types.
1392 The returned type is built so that all of its subtypes
1393 recursively have their typedefs stripped as well.
1394
1395 This is different from just returning TYPE_CANONICAL (T)
1396 Because of several reasons:
1397 * If T is a type that needs structural equality
1398 its TYPE_CANONICAL (T) will be NULL.
1399 * TYPE_CANONICAL (T) desn't carry type attributes
1400 and loses template parameter names.
1401
1402 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1403 affect type identity, and set the referent to true if any were
1404 stripped. */
1405
1406 tree
strip_typedefs(tree t,bool * remove_attributes)1407 strip_typedefs (tree t, bool *remove_attributes)
1408 {
1409 tree result = NULL, type = NULL, t0 = NULL;
1410
1411 if (!t || t == error_mark_node)
1412 return t;
1413
1414 if (TREE_CODE (t) == TREE_LIST)
1415 {
1416 bool changed = false;
1417 vec<tree,va_gc> *vec = make_tree_vector ();
1418 tree r = t;
1419 for (; t; t = TREE_CHAIN (t))
1420 {
1421 gcc_assert (!TREE_PURPOSE (t));
1422 tree elt = strip_typedefs (TREE_VALUE (t), remove_attributes);
1423 if (elt != TREE_VALUE (t))
1424 changed = true;
1425 vec_safe_push (vec, elt);
1426 }
1427 if (changed)
1428 r = build_tree_list_vec (vec);
1429 release_tree_vector (vec);
1430 return r;
1431 }
1432
1433 gcc_assert (TYPE_P (t));
1434
1435 if (t == TYPE_CANONICAL (t))
1436 return t;
1437
1438 if (dependent_alias_template_spec_p (t))
1439 /* DR 1558: However, if the template-id is dependent, subsequent
1440 template argument substitution still applies to the template-id. */
1441 return t;
1442
1443 switch (TREE_CODE (t))
1444 {
1445 case POINTER_TYPE:
1446 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1447 result = build_pointer_type (type);
1448 break;
1449 case REFERENCE_TYPE:
1450 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1451 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1452 break;
1453 case OFFSET_TYPE:
1454 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t), remove_attributes);
1455 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1456 result = build_offset_type (t0, type);
1457 break;
1458 case RECORD_TYPE:
1459 if (TYPE_PTRMEMFUNC_P (t))
1460 {
1461 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t), remove_attributes);
1462 result = build_ptrmemfunc_type (t0);
1463 }
1464 break;
1465 case ARRAY_TYPE:
1466 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1467 t0 = strip_typedefs (TYPE_DOMAIN (t), remove_attributes);
1468 result = build_cplus_array_type (type, t0);
1469 break;
1470 case FUNCTION_TYPE:
1471 case METHOD_TYPE:
1472 {
1473 tree arg_types = NULL, arg_node, arg_node2, arg_type;
1474 bool changed;
1475
1476 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1477 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1478 can't expect that re-hashing a function type will find a previous
1479 equivalent type, so try to reuse the input type if nothing has
1480 changed. If the type is itself a variant, that will change. */
1481 bool is_variant = typedef_variant_p (t);
1482 if (remove_attributes
1483 && (TYPE_ATTRIBUTES (t) || TYPE_USER_ALIGN (t)))
1484 is_variant = true;
1485
1486 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1487 tree canon_spec = (flag_noexcept_type
1488 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t))
1489 : NULL_TREE);
1490 changed = (type != TREE_TYPE (t) || is_variant
1491 || TYPE_RAISES_EXCEPTIONS (t) != canon_spec);
1492
1493 for (arg_node = TYPE_ARG_TYPES (t);
1494 arg_node;
1495 arg_node = TREE_CHAIN (arg_node))
1496 {
1497 if (arg_node == void_list_node)
1498 break;
1499 arg_type = strip_typedefs (TREE_VALUE (arg_node),
1500 remove_attributes);
1501 gcc_assert (arg_type);
1502 if (arg_type == TREE_VALUE (arg_node) && !changed)
1503 continue;
1504
1505 if (!changed)
1506 {
1507 changed = true;
1508 for (arg_node2 = TYPE_ARG_TYPES (t);
1509 arg_node2 != arg_node;
1510 arg_node2 = TREE_CHAIN (arg_node2))
1511 arg_types
1512 = tree_cons (TREE_PURPOSE (arg_node2),
1513 TREE_VALUE (arg_node2), arg_types);
1514 }
1515
1516 arg_types
1517 = tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1518 }
1519
1520 if (!changed)
1521 return t;
1522
1523 if (arg_types)
1524 arg_types = nreverse (arg_types);
1525
1526 /* A list of parameters not ending with an ellipsis
1527 must end with void_list_node. */
1528 if (arg_node)
1529 arg_types = chainon (arg_types, void_list_node);
1530
1531 if (TREE_CODE (t) == METHOD_TYPE)
1532 {
1533 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1534 gcc_assert (class_type);
1535 result =
1536 build_method_type_directly (class_type, type,
1537 TREE_CHAIN (arg_types));
1538 result
1539 = build_ref_qualified_type (result, type_memfn_rqual (t));
1540 }
1541 else
1542 {
1543 result = build_function_type (type,
1544 arg_types);
1545 result = apply_memfn_quals (result,
1546 type_memfn_quals (t),
1547 type_memfn_rqual (t));
1548 }
1549
1550 if (canon_spec)
1551 result = build_exception_variant (result, canon_spec);
1552 if (TYPE_HAS_LATE_RETURN_TYPE (t))
1553 TYPE_HAS_LATE_RETURN_TYPE (result) = 1;
1554 }
1555 break;
1556 case TYPENAME_TYPE:
1557 {
1558 bool changed = false;
1559 tree fullname = TYPENAME_TYPE_FULLNAME (t);
1560 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
1561 && TREE_OPERAND (fullname, 1))
1562 {
1563 tree args = TREE_OPERAND (fullname, 1);
1564 tree new_args = copy_node (args);
1565 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
1566 {
1567 tree arg = TREE_VEC_ELT (args, i);
1568 tree strip_arg;
1569 if (TYPE_P (arg))
1570 strip_arg = strip_typedefs (arg, remove_attributes);
1571 else
1572 strip_arg = strip_typedefs_expr (arg, remove_attributes);
1573 TREE_VEC_ELT (new_args, i) = strip_arg;
1574 if (strip_arg != arg)
1575 changed = true;
1576 }
1577 if (changed)
1578 {
1579 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)
1580 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
1581 fullname
1582 = lookup_template_function (TREE_OPERAND (fullname, 0),
1583 new_args);
1584 }
1585 else
1586 ggc_free (new_args);
1587 }
1588 tree ctx = strip_typedefs (TYPE_CONTEXT (t), remove_attributes);
1589 if (!changed && ctx == TYPE_CONTEXT (t) && !typedef_variant_p (t))
1590 return t;
1591 tree name = fullname;
1592 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
1593 name = TREE_OPERAND (fullname, 0);
1594 /* Use build_typename_type rather than make_typename_type because we
1595 don't want to resolve it here, just strip typedefs. */
1596 result = build_typename_type (ctx, name, fullname, typename_type);
1597 }
1598 break;
1599 case DECLTYPE_TYPE:
1600 result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t),
1601 remove_attributes);
1602 if (result == DECLTYPE_TYPE_EXPR (t))
1603 result = NULL_TREE;
1604 else
1605 result = (finish_decltype_type
1606 (result,
1607 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
1608 tf_none));
1609 break;
1610 case UNDERLYING_TYPE:
1611 type = strip_typedefs (UNDERLYING_TYPE_TYPE (t), remove_attributes);
1612 result = finish_underlying_type (type);
1613 break;
1614 default:
1615 break;
1616 }
1617
1618 if (!result)
1619 {
1620 if (typedef_variant_p (t))
1621 {
1622 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1623 strip typedefs with attributes. */
1624 result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t)));
1625 result = strip_typedefs (result);
1626 }
1627 else
1628 result = TYPE_MAIN_VARIANT (t);
1629 }
1630 gcc_assert (!typedef_variant_p (result));
1631
1632 if (COMPLETE_TYPE_P (result) && !COMPLETE_TYPE_P (t))
1633 /* If RESULT is complete and T isn't, it's likely the case that T
1634 is a variant of RESULT which hasn't been updated yet. Skip the
1635 attribute handling. */;
1636 else
1637 {
1638 if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1639 || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1640 {
1641 gcc_assert (TYPE_USER_ALIGN (t));
1642 if (remove_attributes)
1643 *remove_attributes = true;
1644 else
1645 {
1646 if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1647 result = build_variant_type_copy (result);
1648 else
1649 result = build_aligned_type (result, TYPE_ALIGN (t));
1650 TYPE_USER_ALIGN (result) = true;
1651 }
1652 }
1653
1654 if (TYPE_ATTRIBUTES (t))
1655 {
1656 if (remove_attributes)
1657 result = apply_identity_attributes (result, TYPE_ATTRIBUTES (t),
1658 remove_attributes);
1659 else
1660 result = cp_build_type_attribute_variant (result,
1661 TYPE_ATTRIBUTES (t));
1662 }
1663 }
1664
1665 return cp_build_qualified_type (result, cp_type_quals (t));
1666 }
1667
1668 /* Like strip_typedefs above, but works on expressions, so that in
1669
1670 template<class T> struct A
1671 {
1672 typedef T TT;
1673 B<sizeof(TT)> b;
1674 };
1675
1676 sizeof(TT) is replaced by sizeof(T). */
1677
1678 tree
strip_typedefs_expr(tree t,bool * remove_attributes)1679 strip_typedefs_expr (tree t, bool *remove_attributes)
1680 {
1681 unsigned i,n;
1682 tree r, type, *ops;
1683 enum tree_code code;
1684
1685 if (t == NULL_TREE || t == error_mark_node)
1686 return t;
1687
1688 if (DECL_P (t) || CONSTANT_CLASS_P (t))
1689 return t;
1690
1691 /* Some expressions have type operands, so let's handle types here rather
1692 than check TYPE_P in multiple places below. */
1693 if (TYPE_P (t))
1694 return strip_typedefs (t, remove_attributes);
1695
1696 code = TREE_CODE (t);
1697 switch (code)
1698 {
1699 case IDENTIFIER_NODE:
1700 case TEMPLATE_PARM_INDEX:
1701 case OVERLOAD:
1702 case BASELINK:
1703 case ARGUMENT_PACK_SELECT:
1704 return t;
1705
1706 case TRAIT_EXPR:
1707 {
1708 tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t), remove_attributes);
1709 tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t), remove_attributes);
1710 if (type1 == TRAIT_EXPR_TYPE1 (t)
1711 && type2 == TRAIT_EXPR_TYPE2 (t))
1712 return t;
1713 r = copy_node (t);
1714 TRAIT_EXPR_TYPE1 (r) = type1;
1715 TRAIT_EXPR_TYPE2 (r) = type2;
1716 return r;
1717 }
1718
1719 case TREE_LIST:
1720 {
1721 vec<tree, va_gc> *vec = make_tree_vector ();
1722 bool changed = false;
1723 tree it;
1724 for (it = t; it; it = TREE_CHAIN (it))
1725 {
1726 tree val = strip_typedefs_expr (TREE_VALUE (it), remove_attributes);
1727 vec_safe_push (vec, val);
1728 if (val != TREE_VALUE (it))
1729 changed = true;
1730 gcc_assert (TREE_PURPOSE (it) == NULL_TREE);
1731 }
1732 if (changed)
1733 {
1734 r = NULL_TREE;
1735 FOR_EACH_VEC_ELT_REVERSE (*vec, i, it)
1736 r = tree_cons (NULL_TREE, it, r);
1737 }
1738 else
1739 r = t;
1740 release_tree_vector (vec);
1741 return r;
1742 }
1743
1744 case TREE_VEC:
1745 {
1746 bool changed = false;
1747 vec<tree, va_gc> *vec = make_tree_vector ();
1748 n = TREE_VEC_LENGTH (t);
1749 vec_safe_reserve (vec, n);
1750 for (i = 0; i < n; ++i)
1751 {
1752 tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i),
1753 remove_attributes);
1754 vec->quick_push (op);
1755 if (op != TREE_VEC_ELT (t, i))
1756 changed = true;
1757 }
1758 if (changed)
1759 {
1760 r = copy_node (t);
1761 for (i = 0; i < n; ++i)
1762 TREE_VEC_ELT (r, i) = (*vec)[i];
1763 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)
1764 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
1765 }
1766 else
1767 r = t;
1768 release_tree_vector (vec);
1769 return r;
1770 }
1771
1772 case CONSTRUCTOR:
1773 {
1774 bool changed = false;
1775 vec<constructor_elt, va_gc> *vec
1776 = vec_safe_copy (CONSTRUCTOR_ELTS (t));
1777 n = CONSTRUCTOR_NELTS (t);
1778 type = strip_typedefs (TREE_TYPE (t), remove_attributes);
1779 for (i = 0; i < n; ++i)
1780 {
1781 constructor_elt *e = &(*vec)[i];
1782 tree op = strip_typedefs_expr (e->value, remove_attributes);
1783 if (op != e->value)
1784 {
1785 changed = true;
1786 e->value = op;
1787 }
1788 gcc_checking_assert
1789 (e->index == strip_typedefs_expr (e->index, remove_attributes));
1790 }
1791
1792 if (!changed && type == TREE_TYPE (t))
1793 {
1794 vec_free (vec);
1795 return t;
1796 }
1797 else
1798 {
1799 r = copy_node (t);
1800 TREE_TYPE (r) = type;
1801 CONSTRUCTOR_ELTS (r) = vec;
1802 return r;
1803 }
1804 }
1805
1806 case LAMBDA_EXPR:
1807 error ("lambda-expression in a constant expression");
1808 return error_mark_node;
1809
1810 case STATEMENT_LIST:
1811 error ("statement-expression in a constant expression");
1812 return error_mark_node;
1813
1814 default:
1815 break;
1816 }
1817
1818 gcc_assert (EXPR_P (t));
1819
1820 n = cp_tree_operand_length (t);
1821 ops = XALLOCAVEC (tree, n);
1822 type = TREE_TYPE (t);
1823
1824 switch (code)
1825 {
1826 CASE_CONVERT:
1827 case IMPLICIT_CONV_EXPR:
1828 case DYNAMIC_CAST_EXPR:
1829 case STATIC_CAST_EXPR:
1830 case CONST_CAST_EXPR:
1831 case REINTERPRET_CAST_EXPR:
1832 case CAST_EXPR:
1833 case NEW_EXPR:
1834 type = strip_typedefs (type, remove_attributes);
1835 /* fallthrough */
1836
1837 default:
1838 for (i = 0; i < n; ++i)
1839 ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i), remove_attributes);
1840 break;
1841 }
1842
1843 /* If nothing changed, return t. */
1844 for (i = 0; i < n; ++i)
1845 if (ops[i] != TREE_OPERAND (t, i))
1846 break;
1847 if (i == n && type == TREE_TYPE (t))
1848 return t;
1849
1850 r = copy_node (t);
1851 TREE_TYPE (r) = type;
1852 for (i = 0; i < n; ++i)
1853 TREE_OPERAND (r, i) = ops[i];
1854 return r;
1855 }
1856
1857 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1858 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1859 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1860 VIRT indicates whether TYPE is inherited virtually or not.
1861 IGO_PREV points at the previous binfo of the inheritance graph
1862 order chain. The newly copied binfo's TREE_CHAIN forms this
1863 ordering.
1864
1865 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1866 correct order. That is in the order the bases themselves should be
1867 constructed in.
1868
1869 The BINFO_INHERITANCE of a virtual base class points to the binfo
1870 of the most derived type. ??? We could probably change this so that
1871 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1872 remove a field. They currently can only differ for primary virtual
1873 virtual bases. */
1874
1875 tree
copy_binfo(tree binfo,tree type,tree t,tree * igo_prev,int virt)1876 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1877 {
1878 tree new_binfo;
1879
1880 if (virt)
1881 {
1882 /* See if we've already made this virtual base. */
1883 new_binfo = binfo_for_vbase (type, t);
1884 if (new_binfo)
1885 return new_binfo;
1886 }
1887
1888 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1889 BINFO_TYPE (new_binfo) = type;
1890
1891 /* Chain it into the inheritance graph. */
1892 TREE_CHAIN (*igo_prev) = new_binfo;
1893 *igo_prev = new_binfo;
1894
1895 if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
1896 {
1897 int ix;
1898 tree base_binfo;
1899
1900 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1901
1902 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1903 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1904
1905 /* We do not need to copy the accesses, as they are read only. */
1906 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1907
1908 /* Recursively copy base binfos of BINFO. */
1909 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1910 {
1911 tree new_base_binfo;
1912 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1913 t, igo_prev,
1914 BINFO_VIRTUAL_P (base_binfo));
1915
1916 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1917 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1918 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1919 }
1920 }
1921 else
1922 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1923
1924 if (virt)
1925 {
1926 /* Push it onto the list after any virtual bases it contains
1927 will have been pushed. */
1928 CLASSTYPE_VBASECLASSES (t)->quick_push (new_binfo);
1929 BINFO_VIRTUAL_P (new_binfo) = 1;
1930 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1931 }
1932
1933 return new_binfo;
1934 }
1935
1936 /* Hashing of lists so that we don't make duplicates.
1937 The entry point is `list_hash_canon'. */
1938
1939 struct list_proxy
1940 {
1941 tree purpose;
1942 tree value;
1943 tree chain;
1944 };
1945
1946 struct list_hasher : ggc_ptr_hash<tree_node>
1947 {
1948 typedef list_proxy *compare_type;
1949
1950 static hashval_t hash (tree);
1951 static bool equal (tree, list_proxy *);
1952 };
1953
1954 /* Now here is the hash table. When recording a list, it is added
1955 to the slot whose index is the hash code mod the table size.
1956 Note that the hash table is used for several kinds of lists.
1957 While all these live in the same table, they are completely independent,
1958 and the hash code is computed differently for each of these. */
1959
1960 static GTY (()) hash_table<list_hasher> *list_hash_table;
1961
1962 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1963 for a node we are thinking about adding). */
1964
1965 bool
equal(tree t,list_proxy * proxy)1966 list_hasher::equal (tree t, list_proxy *proxy)
1967 {
1968 return (TREE_VALUE (t) == proxy->value
1969 && TREE_PURPOSE (t) == proxy->purpose
1970 && TREE_CHAIN (t) == proxy->chain);
1971 }
1972
1973 /* Compute a hash code for a list (chain of TREE_LIST nodes
1974 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1975 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1976
1977 static hashval_t
list_hash_pieces(tree purpose,tree value,tree chain)1978 list_hash_pieces (tree purpose, tree value, tree chain)
1979 {
1980 hashval_t hashcode = 0;
1981
1982 if (chain)
1983 hashcode += TREE_HASH (chain);
1984
1985 if (value)
1986 hashcode += TREE_HASH (value);
1987 else
1988 hashcode += 1007;
1989 if (purpose)
1990 hashcode += TREE_HASH (purpose);
1991 else
1992 hashcode += 1009;
1993 return hashcode;
1994 }
1995
1996 /* Hash an already existing TREE_LIST. */
1997
1998 hashval_t
hash(tree t)1999 list_hasher::hash (tree t)
2000 {
2001 return list_hash_pieces (TREE_PURPOSE (t),
2002 TREE_VALUE (t),
2003 TREE_CHAIN (t));
2004 }
2005
2006 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2007 object for an identical list if one already exists. Otherwise, build a
2008 new one, and record it as the canonical object. */
2009
2010 tree
hash_tree_cons(tree purpose,tree value,tree chain)2011 hash_tree_cons (tree purpose, tree value, tree chain)
2012 {
2013 int hashcode = 0;
2014 tree *slot;
2015 struct list_proxy proxy;
2016
2017 /* Hash the list node. */
2018 hashcode = list_hash_pieces (purpose, value, chain);
2019 /* Create a proxy for the TREE_LIST we would like to create. We
2020 don't actually create it so as to avoid creating garbage. */
2021 proxy.purpose = purpose;
2022 proxy.value = value;
2023 proxy.chain = chain;
2024 /* See if it is already in the table. */
2025 slot = list_hash_table->find_slot_with_hash (&proxy, hashcode, INSERT);
2026 /* If not, create a new node. */
2027 if (!*slot)
2028 *slot = tree_cons (purpose, value, chain);
2029 return (tree) *slot;
2030 }
2031
2032 /* Constructor for hashed lists. */
2033
2034 tree
hash_tree_chain(tree value,tree chain)2035 hash_tree_chain (tree value, tree chain)
2036 {
2037 return hash_tree_cons (NULL_TREE, value, chain);
2038 }
2039
2040 void
debug_binfo(tree elem)2041 debug_binfo (tree elem)
2042 {
2043 HOST_WIDE_INT n;
2044 tree virtuals;
2045
2046 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2047 "\nvtable type:\n",
2048 TYPE_NAME_STRING (BINFO_TYPE (elem)),
2049 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
2050 debug_tree (BINFO_TYPE (elem));
2051 if (BINFO_VTABLE (elem))
2052 fprintf (stderr, "vtable decl \"%s\"\n",
2053 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
2054 else
2055 fprintf (stderr, "no vtable decl yet\n");
2056 fprintf (stderr, "virtuals:\n");
2057 virtuals = BINFO_VIRTUALS (elem);
2058 n = 0;
2059
2060 while (virtuals)
2061 {
2062 tree fndecl = TREE_VALUE (virtuals);
2063 fprintf (stderr, "%s [%ld =? %ld]\n",
2064 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
2065 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
2066 ++n;
2067 virtuals = TREE_CHAIN (virtuals);
2068 }
2069 }
2070
2071 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2072 the type of the result expression, if known, or NULL_TREE if the
2073 resulting expression is type-dependent. If TEMPLATE_P is true,
2074 NAME is known to be a template because the user explicitly used the
2075 "template" keyword after the "::".
2076
2077 All SCOPE_REFs should be built by use of this function. */
2078
2079 tree
build_qualified_name(tree type,tree scope,tree name,bool template_p)2080 build_qualified_name (tree type, tree scope, tree name, bool template_p)
2081 {
2082 tree t;
2083 if (type == error_mark_node
2084 || scope == error_mark_node
2085 || name == error_mark_node)
2086 return error_mark_node;
2087 gcc_assert (TREE_CODE (name) != SCOPE_REF);
2088 t = build2 (SCOPE_REF, type, scope, name);
2089 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
2090 PTRMEM_OK_P (t) = true;
2091 if (type)
2092 t = convert_from_reference (t);
2093 return t;
2094 }
2095
2096 /* Like check_qualified_type, but also check ref-qualifier and exception
2097 specification. */
2098
2099 static bool
cp_check_qualified_type(const_tree cand,const_tree base,int type_quals,cp_ref_qualifier rqual,tree raises)2100 cp_check_qualified_type (const_tree cand, const_tree base, int type_quals,
2101 cp_ref_qualifier rqual, tree raises)
2102 {
2103 return (TYPE_QUALS (cand) == type_quals
2104 && check_base_type (cand, base)
2105 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (cand),
2106 ce_exact)
2107 && type_memfn_rqual (cand) == rqual);
2108 }
2109
2110 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2111
2112 tree
build_ref_qualified_type(tree type,cp_ref_qualifier rqual)2113 build_ref_qualified_type (tree type, cp_ref_qualifier rqual)
2114 {
2115 tree t;
2116
2117 if (rqual == type_memfn_rqual (type))
2118 return type;
2119
2120 int type_quals = TYPE_QUALS (type);
2121 tree raises = TYPE_RAISES_EXCEPTIONS (type);
2122 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2123 if (cp_check_qualified_type (t, type, type_quals, rqual, raises))
2124 return t;
2125
2126 t = build_variant_type_copy (type);
2127 switch (rqual)
2128 {
2129 case REF_QUAL_RVALUE:
2130 FUNCTION_RVALUE_QUALIFIED (t) = 1;
2131 FUNCTION_REF_QUALIFIED (t) = 1;
2132 break;
2133 case REF_QUAL_LVALUE:
2134 FUNCTION_RVALUE_QUALIFIED (t) = 0;
2135 FUNCTION_REF_QUALIFIED (t) = 1;
2136 break;
2137 default:
2138 FUNCTION_REF_QUALIFIED (t) = 0;
2139 break;
2140 }
2141
2142 if (TYPE_STRUCTURAL_EQUALITY_P (type))
2143 /* Propagate structural equality. */
2144 SET_TYPE_STRUCTURAL_EQUALITY (t);
2145 else if (TYPE_CANONICAL (type) != type)
2146 /* Build the underlying canonical type, since it is different
2147 from TYPE. */
2148 TYPE_CANONICAL (t) = build_ref_qualified_type (TYPE_CANONICAL (type),
2149 rqual);
2150 else
2151 /* T is its own canonical type. */
2152 TYPE_CANONICAL (t) = t;
2153
2154 return t;
2155 }
2156
2157 /* Cache of free ovl nodes. Uses OVL_FUNCTION for chaining. */
2158 static GTY((deletable)) tree ovl_cache;
2159
2160 /* Make a raw overload node containing FN. */
2161
2162 tree
ovl_make(tree fn,tree next)2163 ovl_make (tree fn, tree next)
2164 {
2165 tree result = ovl_cache;
2166
2167 if (result)
2168 {
2169 ovl_cache = OVL_FUNCTION (result);
2170 /* Zap the flags. */
2171 memset (result, 0, sizeof (tree_base));
2172 TREE_SET_CODE (result, OVERLOAD);
2173 }
2174 else
2175 result = make_node (OVERLOAD);
2176
2177 if (TREE_CODE (fn) == OVERLOAD)
2178 OVL_NESTED_P (result) = true;
2179
2180 TREE_TYPE (result) = (next || TREE_CODE (fn) == TEMPLATE_DECL
2181 ? unknown_type_node : TREE_TYPE (fn));
2182 OVL_FUNCTION (result) = fn;
2183 OVL_CHAIN (result) = next;
2184 return result;
2185 }
2186
2187 static tree
ovl_copy(tree ovl)2188 ovl_copy (tree ovl)
2189 {
2190 tree result = ovl_cache;
2191
2192 if (result)
2193 {
2194 ovl_cache = OVL_FUNCTION (result);
2195 /* Zap the flags. */
2196 memset (result, 0, sizeof (tree_base));
2197 TREE_SET_CODE (result, OVERLOAD);
2198 }
2199 else
2200 result = make_node (OVERLOAD);
2201
2202 gcc_checking_assert (!OVL_NESTED_P (ovl) && OVL_USED_P (ovl));
2203 TREE_TYPE (result) = TREE_TYPE (ovl);
2204 OVL_FUNCTION (result) = OVL_FUNCTION (ovl);
2205 OVL_CHAIN (result) = OVL_CHAIN (ovl);
2206 OVL_HIDDEN_P (result) = OVL_HIDDEN_P (ovl);
2207 OVL_USING_P (result) = OVL_USING_P (ovl);
2208 OVL_LOOKUP_P (result) = OVL_LOOKUP_P (ovl);
2209
2210 return result;
2211 }
2212
2213 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2214 true, if FN is via a using declaration. We also pay attention to
2215 DECL_HIDDEN. Overloads are ordered as hidden, using, regular. */
2216
2217 tree
ovl_insert(tree fn,tree maybe_ovl,bool using_p)2218 ovl_insert (tree fn, tree maybe_ovl, bool using_p)
2219 {
2220 bool copying = false; /* Checking use only. */
2221 bool hidden_p = DECL_HIDDEN_P (fn);
2222 int weight = (hidden_p << 1) | (using_p << 0);
2223
2224 tree result = NULL_TREE;
2225 tree insert_after = NULL_TREE;
2226
2227 /* Find insertion point. */
2228 while (maybe_ovl && TREE_CODE (maybe_ovl) == OVERLOAD
2229 && (weight < ((OVL_HIDDEN_P (maybe_ovl) << 1)
2230 | (OVL_USING_P (maybe_ovl) << 0))))
2231 {
2232 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl)
2233 && (!copying || OVL_USED_P (maybe_ovl)));
2234 if (OVL_USED_P (maybe_ovl))
2235 {
2236 copying = true;
2237 maybe_ovl = ovl_copy (maybe_ovl);
2238 if (insert_after)
2239 OVL_CHAIN (insert_after) = maybe_ovl;
2240 }
2241 if (!result)
2242 result = maybe_ovl;
2243 insert_after = maybe_ovl;
2244 maybe_ovl = OVL_CHAIN (maybe_ovl);
2245 }
2246
2247 tree trail = fn;
2248 if (maybe_ovl || using_p || hidden_p || TREE_CODE (fn) == TEMPLATE_DECL)
2249 {
2250 trail = ovl_make (fn, maybe_ovl);
2251 if (hidden_p)
2252 OVL_HIDDEN_P (trail) = true;
2253 if (using_p)
2254 OVL_USING_P (trail) = true;
2255 }
2256
2257 if (insert_after)
2258 {
2259 OVL_CHAIN (insert_after) = trail;
2260 TREE_TYPE (insert_after) = unknown_type_node;
2261 }
2262 else
2263 result = trail;
2264
2265 return result;
2266 }
2267
2268 /* Skip any hidden names at the beginning of OVL. */
2269
2270 tree
ovl_skip_hidden(tree ovl)2271 ovl_skip_hidden (tree ovl)
2272 {
2273 for (;
2274 ovl && TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
2275 ovl = OVL_CHAIN (ovl))
2276 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl)));
2277
2278 if (ovl && TREE_CODE (ovl) != OVERLOAD && DECL_HIDDEN_P (ovl))
2279 {
2280 /* Any hidden functions should have been wrapped in an
2281 overload, but injected friend classes will not. */
2282 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl));
2283 ovl = NULL_TREE;
2284 }
2285
2286 return ovl;
2287 }
2288
2289 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2290
2291 tree
reveal_node(tree overload,tree node)2292 ovl_iterator::reveal_node (tree overload, tree node)
2293 {
2294 /* We cannot have returned NODE as part of a lookup overload, so it
2295 cannot be USED. */
2296 gcc_checking_assert (!OVL_USED_P (node));
2297
2298 OVL_HIDDEN_P (node) = false;
2299 if (tree chain = OVL_CHAIN (node))
2300 if (TREE_CODE (chain) == OVERLOAD
2301 && (OVL_USING_P (chain) || OVL_HIDDEN_P (chain)))
2302 {
2303 /* The node needs moving, and the simplest way is to remove it
2304 and reinsert. */
2305 overload = remove_node (overload, node);
2306 overload = ovl_insert (OVL_FUNCTION (node), overload);
2307 }
2308 return overload;
2309 }
2310
2311 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2312 OVL_USED_P we must copy OVL nodes, because those are immutable.
2313 The removed node is unaltered and may continue to be iterated
2314 from (i.e. it is safe to remove a node from an overload one is
2315 currently iterating over). */
2316
2317 tree
remove_node(tree overload,tree node)2318 ovl_iterator::remove_node (tree overload, tree node)
2319 {
2320 bool copying = false; /* Checking use only. */
2321
2322 tree *slot = &overload;
2323 while (*slot != node)
2324 {
2325 tree probe = *slot;
2326 gcc_checking_assert (!OVL_LOOKUP_P (probe)
2327 && (!copying || OVL_USED_P (probe)));
2328 if (OVL_USED_P (probe))
2329 {
2330 copying = true;
2331 probe = ovl_copy (probe);
2332 *slot = probe;
2333 }
2334
2335 slot = &OVL_CHAIN (probe);
2336 }
2337
2338 /* Stitch out NODE. We don't have to worry about now making a
2339 singleton overload (and consequently maybe setting its type),
2340 because all uses of this function will be followed by inserting a
2341 new node that must follow the place we've cut this out from. */
2342 if (TREE_CODE (node) != OVERLOAD)
2343 /* Cloned inherited ctors don't mark themselves as via_using. */
2344 *slot = NULL_TREE;
2345 else
2346 *slot = OVL_CHAIN (node);
2347
2348 return overload;
2349 }
2350
2351 /* Mark or unmark a lookup set. */
2352
2353 void
lookup_mark(tree ovl,bool val)2354 lookup_mark (tree ovl, bool val)
2355 {
2356 for (lkp_iterator iter (ovl); iter; ++iter)
2357 {
2358 gcc_checking_assert (LOOKUP_SEEN_P (*iter) != val);
2359 LOOKUP_SEEN_P (*iter) = val;
2360 }
2361 }
2362
2363 /* Add a set of new FNS into a lookup. */
2364
2365 tree
lookup_add(tree fns,tree lookup)2366 lookup_add (tree fns, tree lookup)
2367 {
2368 if (lookup || TREE_CODE (fns) == TEMPLATE_DECL)
2369 {
2370 lookup = ovl_make (fns, lookup);
2371 OVL_LOOKUP_P (lookup) = true;
2372 }
2373 else
2374 lookup = fns;
2375
2376 return lookup;
2377 }
2378
2379 /* FNS is a new overload set, add them to LOOKUP, if they are not
2380 already present there. */
2381
2382 tree
lookup_maybe_add(tree fns,tree lookup,bool deduping)2383 lookup_maybe_add (tree fns, tree lookup, bool deduping)
2384 {
2385 if (deduping)
2386 for (tree next, probe = fns; probe; probe = next)
2387 {
2388 tree fn = probe;
2389 next = NULL_TREE;
2390
2391 if (TREE_CODE (probe) == OVERLOAD)
2392 {
2393 fn = OVL_FUNCTION (probe);
2394 next = OVL_CHAIN (probe);
2395 }
2396
2397 if (!LOOKUP_SEEN_P (fn))
2398 LOOKUP_SEEN_P (fn) = true;
2399 else
2400 {
2401 /* This function was already seen. Insert all the
2402 predecessors onto the lookup. */
2403 for (; fns != probe; fns = OVL_CHAIN (fns))
2404 {
2405 lookup = lookup_add (OVL_FUNCTION (fns), lookup);
2406 /* Propagate OVL_USING, but OVL_HIDDEN doesn't matter. */
2407 if (OVL_USING_P (fns))
2408 OVL_USING_P (lookup) = true;
2409 }
2410
2411 /* And now skip this function. */
2412 fns = next;
2413 }
2414 }
2415
2416 if (fns)
2417 /* We ended in a set of new functions. Add them all in one go. */
2418 lookup = lookup_add (fns, lookup);
2419
2420 return lookup;
2421 }
2422
2423 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2424 it as immutable. */
2425
2426 static void
ovl_used(tree ovl)2427 ovl_used (tree ovl)
2428 {
2429 for (;
2430 ovl && TREE_CODE (ovl) == OVERLOAD
2431 && !OVL_USED_P (ovl);
2432 ovl = OVL_CHAIN (ovl))
2433 {
2434 gcc_checking_assert (!OVL_LOOKUP_P (ovl));
2435 OVL_USED_P (ovl) = true;
2436 }
2437 }
2438
2439 /* If KEEP is true, preserve the contents of a lookup so that it is
2440 available for a later instantiation. Otherwise release the LOOKUP
2441 nodes for reuse. */
2442
2443 void
lookup_keep(tree lookup,bool keep)2444 lookup_keep (tree lookup, bool keep)
2445 {
2446 for (;
2447 lookup && TREE_CODE (lookup) == OVERLOAD
2448 && OVL_LOOKUP_P (lookup) && !OVL_USED_P (lookup);
2449 lookup = OVL_CHAIN (lookup))
2450 if (keep)
2451 {
2452 OVL_USED_P (lookup) = true;
2453 ovl_used (OVL_FUNCTION (lookup));
2454 }
2455 else
2456 {
2457 OVL_FUNCTION (lookup) = ovl_cache;
2458 ovl_cache = lookup;
2459 }
2460
2461 if (keep)
2462 ovl_used (lookup);
2463 }
2464
2465 /* LIST is a TREE_LIST whose TREE_VALUEs may be OVERLOADS that need
2466 keeping, or may be ignored. */
2467
2468 void
lookup_list_keep(tree list,bool keep)2469 lookup_list_keep (tree list, bool keep)
2470 {
2471 for (; list; list = TREE_CHAIN (list))
2472 {
2473 tree v = TREE_VALUE (list);
2474 if (TREE_CODE (v) == OVERLOAD)
2475 lookup_keep (v, keep);
2476 }
2477 }
2478
2479 /* Returns nonzero if X is an expression for a (possibly overloaded)
2480 function. If "f" is a function or function template, "f", "c->f",
2481 "c.f", "C::f", and "f<int>" will all be considered possibly
2482 overloaded functions. Returns 2 if the function is actually
2483 overloaded, i.e., if it is impossible to know the type of the
2484 function without performing overload resolution. */
2485
2486 int
is_overloaded_fn(tree x)2487 is_overloaded_fn (tree x)
2488 {
2489 /* A baselink is also considered an overloaded function. */
2490 if (TREE_CODE (x) == OFFSET_REF
2491 || TREE_CODE (x) == COMPONENT_REF)
2492 x = TREE_OPERAND (x, 1);
2493 x = MAYBE_BASELINK_FUNCTIONS (x);
2494 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
2495 x = TREE_OPERAND (x, 0);
2496
2497 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x))
2498 || (TREE_CODE (x) == OVERLOAD && !OVL_SINGLE_P (x)))
2499 return 2;
2500
2501 return (TREE_CODE (x) == FUNCTION_DECL
2502 || TREE_CODE (x) == OVERLOAD);
2503 }
2504
2505 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2506 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2507 NULL_TREE. */
2508
2509 tree
dependent_name(tree x)2510 dependent_name (tree x)
2511 {
2512 if (identifier_p (x))
2513 return x;
2514 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
2515 x = TREE_OPERAND (x, 0);
2516 if (TREE_CODE (x) == OVERLOAD || TREE_CODE (x) == FUNCTION_DECL)
2517 return OVL_NAME (x);
2518 return NULL_TREE;
2519 }
2520
2521 /* Returns true iff X is an expression for an overloaded function
2522 whose type cannot be known without performing overload
2523 resolution. */
2524
2525 bool
really_overloaded_fn(tree x)2526 really_overloaded_fn (tree x)
2527 {
2528 return is_overloaded_fn (x) == 2;
2529 }
2530
2531 /* Get the overload set FROM refers to. */
2532
2533 tree
get_fns(tree from)2534 get_fns (tree from)
2535 {
2536 /* A baselink is also considered an overloaded function. */
2537 if (TREE_CODE (from) == OFFSET_REF
2538 || TREE_CODE (from) == COMPONENT_REF)
2539 from = TREE_OPERAND (from, 1);
2540 if (BASELINK_P (from))
2541 from = BASELINK_FUNCTIONS (from);
2542 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
2543 from = TREE_OPERAND (from, 0);
2544 gcc_assert (TREE_CODE (from) == OVERLOAD
2545 || TREE_CODE (from) == FUNCTION_DECL);
2546 return from;
2547 }
2548
2549 /* Return the first function of the overload set FROM refers to. */
2550
2551 tree
get_first_fn(tree from)2552 get_first_fn (tree from)
2553 {
2554 return OVL_FIRST (get_fns (from));
2555 }
2556
2557 /* Return the scope where the overloaded functions OVL were found. */
2558
2559 tree
ovl_scope(tree ovl)2560 ovl_scope (tree ovl)
2561 {
2562 if (TREE_CODE (ovl) == OFFSET_REF
2563 || TREE_CODE (ovl) == COMPONENT_REF)
2564 ovl = TREE_OPERAND (ovl, 1);
2565 if (TREE_CODE (ovl) == BASELINK)
2566 return BINFO_TYPE (BASELINK_BINFO (ovl));
2567 if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
2568 ovl = TREE_OPERAND (ovl, 0);
2569 /* Skip using-declarations. */
2570 lkp_iterator iter (ovl);
2571 do
2572 ovl = *iter;
2573 while (iter.using_p () && ++iter);
2574
2575 return CP_DECL_CONTEXT (ovl);
2576 }
2577
2578 #define PRINT_RING_SIZE 4
2579
2580 static const char *
cxx_printable_name_internal(tree decl,int v,bool translate)2581 cxx_printable_name_internal (tree decl, int v, bool translate)
2582 {
2583 static unsigned int uid_ring[PRINT_RING_SIZE];
2584 static char *print_ring[PRINT_RING_SIZE];
2585 static bool trans_ring[PRINT_RING_SIZE];
2586 static int ring_counter;
2587 int i;
2588
2589 /* Only cache functions. */
2590 if (v < 2
2591 || TREE_CODE (decl) != FUNCTION_DECL
2592 || DECL_LANG_SPECIFIC (decl) == 0)
2593 return lang_decl_name (decl, v, translate);
2594
2595 /* See if this print name is lying around. */
2596 for (i = 0; i < PRINT_RING_SIZE; i++)
2597 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
2598 /* yes, so return it. */
2599 return print_ring[i];
2600
2601 if (++ring_counter == PRINT_RING_SIZE)
2602 ring_counter = 0;
2603
2604 if (current_function_decl != NULL_TREE)
2605 {
2606 /* There may be both translated and untranslated versions of the
2607 name cached. */
2608 for (i = 0; i < 2; i++)
2609 {
2610 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
2611 ring_counter += 1;
2612 if (ring_counter == PRINT_RING_SIZE)
2613 ring_counter = 0;
2614 }
2615 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
2616 }
2617
2618 free (print_ring[ring_counter]);
2619
2620 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
2621 uid_ring[ring_counter] = DECL_UID (decl);
2622 trans_ring[ring_counter] = translate;
2623 return print_ring[ring_counter];
2624 }
2625
2626 const char *
cxx_printable_name(tree decl,int v)2627 cxx_printable_name (tree decl, int v)
2628 {
2629 return cxx_printable_name_internal (decl, v, false);
2630 }
2631
2632 const char *
cxx_printable_name_translate(tree decl,int v)2633 cxx_printable_name_translate (tree decl, int v)
2634 {
2635 return cxx_printable_name_internal (decl, v, true);
2636 }
2637
2638 /* Return the canonical version of exception-specification RAISES for a C++17
2639 function type, for use in type comparison and building TYPE_CANONICAL. */
2640
2641 tree
canonical_eh_spec(tree raises)2642 canonical_eh_spec (tree raises)
2643 {
2644 if (raises == NULL_TREE)
2645 return raises;
2646 else if (DEFERRED_NOEXCEPT_SPEC_P (raises)
2647 || uses_template_parms (raises)
2648 || uses_template_parms (TREE_PURPOSE (raises)))
2649 /* Keep a dependent or deferred exception specification. */
2650 return raises;
2651 else if (nothrow_spec_p (raises))
2652 /* throw() -> noexcept. */
2653 return noexcept_true_spec;
2654 else
2655 /* For C++17 type matching, anything else -> nothing. */
2656 return NULL_TREE;
2657 }
2658
2659 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2660 listed in RAISES. */
2661
2662 tree
build_exception_variant(tree type,tree raises)2663 build_exception_variant (tree type, tree raises)
2664 {
2665 tree v;
2666 int type_quals;
2667
2668 if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
2669 return type;
2670
2671 type_quals = TYPE_QUALS (type);
2672 cp_ref_qualifier rqual = type_memfn_rqual (type);
2673 for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
2674 if (cp_check_qualified_type (v, type, type_quals, rqual, raises))
2675 return v;
2676
2677 /* Need to build a new variant. */
2678 v = build_variant_type_copy (type);
2679 TYPE_RAISES_EXCEPTIONS (v) = raises;
2680
2681 if (!flag_noexcept_type)
2682 /* The exception-specification is not part of the canonical type. */
2683 return v;
2684
2685 /* Canonicalize the exception specification. */
2686 tree cr = canonical_eh_spec (raises);
2687
2688 if (TYPE_STRUCTURAL_EQUALITY_P (type))
2689 /* Propagate structural equality. */
2690 SET_TYPE_STRUCTURAL_EQUALITY (v);
2691 else if (TYPE_CANONICAL (type) != type || cr != raises)
2692 /* Build the underlying canonical type, since it is different
2693 from TYPE. */
2694 TYPE_CANONICAL (v) = build_exception_variant (TYPE_CANONICAL (type), cr);
2695 else
2696 /* T is its own canonical type. */
2697 TYPE_CANONICAL (v) = v;
2698
2699 return v;
2700 }
2701
2702 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2703 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2704 arguments. */
2705
2706 tree
bind_template_template_parm(tree t,tree newargs)2707 bind_template_template_parm (tree t, tree newargs)
2708 {
2709 tree decl = TYPE_NAME (t);
2710 tree t2;
2711
2712 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
2713 decl = build_decl (input_location,
2714 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
2715
2716 /* These nodes have to be created to reflect new TYPE_DECL and template
2717 arguments. */
2718 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
2719 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
2720 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
2721 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
2722
2723 TREE_TYPE (decl) = t2;
2724 TYPE_NAME (t2) = decl;
2725 TYPE_STUB_DECL (t2) = decl;
2726 TYPE_SIZE (t2) = 0;
2727 SET_TYPE_STRUCTURAL_EQUALITY (t2);
2728
2729 return t2;
2730 }
2731
2732 /* Called from count_trees via walk_tree. */
2733
2734 static tree
count_trees_r(tree * tp,int * walk_subtrees,void * data)2735 count_trees_r (tree *tp, int *walk_subtrees, void *data)
2736 {
2737 ++*((int *) data);
2738
2739 if (TYPE_P (*tp))
2740 *walk_subtrees = 0;
2741
2742 return NULL_TREE;
2743 }
2744
2745 /* Debugging function for measuring the rough complexity of a tree
2746 representation. */
2747
2748 int
count_trees(tree t)2749 count_trees (tree t)
2750 {
2751 int n_trees = 0;
2752 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
2753 return n_trees;
2754 }
2755
2756 /* Called from verify_stmt_tree via walk_tree. */
2757
2758 static tree
verify_stmt_tree_r(tree * tp,int *,void * data)2759 verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data)
2760 {
2761 tree t = *tp;
2762 hash_table<nofree_ptr_hash <tree_node> > *statements
2763 = static_cast <hash_table<nofree_ptr_hash <tree_node> > *> (data);
2764 tree_node **slot;
2765
2766 if (!STATEMENT_CODE_P (TREE_CODE (t)))
2767 return NULL_TREE;
2768
2769 /* If this statement is already present in the hash table, then
2770 there is a circularity in the statement tree. */
2771 gcc_assert (!statements->find (t));
2772
2773 slot = statements->find_slot (t, INSERT);
2774 *slot = t;
2775
2776 return NULL_TREE;
2777 }
2778
2779 /* Debugging function to check that the statement T has not been
2780 corrupted. For now, this function simply checks that T contains no
2781 circularities. */
2782
2783 void
verify_stmt_tree(tree t)2784 verify_stmt_tree (tree t)
2785 {
2786 hash_table<nofree_ptr_hash <tree_node> > statements (37);
2787 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
2788 }
2789
2790 /* Check if the type T depends on a type with no linkage and if so, return
2791 it. If RELAXED_P then do not consider a class type declared within
2792 a vague-linkage function to have no linkage. */
2793
2794 tree
no_linkage_check(tree t,bool relaxed_p)2795 no_linkage_check (tree t, bool relaxed_p)
2796 {
2797 tree r;
2798
2799 /* There's no point in checking linkage on template functions; we
2800 can't know their complete types. */
2801 if (processing_template_decl)
2802 return NULL_TREE;
2803
2804 switch (TREE_CODE (t))
2805 {
2806 case RECORD_TYPE:
2807 if (TYPE_PTRMEMFUNC_P (t))
2808 goto ptrmem;
2809 /* Lambda types that don't have mangling scope have no linkage. We
2810 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2811 when we get here from pushtag none of the lambda information is
2812 set up yet, so we want to assume that the lambda has linkage and
2813 fix it up later if not. */
2814 if (CLASSTYPE_LAMBDA_EXPR (t)
2815 && CLASSTYPE_LAMBDA_EXPR (t) != error_mark_node
2816 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
2817 return t;
2818 /* Fall through. */
2819 case UNION_TYPE:
2820 if (!CLASS_TYPE_P (t))
2821 return NULL_TREE;
2822 /* Fall through. */
2823 case ENUMERAL_TYPE:
2824 /* Only treat unnamed types as having no linkage if they're at
2825 namespace scope. This is core issue 966. */
2826 if (TYPE_UNNAMED_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
2827 return t;
2828
2829 for (r = CP_TYPE_CONTEXT (t); ; )
2830 {
2831 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2832 have linkage, or we might just be in an anonymous namespace.
2833 If we're in a TREE_PUBLIC class, we have linkage. */
2834 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
2835 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
2836 else if (TREE_CODE (r) == FUNCTION_DECL)
2837 {
2838 if (!relaxed_p || !vague_linkage_p (r))
2839 return t;
2840 else
2841 r = CP_DECL_CONTEXT (r);
2842 }
2843 else
2844 break;
2845 }
2846
2847 return NULL_TREE;
2848
2849 case ARRAY_TYPE:
2850 case POINTER_TYPE:
2851 case REFERENCE_TYPE:
2852 case VECTOR_TYPE:
2853 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2854
2855 case OFFSET_TYPE:
2856 ptrmem:
2857 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
2858 relaxed_p);
2859 if (r)
2860 return r;
2861 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
2862
2863 case METHOD_TYPE:
2864 case FUNCTION_TYPE:
2865 {
2866 tree parm = TYPE_ARG_TYPES (t);
2867 if (TREE_CODE (t) == METHOD_TYPE)
2868 /* The 'this' pointer isn't interesting; a method has the same
2869 linkage (or lack thereof) as its enclosing class. */
2870 parm = TREE_CHAIN (parm);
2871 for (;
2872 parm && parm != void_list_node;
2873 parm = TREE_CHAIN (parm))
2874 {
2875 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
2876 if (r)
2877 return r;
2878 }
2879 return no_linkage_check (TREE_TYPE (t), relaxed_p);
2880 }
2881
2882 default:
2883 return NULL_TREE;
2884 }
2885 }
2886
2887 extern int depth_reached;
2888
2889 void
cxx_print_statistics(void)2890 cxx_print_statistics (void)
2891 {
2892 print_template_statistics ();
2893 if (GATHER_STATISTICS)
2894 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2895 depth_reached);
2896 }
2897
2898 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2899 (which is an ARRAY_TYPE). This counts only elements of the top
2900 array. */
2901
2902 tree
array_type_nelts_top(tree type)2903 array_type_nelts_top (tree type)
2904 {
2905 return fold_build2_loc (input_location,
2906 PLUS_EXPR, sizetype,
2907 array_type_nelts (type),
2908 size_one_node);
2909 }
2910
2911 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2912 (which is an ARRAY_TYPE). This one is a recursive count of all
2913 ARRAY_TYPEs that are clumped together. */
2914
2915 tree
array_type_nelts_total(tree type)2916 array_type_nelts_total (tree type)
2917 {
2918 tree sz = array_type_nelts_top (type);
2919 type = TREE_TYPE (type);
2920 while (TREE_CODE (type) == ARRAY_TYPE)
2921 {
2922 tree n = array_type_nelts_top (type);
2923 sz = fold_build2_loc (input_location,
2924 MULT_EXPR, sizetype, sz, n);
2925 type = TREE_TYPE (type);
2926 }
2927 return sz;
2928 }
2929
2930 struct bot_data
2931 {
2932 splay_tree target_remap;
2933 bool clear_location;
2934 };
2935
2936 /* Called from break_out_target_exprs via mapcar. */
2937
2938 static tree
bot_manip(tree * tp,int * walk_subtrees,void * data_)2939 bot_manip (tree* tp, int* walk_subtrees, void* data_)
2940 {
2941 bot_data &data = *(bot_data*)data_;
2942 splay_tree target_remap = data.target_remap;
2943 tree t = *tp;
2944
2945 if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2946 {
2947 /* There can't be any TARGET_EXPRs or their slot variables below this
2948 point. But we must make a copy, in case subsequent processing
2949 alters any part of it. For example, during gimplification a cast
2950 of the form (T) &X::f (where "f" is a member function) will lead
2951 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2952 *walk_subtrees = 0;
2953 *tp = unshare_expr (t);
2954 return NULL_TREE;
2955 }
2956 if (TREE_CODE (t) == TARGET_EXPR)
2957 {
2958 tree u;
2959
2960 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2961 {
2962 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2963 tf_warning_or_error);
2964 if (u == error_mark_node)
2965 return u;
2966 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2967 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2968 }
2969 else
2970 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2971 tf_warning_or_error);
2972
2973 TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2974 TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2975 TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2976
2977 /* Map the old variable to the new one. */
2978 splay_tree_insert (target_remap,
2979 (splay_tree_key) TREE_OPERAND (t, 0),
2980 (splay_tree_value) TREE_OPERAND (u, 0));
2981
2982 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1),
2983 data.clear_location);
2984 if (TREE_OPERAND (u, 1) == error_mark_node)
2985 return error_mark_node;
2986
2987 /* Replace the old expression with the new version. */
2988 *tp = u;
2989 /* We don't have to go below this point; the recursive call to
2990 break_out_target_exprs will have handled anything below this
2991 point. */
2992 *walk_subtrees = 0;
2993 return NULL_TREE;
2994 }
2995 if (TREE_CODE (*tp) == SAVE_EXPR)
2996 {
2997 t = *tp;
2998 splay_tree_node n = splay_tree_lookup (target_remap,
2999 (splay_tree_key) t);
3000 if (n)
3001 {
3002 *tp = (tree)n->value;
3003 *walk_subtrees = 0;
3004 }
3005 else
3006 {
3007 copy_tree_r (tp, walk_subtrees, NULL);
3008 splay_tree_insert (target_remap,
3009 (splay_tree_key)t,
3010 (splay_tree_value)*tp);
3011 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3012 splay_tree_insert (target_remap,
3013 (splay_tree_key)*tp,
3014 (splay_tree_value)*tp);
3015 }
3016 return NULL_TREE;
3017 }
3018
3019 /* Make a copy of this node. */
3020 t = copy_tree_r (tp, walk_subtrees, NULL);
3021 if (TREE_CODE (*tp) == CALL_EXPR)
3022 if (!processing_template_decl)
3023 set_flags_from_callee (*tp);
3024 if (data.clear_location && EXPR_HAS_LOCATION (*tp))
3025 SET_EXPR_LOCATION (*tp, input_location);
3026 return t;
3027 }
3028
3029 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3030 DATA is really a splay-tree mapping old variables to new
3031 variables. */
3032
3033 static tree
bot_replace(tree * t,int *,void * data_)3034 bot_replace (tree* t, int* /*walk_subtrees*/, void* data_)
3035 {
3036 bot_data &data = *(bot_data*)data_;
3037 splay_tree target_remap = data.target_remap;
3038
3039 if (VAR_P (*t))
3040 {
3041 splay_tree_node n = splay_tree_lookup (target_remap,
3042 (splay_tree_key) *t);
3043 if (n)
3044 *t = (tree) n->value;
3045 }
3046 else if (TREE_CODE (*t) == PARM_DECL
3047 && DECL_NAME (*t) == this_identifier
3048 && !DECL_CONTEXT (*t))
3049 {
3050 /* In an NSDMI we need to replace the 'this' parameter we used for
3051 parsing with the real one for this function. */
3052 *t = current_class_ptr;
3053 }
3054 else if (TREE_CODE (*t) == CONVERT_EXPR
3055 && CONVERT_EXPR_VBASE_PATH (*t))
3056 {
3057 /* In an NSDMI build_base_path defers building conversions to virtual
3058 bases, and we handle it here. */
3059 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
3060 vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
3061 int i; tree binfo;
3062 FOR_EACH_VEC_SAFE_ELT (vbases, i, binfo)
3063 if (BINFO_TYPE (binfo) == basetype)
3064 break;
3065 *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
3066 tf_warning_or_error);
3067 }
3068
3069 return NULL_TREE;
3070 }
3071
3072 /* When we parse a default argument expression, we may create
3073 temporary variables via TARGET_EXPRs. When we actually use the
3074 default-argument expression, we make a copy of the expression
3075 and replace the temporaries with appropriate local versions.
3076
3077 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3078 input_location. */
3079
3080 tree
break_out_target_exprs(tree t,bool clear_location)3081 break_out_target_exprs (tree t, bool clear_location /* = false */)
3082 {
3083 static int target_remap_count;
3084 static splay_tree target_remap;
3085
3086 if (!target_remap_count++)
3087 target_remap = splay_tree_new (splay_tree_compare_pointers,
3088 /*splay_tree_delete_key_fn=*/NULL,
3089 /*splay_tree_delete_value_fn=*/NULL);
3090 bot_data data = { target_remap, clear_location };
3091 if (cp_walk_tree (&t, bot_manip, &data, NULL) == error_mark_node)
3092 t = error_mark_node;
3093 cp_walk_tree (&t, bot_replace, &data, NULL);
3094
3095 if (!--target_remap_count)
3096 {
3097 splay_tree_delete (target_remap);
3098 target_remap = NULL;
3099 }
3100
3101 return t;
3102 }
3103
3104 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3105 which we expect to have type TYPE. */
3106
3107 tree
build_ctor_subob_ref(tree index,tree type,tree obj)3108 build_ctor_subob_ref (tree index, tree type, tree obj)
3109 {
3110 if (index == NULL_TREE)
3111 /* Can't refer to a particular member of a vector. */
3112 obj = NULL_TREE;
3113 else if (TREE_CODE (index) == INTEGER_CST)
3114 obj = cp_build_array_ref (input_location, obj, index, tf_none);
3115 else
3116 obj = build_class_member_access_expr (obj, index, NULL_TREE,
3117 /*reference*/false, tf_none);
3118 if (obj)
3119 {
3120 tree objtype = TREE_TYPE (obj);
3121 if (TREE_CODE (objtype) == ARRAY_TYPE && !TYPE_DOMAIN (objtype))
3122 {
3123 /* When the destination object refers to a flexible array member
3124 verify that it matches the type of the source object except
3125 for its domain and qualifiers. */
3126 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),
3127 TYPE_MAIN_VARIANT (objtype),
3128 COMPARE_REDECLARATION));
3129 }
3130 else
3131 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype));
3132 }
3133
3134 return obj;
3135 }
3136
3137 struct replace_placeholders_t
3138 {
3139 tree obj; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3140 tree exp; /* The outermost exp. */
3141 bool seen; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3142 hash_set<tree> *pset; /* To avoid walking same trees multiple times. */
3143 };
3144
3145 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3146 build up subexpressions as we go deeper. */
3147
3148 static tree
replace_placeholders_r(tree * t,int * walk_subtrees,void * data_)3149 replace_placeholders_r (tree* t, int* walk_subtrees, void* data_)
3150 {
3151 replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_);
3152 tree obj = d->obj;
3153
3154 if (TYPE_P (*t) || TREE_CONSTANT (*t))
3155 {
3156 *walk_subtrees = false;
3157 return NULL_TREE;
3158 }
3159
3160 switch (TREE_CODE (*t))
3161 {
3162 case PLACEHOLDER_EXPR:
3163 {
3164 tree x = obj;
3165 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t),
3166 TREE_TYPE (x));
3167 x = TREE_OPERAND (x, 0))
3168 gcc_assert (handled_component_p (x));
3169 *t = unshare_expr (x);
3170 *walk_subtrees = false;
3171 d->seen = true;
3172 }
3173 break;
3174
3175 case CONSTRUCTOR:
3176 {
3177 constructor_elt *ce;
3178 vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t);
3179 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3180 other than the d->exp one, those have PLACEHOLDER_EXPRs
3181 related to another object. */
3182 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t)
3183 && *t != d->exp)
3184 || d->pset->add (*t))
3185 {
3186 *walk_subtrees = false;
3187 return NULL_TREE;
3188 }
3189 for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i)
3190 {
3191 tree *valp = &ce->value;
3192 tree type = TREE_TYPE (*valp);
3193 tree subob = obj;
3194
3195 if (TREE_CODE (*valp) == CONSTRUCTOR
3196 && AGGREGATE_TYPE_P (type))
3197 {
3198 /* If we're looking at the initializer for OBJ, then build
3199 a sub-object reference. If we're looking at an
3200 initializer for another object, just pass OBJ down. */
3201 if (same_type_ignoring_top_level_qualifiers_p
3202 (TREE_TYPE (*t), TREE_TYPE (obj)))
3203 subob = build_ctor_subob_ref (ce->index, type, obj);
3204 if (TREE_CODE (*valp) == TARGET_EXPR)
3205 valp = &TARGET_EXPR_INITIAL (*valp);
3206 }
3207 d->obj = subob;
3208 cp_walk_tree (valp, replace_placeholders_r, data_, NULL);
3209 d->obj = obj;
3210 }
3211 *walk_subtrees = false;
3212 break;
3213 }
3214
3215 default:
3216 if (d->pset->add (*t))
3217 *walk_subtrees = false;
3218 break;
3219 }
3220
3221 return NULL_TREE;
3222 }
3223
3224 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3225 a PLACEHOLDER_EXPR has been encountered. */
3226
3227 tree
replace_placeholders(tree exp,tree obj,bool * seen_p)3228 replace_placeholders (tree exp, tree obj, bool *seen_p)
3229 {
3230 /* This is only relevant for C++14. */
3231 if (cxx_dialect < cxx14)
3232 return exp;
3233
3234 /* If the object isn't a (member of a) class, do nothing. */
3235 tree op0 = obj;
3236 while (TREE_CODE (op0) == COMPONENT_REF)
3237 op0 = TREE_OPERAND (op0, 0);
3238 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0))))
3239 return exp;
3240
3241 tree *tp = &exp;
3242 if (TREE_CODE (exp) == TARGET_EXPR)
3243 tp = &TARGET_EXPR_INITIAL (exp);
3244 hash_set<tree> pset;
3245 replace_placeholders_t data = { obj, *tp, false, &pset };
3246 cp_walk_tree (tp, replace_placeholders_r, &data, NULL);
3247 if (seen_p)
3248 *seen_p = data.seen;
3249 return exp;
3250 }
3251
3252 /* Callback function for find_placeholders. */
3253
3254 static tree
find_placeholders_r(tree * t,int * walk_subtrees,void *)3255 find_placeholders_r (tree *t, int *walk_subtrees, void *)
3256 {
3257 if (TYPE_P (*t) || TREE_CONSTANT (*t))
3258 {
3259 *walk_subtrees = false;
3260 return NULL_TREE;
3261 }
3262
3263 switch (TREE_CODE (*t))
3264 {
3265 case PLACEHOLDER_EXPR:
3266 return *t;
3267
3268 case CONSTRUCTOR:
3269 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t))
3270 *walk_subtrees = false;
3271 break;
3272
3273 default:
3274 break;
3275 }
3276
3277 return NULL_TREE;
3278 }
3279
3280 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3281 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3282
3283 bool
find_placeholders(tree exp)3284 find_placeholders (tree exp)
3285 {
3286 /* This is only relevant for C++14. */
3287 if (cxx_dialect < cxx14)
3288 return false;
3289
3290 return cp_walk_tree_without_duplicates (&exp, find_placeholders_r, NULL);
3291 }
3292
3293 /* Similar to `build_nt', but for template definitions of dependent
3294 expressions */
3295
3296 tree
build_min_nt_loc(location_t loc,enum tree_code code,...)3297 build_min_nt_loc (location_t loc, enum tree_code code, ...)
3298 {
3299 tree t;
3300 int length;
3301 int i;
3302 va_list p;
3303
3304 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3305
3306 va_start (p, code);
3307
3308 t = make_node (code);
3309 SET_EXPR_LOCATION (t, loc);
3310 length = TREE_CODE_LENGTH (code);
3311
3312 for (i = 0; i < length; i++)
3313 {
3314 tree x = va_arg (p, tree);
3315 TREE_OPERAND (t, i) = x;
3316 if (x && TREE_CODE (x) == OVERLOAD)
3317 lookup_keep (x, true);
3318 }
3319
3320 va_end (p);
3321 return t;
3322 }
3323
3324 /* Similar to `build', but for template definitions. */
3325
3326 tree
build_min(enum tree_code code,tree tt,...)3327 build_min (enum tree_code code, tree tt, ...)
3328 {
3329 tree t;
3330 int length;
3331 int i;
3332 va_list p;
3333
3334 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3335
3336 va_start (p, tt);
3337
3338 t = make_node (code);
3339 length = TREE_CODE_LENGTH (code);
3340 TREE_TYPE (t) = tt;
3341
3342 for (i = 0; i < length; i++)
3343 {
3344 tree x = va_arg (p, tree);
3345 TREE_OPERAND (t, i) = x;
3346 if (x)
3347 {
3348 if (!TYPE_P (x) && TREE_SIDE_EFFECTS (x))
3349 TREE_SIDE_EFFECTS (t) = 1;
3350 if (TREE_CODE (x) == OVERLOAD)
3351 lookup_keep (x, true);
3352 }
3353 }
3354
3355 va_end (p);
3356
3357 if (code == CAST_EXPR)
3358 /* The single operand is a TREE_LIST, which we have to check. */
3359 lookup_list_keep (TREE_OPERAND (t, 0), true);
3360
3361 return t;
3362 }
3363
3364 /* Similar to `build', but for template definitions of non-dependent
3365 expressions. NON_DEP is the non-dependent expression that has been
3366 built. */
3367
3368 tree
build_min_non_dep(enum tree_code code,tree non_dep,...)3369 build_min_non_dep (enum tree_code code, tree non_dep, ...)
3370 {
3371 tree t;
3372 int length;
3373 int i;
3374 va_list p;
3375
3376 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3377
3378 va_start (p, non_dep);
3379
3380 if (REFERENCE_REF_P (non_dep))
3381 non_dep = TREE_OPERAND (non_dep, 0);
3382
3383 t = make_node (code);
3384 length = TREE_CODE_LENGTH (code);
3385 TREE_TYPE (t) = unlowered_expr_type (non_dep);
3386 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3387
3388 for (i = 0; i < length; i++)
3389 {
3390 tree x = va_arg (p, tree);
3391 TREE_OPERAND (t, i) = x;
3392 if (x && TREE_CODE (x) == OVERLOAD)
3393 lookup_keep (x, true);
3394 }
3395
3396 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
3397 /* This should not be considered a COMPOUND_EXPR, because it
3398 resolves to an overload. */
3399 COMPOUND_EXPR_OVERLOADED (t) = 1;
3400
3401 va_end (p);
3402 return convert_from_reference (t);
3403 }
3404
3405 /* Similar to build_min_nt, but call expressions */
3406
3407 tree
build_min_nt_call_vec(tree fn,vec<tree,va_gc> * args)3408 build_min_nt_call_vec (tree fn, vec<tree, va_gc> *args)
3409 {
3410 tree ret, t;
3411 unsigned int ix;
3412
3413 ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
3414 CALL_EXPR_FN (ret) = fn;
3415 CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3416 FOR_EACH_VEC_SAFE_ELT (args, ix, t)
3417 {
3418 CALL_EXPR_ARG (ret, ix) = t;
3419 if (TREE_CODE (t) == OVERLOAD)
3420 lookup_keep (t, true);
3421 }
3422 return ret;
3423 }
3424
3425 /* Similar to `build_min_nt_call_vec', but for template definitions of
3426 non-dependent expressions. NON_DEP is the non-dependent expression
3427 that has been built. */
3428
3429 tree
build_min_non_dep_call_vec(tree non_dep,tree fn,vec<tree,va_gc> * argvec)3430 build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
3431 {
3432 tree t = build_min_nt_call_vec (fn, argvec);
3433 if (REFERENCE_REF_P (non_dep))
3434 non_dep = TREE_OPERAND (non_dep, 0);
3435 TREE_TYPE (t) = TREE_TYPE (non_dep);
3436 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3437 return convert_from_reference (t);
3438 }
3439
3440 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3441 a call to an operator overload. OP is the operator that has been
3442 overloaded. NON_DEP is the non-dependent expression that's been built,
3443 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3444 the overload that NON_DEP is calling. */
3445
3446 tree
build_min_non_dep_op_overload(enum tree_code op,tree non_dep,tree overload,...)3447 build_min_non_dep_op_overload (enum tree_code op,
3448 tree non_dep,
3449 tree overload, ...)
3450 {
3451 va_list p;
3452 int nargs, expected_nargs;
3453 tree fn, call;
3454 vec<tree, va_gc> *args;
3455
3456 non_dep = extract_call_expr (non_dep);
3457
3458 nargs = call_expr_nargs (non_dep);
3459
3460 expected_nargs = cp_tree_code_length (op);
3461 if ((op == POSTINCREMENT_EXPR
3462 || op == POSTDECREMENT_EXPR)
3463 /* With -fpermissive non_dep could be operator++(). */
3464 && (!flag_permissive || nargs != expected_nargs))
3465 expected_nargs += 1;
3466 gcc_assert (nargs == expected_nargs);
3467
3468 args = make_tree_vector ();
3469 va_start (p, overload);
3470
3471 if (TREE_CODE (TREE_TYPE (overload)) == FUNCTION_TYPE)
3472 {
3473 fn = overload;
3474 for (int i = 0; i < nargs; i++)
3475 {
3476 tree arg = va_arg (p, tree);
3477 vec_safe_push (args, arg);
3478 }
3479 }
3480 else if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE)
3481 {
3482 tree object = va_arg (p, tree);
3483 tree binfo = TYPE_BINFO (TREE_TYPE (object));
3484 tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
3485 fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
3486 object, method, NULL_TREE);
3487 for (int i = 1; i < nargs; i++)
3488 {
3489 tree arg = va_arg (p, tree);
3490 vec_safe_push (args, arg);
3491 }
3492 }
3493 else
3494 gcc_unreachable ();
3495
3496 va_end (p);
3497 call = build_min_non_dep_call_vec (non_dep, fn, args);
3498 release_tree_vector (args);
3499
3500 tree call_expr = extract_call_expr (call);
3501 KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
3502 CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
3503 CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
3504 CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
3505
3506 return call;
3507 }
3508
3509 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3510
3511 vec<tree, va_gc> *
vec_copy_and_insert(vec<tree,va_gc> * old_vec,tree elt,unsigned idx)3512 vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx)
3513 {
3514 unsigned len = vec_safe_length (old_vec);
3515 gcc_assert (idx <= len);
3516
3517 vec<tree, va_gc> *new_vec = NULL;
3518 vec_alloc (new_vec, len + 1);
3519
3520 unsigned i;
3521 for (i = 0; i < len; ++i)
3522 {
3523 if (i == idx)
3524 new_vec->quick_push (elt);
3525 new_vec->quick_push ((*old_vec)[i]);
3526 }
3527 if (i == idx)
3528 new_vec->quick_push (elt);
3529
3530 return new_vec;
3531 }
3532
3533 tree
get_type_decl(tree t)3534 get_type_decl (tree t)
3535 {
3536 if (TREE_CODE (t) == TYPE_DECL)
3537 return t;
3538 if (TYPE_P (t))
3539 return TYPE_STUB_DECL (t);
3540 gcc_assert (t == error_mark_node);
3541 return t;
3542 }
3543
3544 /* Returns the namespace that contains DECL, whether directly or
3545 indirectly. */
3546
3547 tree
decl_namespace_context(tree decl)3548 decl_namespace_context (tree decl)
3549 {
3550 while (1)
3551 {
3552 if (TREE_CODE (decl) == NAMESPACE_DECL)
3553 return decl;
3554 else if (TYPE_P (decl))
3555 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
3556 else
3557 decl = CP_DECL_CONTEXT (decl);
3558 }
3559 }
3560
3561 /* Returns true if decl is within an anonymous namespace, however deeply
3562 nested, or false otherwise. */
3563
3564 bool
decl_anon_ns_mem_p(const_tree decl)3565 decl_anon_ns_mem_p (const_tree decl)
3566 {
3567 while (TREE_CODE (decl) != NAMESPACE_DECL)
3568 {
3569 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3570 if (TYPE_P (decl))
3571 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl));
3572
3573 decl = CP_DECL_CONTEXT (decl);
3574 }
3575 return !TREE_PUBLIC (decl);
3576 }
3577
3578 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3579 CALL_EXPRS. Return whether they are equivalent. */
3580
3581 static bool
called_fns_equal(tree t1,tree t2)3582 called_fns_equal (tree t1, tree t2)
3583 {
3584 /* Core 1321: dependent names are equivalent even if the overload sets
3585 are different. But do compare explicit template arguments. */
3586 tree name1 = dependent_name (t1);
3587 tree name2 = dependent_name (t2);
3588 if (name1 || name2)
3589 {
3590 tree targs1 = NULL_TREE, targs2 = NULL_TREE;
3591
3592 if (name1 != name2)
3593 return false;
3594
3595 if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
3596 targs1 = TREE_OPERAND (t1, 1);
3597 if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
3598 targs2 = TREE_OPERAND (t2, 1);
3599 return cp_tree_equal (targs1, targs2);
3600 }
3601 else
3602 return cp_tree_equal (t1, t2);
3603 }
3604
3605 /* Return truthvalue of whether T1 is the same tree structure as T2.
3606 Return 1 if they are the same. Return 0 if they are different. */
3607
3608 bool
cp_tree_equal(tree t1,tree t2)3609 cp_tree_equal (tree t1, tree t2)
3610 {
3611 enum tree_code code1, code2;
3612
3613 if (t1 == t2)
3614 return true;
3615 if (!t1 || !t2)
3616 return false;
3617
3618 code1 = TREE_CODE (t1);
3619 code2 = TREE_CODE (t2);
3620
3621 if (code1 != code2)
3622 return false;
3623
3624 if (CONSTANT_CLASS_P (t1)
3625 && !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3626 return false;
3627
3628 switch (code1)
3629 {
3630 case VOID_CST:
3631 /* There's only a single VOID_CST node, so we should never reach
3632 here. */
3633 gcc_unreachable ();
3634
3635 case INTEGER_CST:
3636 return tree_int_cst_equal (t1, t2);
3637
3638 case REAL_CST:
3639 return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
3640
3641 case STRING_CST:
3642 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3643 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3644 TREE_STRING_LENGTH (t1));
3645
3646 case FIXED_CST:
3647 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
3648 TREE_FIXED_CST (t2));
3649
3650 case COMPLEX_CST:
3651 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
3652 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
3653
3654 case VECTOR_CST:
3655 return operand_equal_p (t1, t2, OEP_ONLY_CONST);
3656
3657 case CONSTRUCTOR:
3658 /* We need to do this when determining whether or not two
3659 non-type pointer to member function template arguments
3660 are the same. */
3661 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
3662 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
3663 return false;
3664 {
3665 tree field, value;
3666 unsigned int i;
3667 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
3668 {
3669 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
3670 if (!cp_tree_equal (field, elt2->index)
3671 || !cp_tree_equal (value, elt2->value))
3672 return false;
3673 }
3674 }
3675 return true;
3676
3677 case TREE_LIST:
3678 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
3679 return false;
3680 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
3681 return false;
3682 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
3683
3684 case SAVE_EXPR:
3685 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3686
3687 case CALL_EXPR:
3688 {
3689 tree arg1, arg2;
3690 call_expr_arg_iterator iter1, iter2;
3691 if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
3692 return false;
3693 for (arg1 = first_call_expr_arg (t1, &iter1),
3694 arg2 = first_call_expr_arg (t2, &iter2);
3695 arg1 && arg2;
3696 arg1 = next_call_expr_arg (&iter1),
3697 arg2 = next_call_expr_arg (&iter2))
3698 if (!cp_tree_equal (arg1, arg2))
3699 return false;
3700 if (arg1 || arg2)
3701 return false;
3702 return true;
3703 }
3704
3705 case TARGET_EXPR:
3706 {
3707 tree o1 = TREE_OPERAND (t1, 0);
3708 tree o2 = TREE_OPERAND (t2, 0);
3709
3710 /* Special case: if either target is an unallocated VAR_DECL,
3711 it means that it's going to be unified with whatever the
3712 TARGET_EXPR is really supposed to initialize, so treat it
3713 as being equivalent to anything. */
3714 if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
3715 && !DECL_RTL_SET_P (o1))
3716 /*Nop*/;
3717 else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
3718 && !DECL_RTL_SET_P (o2))
3719 /*Nop*/;
3720 else if (!cp_tree_equal (o1, o2))
3721 return false;
3722
3723 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3724 }
3725
3726 case PARM_DECL:
3727 /* For comparing uses of parameters in late-specified return types
3728 with an out-of-class definition of the function, but can also come
3729 up for expressions that involve 'this' in a member function
3730 template. */
3731
3732 if (comparing_specializations && !CONSTRAINT_VAR_P (t1))
3733 /* When comparing hash table entries, only an exact match is
3734 good enough; we don't want to replace 'this' with the
3735 version from another function. But be more flexible
3736 with local parameters in a requires-expression. */
3737 return false;
3738
3739 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3740 {
3741 if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
3742 return false;
3743 if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2))
3744 return false;
3745 if (DECL_ARTIFICIAL (t1)
3746 || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
3747 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
3748 return true;
3749 }
3750 return false;
3751
3752 case VAR_DECL:
3753 case CONST_DECL:
3754 case FIELD_DECL:
3755 case FUNCTION_DECL:
3756 case TEMPLATE_DECL:
3757 case IDENTIFIER_NODE:
3758 case SSA_NAME:
3759 return false;
3760
3761 case BASELINK:
3762 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
3763 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
3764 && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
3765 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
3766 BASELINK_FUNCTIONS (t2)));
3767
3768 case TEMPLATE_PARM_INDEX:
3769 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
3770 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
3771 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
3772 == TEMPLATE_PARM_PARAMETER_PACK (t2))
3773 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
3774 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
3775
3776 case TEMPLATE_ID_EXPR:
3777 return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3778 && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3779
3780 case CONSTRAINT_INFO:
3781 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1),
3782 CI_ASSOCIATED_CONSTRAINTS (t2));
3783
3784 case CHECK_CONSTR:
3785 return (CHECK_CONSTR_CONCEPT (t1) == CHECK_CONSTR_CONCEPT (t2)
3786 && comp_template_args (CHECK_CONSTR_ARGS (t1),
3787 CHECK_CONSTR_ARGS (t2)));
3788
3789 case TREE_VEC:
3790 {
3791 unsigned ix;
3792 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3793 return false;
3794 for (ix = TREE_VEC_LENGTH (t1); ix--;)
3795 if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
3796 TREE_VEC_ELT (t2, ix)))
3797 return false;
3798 return true;
3799 }
3800
3801 case SIZEOF_EXPR:
3802 case ALIGNOF_EXPR:
3803 {
3804 tree o1 = TREE_OPERAND (t1, 0);
3805 tree o2 = TREE_OPERAND (t2, 0);
3806
3807 if (code1 == SIZEOF_EXPR)
3808 {
3809 if (SIZEOF_EXPR_TYPE_P (t1))
3810 o1 = TREE_TYPE (o1);
3811 if (SIZEOF_EXPR_TYPE_P (t2))
3812 o2 = TREE_TYPE (o2);
3813 }
3814 if (TREE_CODE (o1) != TREE_CODE (o2))
3815 return false;
3816 if (TYPE_P (o1))
3817 return same_type_p (o1, o2);
3818 else
3819 return cp_tree_equal (o1, o2);
3820 }
3821
3822 case MODOP_EXPR:
3823 {
3824 tree t1_op1, t2_op1;
3825
3826 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
3827 return false;
3828
3829 t1_op1 = TREE_OPERAND (t1, 1);
3830 t2_op1 = TREE_OPERAND (t2, 1);
3831 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
3832 return false;
3833
3834 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
3835 }
3836
3837 case PTRMEM_CST:
3838 /* Two pointer-to-members are the same if they point to the same
3839 field or function in the same class. */
3840 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
3841 return false;
3842
3843 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
3844
3845 case OVERLOAD:
3846 {
3847 /* Two overloads. Must be exactly the same set of decls. */
3848 lkp_iterator first (t1);
3849 lkp_iterator second (t2);
3850
3851 for (; first && second; ++first, ++second)
3852 if (*first != *second)
3853 return false;
3854 return !(first || second);
3855 }
3856
3857 case TRAIT_EXPR:
3858 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
3859 return false;
3860 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
3861 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
3862
3863 case CAST_EXPR:
3864 case STATIC_CAST_EXPR:
3865 case REINTERPRET_CAST_EXPR:
3866 case CONST_CAST_EXPR:
3867 case DYNAMIC_CAST_EXPR:
3868 case IMPLICIT_CONV_EXPR:
3869 case NEW_EXPR:
3870 CASE_CONVERT:
3871 case NON_LVALUE_EXPR:
3872 case VIEW_CONVERT_EXPR:
3873 if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3874 return false;
3875 /* Now compare operands as usual. */
3876 break;
3877
3878 case DEFERRED_NOEXCEPT:
3879 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
3880 DEFERRED_NOEXCEPT_PATTERN (t2))
3881 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
3882 DEFERRED_NOEXCEPT_ARGS (t2)));
3883 break;
3884
3885 case USING_DECL:
3886 if (DECL_DEPENDENT_P (t1) && DECL_DEPENDENT_P (t2))
3887 return (cp_tree_equal (USING_DECL_SCOPE (t1),
3888 USING_DECL_SCOPE (t2))
3889 && cp_tree_equal (DECL_NAME (t1),
3890 DECL_NAME (t2)));
3891 return false;
3892
3893 default:
3894 break;
3895 }
3896
3897 switch (TREE_CODE_CLASS (code1))
3898 {
3899 case tcc_unary:
3900 case tcc_binary:
3901 case tcc_comparison:
3902 case tcc_expression:
3903 case tcc_vl_exp:
3904 case tcc_reference:
3905 case tcc_statement:
3906 {
3907 int i, n;
3908
3909 n = cp_tree_operand_length (t1);
3910 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
3911 && n != TREE_OPERAND_LENGTH (t2))
3912 return false;
3913
3914 for (i = 0; i < n; ++i)
3915 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
3916 return false;
3917
3918 return true;
3919 }
3920
3921 case tcc_type:
3922 return same_type_p (t1, t2);
3923 default:
3924 gcc_unreachable ();
3925 }
3926 /* We can get here with --disable-checking. */
3927 return false;
3928 }
3929
3930 /* The type of ARG when used as an lvalue. */
3931
3932 tree
lvalue_type(tree arg)3933 lvalue_type (tree arg)
3934 {
3935 tree type = TREE_TYPE (arg);
3936 return type;
3937 }
3938
3939 /* The type of ARG for printing error messages; denote lvalues with
3940 reference types. */
3941
3942 tree
error_type(tree arg)3943 error_type (tree arg)
3944 {
3945 tree type = TREE_TYPE (arg);
3946
3947 if (TREE_CODE (type) == ARRAY_TYPE)
3948 ;
3949 else if (TREE_CODE (type) == ERROR_MARK)
3950 ;
3951 else if (lvalue_p (arg))
3952 type = build_reference_type (lvalue_type (arg));
3953 else if (MAYBE_CLASS_TYPE_P (type))
3954 type = lvalue_type (arg);
3955
3956 return type;
3957 }
3958
3959 /* Does FUNCTION use a variable-length argument list? */
3960
3961 int
varargs_function_p(const_tree function)3962 varargs_function_p (const_tree function)
3963 {
3964 return stdarg_p (TREE_TYPE (function));
3965 }
3966
3967 /* Returns 1 if decl is a member of a class. */
3968
3969 int
member_p(const_tree decl)3970 member_p (const_tree decl)
3971 {
3972 const_tree const ctx = DECL_CONTEXT (decl);
3973 return (ctx && TYPE_P (ctx));
3974 }
3975
3976 /* Create a placeholder for member access where we don't actually have an
3977 object that the access is against. */
3978
3979 tree
build_dummy_object(tree type)3980 build_dummy_object (tree type)
3981 {
3982 tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node);
3983 return cp_build_fold_indirect_ref (decl);
3984 }
3985
3986 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3987 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3988 binfo path from current_class_type to TYPE, or 0. */
3989
3990 tree
maybe_dummy_object(tree type,tree * binfop)3991 maybe_dummy_object (tree type, tree* binfop)
3992 {
3993 tree decl, context;
3994 tree binfo;
3995 tree current = current_nonlambda_class_type ();
3996
3997 if (current
3998 && (binfo = lookup_base (current, type, ba_any, NULL,
3999 tf_warning_or_error)))
4000 context = current;
4001 else
4002 {
4003 /* Reference from a nested class member function. */
4004 context = type;
4005 binfo = TYPE_BINFO (type);
4006 }
4007
4008 if (binfop)
4009 *binfop = binfo;
4010
4011 if (current_class_ref
4012 /* current_class_ref might not correspond to current_class_type if
4013 we're in tsubst_default_argument or a lambda-declarator; in either
4014 case, we want to use current_class_ref if it matches CONTEXT. */
4015 && (same_type_ignoring_top_level_qualifiers_p
4016 (TREE_TYPE (current_class_ref), context)))
4017 decl = current_class_ref;
4018 else
4019 decl = build_dummy_object (context);
4020
4021 return decl;
4022 }
4023
4024 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4025
4026 int
is_dummy_object(const_tree ob)4027 is_dummy_object (const_tree ob)
4028 {
4029 if (INDIRECT_REF_P (ob))
4030 ob = TREE_OPERAND (ob, 0);
4031 return (TREE_CODE (ob) == CONVERT_EXPR
4032 && TREE_OPERAND (ob, 0) == void_node);
4033 }
4034
4035 /* Returns 1 iff type T is something we want to treat as a scalar type for
4036 the purpose of deciding whether it is trivial/POD/standard-layout. */
4037
4038 bool
scalarish_type_p(const_tree t)4039 scalarish_type_p (const_tree t)
4040 {
4041 if (t == error_mark_node)
4042 return 1;
4043
4044 return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t));
4045 }
4046
4047 /* Returns true iff T requires non-trivial default initialization. */
4048
4049 bool
type_has_nontrivial_default_init(const_tree t)4050 type_has_nontrivial_default_init (const_tree t)
4051 {
4052 t = strip_array_types (CONST_CAST_TREE (t));
4053
4054 if (CLASS_TYPE_P (t))
4055 return TYPE_HAS_COMPLEX_DFLT (t);
4056 else
4057 return 0;
4058 }
4059
4060 /* Track classes with only deleted copy/move constructors so that we can warn
4061 if they are used in call/return by value. */
4062
4063 static GTY(()) hash_set<tree>* deleted_copy_types;
4064 static void
remember_deleted_copy(const_tree t)4065 remember_deleted_copy (const_tree t)
4066 {
4067 if (!deleted_copy_types)
4068 deleted_copy_types = hash_set<tree>::create_ggc(37);
4069 deleted_copy_types->add (CONST_CAST_TREE (t));
4070 }
4071 void
maybe_warn_parm_abi(tree t,location_t loc)4072 maybe_warn_parm_abi (tree t, location_t loc)
4073 {
4074 if (!deleted_copy_types
4075 || !deleted_copy_types->contains (t))
4076 return;
4077
4078 if ((flag_abi_version == 12 || warn_abi_version == 12)
4079 && classtype_has_non_deleted_move_ctor (t))
4080 {
4081 bool w;
4082 if (flag_abi_version > 12)
4083 w = warning_at (loc, OPT_Wabi, "-fabi-version=13 (GCC 8.2) fixes the "
4084 "calling convention for %qT, which was accidentally "
4085 "changed in 8.1", t);
4086 else
4087 w = warning_at (loc, OPT_Wabi, "-fabi-version=12 (GCC 8.1) accident"
4088 "ally changes the calling convention for %qT", t);
4089 if (w)
4090 inform (location_of (t), " declared here");
4091 return;
4092 }
4093
4094 if (warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
4095 "-fabi-version=13 (GCC 8.2)", t))
4096 inform (location_of (t), " because all of its copy and move "
4097 "constructors are deleted");
4098 }
4099
4100 /* Returns true iff copying an object of type T (including via move
4101 constructor) is non-trivial. That is, T has no non-trivial copy
4102 constructors and no non-trivial move constructors, and not all copy/move
4103 constructors are deleted. This function implements the ABI notion of
4104 non-trivial copy, which has diverged from the one in the standard. */
4105
4106 bool
type_has_nontrivial_copy_init(const_tree type)4107 type_has_nontrivial_copy_init (const_tree type)
4108 {
4109 tree t = strip_array_types (CONST_CAST_TREE (type));
4110
4111 if (CLASS_TYPE_P (t))
4112 {
4113 gcc_assert (COMPLETE_TYPE_P (t));
4114
4115 if (TYPE_HAS_COMPLEX_COPY_CTOR (t)
4116 || TYPE_HAS_COMPLEX_MOVE_CTOR (t))
4117 /* Nontrivial. */
4118 return true;
4119
4120 if (cxx_dialect < cxx11)
4121 /* No deleted functions before C++11. */
4122 return false;
4123
4124 /* Before ABI v12 we did a bitwise copy of types with only deleted
4125 copy/move constructors. */
4126 if (!abi_version_at_least (12)
4127 && !(warn_abi && abi_version_crosses (12)))
4128 return false;
4129
4130 bool saw_copy = false;
4131 bool saw_non_deleted = false;
4132 bool saw_non_deleted_move = false;
4133
4134 if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4135 saw_copy = saw_non_deleted = true;
4136 else if (CLASSTYPE_LAZY_COPY_CTOR (t))
4137 {
4138 saw_copy = true;
4139 if (classtype_has_move_assign_or_move_ctor_p (t, true))
4140 /* [class.copy]/8 If the class definition declares a move
4141 constructor or move assignment operator, the implicitly declared
4142 copy constructor is defined as deleted.... */;
4143 else
4144 /* Any other reason the implicitly-declared function would be
4145 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4146 set. */
4147 saw_non_deleted = true;
4148 }
4149
4150 if (!saw_non_deleted)
4151 for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
4152 {
4153 tree fn = *iter;
4154 if (copy_fn_p (fn))
4155 {
4156 saw_copy = true;
4157 if (!DECL_DELETED_FN (fn))
4158 {
4159 /* Not deleted, therefore trivial. */
4160 saw_non_deleted = true;
4161 break;
4162 }
4163 }
4164 else if (move_fn_p (fn))
4165 if (!DECL_DELETED_FN (fn))
4166 saw_non_deleted_move = true;
4167 }
4168
4169 gcc_assert (saw_copy);
4170
4171 /* ABI v12 buggily ignored move constructors. */
4172 bool v11nontriv = false;
4173 bool v12nontriv = !saw_non_deleted;
4174 bool v13nontriv = !saw_non_deleted && !saw_non_deleted_move;
4175 bool nontriv = (abi_version_at_least (13) ? v13nontriv
4176 : flag_abi_version == 12 ? v12nontriv
4177 : v11nontriv);
4178 bool warn_nontriv = (warn_abi_version >= 13 ? v13nontriv
4179 : warn_abi_version == 12 ? v12nontriv
4180 : v11nontriv);
4181 if (nontriv != warn_nontriv)
4182 remember_deleted_copy (t);
4183
4184 return nontriv;
4185 }
4186 else
4187 return 0;
4188 }
4189
4190 /* Returns 1 iff type T is a trivially copyable type, as defined in
4191 [basic.types] and [class]. */
4192
4193 bool
trivially_copyable_p(const_tree t)4194 trivially_copyable_p (const_tree t)
4195 {
4196 t = strip_array_types (CONST_CAST_TREE (t));
4197
4198 if (CLASS_TYPE_P (t))
4199 return ((!TYPE_HAS_COPY_CTOR (t)
4200 || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
4201 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
4202 && (!TYPE_HAS_COPY_ASSIGN (t)
4203 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
4204 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
4205 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
4206 else
4207 return !CP_TYPE_VOLATILE_P (t) && scalarish_type_p (t);
4208 }
4209
4210 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4211 [class]. */
4212
4213 bool
trivial_type_p(const_tree t)4214 trivial_type_p (const_tree t)
4215 {
4216 t = strip_array_types (CONST_CAST_TREE (t));
4217
4218 if (CLASS_TYPE_P (t))
4219 return (TYPE_HAS_TRIVIAL_DFLT (t)
4220 && trivially_copyable_p (t));
4221 else
4222 return scalarish_type_p (t);
4223 }
4224
4225 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4226
4227 bool
pod_type_p(const_tree t)4228 pod_type_p (const_tree t)
4229 {
4230 /* This CONST_CAST is okay because strip_array_types returns its
4231 argument unmodified and we assign it to a const_tree. */
4232 t = strip_array_types (CONST_CAST_TREE(t));
4233
4234 if (!CLASS_TYPE_P (t))
4235 return scalarish_type_p (t);
4236 else if (cxx_dialect > cxx98)
4237 /* [class]/10: A POD struct is a class that is both a trivial class and a
4238 standard-layout class, and has no non-static data members of type
4239 non-POD struct, non-POD union (or array of such types).
4240
4241 We don't need to check individual members because if a member is
4242 non-std-layout or non-trivial, the class will be too. */
4243 return (std_layout_type_p (t) && trivial_type_p (t));
4244 else
4245 /* The C++98 definition of POD is different. */
4246 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4247 }
4248
4249 /* Returns true iff T is POD for the purpose of layout, as defined in the
4250 C++ ABI. */
4251
4252 bool
layout_pod_type_p(const_tree t)4253 layout_pod_type_p (const_tree t)
4254 {
4255 t = strip_array_types (CONST_CAST_TREE (t));
4256
4257 if (CLASS_TYPE_P (t))
4258 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4259 else
4260 return scalarish_type_p (t);
4261 }
4262
4263 /* Returns true iff T is a standard-layout type, as defined in
4264 [basic.types]. */
4265
4266 bool
std_layout_type_p(const_tree t)4267 std_layout_type_p (const_tree t)
4268 {
4269 t = strip_array_types (CONST_CAST_TREE (t));
4270
4271 if (CLASS_TYPE_P (t))
4272 return !CLASSTYPE_NON_STD_LAYOUT (t);
4273 else
4274 return scalarish_type_p (t);
4275 }
4276
4277 static bool record_has_unique_obj_representations (const_tree, const_tree);
4278
4279 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4280 as defined in [meta.unary.prop]. */
4281
4282 bool
type_has_unique_obj_representations(const_tree t)4283 type_has_unique_obj_representations (const_tree t)
4284 {
4285 bool ret;
4286
4287 t = strip_array_types (CONST_CAST_TREE (t));
4288
4289 if (!trivially_copyable_p (t))
4290 return false;
4291
4292 if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t))
4293 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t);
4294
4295 switch (TREE_CODE (t))
4296 {
4297 case INTEGER_TYPE:
4298 case POINTER_TYPE:
4299 case REFERENCE_TYPE:
4300 /* If some backend has any paddings in these types, we should add
4301 a target hook for this and handle it there. */
4302 return true;
4303
4304 case BOOLEAN_TYPE:
4305 /* For bool values other than 0 and 1 should only appear with
4306 undefined behavior. */
4307 return true;
4308
4309 case ENUMERAL_TYPE:
4310 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t));
4311
4312 case REAL_TYPE:
4313 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4314 when storing long double values, so for that we have to return false.
4315 Other kinds of floating point values are questionable due to +.0/-.0
4316 and NaNs, let's play safe for now. */
4317 return false;
4318
4319 case FIXED_POINT_TYPE:
4320 return false;
4321
4322 case OFFSET_TYPE:
4323 return true;
4324
4325 case COMPLEX_TYPE:
4326 case VECTOR_TYPE:
4327 return type_has_unique_obj_representations (TREE_TYPE (t));
4328
4329 case RECORD_TYPE:
4330 ret = record_has_unique_obj_representations (t, TYPE_SIZE (t));
4331 if (CLASS_TYPE_P (t))
4332 {
4333 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4334 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4335 }
4336 return ret;
4337
4338 case UNION_TYPE:
4339 ret = true;
4340 bool any_fields;
4341 any_fields = false;
4342 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4343 if (TREE_CODE (field) == FIELD_DECL)
4344 {
4345 any_fields = true;
4346 if (!type_has_unique_obj_representations (TREE_TYPE (field))
4347 || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1)
4348 {
4349 ret = false;
4350 break;
4351 }
4352 }
4353 if (!any_fields && !integer_zerop (TYPE_SIZE (t)))
4354 ret = false;
4355 if (CLASS_TYPE_P (t))
4356 {
4357 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4358 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4359 }
4360 return ret;
4361
4362 case NULLPTR_TYPE:
4363 return false;
4364
4365 case ERROR_MARK:
4366 return false;
4367
4368 default:
4369 gcc_unreachable ();
4370 }
4371 }
4372
4373 /* Helper function for type_has_unique_obj_representations. */
4374
4375 static bool
record_has_unique_obj_representations(const_tree t,const_tree sz)4376 record_has_unique_obj_representations (const_tree t, const_tree sz)
4377 {
4378 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4379 if (TREE_CODE (field) != FIELD_DECL)
4380 ;
4381 /* For bases, can't use type_has_unique_obj_representations here, as in
4382 struct S { int i : 24; S (); };
4383 struct T : public S { int j : 8; T (); };
4384 S doesn't have unique obj representations, but T does. */
4385 else if (DECL_FIELD_IS_BASE (field))
4386 {
4387 if (!record_has_unique_obj_representations (TREE_TYPE (field),
4388 DECL_SIZE (field)))
4389 return false;
4390 }
4391 else if (DECL_C_BIT_FIELD (field))
4392 {
4393 tree btype = DECL_BIT_FIELD_TYPE (field);
4394 if (!type_has_unique_obj_representations (btype))
4395 return false;
4396 }
4397 else if (!type_has_unique_obj_representations (TREE_TYPE (field)))
4398 return false;
4399
4400 offset_int cur = 0;
4401 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4402 if (TREE_CODE (field) == FIELD_DECL)
4403 {
4404 offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field));
4405 offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
4406 fld = fld * BITS_PER_UNIT + bitpos;
4407 if (cur != fld)
4408 return false;
4409 if (DECL_SIZE (field))
4410 {
4411 offset_int size = wi::to_offset (DECL_SIZE (field));
4412 cur += size;
4413 }
4414 }
4415 if (cur != wi::to_offset (sz))
4416 return false;
4417
4418 return true;
4419 }
4420
4421 /* Nonzero iff type T is a class template implicit specialization. */
4422
4423 bool
class_tmpl_impl_spec_p(const_tree t)4424 class_tmpl_impl_spec_p (const_tree t)
4425 {
4426 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
4427 }
4428
4429 /* Returns 1 iff zero initialization of type T means actually storing
4430 zeros in it. */
4431
4432 int
zero_init_p(const_tree t)4433 zero_init_p (const_tree t)
4434 {
4435 /* This CONST_CAST is okay because strip_array_types returns its
4436 argument unmodified and we assign it to a const_tree. */
4437 t = strip_array_types (CONST_CAST_TREE(t));
4438
4439 if (t == error_mark_node)
4440 return 1;
4441
4442 /* NULL pointers to data members are initialized with -1. */
4443 if (TYPE_PTRDATAMEM_P (t))
4444 return 0;
4445
4446 /* Classes that contain types that can't be zero-initialized, cannot
4447 be zero-initialized themselves. */
4448 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
4449 return 0;
4450
4451 return 1;
4452 }
4453
4454 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4455 warn_unused_result attribute. */
4456
4457 static tree
handle_nodiscard_attribute(tree * node,tree name,tree,int,bool * no_add_attrs)4458 handle_nodiscard_attribute (tree *node, tree name, tree /*args*/,
4459 int /*flags*/, bool *no_add_attrs)
4460 {
4461 if (TREE_CODE (*node) == FUNCTION_DECL)
4462 {
4463 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
4464 warning (OPT_Wattributes, "%qE attribute applied to %qD with void "
4465 "return type", name, *node);
4466 }
4467 else if (OVERLOAD_TYPE_P (*node))
4468 /* OK */;
4469 else
4470 {
4471 warning (OPT_Wattributes, "%qE attribute can only be applied to "
4472 "functions or to class or enumeration types", name);
4473 *no_add_attrs = true;
4474 }
4475 return NULL_TREE;
4476 }
4477
4478 /* Table of valid C++ attributes. */
4479 const struct attribute_spec cxx_attribute_table[] =
4480 {
4481 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4482 affects_type_identity, handler, exclude } */
4483 { "init_priority", 1, 1, true, false, false, false,
4484 handle_init_priority_attribute, NULL },
4485 { "abi_tag", 1, -1, false, false, false, true,
4486 handle_abi_tag_attribute, NULL },
4487 { NULL, 0, 0, false, false, false, false, NULL, NULL }
4488 };
4489
4490 /* Table of C++ standard attributes. */
4491 const struct attribute_spec std_attribute_table[] =
4492 {
4493 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4494 affects_type_identity, handler, exclude } */
4495 { "maybe_unused", 0, 0, false, false, false, false,
4496 handle_unused_attribute, NULL },
4497 { "nodiscard", 0, 0, false, false, false, false,
4498 handle_nodiscard_attribute, NULL },
4499 { NULL, 0, 0, false, false, false, false, NULL, NULL }
4500 };
4501
4502 /* Handle an "init_priority" attribute; arguments as in
4503 struct attribute_spec.handler. */
4504 static tree
handle_init_priority_attribute(tree * node,tree name,tree args,int,bool * no_add_attrs)4505 handle_init_priority_attribute (tree* node,
4506 tree name,
4507 tree args,
4508 int /*flags*/,
4509 bool* no_add_attrs)
4510 {
4511 tree initp_expr = TREE_VALUE (args);
4512 tree decl = *node;
4513 tree type = TREE_TYPE (decl);
4514 int pri;
4515
4516 STRIP_NOPS (initp_expr);
4517 initp_expr = default_conversion (initp_expr);
4518 if (initp_expr)
4519 initp_expr = maybe_constant_value (initp_expr);
4520
4521 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
4522 {
4523 error ("requested init_priority is not an integer constant");
4524 cxx_constant_value (initp_expr);
4525 *no_add_attrs = true;
4526 return NULL_TREE;
4527 }
4528
4529 pri = TREE_INT_CST_LOW (initp_expr);
4530
4531 type = strip_array_types (type);
4532
4533 if (decl == NULL_TREE
4534 || !VAR_P (decl)
4535 || !TREE_STATIC (decl)
4536 || DECL_EXTERNAL (decl)
4537 || (TREE_CODE (type) != RECORD_TYPE
4538 && TREE_CODE (type) != UNION_TYPE)
4539 /* Static objects in functions are initialized the
4540 first time control passes through that
4541 function. This is not precise enough to pin down an
4542 init_priority value, so don't allow it. */
4543 || current_function_decl)
4544 {
4545 error ("can only use %qE attribute on file-scope definitions "
4546 "of objects of class type", name);
4547 *no_add_attrs = true;
4548 return NULL_TREE;
4549 }
4550
4551 if (pri > MAX_INIT_PRIORITY || pri <= 0)
4552 {
4553 error ("requested init_priority is out of range");
4554 *no_add_attrs = true;
4555 return NULL_TREE;
4556 }
4557
4558 /* Check for init_priorities that are reserved for
4559 language and runtime support implementations.*/
4560 if (pri <= MAX_RESERVED_INIT_PRIORITY)
4561 {
4562 warning
4563 (0, "requested init_priority is reserved for internal use");
4564 }
4565
4566 if (SUPPORTS_INIT_PRIORITY)
4567 {
4568 SET_DECL_INIT_PRIORITY (decl, pri);
4569 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
4570 return NULL_TREE;
4571 }
4572 else
4573 {
4574 error ("%qE attribute is not supported on this platform", name);
4575 *no_add_attrs = true;
4576 return NULL_TREE;
4577 }
4578 }
4579
4580 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4581 and the new one has the tags in NEW_. Give an error if there are tags
4582 in NEW_ that weren't in OLD. */
4583
4584 bool
check_abi_tag_redeclaration(const_tree decl,const_tree old,const_tree new_)4585 check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
4586 {
4587 if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
4588 old = TREE_VALUE (old);
4589 if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
4590 new_ = TREE_VALUE (new_);
4591 bool err = false;
4592 for (const_tree t = new_; t; t = TREE_CHAIN (t))
4593 {
4594 tree str = TREE_VALUE (t);
4595 for (const_tree in = old; in; in = TREE_CHAIN (in))
4596 {
4597 tree ostr = TREE_VALUE (in);
4598 if (cp_tree_equal (str, ostr))
4599 goto found;
4600 }
4601 error ("redeclaration of %qD adds abi tag %qE", decl, str);
4602 err = true;
4603 found:;
4604 }
4605 if (err)
4606 {
4607 inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
4608 return false;
4609 }
4610 return true;
4611 }
4612
4613 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4614 ill-formed, give an error and return false; otherwise, return true. */
4615
4616 bool
check_abi_tag_args(tree args,tree name)4617 check_abi_tag_args (tree args, tree name)
4618 {
4619 if (!args)
4620 {
4621 error ("the %qE attribute requires arguments", name);
4622 return false;
4623 }
4624 for (tree arg = args; arg; arg = TREE_CHAIN (arg))
4625 {
4626 tree elt = TREE_VALUE (arg);
4627 if (TREE_CODE (elt) != STRING_CST
4628 || (!same_type_ignoring_top_level_qualifiers_p
4629 (strip_array_types (TREE_TYPE (elt)),
4630 char_type_node)))
4631 {
4632 error ("arguments to the %qE attribute must be narrow string "
4633 "literals", name);
4634 return false;
4635 }
4636 const char *begin = TREE_STRING_POINTER (elt);
4637 const char *end = begin + TREE_STRING_LENGTH (elt);
4638 for (const char *p = begin; p != end; ++p)
4639 {
4640 char c = *p;
4641 if (p == begin)
4642 {
4643 if (!ISALPHA (c) && c != '_')
4644 {
4645 error ("arguments to the %qE attribute must contain valid "
4646 "identifiers", name);
4647 inform (input_location, "%<%c%> is not a valid first "
4648 "character for an identifier", c);
4649 return false;
4650 }
4651 }
4652 else if (p == end - 1)
4653 gcc_assert (c == 0);
4654 else
4655 {
4656 if (!ISALNUM (c) && c != '_')
4657 {
4658 error ("arguments to the %qE attribute must contain valid "
4659 "identifiers", name);
4660 inform (input_location, "%<%c%> is not a valid character "
4661 "in an identifier", c);
4662 return false;
4663 }
4664 }
4665 }
4666 }
4667 return true;
4668 }
4669
4670 /* Handle an "abi_tag" attribute; arguments as in
4671 struct attribute_spec.handler. */
4672
4673 static tree
handle_abi_tag_attribute(tree * node,tree name,tree args,int flags,bool * no_add_attrs)4674 handle_abi_tag_attribute (tree* node, tree name, tree args,
4675 int flags, bool* no_add_attrs)
4676 {
4677 if (!check_abi_tag_args (args, name))
4678 goto fail;
4679
4680 if (TYPE_P (*node))
4681 {
4682 if (!OVERLOAD_TYPE_P (*node))
4683 {
4684 error ("%qE attribute applied to non-class, non-enum type %qT",
4685 name, *node);
4686 goto fail;
4687 }
4688 else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
4689 {
4690 error ("%qE attribute applied to %qT after its definition",
4691 name, *node);
4692 goto fail;
4693 }
4694 else if (CLASS_TYPE_P (*node)
4695 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node))
4696 {
4697 warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4698 "template instantiation %qT", name, *node);
4699 goto fail;
4700 }
4701 else if (CLASS_TYPE_P (*node)
4702 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node))
4703 {
4704 warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4705 "template specialization %qT", name, *node);
4706 goto fail;
4707 }
4708
4709 tree attributes = TYPE_ATTRIBUTES (*node);
4710 tree decl = TYPE_NAME (*node);
4711
4712 /* Make sure all declarations have the same abi tags. */
4713 if (DECL_SOURCE_LOCATION (decl) != input_location)
4714 {
4715 if (!check_abi_tag_redeclaration (decl,
4716 lookup_attribute ("abi_tag",
4717 attributes),
4718 args))
4719 goto fail;
4720 }
4721 }
4722 else
4723 {
4724 if (!VAR_OR_FUNCTION_DECL_P (*node))
4725 {
4726 error ("%qE attribute applied to non-function, non-variable %qD",
4727 name, *node);
4728 goto fail;
4729 }
4730 else if (DECL_LANGUAGE (*node) == lang_c)
4731 {
4732 error ("%qE attribute applied to extern \"C\" declaration %qD",
4733 name, *node);
4734 goto fail;
4735 }
4736 }
4737
4738 return NULL_TREE;
4739
4740 fail:
4741 *no_add_attrs = true;
4742 return NULL_TREE;
4743 }
4744
4745 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4746 thing pointed to by the constant. */
4747
4748 tree
make_ptrmem_cst(tree type,tree member)4749 make_ptrmem_cst (tree type, tree member)
4750 {
4751 tree ptrmem_cst = make_node (PTRMEM_CST);
4752 TREE_TYPE (ptrmem_cst) = type;
4753 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
4754 return ptrmem_cst;
4755 }
4756
4757 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4758 return an existing type if an appropriate type already exists. */
4759
4760 tree
cp_build_type_attribute_variant(tree type,tree attributes)4761 cp_build_type_attribute_variant (tree type, tree attributes)
4762 {
4763 tree new_type;
4764
4765 new_type = build_type_attribute_variant (type, attributes);
4766 if (TREE_CODE (new_type) == FUNCTION_TYPE
4767 || TREE_CODE (new_type) == METHOD_TYPE)
4768 {
4769 new_type = build_exception_variant (new_type,
4770 TYPE_RAISES_EXCEPTIONS (type));
4771 new_type = build_ref_qualified_type (new_type,
4772 type_memfn_rqual (type));
4773 }
4774
4775 /* Making a new main variant of a class type is broken. */
4776 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
4777
4778 return new_type;
4779 }
4780
4781 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4782 Called only after doing all language independent checks. */
4783
4784 bool
cxx_type_hash_eq(const_tree typea,const_tree typeb)4785 cxx_type_hash_eq (const_tree typea, const_tree typeb)
4786 {
4787 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
4788 || TREE_CODE (typea) == METHOD_TYPE);
4789
4790 if (type_memfn_rqual (typea) != type_memfn_rqual (typeb))
4791 return false;
4792 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
4793 TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
4794 }
4795
4796 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4797 C++, these are the exception-specifier and ref-qualifier. */
4798
4799 tree
cxx_copy_lang_qualifiers(const_tree typea,const_tree typeb)4800 cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb)
4801 {
4802 tree type = CONST_CAST_TREE (typea);
4803 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
4804 {
4805 type = build_exception_variant (type, TYPE_RAISES_EXCEPTIONS (typeb));
4806 type = build_ref_qualified_type (type, type_memfn_rqual (typeb));
4807 }
4808 return type;
4809 }
4810
4811 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4812 traversal. Called from walk_tree. */
4813
4814 tree
cp_walk_subtrees(tree * tp,int * walk_subtrees_p,walk_tree_fn func,void * data,hash_set<tree> * pset)4815 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
4816 void *data, hash_set<tree> *pset)
4817 {
4818 enum tree_code code = TREE_CODE (*tp);
4819 tree result;
4820
4821 #define WALK_SUBTREE(NODE) \
4822 do \
4823 { \
4824 result = cp_walk_tree (&(NODE), func, data, pset); \
4825 if (result) goto out; \
4826 } \
4827 while (0)
4828
4829 /* Not one of the easy cases. We must explicitly go through the
4830 children. */
4831 result = NULL_TREE;
4832 switch (code)
4833 {
4834 case DEFAULT_ARG:
4835 case TEMPLATE_TEMPLATE_PARM:
4836 case BOUND_TEMPLATE_TEMPLATE_PARM:
4837 case UNBOUND_CLASS_TEMPLATE:
4838 case TEMPLATE_PARM_INDEX:
4839 case TEMPLATE_TYPE_PARM:
4840 case TYPENAME_TYPE:
4841 case TYPEOF_TYPE:
4842 case UNDERLYING_TYPE:
4843 /* None of these have subtrees other than those already walked
4844 above. */
4845 *walk_subtrees_p = 0;
4846 break;
4847
4848 case BASELINK:
4849 if (BASELINK_QUALIFIED_P (*tp))
4850 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp)));
4851 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
4852 *walk_subtrees_p = 0;
4853 break;
4854
4855 case PTRMEM_CST:
4856 WALK_SUBTREE (TREE_TYPE (*tp));
4857 *walk_subtrees_p = 0;
4858 break;
4859
4860 case TREE_LIST:
4861 WALK_SUBTREE (TREE_PURPOSE (*tp));
4862 break;
4863
4864 case OVERLOAD:
4865 WALK_SUBTREE (OVL_FUNCTION (*tp));
4866 WALK_SUBTREE (OVL_CHAIN (*tp));
4867 *walk_subtrees_p = 0;
4868 break;
4869
4870 case USING_DECL:
4871 WALK_SUBTREE (DECL_NAME (*tp));
4872 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
4873 WALK_SUBTREE (USING_DECL_DECLS (*tp));
4874 *walk_subtrees_p = 0;
4875 break;
4876
4877 case RECORD_TYPE:
4878 if (TYPE_PTRMEMFUNC_P (*tp))
4879 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp));
4880 break;
4881
4882 case TYPE_ARGUMENT_PACK:
4883 case NONTYPE_ARGUMENT_PACK:
4884 {
4885 tree args = ARGUMENT_PACK_ARGS (*tp);
4886 int i, len = TREE_VEC_LENGTH (args);
4887 for (i = 0; i < len; i++)
4888 WALK_SUBTREE (TREE_VEC_ELT (args, i));
4889 }
4890 break;
4891
4892 case TYPE_PACK_EXPANSION:
4893 WALK_SUBTREE (TREE_TYPE (*tp));
4894 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4895 *walk_subtrees_p = 0;
4896 break;
4897
4898 case EXPR_PACK_EXPANSION:
4899 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
4900 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4901 *walk_subtrees_p = 0;
4902 break;
4903
4904 case CAST_EXPR:
4905 case REINTERPRET_CAST_EXPR:
4906 case STATIC_CAST_EXPR:
4907 case CONST_CAST_EXPR:
4908 case DYNAMIC_CAST_EXPR:
4909 case IMPLICIT_CONV_EXPR:
4910 if (TREE_TYPE (*tp))
4911 WALK_SUBTREE (TREE_TYPE (*tp));
4912
4913 {
4914 int i;
4915 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
4916 WALK_SUBTREE (TREE_OPERAND (*tp, i));
4917 }
4918 *walk_subtrees_p = 0;
4919 break;
4920
4921 case TRAIT_EXPR:
4922 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
4923 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
4924 *walk_subtrees_p = 0;
4925 break;
4926
4927 case DECLTYPE_TYPE:
4928 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
4929 *walk_subtrees_p = 0;
4930 break;
4931
4932 case REQUIRES_EXPR:
4933 // Only recurse through the nested expression. Do not
4934 // walk the parameter list. Doing so causes false
4935 // positives in the pack expansion checker since the
4936 // requires parameters are introduced as pack expansions.
4937 WALK_SUBTREE (TREE_OPERAND (*tp, 1));
4938 *walk_subtrees_p = 0;
4939 break;
4940
4941 case DECL_EXPR:
4942 /* User variables should be mentioned in BIND_EXPR_VARS
4943 and their initializers and sizes walked when walking
4944 the containing BIND_EXPR. Compiler temporaries are
4945 handled here. And also normal variables in templates,
4946 since do_poplevel doesn't build a BIND_EXPR then. */
4947 if (VAR_P (TREE_OPERAND (*tp, 0))
4948 && (processing_template_decl
4949 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp, 0))
4950 && !TREE_STATIC (TREE_OPERAND (*tp, 0)))))
4951 {
4952 tree decl = TREE_OPERAND (*tp, 0);
4953 WALK_SUBTREE (DECL_INITIAL (decl));
4954 WALK_SUBTREE (DECL_SIZE (decl));
4955 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
4956 }
4957 break;
4958
4959 case LAMBDA_EXPR:
4960 /* Don't walk into the body of the lambda, but the capture initializers
4961 are part of the enclosing context. */
4962 for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (*tp); cap;
4963 cap = TREE_CHAIN (cap))
4964 WALK_SUBTREE (TREE_VALUE (cap));
4965 break;
4966
4967 default:
4968 return NULL_TREE;
4969 }
4970
4971 /* We didn't find what we were looking for. */
4972 out:
4973 return result;
4974
4975 #undef WALK_SUBTREE
4976 }
4977
4978 /* Like save_expr, but for C++. */
4979
4980 tree
cp_save_expr(tree expr)4981 cp_save_expr (tree expr)
4982 {
4983 /* There is no reason to create a SAVE_EXPR within a template; if
4984 needed, we can create the SAVE_EXPR when instantiating the
4985 template. Furthermore, the middle-end cannot handle C++-specific
4986 tree codes. */
4987 if (processing_template_decl)
4988 return expr;
4989 return save_expr (expr);
4990 }
4991
4992 /* Initialize tree.c. */
4993
4994 void
init_tree(void)4995 init_tree (void)
4996 {
4997 list_hash_table = hash_table<list_hasher>::create_ggc (61);
4998 register_scoped_attributes (std_attribute_table, NULL);
4999 }
5000
5001 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5002 is. Note that sfk_none is zero, so this function can be used as a
5003 predicate to test whether or not DECL is a special function. */
5004
5005 special_function_kind
special_function_p(const_tree decl)5006 special_function_p (const_tree decl)
5007 {
5008 /* Rather than doing all this stuff with magic names, we should
5009 probably have a field of type `special_function_kind' in
5010 DECL_LANG_SPECIFIC. */
5011 if (DECL_INHERITED_CTOR (decl))
5012 return sfk_inheriting_constructor;
5013 if (DECL_COPY_CONSTRUCTOR_P (decl))
5014 return sfk_copy_constructor;
5015 if (DECL_MOVE_CONSTRUCTOR_P (decl))
5016 return sfk_move_constructor;
5017 if (DECL_CONSTRUCTOR_P (decl))
5018 return sfk_constructor;
5019 if (DECL_ASSIGNMENT_OPERATOR_P (decl)
5020 && DECL_OVERLOADED_OPERATOR_IS (decl, NOP_EXPR))
5021 {
5022 if (copy_fn_p (decl))
5023 return sfk_copy_assignment;
5024 if (move_fn_p (decl))
5025 return sfk_move_assignment;
5026 }
5027 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
5028 return sfk_destructor;
5029 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
5030 return sfk_complete_destructor;
5031 if (DECL_BASE_DESTRUCTOR_P (decl))
5032 return sfk_base_destructor;
5033 if (DECL_DELETING_DESTRUCTOR_P (decl))
5034 return sfk_deleting_destructor;
5035 if (DECL_CONV_FN_P (decl))
5036 return sfk_conversion;
5037 if (deduction_guide_p (decl))
5038 return sfk_deduction_guide;
5039
5040 return sfk_none;
5041 }
5042
5043 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5044
5045 int
char_type_p(tree type)5046 char_type_p (tree type)
5047 {
5048 return (same_type_p (type, char_type_node)
5049 || same_type_p (type, unsigned_char_type_node)
5050 || same_type_p (type, signed_char_type_node)
5051 || same_type_p (type, char16_type_node)
5052 || same_type_p (type, char32_type_node)
5053 || same_type_p (type, wchar_type_node));
5054 }
5055
5056 /* Returns the kind of linkage associated with the indicated DECL. Th
5057 value returned is as specified by the language standard; it is
5058 independent of implementation details regarding template
5059 instantiation, etc. For example, it is possible that a declaration
5060 to which this function assigns external linkage would not show up
5061 as a global symbol when you run `nm' on the resulting object file. */
5062
5063 linkage_kind
decl_linkage(tree decl)5064 decl_linkage (tree decl)
5065 {
5066 /* This function doesn't attempt to calculate the linkage from first
5067 principles as given in [basic.link]. Instead, it makes use of
5068 the fact that we have already set TREE_PUBLIC appropriately, and
5069 then handles a few special cases. Ideally, we would calculate
5070 linkage first, and then transform that into a concrete
5071 implementation. */
5072
5073 /* Things that don't have names have no linkage. */
5074 if (!DECL_NAME (decl))
5075 return lk_none;
5076
5077 /* Fields have no linkage. */
5078 if (TREE_CODE (decl) == FIELD_DECL)
5079 return lk_none;
5080
5081 /* Things that are TREE_PUBLIC have external linkage. */
5082 if (TREE_PUBLIC (decl))
5083 return lk_external;
5084
5085 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5086 check one of the "clones" for the real linkage. */
5087 if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
5088 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))
5089 && DECL_CHAIN (decl)
5090 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)))
5091 return decl_linkage (DECL_CHAIN (decl));
5092
5093 if (TREE_CODE (decl) == NAMESPACE_DECL)
5094 return lk_external;
5095
5096 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5097 type. */
5098 if (TREE_CODE (decl) == CONST_DECL)
5099 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
5100
5101 /* Things in local scope do not have linkage, if they don't have
5102 TREE_PUBLIC set. */
5103 if (decl_function_context (decl))
5104 return lk_none;
5105
5106 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5107 are considered to have external linkage for language purposes, as do
5108 template instantiations on targets without weak symbols. DECLs really
5109 meant to have internal linkage have DECL_THIS_STATIC set. */
5110 if (TREE_CODE (decl) == TYPE_DECL)
5111 return lk_external;
5112 if (VAR_OR_FUNCTION_DECL_P (decl))
5113 {
5114 if (!DECL_THIS_STATIC (decl))
5115 return lk_external;
5116
5117 /* Static data members and static member functions from classes
5118 in anonymous namespace also don't have TREE_PUBLIC set. */
5119 if (DECL_CLASS_CONTEXT (decl))
5120 return lk_external;
5121 }
5122
5123 /* Everything else has internal linkage. */
5124 return lk_internal;
5125 }
5126
5127 /* Returns the storage duration of the object or reference associated with
5128 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5129
5130 duration_kind
decl_storage_duration(tree decl)5131 decl_storage_duration (tree decl)
5132 {
5133 if (TREE_CODE (decl) == PARM_DECL)
5134 return dk_auto;
5135 if (TREE_CODE (decl) == FUNCTION_DECL)
5136 return dk_static;
5137 gcc_assert (VAR_P (decl));
5138 if (!TREE_STATIC (decl)
5139 && !DECL_EXTERNAL (decl))
5140 return dk_auto;
5141 if (CP_DECL_THREAD_LOCAL_P (decl))
5142 return dk_thread;
5143 return dk_static;
5144 }
5145
5146 /* EXP is an expression that we want to pre-evaluate. Returns (in
5147 *INITP) an expression that will perform the pre-evaluation. The
5148 value returned by this function is a side-effect free expression
5149 equivalent to the pre-evaluated expression. Callers must ensure
5150 that *INITP is evaluated before EXP. */
5151
5152 tree
stabilize_expr(tree exp,tree * initp)5153 stabilize_expr (tree exp, tree* initp)
5154 {
5155 tree init_expr;
5156
5157 if (!TREE_SIDE_EFFECTS (exp))
5158 init_expr = NULL_TREE;
5159 else if (VOID_TYPE_P (TREE_TYPE (exp)))
5160 {
5161 init_expr = exp;
5162 exp = void_node;
5163 }
5164 /* There are no expressions with REFERENCE_TYPE, but there can be call
5165 arguments with such a type; just treat it as a pointer. */
5166 else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
5167 || SCALAR_TYPE_P (TREE_TYPE (exp))
5168 || !glvalue_p (exp))
5169 {
5170 init_expr = get_target_expr (exp);
5171 exp = TARGET_EXPR_SLOT (init_expr);
5172 if (CLASS_TYPE_P (TREE_TYPE (exp)))
5173 exp = move (exp);
5174 else
5175 exp = rvalue (exp);
5176 }
5177 else
5178 {
5179 bool xval = !lvalue_p (exp);
5180 exp = cp_build_addr_expr (exp, tf_warning_or_error);
5181 init_expr = get_target_expr (exp);
5182 exp = TARGET_EXPR_SLOT (init_expr);
5183 exp = cp_build_fold_indirect_ref (exp);
5184 if (xval)
5185 exp = move (exp);
5186 }
5187 *initp = init_expr;
5188
5189 gcc_assert (!TREE_SIDE_EFFECTS (exp));
5190 return exp;
5191 }
5192
5193 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5194 similar expression ORIG. */
5195
5196 tree
add_stmt_to_compound(tree orig,tree new_expr)5197 add_stmt_to_compound (tree orig, tree new_expr)
5198 {
5199 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
5200 return orig;
5201 if (!orig || !TREE_SIDE_EFFECTS (orig))
5202 return new_expr;
5203 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
5204 }
5205
5206 /* Like stabilize_expr, but for a call whose arguments we want to
5207 pre-evaluate. CALL is modified in place to use the pre-evaluated
5208 arguments, while, upon return, *INITP contains an expression to
5209 compute the arguments. */
5210
5211 void
stabilize_call(tree call,tree * initp)5212 stabilize_call (tree call, tree *initp)
5213 {
5214 tree inits = NULL_TREE;
5215 int i;
5216 int nargs = call_expr_nargs (call);
5217
5218 if (call == error_mark_node || processing_template_decl)
5219 {
5220 *initp = NULL_TREE;
5221 return;
5222 }
5223
5224 gcc_assert (TREE_CODE (call) == CALL_EXPR);
5225
5226 for (i = 0; i < nargs; i++)
5227 {
5228 tree init;
5229 CALL_EXPR_ARG (call, i) =
5230 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
5231 inits = add_stmt_to_compound (inits, init);
5232 }
5233
5234 *initp = inits;
5235 }
5236
5237 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5238 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5239 arguments, while, upon return, *INITP contains an expression to
5240 compute the arguments. */
5241
5242 static void
stabilize_aggr_init(tree call,tree * initp)5243 stabilize_aggr_init (tree call, tree *initp)
5244 {
5245 tree inits = NULL_TREE;
5246 int i;
5247 int nargs = aggr_init_expr_nargs (call);
5248
5249 if (call == error_mark_node)
5250 return;
5251
5252 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
5253
5254 for (i = 0; i < nargs; i++)
5255 {
5256 tree init;
5257 AGGR_INIT_EXPR_ARG (call, i) =
5258 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
5259 inits = add_stmt_to_compound (inits, init);
5260 }
5261
5262 *initp = inits;
5263 }
5264
5265 /* Like stabilize_expr, but for an initialization.
5266
5267 If the initialization is for an object of class type, this function
5268 takes care not to introduce additional temporaries.
5269
5270 Returns TRUE iff the expression was successfully pre-evaluated,
5271 i.e., if INIT is now side-effect free, except for, possibly, a
5272 single call to a constructor. */
5273
5274 bool
stabilize_init(tree init,tree * initp)5275 stabilize_init (tree init, tree *initp)
5276 {
5277 tree t = init;
5278
5279 *initp = NULL_TREE;
5280
5281 if (t == error_mark_node || processing_template_decl)
5282 return true;
5283
5284 if (TREE_CODE (t) == INIT_EXPR)
5285 t = TREE_OPERAND (t, 1);
5286 if (TREE_CODE (t) == TARGET_EXPR)
5287 t = TARGET_EXPR_INITIAL (t);
5288
5289 /* If the RHS can be stabilized without breaking copy elision, stabilize
5290 it. We specifically don't stabilize class prvalues here because that
5291 would mean an extra copy, but they might be stabilized below. */
5292 if (TREE_CODE (init) == INIT_EXPR
5293 && TREE_CODE (t) != CONSTRUCTOR
5294 && TREE_CODE (t) != AGGR_INIT_EXPR
5295 && (SCALAR_TYPE_P (TREE_TYPE (t))
5296 || glvalue_p (t)))
5297 {
5298 TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
5299 return true;
5300 }
5301
5302 if (TREE_CODE (t) == COMPOUND_EXPR
5303 && TREE_CODE (init) == INIT_EXPR)
5304 {
5305 tree last = expr_last (t);
5306 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5307 if (!TREE_SIDE_EFFECTS (last))
5308 {
5309 *initp = t;
5310 TREE_OPERAND (init, 1) = last;
5311 return true;
5312 }
5313 }
5314
5315 if (TREE_CODE (t) == CONSTRUCTOR)
5316 {
5317 /* Aggregate initialization: stabilize each of the field
5318 initializers. */
5319 unsigned i;
5320 constructor_elt *ce;
5321 bool good = true;
5322 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5323 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5324 {
5325 tree type = TREE_TYPE (ce->value);
5326 tree subinit;
5327 if (TREE_CODE (type) == REFERENCE_TYPE
5328 || SCALAR_TYPE_P (type))
5329 ce->value = stabilize_expr (ce->value, &subinit);
5330 else if (!stabilize_init (ce->value, &subinit))
5331 good = false;
5332 *initp = add_stmt_to_compound (*initp, subinit);
5333 }
5334 return good;
5335 }
5336
5337 if (TREE_CODE (t) == CALL_EXPR)
5338 {
5339 stabilize_call (t, initp);
5340 return true;
5341 }
5342
5343 if (TREE_CODE (t) == AGGR_INIT_EXPR)
5344 {
5345 stabilize_aggr_init (t, initp);
5346 return true;
5347 }
5348
5349 /* The initialization is being performed via a bitwise copy -- and
5350 the item copied may have side effects. */
5351 return !TREE_SIDE_EFFECTS (init);
5352 }
5353
5354 /* Returns true if a cast to TYPE may appear in an integral constant
5355 expression. */
5356
5357 bool
cast_valid_in_integral_constant_expression_p(tree type)5358 cast_valid_in_integral_constant_expression_p (tree type)
5359 {
5360 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
5361 || cxx_dialect >= cxx11
5362 || dependent_type_p (type)
5363 || type == error_mark_node);
5364 }
5365
5366 /* Return true if we need to fix linkage information of DECL. */
5367
5368 static bool
cp_fix_function_decl_p(tree decl)5369 cp_fix_function_decl_p (tree decl)
5370 {
5371 /* Skip if DECL is not externally visible. */
5372 if (!TREE_PUBLIC (decl))
5373 return false;
5374
5375 /* We need to fix DECL if it a appears to be exported but with no
5376 function body. Thunks do not have CFGs and we may need to
5377 handle them specially later. */
5378 if (!gimple_has_body_p (decl)
5379 && !DECL_THUNK_P (decl)
5380 && !DECL_EXTERNAL (decl))
5381 {
5382 struct cgraph_node *node = cgraph_node::get (decl);
5383
5384 /* Don't fix same_body aliases. Although they don't have their own
5385 CFG, they share it with what they alias to. */
5386 if (!node || !node->alias
5387 || !vec_safe_length (node->ref_list.references))
5388 return true;
5389 }
5390
5391 return false;
5392 }
5393
5394 /* Clean the C++ specific parts of the tree T. */
5395
5396 void
cp_free_lang_data(tree t)5397 cp_free_lang_data (tree t)
5398 {
5399 if (TREE_CODE (t) == METHOD_TYPE
5400 || TREE_CODE (t) == FUNCTION_TYPE)
5401 {
5402 /* Default args are not interesting anymore. */
5403 tree argtypes = TYPE_ARG_TYPES (t);
5404 while (argtypes)
5405 {
5406 TREE_PURPOSE (argtypes) = 0;
5407 argtypes = TREE_CHAIN (argtypes);
5408 }
5409 }
5410 else if (TREE_CODE (t) == FUNCTION_DECL
5411 && cp_fix_function_decl_p (t))
5412 {
5413 /* If T is used in this translation unit at all, the definition
5414 must exist somewhere else since we have decided to not emit it
5415 in this TU. So make it an external reference. */
5416 DECL_EXTERNAL (t) = 1;
5417 TREE_STATIC (t) = 0;
5418 }
5419 if (TREE_CODE (t) == NAMESPACE_DECL)
5420 /* We do not need the leftover chaining of namespaces from the
5421 binding level. */
5422 DECL_CHAIN (t) = NULL_TREE;
5423 }
5424
5425 /* Stub for c-common. Please keep in sync with c-decl.c.
5426 FIXME: If address space support is target specific, then this
5427 should be a C target hook. But currently this is not possible,
5428 because this function is called via REGISTER_TARGET_PRAGMAS. */
5429 void
c_register_addr_space(const char *,addr_space_t)5430 c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
5431 {
5432 }
5433
5434 /* Return the number of operands in T that we care about for things like
5435 mangling. */
5436
5437 int
cp_tree_operand_length(const_tree t)5438 cp_tree_operand_length (const_tree t)
5439 {
5440 enum tree_code code = TREE_CODE (t);
5441
5442 if (TREE_CODE_CLASS (code) == tcc_vl_exp)
5443 return VL_EXP_OPERAND_LENGTH (t);
5444
5445 return cp_tree_code_length (code);
5446 }
5447
5448 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5449
5450 int
cp_tree_code_length(enum tree_code code)5451 cp_tree_code_length (enum tree_code code)
5452 {
5453 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
5454
5455 switch (code)
5456 {
5457 case PREINCREMENT_EXPR:
5458 case PREDECREMENT_EXPR:
5459 case POSTINCREMENT_EXPR:
5460 case POSTDECREMENT_EXPR:
5461 return 1;
5462
5463 case ARRAY_REF:
5464 return 2;
5465
5466 case EXPR_PACK_EXPANSION:
5467 return 1;
5468
5469 default:
5470 return TREE_CODE_LENGTH (code);
5471 }
5472 }
5473
5474 /* Wrapper around warn_deprecated_use that doesn't warn for
5475 current_class_type. */
5476
5477 void
cp_warn_deprecated_use(tree node)5478 cp_warn_deprecated_use (tree node)
5479 {
5480 if (TYPE_P (node)
5481 && current_class_type
5482 && TYPE_MAIN_VARIANT (node) == current_class_type)
5483 return;
5484 warn_deprecated_use (node, NULL_TREE);
5485 }
5486
5487 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5488 conditions for the warning hold, false otherwise. */
5489 bool
maybe_warn_zero_as_null_pointer_constant(tree expr,location_t loc)5490 maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
5491 {
5492 if (c_inhibit_evaluation_warnings == 0
5493 && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
5494 {
5495 warning_at (loc, OPT_Wzero_as_null_pointer_constant,
5496 "zero as null pointer constant");
5497 return true;
5498 }
5499 return false;
5500 }
5501
5502 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5503 /* Complain that some language-specific thing hanging off a tree
5504 node has been accessed improperly. */
5505
5506 void
lang_check_failed(const char * file,int line,const char * function)5507 lang_check_failed (const char* file, int line, const char* function)
5508 {
5509 internal_error ("lang_* check: failed in %s, at %s:%d",
5510 function, trim_filename (file), line);
5511 }
5512 #endif /* ENABLE_TREE_CHECKING */
5513
5514 #if CHECKING_P
5515
5516 namespace selftest {
5517
5518 /* Verify that lvalue_kind () works, for various expressions,
5519 and that location wrappers don't affect the results. */
5520
5521 static void
test_lvalue_kind()5522 test_lvalue_kind ()
5523 {
5524 location_t loc = BUILTINS_LOCATION;
5525
5526 /* Verify constants and parameters, without and with
5527 location wrappers. */
5528 tree int_cst = build_int_cst (integer_type_node, 42);
5529 ASSERT_EQ (clk_none, lvalue_kind (int_cst));
5530
5531 tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
5532 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
5533 ASSERT_EQ (clk_none, lvalue_kind (wrapped_int_cst));
5534
5535 tree string_lit = build_string (4, "foo");
5536 TREE_TYPE (string_lit) = char_array_type_node;
5537 string_lit = fix_string_type (string_lit);
5538 ASSERT_EQ (clk_ordinary, lvalue_kind (string_lit));
5539
5540 tree wrapped_string_lit = maybe_wrap_with_location (string_lit, loc);
5541 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit));
5542 ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_string_lit));
5543
5544 tree parm = build_decl (UNKNOWN_LOCATION, PARM_DECL,
5545 get_identifier ("some_parm"),
5546 integer_type_node);
5547 ASSERT_EQ (clk_ordinary, lvalue_kind (parm));
5548
5549 tree wrapped_parm = maybe_wrap_with_location (parm, loc);
5550 ASSERT_TRUE (location_wrapper_p (wrapped_parm));
5551 ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_parm));
5552
5553 /* Verify that lvalue_kind of std::move on a parm isn't
5554 affected by location wrappers. */
5555 tree rvalue_ref_of_parm = move (parm);
5556 ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_parm));
5557 tree rvalue_ref_of_wrapped_parm = move (wrapped_parm);
5558 ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_wrapped_parm));
5559 }
5560
5561 /* Run all of the selftests within this file. */
5562
5563 void
cp_tree_c_tests()5564 cp_tree_c_tests ()
5565 {
5566 test_lvalue_kind ();
5567 }
5568
5569 } // namespace selftest
5570
5571 #endif /* #if CHECKING_P */
5572
5573
5574 #include "gt-cp-tree.h"
5575