Branch data Line data Source code
1 : : /* Language-dependent node constructors for parse phase of GNU compiler.
2 : : Copyright (C) 1987-2024 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 : :
47 : : static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
48 : : static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
49 : : static tree handle_contract_attribute (tree *, tree, tree, int, bool *);
50 : : static tree handle_no_dangling_attribute (tree *, tree, tree, int, bool *);
51 : :
52 : : /* If REF is an lvalue, returns the kind of lvalue that REF is.
53 : : Otherwise, returns clk_none. */
54 : :
55 : : cp_lvalue_kind
56 : 1831855887 : lvalue_kind (const_tree ref)
57 : : {
58 : 1979807124 : cp_lvalue_kind op1_lvalue_kind = clk_none;
59 : 1979807124 : cp_lvalue_kind op2_lvalue_kind = clk_none;
60 : :
61 : : /* Expressions of reference type are sometimes wrapped in
62 : : INDIRECT_REFs. INDIRECT_REFs are just internal compiler
63 : : representation, not part of the language, so we have to look
64 : : through them. */
65 : 1979807124 : if (REFERENCE_REF_P (ref))
66 : 137722749 : return lvalue_kind (TREE_OPERAND (ref, 0));
67 : :
68 : 1842084375 : if (TREE_TYPE (ref)
69 : 1842084375 : && TYPE_REF_P (TREE_TYPE (ref)))
70 : : {
71 : : /* unnamed rvalue references are rvalues */
72 : 140280391 : if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
73 : : && TREE_CODE (ref) != PARM_DECL
74 : : && !VAR_P (ref)
75 : : && TREE_CODE (ref) != COMPONENT_REF
76 : : /* Functions are always lvalues. */
77 : 169663767 : && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
78 : : {
79 : 29382996 : op1_lvalue_kind = clk_rvalueref;
80 : 29382996 : if (implicit_rvalue_p (ref))
81 : 5151245 : op1_lvalue_kind |= clk_implicit_rval;
82 : 29382996 : return op1_lvalue_kind;
83 : : }
84 : :
85 : : /* lvalue references and named rvalue references are lvalues. */
86 : : return clk_ordinary;
87 : : }
88 : :
89 : 1701803984 : if (ref == current_class_ptr)
90 : : return clk_none;
91 : :
92 : : /* Expressions with cv void type are prvalues. */
93 : 1700033291 : if (TREE_TYPE (ref) && VOID_TYPE_P (TREE_TYPE (ref)))
94 : : return clk_none;
95 : :
96 : 1699677091 : switch (TREE_CODE (ref))
97 : : {
98 : : case SAVE_EXPR:
99 : : return clk_none;
100 : :
101 : : /* preincrements and predecrements are valid lvals, provided
102 : : what they refer to are valid lvals. */
103 : 226362380 : case PREINCREMENT_EXPR:
104 : 226362380 : case PREDECREMENT_EXPR:
105 : 226362380 : case TRY_CATCH_EXPR:
106 : 226362380 : case REALPART_EXPR:
107 : 226362380 : case IMAGPART_EXPR:
108 : 226362380 : case VIEW_CONVERT_EXPR:
109 : 226362380 : op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
110 : : /* As for ARRAY_REF and COMPONENT_REF, these codes turn a class prvalue
111 : : into an xvalue: we need to materialize the temporary before we mess
112 : : with it. Except VIEW_CONVERT_EXPR that doesn't actually change the
113 : : type, as in location wrapper and REF_PARENTHESIZED_P. */
114 : 226362380 : if (op1_lvalue_kind == clk_class
115 : 226362394 : && !(TREE_CODE (ref) == VIEW_CONVERT_EXPR
116 : : && (same_type_ignoring_top_level_qualifiers_p
117 : 14 : (TREE_TYPE (ref), TREE_TYPE (TREE_OPERAND (ref, 0))))))
118 : 14 : return clk_rvalueref;
119 : : return op1_lvalue_kind;
120 : :
121 : 2722569 : case ARRAY_REF:
122 : 2722569 : {
123 : 2722569 : tree op1 = TREE_OPERAND (ref, 0);
124 : 2722569 : if (TREE_CODE (TREE_TYPE (op1)) == ARRAY_TYPE)
125 : : {
126 : 2250050 : op1_lvalue_kind = lvalue_kind (op1);
127 : 2250050 : if (op1_lvalue_kind == clk_class)
128 : : /* in the case of an array operand, the result is an lvalue if
129 : : that operand is an lvalue and an xvalue otherwise */
130 : 906 : op1_lvalue_kind = clk_rvalueref;
131 : 2250050 : return op1_lvalue_kind;
132 : : }
133 : : else
134 : : return clk_ordinary;
135 : : }
136 : :
137 : 21 : case MEMBER_REF:
138 : 21 : case DOTSTAR_EXPR:
139 : 21 : if (TREE_CODE (ref) == MEMBER_REF)
140 : : op1_lvalue_kind = clk_ordinary;
141 : : else
142 : 9 : op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
143 : 21 : if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1))))
144 : : op1_lvalue_kind = clk_none;
145 : 21 : else if (op1_lvalue_kind == clk_class)
146 : : /* The result of a .* expression whose second operand is a pointer to a
147 : : data member is an lvalue if the first operand is an lvalue and an
148 : : xvalue otherwise. */
149 : 14 : op1_lvalue_kind = clk_rvalueref;
150 : : return op1_lvalue_kind;
151 : :
152 : 121633518 : case COMPONENT_REF:
153 : 121633518 : if (BASELINK_P (TREE_OPERAND (ref, 1)))
154 : : {
155 : 115 : tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1));
156 : :
157 : : /* For static member function recurse on the BASELINK, we can get
158 : : here e.g. from reference_binding. If BASELINK_FUNCTIONS is
159 : : OVERLOAD, the overload is resolved first if possible through
160 : : resolve_address_of_overloaded_function. */
161 : 115 : if (TREE_CODE (fn) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn))
162 : 27 : return lvalue_kind (TREE_OPERAND (ref, 1));
163 : : }
164 : 121633491 : op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
165 : 121633491 : if (op1_lvalue_kind == clk_class)
166 : : /* If E1 is an lvalue, then E1.E2 is an lvalue;
167 : : otherwise E1.E2 is an xvalue. */
168 : : op1_lvalue_kind = clk_rvalueref;
169 : :
170 : : /* Look at the member designator. */
171 : 121509516 : if (!op1_lvalue_kind)
172 : : ;
173 : 121595597 : else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
174 : : /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
175 : : situations. If we're seeing a COMPONENT_REF, it's a non-static
176 : : member, so it isn't an lvalue. */
177 : : op1_lvalue_kind = clk_none;
178 : 121595509 : else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
179 : : /* This can be IDENTIFIER_NODE in a template. */;
180 : 115171449 : else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
181 : : {
182 : : /* Clear the ordinary bit. If this object was a class
183 : : rvalue we want to preserve that information. */
184 : 5867875 : op1_lvalue_kind &= ~clk_ordinary;
185 : : /* The lvalue is for a bitfield. */
186 : 5867875 : op1_lvalue_kind |= clk_bitfield;
187 : : }
188 : 109303574 : else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
189 : 15177 : op1_lvalue_kind |= clk_packed;
190 : :
191 : : return op1_lvalue_kind;
192 : :
193 : : case STRING_CST:
194 : : case COMPOUND_LITERAL_EXPR:
195 : : return clk_ordinary;
196 : :
197 : 1307766 : case CONST_DECL:
198 : : /* CONST_DECL without TREE_STATIC are enumeration values and
199 : : thus not lvalues. With TREE_STATIC they are used by ObjC++
200 : : in objc_build_string_object and need to be considered as
201 : : lvalues. */
202 : 1307766 : if (! TREE_STATIC (ref))
203 : : return clk_none;
204 : : /* FALLTHRU */
205 : 182800811 : case VAR_DECL:
206 : 182800811 : if (VAR_P (ref) && DECL_HAS_VALUE_EXPR_P (ref))
207 : 531182 : return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref)));
208 : :
209 : 250750146 : if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
210 : 11224062 : && DECL_LANG_SPECIFIC (ref)
211 : 182576063 : && DECL_IN_AGGR_P (ref))
212 : : return clk_none;
213 : : /* FALLTHRU */
214 : : case INDIRECT_REF:
215 : : case ARROW_EXPR:
216 : : case PARM_DECL:
217 : : case RESULT_DECL:
218 : : case PLACEHOLDER_EXPR:
219 : : return clk_ordinary;
220 : :
221 : : /* A scope ref in a template, left as SCOPE_REF to support later
222 : : access checking. */
223 : 8358117 : case SCOPE_REF:
224 : 8358117 : gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
225 : 8358117 : {
226 : 8358117 : tree op = TREE_OPERAND (ref, 1);
227 : 8358117 : if (TREE_CODE (op) == FIELD_DECL)
228 : 22767 : return (DECL_C_BIT_FIELD (op) ? clk_bitfield : clk_ordinary);
229 : : else
230 : : return lvalue_kind (op);
231 : : }
232 : :
233 : 485 : case MAX_EXPR:
234 : 485 : case MIN_EXPR:
235 : : /* Disallow <? and >? as lvalues if either argument side-effects. */
236 : 485 : if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
237 : 485 : || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
238 : : return clk_none;
239 : 485 : op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
240 : 485 : op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
241 : 485 : break;
242 : :
243 : 8977645 : case COND_EXPR:
244 : 8977645 : if (processing_template_decl)
245 : : {
246 : : /* Within templates, a REFERENCE_TYPE will indicate whether
247 : : the COND_EXPR result is an ordinary lvalue or rvalueref.
248 : : Since REFERENCE_TYPEs are handled above, if we reach this
249 : : point, we know we got a plain rvalue. Unless we have a
250 : : type-dependent expr, that is, but we shouldn't be testing
251 : : lvalueness if we can't even tell the types yet! */
252 : 913900 : gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
253 : 913900 : goto default_;
254 : : }
255 : 8063745 : {
256 : 8063745 : tree op1 = TREE_OPERAND (ref, 1);
257 : 8063745 : if (!op1) op1 = TREE_OPERAND (ref, 0);
258 : 8063745 : tree op2 = TREE_OPERAND (ref, 2);
259 : 8063745 : op1_lvalue_kind = lvalue_kind (op1);
260 : 8063745 : op2_lvalue_kind = lvalue_kind (op2);
261 : 8063745 : if (!op1_lvalue_kind != !op2_lvalue_kind)
262 : : {
263 : : /* The second or the third operand (but not both) is a
264 : : throw-expression; the result is of the type
265 : : and value category of the other. */
266 : 597043 : if (op1_lvalue_kind && TREE_CODE (op2) == THROW_EXPR)
267 : : op2_lvalue_kind = op1_lvalue_kind;
268 : 597001 : else if (op2_lvalue_kind && TREE_CODE (op1) == THROW_EXPR)
269 : 8064230 : op1_lvalue_kind = op2_lvalue_kind;
270 : : }
271 : : }
272 : : break;
273 : :
274 : 67442 : case MODOP_EXPR:
275 : : /* We expect to see unlowered MODOP_EXPRs only during
276 : : template processing. */
277 : 67442 : gcc_assert (processing_template_decl);
278 : 67442 : if (CLASS_TYPE_P (TREE_TYPE (TREE_OPERAND (ref, 0))))
279 : 3 : goto default_;
280 : : else
281 : : return clk_ordinary;
282 : :
283 : : case MODIFY_EXPR:
284 : : case TYPEID_EXPR:
285 : : return clk_ordinary;
286 : :
287 : 1325045 : case COMPOUND_EXPR:
288 : 1325045 : return lvalue_kind (TREE_OPERAND (ref, 1));
289 : :
290 : : case TARGET_EXPR:
291 : : return clk_class;
292 : :
293 : 1373 : case VA_ARG_EXPR:
294 : 1373 : return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
295 : :
296 : 90784427 : case CALL_EXPR:
297 : : /* We can see calls outside of TARGET_EXPR in templates. */
298 : 90784427 : if (CLASS_TYPE_P (TREE_TYPE (ref)))
299 : : return clk_class;
300 : : return clk_none;
301 : :
302 : 86654960 : case FUNCTION_DECL:
303 : : /* All functions (except non-static-member functions) are
304 : : lvalues. */
305 : 86654960 : return (DECL_IOBJ_MEMBER_FUNCTION_P (ref)
306 : 86654960 : ? clk_none : clk_ordinary);
307 : :
308 : 4576 : case BASELINK:
309 : : /* We now represent a reference to a single static member function
310 : : with a BASELINK. */
311 : : /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
312 : : its argument unmodified and we assign it to a const_tree. */
313 : 4576 : return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
314 : :
315 : 32308 : case PAREN_EXPR:
316 : 32308 : return lvalue_kind (TREE_OPERAND (ref, 0));
317 : :
318 : 14744353 : case TEMPLATE_PARM_INDEX:
319 : 14744353 : if (CLASS_TYPE_P (TREE_TYPE (ref)))
320 : : /* A template parameter object is an lvalue. */
321 : : return clk_ordinary;
322 : : return clk_none;
323 : :
324 : 682691899 : default:
325 : 682691899 : default_:
326 : 682691899 : if (!TREE_TYPE (ref))
327 : : return clk_none;
328 : 1365383798 : if (CLASS_TYPE_P (TREE_TYPE (ref))
329 : 1363600682 : || TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
330 : : return clk_class;
331 : : return clk_none;
332 : : }
333 : :
334 : : /* If one operand is not an lvalue at all, then this expression is
335 : : not an lvalue. */
336 : 8064230 : if (!op1_lvalue_kind || !op2_lvalue_kind)
337 : : return clk_none;
338 : :
339 : : /* Otherwise, it's an lvalue, and it has all the odd properties
340 : : contributed by either operand. */
341 : 1462176 : op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
342 : : /* It's not an ordinary lvalue if it involves any other kind. */
343 : 1462176 : if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
344 : 22380 : op1_lvalue_kind &= ~clk_ordinary;
345 : : /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
346 : : A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
347 : 1462176 : if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
348 : 22175 : && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
349 : 786815462 : op1_lvalue_kind = clk_none;
350 : : return op1_lvalue_kind;
351 : : }
352 : :
353 : : /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
354 : :
355 : : cp_lvalue_kind
356 : 34664331 : real_lvalue_p (const_tree ref)
357 : : {
358 : 34664331 : cp_lvalue_kind kind = lvalue_kind (ref);
359 : 34664331 : if (kind & (clk_rvalueref|clk_class))
360 : : return clk_none;
361 : : else
362 : 33102877 : return kind;
363 : : }
364 : :
365 : : /* c-common wants us to return bool. */
366 : :
367 : : bool
368 : 34293384 : lvalue_p (const_tree t)
369 : : {
370 : 34293384 : return real_lvalue_p (t);
371 : : }
372 : :
373 : : /* This differs from lvalue_p in that xvalues are included. */
374 : :
375 : : bool
376 : 112262370 : glvalue_p (const_tree ref)
377 : : {
378 : 112262370 : cp_lvalue_kind kind = lvalue_kind (ref);
379 : 112262370 : if (kind & clk_class)
380 : : return false;
381 : : else
382 : 110825806 : return (kind != clk_none);
383 : : }
384 : :
385 : : /* This differs from glvalue_p in that class prvalues are included. */
386 : :
387 : : bool
388 : 878645387 : obvalue_p (const_tree ref)
389 : : {
390 : 878645387 : return (lvalue_kind (ref) != clk_none);
391 : : }
392 : :
393 : : /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
394 : : reference), false otherwise. */
395 : :
396 : : bool
397 : 4819479 : xvalue_p (const_tree ref)
398 : : {
399 : 4819479 : return (lvalue_kind (ref) & clk_rvalueref);
400 : : }
401 : :
402 : : /* True if REF is a bit-field. */
403 : :
404 : : bool
405 : 146757056 : bitfield_p (const_tree ref)
406 : : {
407 : 146757056 : return (lvalue_kind (ref) & clk_bitfield);
408 : : }
409 : :
410 : : /* C++-specific version of stabilize_reference. */
411 : :
412 : : tree
413 : 3923437 : cp_stabilize_reference (tree ref)
414 : : {
415 : 3923437 : if (processing_template_decl)
416 : : /* As in cp_save_expr. */
417 : : return ref;
418 : :
419 : 3307019 : STRIP_ANY_LOCATION_WRAPPER (ref);
420 : 3307019 : switch (TREE_CODE (ref))
421 : : {
422 : : /* We need to treat specially anything stabilize_reference doesn't
423 : : handle specifically. */
424 : : case VAR_DECL:
425 : : case PARM_DECL:
426 : : case RESULT_DECL:
427 : : CASE_CONVERT:
428 : : case FLOAT_EXPR:
429 : : case FIX_TRUNC_EXPR:
430 : : case INDIRECT_REF:
431 : : case COMPONENT_REF:
432 : : case BIT_FIELD_REF:
433 : : case ARRAY_REF:
434 : : case ARRAY_RANGE_REF:
435 : : case ERROR_MARK:
436 : : break;
437 : 428 : default:
438 : 428 : cp_lvalue_kind kind = lvalue_kind (ref);
439 : 428 : if ((kind & ~clk_class) != clk_none)
440 : : {
441 : 416 : tree type = unlowered_expr_type (ref);
442 : 416 : bool rval = !!(kind & clk_rvalueref);
443 : 416 : type = cp_build_reference_type (type, rval);
444 : : /* This inhibits warnings in, eg, cxx_mark_addressable
445 : : (c++/60955). */
446 : 416 : warning_sentinel s (extra_warnings);
447 : 416 : ref = build_static_cast (input_location, type, ref,
448 : : tf_error);
449 : 416 : }
450 : : }
451 : :
452 : 3307019 : return stabilize_reference (ref);
453 : : }
454 : :
455 : : /* Test whether DECL is a builtin that may appear in a
456 : : constant-expression. */
457 : :
458 : : bool
459 : 366696141 : builtin_valid_in_constant_expr_p (const_tree decl)
460 : : {
461 : 366696141 : STRIP_ANY_LOCATION_WRAPPER (decl);
462 : 366696141 : if (TREE_CODE (decl) != FUNCTION_DECL)
463 : : /* Not a function. */
464 : : return false;
465 : 157011181 : if (DECL_BUILT_IN_CLASS (decl) != BUILT_IN_NORMAL)
466 : : {
467 : 116866820 : if (fndecl_built_in_p (decl, BUILT_IN_FRONTEND))
468 : 152672 : switch (DECL_FE_FUNCTION_CODE (decl))
469 : : {
470 : : case CP_BUILT_IN_IS_CONSTANT_EVALUATED:
471 : : case CP_BUILT_IN_SOURCE_LOCATION:
472 : : case CP_BUILT_IN_IS_CORRESPONDING_MEMBER:
473 : : case CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS:
474 : : return true;
475 : : default:
476 : : break;
477 : : }
478 : : /* Not a built-in. */
479 : : return false;
480 : : }
481 : 40144361 : switch (DECL_FUNCTION_CODE (decl))
482 : : {
483 : : /* These always have constant results like the corresponding
484 : : macros/symbol. */
485 : : case BUILT_IN_FILE:
486 : : case BUILT_IN_FUNCTION:
487 : : case BUILT_IN_LINE:
488 : :
489 : : /* The following built-ins are valid in constant expressions
490 : : when their arguments are. */
491 : : case BUILT_IN_ADD_OVERFLOW_P:
492 : : case BUILT_IN_SUB_OVERFLOW_P:
493 : : case BUILT_IN_MUL_OVERFLOW_P:
494 : :
495 : : /* These have constant results even if their operands are
496 : : non-constant. */
497 : : case BUILT_IN_CONSTANT_P:
498 : : case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
499 : : return true;
500 : : default:
501 : : return false;
502 : : }
503 : : }
504 : :
505 : : /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
506 : :
507 : : static tree
508 : 22005627 : build_target_expr (tree decl, tree value, tsubst_flags_t complain)
509 : : {
510 : 22005627 : tree t;
511 : 22005627 : tree type = TREE_TYPE (decl);
512 : :
513 : 22005627 : value = mark_rvalue_use (value);
514 : :
515 : 22005627 : gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value))
516 : : || TREE_TYPE (decl) == TREE_TYPE (value)
517 : : /* On ARM ctors return 'this'. */
518 : : || (TYPE_PTR_P (TREE_TYPE (value))
519 : : && TREE_CODE (value) == CALL_EXPR)
520 : : || useless_type_conversion_p (TREE_TYPE (decl),
521 : : TREE_TYPE (value)));
522 : :
523 : : /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
524 : : moving a constant aggregate into .rodata. */
525 : 22005627 : if (CP_TYPE_CONST_NON_VOLATILE_P (type)
526 : 1473829 : && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
527 : 1311187 : && !VOID_TYPE_P (TREE_TYPE (value))
528 : 841659 : && !TYPE_HAS_MUTABLE_P (type)
529 : 22847283 : && reduced_constant_expression_p (value))
530 : 297950 : TREE_READONLY (decl) = true;
531 : :
532 : 22005627 : if (complain & tf_no_cleanup)
533 : : /* The caller is building a new-expr and does not need a cleanup. */
534 : : t = NULL_TREE;
535 : : else
536 : : {
537 : 21411354 : t = cxx_maybe_build_cleanup (decl, complain);
538 : 21411354 : if (t == error_mark_node)
539 : : return error_mark_node;
540 : : }
541 : :
542 : 22005597 : set_target_expr_eliding (value);
543 : :
544 : 22005597 : t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
545 : 22005597 : if (location_t eloc = cp_expr_location (value))
546 : 14013546 : SET_EXPR_LOCATION (t, eloc);
547 : : /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
548 : : ignore the TARGET_EXPR. If there really turn out to be no
549 : : side-effects, then the optimizer should be able to get rid of
550 : : whatever code is generated anyhow. */
551 : 22005597 : TREE_SIDE_EFFECTS (t) = 1;
552 : :
553 : 22005597 : return t;
554 : : }
555 : :
556 : : /* Return an undeclared local temporary of type TYPE for use in building a
557 : : TARGET_EXPR. */
558 : :
559 : : tree
560 : 24075034 : build_local_temp (tree type)
561 : : {
562 : 24075034 : tree slot = build_decl (input_location,
563 : : VAR_DECL, NULL_TREE, type);
564 : 24075034 : DECL_ARTIFICIAL (slot) = 1;
565 : 24075034 : DECL_IGNORED_P (slot) = 1;
566 : 24075034 : DECL_CONTEXT (slot) = current_function_decl;
567 : 24075034 : layout_decl (slot, 0);
568 : 24075034 : return slot;
569 : : }
570 : :
571 : : /* Return whether DECL is such a local temporary (or one from
572 : : create_tmp_var_raw). */
573 : :
574 : : bool
575 : 237583 : is_local_temp (tree decl)
576 : : {
577 : 237583 : return (VAR_P (decl) && DECL_ARTIFICIAL (decl)
578 : 238181 : && !TREE_STATIC (decl));
579 : : }
580 : :
581 : : /* Set various status flags when building an AGGR_INIT_EXPR object T. */
582 : :
583 : : static void
584 : 7030341 : process_aggr_init_operands (tree t)
585 : : {
586 : 7030341 : bool side_effects;
587 : :
588 : 7030341 : side_effects = TREE_SIDE_EFFECTS (t);
589 : 7030341 : if (!side_effects)
590 : : {
591 : 7030341 : int i, n;
592 : 7030341 : n = TREE_OPERAND_LENGTH (t);
593 : 31055900 : for (i = 1; i < n; i++)
594 : : {
595 : 26087196 : tree op = TREE_OPERAND (t, i);
596 : 26087196 : if (op && TREE_SIDE_EFFECTS (op))
597 : : {
598 : : side_effects = 1;
599 : : break;
600 : : }
601 : : }
602 : : }
603 : 7030341 : TREE_SIDE_EFFECTS (t) = side_effects;
604 : 7030341 : }
605 : :
606 : : /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
607 : : FN, and SLOT. NARGS is the number of call arguments which are specified
608 : : as a tree array ARGS. */
609 : :
610 : : static tree
611 : 7030341 : build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
612 : : tree *args)
613 : : {
614 : 7030341 : tree t;
615 : 7030341 : int i;
616 : :
617 : 7030341 : t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
618 : 7030341 : TREE_TYPE (t) = return_type;
619 : 7030341 : AGGR_INIT_EXPR_FN (t) = fn;
620 : 7030341 : AGGR_INIT_EXPR_SLOT (t) = slot;
621 : 19966436 : for (i = 0; i < nargs; i++)
622 : 12936095 : AGGR_INIT_EXPR_ARG (t, i) = args[i];
623 : 7030341 : process_aggr_init_operands (t);
624 : 7030341 : return t;
625 : : }
626 : :
627 : : /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
628 : : target. TYPE is the type to be initialized.
629 : :
630 : : Build an AGGR_INIT_EXPR to represent the initialization. This function
631 : : differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
632 : : to initialize another object, whereas a TARGET_EXPR can either
633 : : initialize another object or create its own temporary object, and as a
634 : : result building up a TARGET_EXPR requires that the type's destructor be
635 : : callable. */
636 : :
637 : : tree
638 : 23542918 : build_aggr_init_expr (tree type, tree init)
639 : : {
640 : 23542918 : tree fn;
641 : 23542918 : tree slot;
642 : 23542918 : tree rval;
643 : 23542918 : int is_ctor;
644 : :
645 : 23542918 : gcc_assert (!VOID_TYPE_P (type));
646 : :
647 : : /* Don't build AGGR_INIT_EXPR in a template. */
648 : 23542918 : if (processing_template_decl)
649 : : return init;
650 : :
651 : 23468408 : fn = cp_get_callee (init);
652 : 23468408 : if (fn == NULL_TREE)
653 : 10102443 : return convert (type, init);
654 : :
655 : 27786488 : is_ctor = (TREE_CODE (fn) == ADDR_EXPR
656 : 13313534 : && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
657 : 39993033 : && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
658 : :
659 : : /* We split the CALL_EXPR into its function and its arguments here.
660 : : Then, in expand_expr, we put them back together. The reason for
661 : : this is that this expression might be a default argument
662 : : expression. In that case, we need a new temporary every time the
663 : : expression is used. That's what break_out_target_exprs does; it
664 : : replaces every AGGR_INIT_EXPR with a copy that uses a fresh
665 : : temporary slot. Then, expand_expr builds up a call-expression
666 : : using the new slot. */
667 : :
668 : : /* If we don't need to use a constructor to create an object of this
669 : : type, don't mess with AGGR_INIT_EXPR. */
670 : 7390182 : if (is_ctor || TREE_ADDRESSABLE (type))
671 : : {
672 : 7030341 : slot = build_local_temp (type);
673 : :
674 : 7030341 : if (TREE_CODE (init) == CALL_EXPR)
675 : : {
676 : 26970532 : rval = build_aggr_init_array (void_type_node, fn, slot,
677 : 6742633 : call_expr_nargs (init),
678 : 6742633 : CALL_EXPR_ARGP (init));
679 : 6742633 : AGGR_INIT_FROM_THUNK_P (rval)
680 : 6742633 : = CALL_FROM_THUNK_P (init);
681 : : }
682 : : else
683 : : {
684 : 287708 : rval = build_aggr_init_array (void_type_node, fn, slot,
685 : 287708 : aggr_init_expr_nargs (init),
686 : 287708 : AGGR_INIT_EXPR_ARGP (init));
687 : 287708 : AGGR_INIT_FROM_THUNK_P (rval)
688 : 287708 : = AGGR_INIT_FROM_THUNK_P (init);
689 : : }
690 : 7030341 : TREE_SIDE_EFFECTS (rval) = 1;
691 : 7030341 : AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
692 : 7030341 : TREE_NOTHROW (rval) = TREE_NOTHROW (init);
693 : 7030341 : CALL_EXPR_OPERATOR_SYNTAX (rval) = CALL_EXPR_OPERATOR_SYNTAX (init);
694 : 7030341 : CALL_EXPR_ORDERED_ARGS (rval) = CALL_EXPR_ORDERED_ARGS (init);
695 : 7030341 : CALL_EXPR_REVERSE_ARGS (rval) = CALL_EXPR_REVERSE_ARGS (init);
696 : 7030341 : SET_EXPR_LOCATION (rval, EXPR_LOCATION (init));
697 : : }
698 : : else
699 : : rval = init;
700 : :
701 : : return rval;
702 : : }
703 : :
704 : : /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
705 : : target. TYPE is the type that this initialization should appear to
706 : : have.
707 : :
708 : : Build an encapsulation of the initialization to perform
709 : : and return it so that it can be processed by language-independent
710 : : and language-specific expression expanders. */
711 : :
712 : : tree
713 : 20811548 : build_cplus_new (tree type, tree init, tsubst_flags_t complain)
714 : : {
715 : : /* This function should cope with what build_special_member_call
716 : : can produce. When performing parenthesized aggregate initialization,
717 : : it can produce a { }. */
718 : 20811548 : if (BRACE_ENCLOSED_INITIALIZER_P (init))
719 : : {
720 : 162 : gcc_assert (cxx_dialect >= cxx20);
721 : 162 : return finish_compound_literal (type, init, complain);
722 : : }
723 : :
724 : 20811386 : tree rval = build_aggr_init_expr (type, init);
725 : 20811386 : tree slot;
726 : :
727 : 20811386 : if (init == error_mark_node)
728 : : return error_mark_node;
729 : :
730 : 20809535 : if (!complete_type_or_maybe_complain (type, init, complain))
731 : 6 : return error_mark_node;
732 : :
733 : : /* Make sure that we're not trying to create an instance of an
734 : : abstract class. */
735 : 20809529 : if (abstract_virtuals_error (NULL_TREE, type, complain))
736 : 15 : return error_mark_node;
737 : :
738 : 20809514 : if (TREE_CODE (rval) == AGGR_INIT_EXPR)
739 : 4514038 : slot = AGGR_INIT_EXPR_SLOT (rval);
740 : 16295476 : else if (TREE_CODE (rval) == CALL_EXPR
741 : 9885351 : || TREE_CODE (rval) == CONSTRUCTOR)
742 : 6410142 : slot = build_local_temp (type);
743 : : else
744 : : return rval;
745 : :
746 : 10924180 : rval = build_target_expr (slot, rval, complain);
747 : :
748 : 10924180 : if (rval != error_mark_node)
749 : 10924180 : TARGET_EXPR_IMPLICIT_P (rval) = 1;
750 : :
751 : : return rval;
752 : : }
753 : :
754 : : /* Subroutine of build_vec_init_expr: Build up a single element
755 : : intialization as a proxy for the full array initialization to get things
756 : : marked as used and any appropriate diagnostics.
757 : :
758 : : This used to be necessary because we were deferring building the actual
759 : : constructor calls until gimplification time; now we only do it to set
760 : : VEC_INIT_EXPR_IS_CONSTEXPR.
761 : :
762 : : We assume that init is either NULL_TREE, {}, void_type_node (indicating
763 : : value-initialization), or another array to copy. */
764 : :
765 : : static tree
766 : 1091 : build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
767 : : {
768 : 1091 : tree inner_type = strip_array_types (type);
769 : :
770 : 1091 : if (integer_zerop (array_type_nelts_total (type))
771 : 1091 : || !CLASS_TYPE_P (inner_type))
772 : : /* No interesting initialization to do. */
773 : 207 : return integer_zero_node;
774 : 884 : if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
775 : : {
776 : : /* Even if init has initializers for some array elements,
777 : : we're interested in the {}-init of trailing elements. */
778 : 130 : if (CP_AGGREGATE_TYPE_P (inner_type))
779 : : {
780 : 51 : tree empty = build_constructor (init_list_type_node, nullptr);
781 : 51 : return digest_init (inner_type, empty, complain);
782 : : }
783 : : else
784 : : /* It's equivalent to value-init. */
785 : 79 : init = void_type_node;
786 : : }
787 : 833 : if (init == void_type_node)
788 : 108 : return build_value_init (inner_type, complain);
789 : :
790 : 725 : releasing_vec argvec;
791 : 725 : if (init && !BRACE_ENCLOSED_INITIALIZER_P (init))
792 : : {
793 : 169 : tree init_type = strip_array_types (TREE_TYPE (init));
794 : 169 : tree dummy = build_dummy_object (init_type);
795 : 169 : if (!lvalue_p (init))
796 : 139 : dummy = move (dummy);
797 : 169 : argvec->quick_push (dummy);
798 : : }
799 : 725 : init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
800 : : &argvec, inner_type, LOOKUP_NORMAL,
801 : : complain);
802 : :
803 : : /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
804 : : we don't want one here because we aren't creating a temporary. */
805 : 725 : if (TREE_CODE (init) == TARGET_EXPR)
806 : 23 : init = TARGET_EXPR_INITIAL (init);
807 : :
808 : 725 : return init;
809 : 725 : }
810 : :
811 : : /* Return a TARGET_EXPR which expresses the initialization of an array to
812 : : be named later, either default-initialization or copy-initialization
813 : : from another array of the same type. */
814 : :
815 : : tree
816 : 1103 : build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
817 : : {
818 : 1103 : if (tree vi = get_vec_init_expr (init))
819 : : return vi;
820 : :
821 : 1091 : tree elt_init;
822 : 523 : if (init && TREE_CODE (init) == CONSTRUCTOR
823 : 1224 : && !BRACE_ENCLOSED_INITIALIZER_P (init))
824 : : /* We built any needed constructor calls in digest_init. */
825 : : elt_init = init;
826 : : else
827 : 1088 : elt_init = build_vec_init_elt (type, init, complain);
828 : :
829 : 1091 : bool value_init = false;
830 : 1091 : if (init == void_type_node)
831 : : {
832 : 214 : value_init = true;
833 : 214 : init = NULL_TREE;
834 : : }
835 : :
836 : 1091 : tree slot = build_local_temp (type);
837 : 1091 : init = build2 (VEC_INIT_EXPR, type, slot, init);
838 : 1091 : TREE_SIDE_EFFECTS (init) = true;
839 : 1091 : SET_EXPR_LOCATION (init, input_location);
840 : :
841 : 1091 : if (cxx_dialect >= cxx11)
842 : : {
843 : 1032 : bool cx = potential_constant_expression (elt_init);
844 : 1032 : if (BRACE_ENCLOSED_INITIALIZER_P (init))
845 : 0 : cx &= potential_constant_expression (init);
846 : 1032 : VEC_INIT_EXPR_IS_CONSTEXPR (init) = cx;
847 : : }
848 : 1091 : VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
849 : :
850 : 1091 : return init;
851 : : }
852 : :
853 : : /* Call build_vec_init to expand VEC_INIT into TARGET (for which NULL_TREE
854 : : means VEC_INIT_EXPR_SLOT). */
855 : :
856 : : tree
857 : 1121 : expand_vec_init_expr (tree target, tree vec_init, tsubst_flags_t complain,
858 : : vec<tree,va_gc> **flags)
859 : : {
860 : 1121 : iloc_sentinel ils = EXPR_LOCATION (vec_init);
861 : :
862 : 1121 : if (!target)
863 : 0 : target = VEC_INIT_EXPR_SLOT (vec_init);
864 : 1121 : tree init = VEC_INIT_EXPR_INIT (vec_init);
865 : 1121 : int from_array = (init && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE);
866 : 3363 : return build_vec_init (target, NULL_TREE, init,
867 : 1121 : VEC_INIT_EXPR_VALUE_INIT (vec_init),
868 : 1121 : from_array, complain, flags);
869 : 1121 : }
870 : :
871 : : /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
872 : : that requires a constant expression. */
873 : :
874 : : void
875 : 3 : diagnose_non_constexpr_vec_init (tree expr)
876 : : {
877 : 3 : tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
878 : 3 : tree init, elt_init;
879 : 3 : if (VEC_INIT_EXPR_VALUE_INIT (expr))
880 : 3 : init = void_type_node;
881 : : else
882 : 0 : init = VEC_INIT_EXPR_INIT (expr);
883 : :
884 : 3 : elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
885 : 3 : require_potential_constant_expression (elt_init);
886 : 3 : }
887 : :
888 : : tree
889 : 19 : build_array_copy (tree init)
890 : : {
891 : 19 : return get_target_expr (build_vec_init_expr
892 : 19 : (TREE_TYPE (init), init, tf_warning_or_error));
893 : : }
894 : :
895 : : /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
896 : : indicated TYPE. */
897 : :
898 : : tree
899 : 8142232 : build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
900 : : {
901 : 8142232 : gcc_assert (!VOID_TYPE_P (type));
902 : 8142232 : gcc_assert (!VOID_TYPE_P (TREE_TYPE (init)));
903 : :
904 : 8142232 : if (TREE_CODE (init) == TARGET_EXPR
905 : 7609759 : || init == error_mark_node)
906 : : return init;
907 : 4739578 : else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
908 : 62031 : && TREE_CODE (init) != COND_EXPR
909 : : && TREE_CODE (init) != CONSTRUCTOR
910 : : && TREE_CODE (init) != VA_ARG_EXPR
911 : 7609528 : && TREE_CODE (init) != CALL_EXPR)
912 : : /* We need to build up a copy constructor call. COND_EXPR is a special
913 : : case because we already have copies on the arms and we don't want
914 : : another one here. A CONSTRUCTOR is aggregate initialization, which
915 : : is handled separately. A VA_ARG_EXPR is magic creation of an
916 : : aggregate; there's no additional work to be done. A CALL_EXPR
917 : : already creates a prvalue. */
918 : 0 : return force_rvalue (init, complain);
919 : :
920 : 7609528 : return force_target_expr (type, init, complain);
921 : : }
922 : :
923 : : /* Like the above function, but without the checking. This function should
924 : : only be used by code which is deliberately trying to subvert the type
925 : : system, such as call_builtin_trap. Or build_over_call, to avoid
926 : : infinite recursion. */
927 : :
928 : : tree
929 : 10633403 : force_target_expr (tree type, tree init, tsubst_flags_t complain)
930 : : {
931 : 10633403 : tree slot;
932 : :
933 : 10633403 : gcc_assert (!VOID_TYPE_P (type));
934 : :
935 : 10633403 : slot = build_local_temp (type);
936 : 10633403 : return build_target_expr (slot, init, complain);
937 : : }
938 : :
939 : : /* Like build_target_expr_with_type, but use the type of INIT. */
940 : :
941 : : tree
942 : 6688827 : get_target_expr (tree init, tsubst_flags_t complain /* = tf_warning_or_error */)
943 : : {
944 : 6688827 : if (TREE_CODE (init) == AGGR_INIT_EXPR)
945 : 447763 : return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
946 : 6241064 : else if (TREE_CODE (init) == VEC_INIT_EXPR)
947 : 281 : return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
948 : : else
949 : : {
950 : 6240783 : init = convert_bitfield_to_declared_type (init);
951 : 6240783 : return build_target_expr_with_type (init, TREE_TYPE (init), complain);
952 : : }
953 : : }
954 : :
955 : : /* If EXPR is a bitfield reference, convert it to the declared type of
956 : : the bitfield, and return the resulting expression. Otherwise,
957 : : return EXPR itself. */
958 : :
959 : : tree
960 : 769851502 : convert_bitfield_to_declared_type (tree expr)
961 : : {
962 : 769851502 : tree bitfield_type;
963 : :
964 : 769851502 : bitfield_type = is_bitfield_expr_with_lowered_type (expr);
965 : 769851502 : if (bitfield_type)
966 : 252857 : expr = convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type),
967 : : expr);
968 : 769851502 : return expr;
969 : : }
970 : :
971 : : /* EXPR is being used in an rvalue context. Return a version of EXPR
972 : : that is marked as an rvalue. */
973 : :
974 : : tree
975 : 144370658 : rvalue (tree expr)
976 : : {
977 : 144370658 : tree type;
978 : :
979 : 144370658 : if (error_operand_p (expr))
980 : : return expr;
981 : :
982 : 144370458 : expr = mark_rvalue_use (expr);
983 : :
984 : : /* [expr.type]: "If a prvalue initially has the type "cv T", where T is a
985 : : cv-unqualified non-class, non-array type, the type of the expression is
986 : : adjusted to T prior to any further analysis. */
987 : 144370458 : type = TREE_TYPE (expr);
988 : 144370458 : if (!CLASS_TYPE_P (type) && TREE_CODE (type) != ARRAY_TYPE
989 : 287306073 : && cv_qualified_p (type))
990 : 30633529 : type = cv_unqualified (type);
991 : :
992 : : /* We need to do this for rvalue refs as well to get the right answer
993 : : from decltype; see c++/36628. */
994 : 144370458 : if (!processing_template_decl && glvalue_p (expr))
995 : : {
996 : : /* But don't use this function for class lvalues; use move (to treat an
997 : : lvalue as an xvalue) or force_rvalue (to make a prvalue copy). */
998 : 7369662 : gcc_checking_assert (!CLASS_TYPE_P (type));
999 : 7369662 : expr = build1 (NON_LVALUE_EXPR, type, expr);
1000 : : }
1001 : 137000796 : else if (type != TREE_TYPE (expr))
1002 : 30373454 : expr = build_nop (type, expr);
1003 : :
1004 : : return expr;
1005 : : }
1006 : :
1007 : :
1008 : : struct cplus_array_info
1009 : : {
1010 : : tree type;
1011 : : tree domain;
1012 : : };
1013 : :
1014 : : struct cplus_array_hasher : ggc_ptr_hash<tree_node>
1015 : : {
1016 : : typedef cplus_array_info *compare_type;
1017 : :
1018 : : static hashval_t hash (tree t);
1019 : : static bool equal (tree, cplus_array_info *);
1020 : : };
1021 : :
1022 : : /* Hash an ARRAY_TYPE. K is really of type `tree'. */
1023 : :
1024 : : hashval_t
1025 : 26483186 : cplus_array_hasher::hash (tree t)
1026 : : {
1027 : 26483186 : hashval_t hash;
1028 : :
1029 : 26483186 : hash = TYPE_UID (TREE_TYPE (t));
1030 : 26483186 : if (TYPE_DOMAIN (t))
1031 : 22606233 : hash ^= TYPE_UID (TYPE_DOMAIN (t));
1032 : 26483186 : return hash;
1033 : : }
1034 : :
1035 : : /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
1036 : : of type `cplus_array_info*'. */
1037 : :
1038 : : bool
1039 : 31707062 : cplus_array_hasher::equal (tree t1, cplus_array_info *t2)
1040 : : {
1041 : 33710478 : return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
1042 : : }
1043 : :
1044 : : /* Hash table containing dependent array types, which are unsuitable for
1045 : : the language-independent type hash table. */
1046 : : static GTY (()) hash_table<cplus_array_hasher> *cplus_array_htab;
1047 : :
1048 : : /* Build an ARRAY_TYPE without laying it out. */
1049 : :
1050 : : static tree
1051 : 3873428 : build_min_array_type (tree elt_type, tree index_type)
1052 : : {
1053 : 3873428 : tree t = cxx_make_type (ARRAY_TYPE);
1054 : 3873428 : TREE_TYPE (t) = elt_type;
1055 : 3873428 : TYPE_DOMAIN (t) = index_type;
1056 : 3873428 : return t;
1057 : : }
1058 : :
1059 : : /* Set TYPE_CANONICAL like build_array_type_1, but using
1060 : : build_cplus_array_type. */
1061 : :
1062 : : static void
1063 : 3873428 : set_array_type_canon (tree t, tree elt_type, tree index_type, bool dep)
1064 : : {
1065 : : /* Set the canonical type for this new node. */
1066 : 3873428 : if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
1067 : 3873428 : || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
1068 : 925027 : SET_TYPE_STRUCTURAL_EQUALITY (t);
1069 : 2948401 : else if (TYPE_CANONICAL (elt_type) != elt_type
1070 : 2948401 : || (index_type && TYPE_CANONICAL (index_type) != index_type))
1071 : 803208 : TYPE_CANONICAL (t)
1072 : 2081948 : = build_cplus_array_type (TYPE_CANONICAL (elt_type),
1073 : : index_type
1074 : 475532 : ? TYPE_CANONICAL (index_type) : index_type,
1075 : : dep);
1076 : : else
1077 : 2145193 : TYPE_CANONICAL (t) = t;
1078 : 3873428 : }
1079 : :
1080 : : /* Like build_array_type, but handle special C++ semantics: an array of a
1081 : : variant element type is a variant of the array of the main variant of
1082 : : the element type. IS_DEPENDENT is -ve if we should determine the
1083 : : dependency. Otherwise its bool value indicates dependency. */
1084 : :
1085 : : tree
1086 : 45218860 : build_cplus_array_type (tree elt_type, tree index_type, int dependent)
1087 : : {
1088 : 45218860 : tree t;
1089 : :
1090 : 45218860 : if (elt_type == error_mark_node || index_type == error_mark_node)
1091 : : return error_mark_node;
1092 : :
1093 : 45218857 : if (dependent < 0)
1094 : 46934490 : dependent = (uses_template_parms (elt_type)
1095 : 23467245 : || (index_type && uses_template_parms (index_type)));
1096 : :
1097 : 45218857 : if (elt_type != TYPE_MAIN_VARIANT (elt_type))
1098 : : /* Start with an array of the TYPE_MAIN_VARIANT. */
1099 : 19294464 : t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
1100 : : index_type, dependent);
1101 : 25924393 : else if (dependent)
1102 : : {
1103 : : /* Since type_hash_canon calls layout_type, we need to use our own
1104 : : hash table. */
1105 : 3291799 : cplus_array_info cai;
1106 : 3291799 : hashval_t hash;
1107 : :
1108 : 3291799 : if (cplus_array_htab == NULL)
1109 : 16303 : cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61);
1110 : :
1111 : 3291799 : hash = TYPE_UID (elt_type);
1112 : 3291799 : if (index_type)
1113 : 1784002 : hash ^= TYPE_UID (index_type);
1114 : 3291799 : cai.type = elt_type;
1115 : 3291799 : cai.domain = index_type;
1116 : :
1117 : 3291799 : tree *e = cplus_array_htab->find_slot_with_hash (&cai, hash, INSERT);
1118 : 3291799 : if (*e)
1119 : : /* We have found the type: we're done. */
1120 : 1923460 : return (tree) *e;
1121 : : else
1122 : : {
1123 : : /* Build a new array type. */
1124 : 1368339 : t = build_min_array_type (elt_type, index_type);
1125 : :
1126 : : /* Store it in the hash table. */
1127 : 1368339 : *e = t;
1128 : :
1129 : : /* Set the canonical type for this new node. */
1130 : 1368339 : set_array_type_canon (t, elt_type, index_type, dependent);
1131 : :
1132 : : /* Mark it as dependent now, this saves time later. */
1133 : 1368339 : TYPE_DEPENDENT_P_VALID (t) = true;
1134 : 1368339 : TYPE_DEPENDENT_P (t) = true;
1135 : : }
1136 : : }
1137 : : else
1138 : : {
1139 : 22632594 : bool typeless_storage = is_byte_access_type (elt_type);
1140 : 22632594 : t = build_array_type (elt_type, index_type, typeless_storage);
1141 : :
1142 : : /* Mark as non-dependenty now, this will save time later. */
1143 : 22632594 : TYPE_DEPENDENT_P_VALID (t) = true;
1144 : : }
1145 : :
1146 : : /* Now check whether we already have this array variant. */
1147 : 43295397 : if (elt_type != TYPE_MAIN_VARIANT (elt_type))
1148 : : {
1149 : : tree m = t;
1150 : 38921150 : for (t = m; t; t = TYPE_NEXT_VARIANT (t))
1151 : 36416061 : if (TREE_TYPE (t) == elt_type
1152 : 16798824 : && TYPE_NAME (t) == NULL_TREE
1153 : 53205436 : && TYPE_ATTRIBUTES (t) == NULL_TREE)
1154 : : break;
1155 : 19294464 : if (!t)
1156 : : {
1157 : 2505089 : t = build_min_array_type (elt_type, index_type);
1158 : : /* Mark dependency now, this saves time later. */
1159 : 2505089 : TYPE_DEPENDENT_P_VALID (t) = true;
1160 : 2505089 : TYPE_DEPENDENT_P (t) = dependent;
1161 : 2505089 : set_array_type_canon (t, elt_type, index_type, dependent);
1162 : 2505089 : if (!dependent)
1163 : : {
1164 : 2101765 : layout_type (t);
1165 : : /* Make sure sizes are shared with the main variant.
1166 : : layout_type can't be called after setting TYPE_NEXT_VARIANT,
1167 : : as it will overwrite alignment etc. of all variants. */
1168 : 2101765 : TYPE_SIZE (t) = TYPE_SIZE (m);
1169 : 2101765 : TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (m);
1170 : 2101765 : TYPE_TYPELESS_STORAGE (t) = TYPE_TYPELESS_STORAGE (m);
1171 : : }
1172 : :
1173 : 2505089 : TYPE_MAIN_VARIANT (t) = m;
1174 : 2505089 : TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
1175 : 2505089 : TYPE_NEXT_VARIANT (m) = t;
1176 : : }
1177 : : }
1178 : :
1179 : : /* Avoid spurious warnings with VLAs (c++/54583). */
1180 : 43295397 : if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t)))
1181 : 1765 : suppress_warning (TYPE_SIZE (t), OPT_Wunused);
1182 : :
1183 : : /* Push these needs up to the ARRAY_TYPE so that initialization takes
1184 : : place more easily. */
1185 : 86590794 : bool needs_ctor = (TYPE_NEEDS_CONSTRUCTING (t)
1186 : 43295397 : = TYPE_NEEDS_CONSTRUCTING (elt_type));
1187 : 86590794 : bool needs_dtor = (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1188 : 43295397 : = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type));
1189 : :
1190 : 41385945 : if (!dependent && t == TYPE_MAIN_VARIANT (t)
1191 : 65927991 : && !COMPLETE_TYPE_P (t) && COMPLETE_TYPE_P (elt_type))
1192 : : {
1193 : : /* The element type has been completed since the last time we saw
1194 : : this array type; update the layout and 'tor flags for any variants
1195 : : that need it. */
1196 : 998989 : layout_type (t);
1197 : 1714762 : for (tree v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
1198 : : {
1199 : 715773 : TYPE_NEEDS_CONSTRUCTING (v) = needs_ctor;
1200 : 715773 : TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v) = needs_dtor;
1201 : : }
1202 : : }
1203 : :
1204 : : return t;
1205 : : }
1206 : :
1207 : : /* Return an ARRAY_TYPE with element type ELT and length N. */
1208 : :
1209 : : tree
1210 : 2071330 : build_array_of_n_type (tree elt, int n)
1211 : : {
1212 : 2071330 : return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
1213 : : }
1214 : :
1215 : : /* True iff T is an array of unknown bound. */
1216 : :
1217 : : bool
1218 : 5220377 : array_of_unknown_bound_p (const_tree t)
1219 : : {
1220 : 5220377 : return (TREE_CODE (t) == ARRAY_TYPE
1221 : 5220377 : && !TYPE_DOMAIN (t));
1222 : : }
1223 : :
1224 : : /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1225 : : for C++14 but then removed. This should only be used for N3639
1226 : : specifically; code wondering more generally if something is a VLA should use
1227 : : vla_type_p. */
1228 : :
1229 : : bool
1230 : 282399 : array_of_runtime_bound_p (tree t)
1231 : : {
1232 : 282399 : if (!t || TREE_CODE (t) != ARRAY_TYPE)
1233 : : return false;
1234 : 220 : if (variably_modified_type_p (TREE_TYPE (t), NULL_TREE))
1235 : : return false;
1236 : 208 : tree dom = TYPE_DOMAIN (t);
1237 : 208 : if (!dom)
1238 : : return false;
1239 : 205 : tree max = TYPE_MAX_VALUE (dom);
1240 : 205 : return (!potential_rvalue_constant_expression (max)
1241 : 205 : || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)));
1242 : : }
1243 : :
1244 : : /* True iff T is a variable length array. */
1245 : :
1246 : : bool
1247 : 25946931 : vla_type_p (tree t)
1248 : : {
1249 : 26552414 : for (; t && TREE_CODE (t) == ARRAY_TYPE;
1250 : 605483 : t = TREE_TYPE (t))
1251 : 605660 : if (tree dom = TYPE_DOMAIN (t))
1252 : : {
1253 : 605596 : tree max = TYPE_MAX_VALUE (dom);
1254 : 605596 : if (!potential_rvalue_constant_expression (max)
1255 : 605596 : || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)))
1256 : 177 : return true;
1257 : : }
1258 : : return false;
1259 : : }
1260 : :
1261 : :
1262 : : /* Return a reference type node of MODE referring to TO_TYPE. If MODE
1263 : : is VOIDmode the standard pointer mode will be picked. If RVAL is
1264 : : true, return an rvalue reference type, otherwise return an lvalue
1265 : : reference type. If a type node exists, reuse it, otherwise create
1266 : : a new one. */
1267 : : tree
1268 : 420267010 : cp_build_reference_type_for_mode (tree to_type, machine_mode mode, bool rval)
1269 : : {
1270 : 420267010 : tree lvalue_ref, t;
1271 : :
1272 : 420267010 : if (to_type == error_mark_node)
1273 : : return error_mark_node;
1274 : :
1275 : 420267005 : if (TYPE_REF_P (to_type))
1276 : : {
1277 : 729 : rval = rval && TYPE_REF_IS_RVALUE (to_type);
1278 : 729 : to_type = TREE_TYPE (to_type);
1279 : : }
1280 : :
1281 : 420267005 : lvalue_ref = build_reference_type_for_mode (to_type, mode, false);
1282 : :
1283 : 420267005 : if (!rval)
1284 : : return lvalue_ref;
1285 : :
1286 : : /* This code to create rvalue reference types is based on and tied
1287 : : to the code creating lvalue reference types in the middle-end
1288 : : functions build_reference_type_for_mode and build_reference_type.
1289 : :
1290 : : It works by putting the rvalue reference type nodes after the
1291 : : lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1292 : : they will effectively be ignored by the middle end. */
1293 : :
1294 : 85234964 : for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
1295 : 64028951 : if (TYPE_REF_IS_RVALUE (t))
1296 : 64028951 : return t;
1297 : :
1298 : 21206013 : t = build_distinct_type_copy (lvalue_ref);
1299 : :
1300 : 21206013 : TYPE_REF_IS_RVALUE (t) = true;
1301 : 21206013 : TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
1302 : 21206013 : TYPE_NEXT_REF_TO (lvalue_ref) = t;
1303 : :
1304 : 21206013 : if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
1305 : 735758 : SET_TYPE_STRUCTURAL_EQUALITY (t);
1306 : 20470255 : else if (TYPE_CANONICAL (to_type) != to_type)
1307 : 12056642 : TYPE_CANONICAL (t)
1308 : 24113284 : = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type), mode, rval);
1309 : : else
1310 : 8413613 : TYPE_CANONICAL (t) = t;
1311 : :
1312 : 21206013 : layout_type (t);
1313 : :
1314 : 21206013 : return t;
1315 : :
1316 : : }
1317 : :
1318 : : /* Return a reference type node referring to TO_TYPE. If RVAL is
1319 : : true, return an rvalue reference type, otherwise return an lvalue
1320 : : reference type. If a type node exists, reuse it, otherwise create
1321 : : a new one. */
1322 : : tree
1323 : 365891760 : cp_build_reference_type (tree to_type, bool rval)
1324 : : {
1325 : 365891760 : return cp_build_reference_type_for_mode (to_type, VOIDmode, rval);
1326 : : }
1327 : :
1328 : : /* Returns EXPR cast to rvalue reference type, like std::move. */
1329 : :
1330 : : tree
1331 : 1399337 : move (tree expr)
1332 : : {
1333 : 1399337 : tree type = TREE_TYPE (expr);
1334 : 1399337 : gcc_assert (!TYPE_REF_P (type));
1335 : 1399337 : if (xvalue_p (expr))
1336 : : return expr;
1337 : 1399242 : type = cp_build_reference_type (type, /*rval*/true);
1338 : 1399242 : return build_static_cast (input_location, type, expr,
1339 : 1399242 : tf_warning_or_error);
1340 : : }
1341 : :
1342 : : /* Used by the C++ front end to build qualified array types. However,
1343 : : the C version of this function does not properly maintain canonical
1344 : : types (which are not used in C). */
1345 : : tree
1346 : 18322429 : c_build_qualified_type (tree type, int type_quals, tree /* orig_qual_type */,
1347 : : size_t /* orig_qual_indirect */)
1348 : : {
1349 : 18322429 : return cp_build_qualified_type (type, type_quals);
1350 : : }
1351 : :
1352 : :
1353 : : /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1354 : : arrays correctly. In particular, if TYPE is an array of T's, and
1355 : : TYPE_QUALS is non-empty, returns an array of qualified T's.
1356 : :
1357 : : FLAGS determines how to deal with ill-formed qualifications. If
1358 : : tf_ignore_bad_quals is set, then bad qualifications are dropped
1359 : : (this is permitted if TYPE was introduced via a typedef or template
1360 : : type parameter). If bad qualifications are dropped and tf_warning
1361 : : is set, then a warning is issued for non-const qualifications. If
1362 : : tf_ignore_bad_quals is not set and tf_error is not set, we
1363 : : return error_mark_node. Otherwise, we issue an error, and ignore
1364 : : the qualifications.
1365 : :
1366 : : Qualification of a reference type is valid when the reference came
1367 : : via a typedef or template type argument. [dcl.ref] No such
1368 : : dispensation is provided for qualifying a function type. [dcl.fct]
1369 : : DR 295 queries this and the proposed resolution brings it into line
1370 : : with qualifying a reference. We implement the DR. We also behave
1371 : : in a similar manner for restricting non-pointer types. */
1372 : :
1373 : : tree
1374 : 12555862383 : cp_build_qualified_type (tree type, int type_quals,
1375 : : tsubst_flags_t complain /* = tf_warning_or_error */)
1376 : : {
1377 : 12555862383 : tree result;
1378 : 12555862383 : int bad_quals = TYPE_UNQUALIFIED;
1379 : :
1380 : 12555862383 : if (type == error_mark_node)
1381 : : return type;
1382 : :
1383 : 12528889204 : if (type_quals == cp_type_quals (type))
1384 : : return type;
1385 : :
1386 : 2062247574 : if (TREE_CODE (type) == ARRAY_TYPE)
1387 : : {
1388 : : /* In C++, the qualification really applies to the array element
1389 : : type. Obtain the appropriately qualified element type. */
1390 : 20956672 : tree t;
1391 : 20956672 : tree element_type
1392 : 20956672 : = cp_build_qualified_type (TREE_TYPE (type), type_quals, complain);
1393 : :
1394 : 20956672 : if (element_type == error_mark_node)
1395 : : return error_mark_node;
1396 : :
1397 : : /* See if we already have an identically qualified type. Tests
1398 : : should be equivalent to those in check_qualified_type. */
1399 : 39855466 : for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
1400 : 22110428 : if (TREE_TYPE (t) == element_type
1401 : 3242579 : && TYPE_NAME (t) == TYPE_NAME (type)
1402 : 3211634 : && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
1403 : 25322062 : && attribute_list_equal (TYPE_ATTRIBUTES (t),
1404 : 3211634 : TYPE_ATTRIBUTES (type)))
1405 : : break;
1406 : :
1407 : 20956672 : if (!t)
1408 : : {
1409 : : /* If we already know the dependentness, tell the array type
1410 : : constructor. This is important for module streaming, as we cannot
1411 : : dynamically determine that on read in. */
1412 : 17745038 : t = build_cplus_array_type (element_type, TYPE_DOMAIN (type),
1413 : 17745038 : TYPE_DEPENDENT_P_VALID (type)
1414 : 336893 : ? int (TYPE_DEPENDENT_P (type)) : -1);
1415 : :
1416 : : /* Keep the typedef name. */
1417 : 17745038 : if (TYPE_NAME (t) != TYPE_NAME (type))
1418 : : {
1419 : 5092 : t = build_variant_type_copy (t);
1420 : 5092 : TYPE_NAME (t) = TYPE_NAME (type);
1421 : 5092 : SET_TYPE_ALIGN (t, TYPE_ALIGN (type));
1422 : 5092 : TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (type);
1423 : : }
1424 : : }
1425 : :
1426 : : /* Even if we already had this variant, we update
1427 : : TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1428 : : they changed since the variant was originally created.
1429 : :
1430 : : This seems hokey; if there is some way to use a previous
1431 : : variant *without* coming through here,
1432 : : TYPE_NEEDS_CONSTRUCTING will never be updated. */
1433 : 41913344 : TYPE_NEEDS_CONSTRUCTING (t)
1434 : 20956672 : = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
1435 : 41913344 : TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1436 : 20956672 : = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
1437 : 20956672 : return t;
1438 : : }
1439 : 2041290902 : else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
1440 : : {
1441 : 3 : tree t = PACK_EXPANSION_PATTERN (type);
1442 : :
1443 : 3 : t = cp_build_qualified_type (t, type_quals, complain);
1444 : 3 : return make_pack_expansion (t, complain);
1445 : : }
1446 : :
1447 : : /* A reference or method type shall not be cv-qualified.
1448 : : [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1449 : : (in CD1) we always ignore extra cv-quals on functions. */
1450 : :
1451 : : /* [dcl.ref/1] Cv-qualified references are ill-formed except when
1452 : : the cv-qualifiers are introduced through the use of a typedef-name
1453 : : ([dcl.typedef], [temp.param]) or decltype-specifier
1454 : : ([dcl.type.decltype]),in which case the cv-qualifiers are
1455 : : ignored. */
1456 : 2041290899 : if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1457 : 763104262 : && (TYPE_REF_P (type)
1458 : 762859689 : || FUNC_OR_METHOD_TYPE_P (type)))
1459 : : {
1460 : 245303 : if (TYPE_REF_P (type)
1461 : 245303 : && (!typedef_variant_p (type) || FUNC_OR_METHOD_TYPE_P (type)))
1462 : : bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1463 : 245303 : type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1464 : : }
1465 : :
1466 : : /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1467 : 2041290899 : if (TREE_CODE (type) == FUNCTION_TYPE)
1468 : 733 : type_quals |= type_memfn_quals (type);
1469 : :
1470 : : /* A restrict-qualified type must be a pointer (or reference)
1471 : : to object or incomplete type. */
1472 : 2041290899 : if ((type_quals & TYPE_QUAL_RESTRICT)
1473 : 8423138 : && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1474 : 8423101 : && TREE_CODE (type) != TYPENAME_TYPE
1475 : 8423095 : && !INDIRECT_TYPE_P (type))
1476 : : {
1477 : 25 : bad_quals |= TYPE_QUAL_RESTRICT;
1478 : 25 : type_quals &= ~TYPE_QUAL_RESTRICT;
1479 : : }
1480 : :
1481 : 2041290899 : if (bad_quals == TYPE_UNQUALIFIED
1482 : 196072 : || (complain & tf_ignore_bad_quals))
1483 : : /*OK*/;
1484 : 12 : else if (!(complain & tf_error))
1485 : 0 : return error_mark_node;
1486 : : else
1487 : : {
1488 : 12 : tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1489 : 12 : error ("%qV qualifiers cannot be applied to %qT",
1490 : : bad_type, type);
1491 : : }
1492 : :
1493 : : /* Retrieve (or create) the appropriately qualified variant. */
1494 : 2041290899 : result = build_qualified_type (type, type_quals);
1495 : :
1496 : 2041290899 : return result;
1497 : : }
1498 : :
1499 : : /* Return TYPE with const and volatile removed. */
1500 : :
1501 : : tree
1502 : 1173719460 : cv_unqualified (tree type)
1503 : : {
1504 : 1173719460 : int quals;
1505 : :
1506 : 1173719460 : if (type == error_mark_node)
1507 : : return type;
1508 : :
1509 : 1173719276 : quals = cp_type_quals (type);
1510 : 1173719276 : quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1511 : 1173719276 : return cp_build_qualified_type (type, quals);
1512 : : }
1513 : :
1514 : : /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1515 : : from ATTRIBS that affect type identity, and no others. If any are not
1516 : : applied, set *remove_attributes to true. */
1517 : :
1518 : : static tree
1519 : 3405313 : apply_identity_attributes (tree result, tree attribs, bool *remove_attributes)
1520 : : {
1521 : 3405313 : tree first_ident = NULL_TREE;
1522 : 3405313 : tree new_attribs = NULL_TREE;
1523 : 3405313 : tree *p = &new_attribs;
1524 : :
1525 : 3405313 : if (OVERLOAD_TYPE_P (result))
1526 : : {
1527 : : /* On classes and enums all attributes are ingrained. */
1528 : 3404356 : gcc_assert (attribs == TYPE_ATTRIBUTES (result));
1529 : : return result;
1530 : : }
1531 : :
1532 : 1917 : for (tree a = attribs; a; a = TREE_CHAIN (a))
1533 : : {
1534 : 960 : const attribute_spec *as
1535 : 960 : = lookup_attribute_spec (get_attribute_name (a));
1536 : 960 : if (as && as->affects_type_identity)
1537 : : {
1538 : 369 : if (!first_ident)
1539 : : first_ident = a;
1540 : 0 : else if (first_ident == error_mark_node)
1541 : : {
1542 : 0 : *p = tree_cons (TREE_PURPOSE (a), TREE_VALUE (a), NULL_TREE);
1543 : 0 : p = &TREE_CHAIN (*p);
1544 : : }
1545 : : }
1546 : 591 : else if (first_ident && first_ident != error_mark_node)
1547 : : {
1548 : 0 : for (tree a2 = first_ident; a2 != a; a2 = TREE_CHAIN (a2))
1549 : : {
1550 : 0 : *p = tree_cons (TREE_PURPOSE (a2), TREE_VALUE (a2), NULL_TREE);
1551 : 0 : p = &TREE_CHAIN (*p);
1552 : : }
1553 : 0 : first_ident = error_mark_node;
1554 : : }
1555 : : }
1556 : 957 : if (first_ident != error_mark_node)
1557 : 957 : new_attribs = first_ident;
1558 : :
1559 : 957 : if (first_ident == attribs)
1560 : : /* All attributes affected type identity. */;
1561 : : else
1562 : 588 : *remove_attributes = true;
1563 : :
1564 : 957 : return cp_build_type_attribute_variant (result, new_attribs);
1565 : : }
1566 : :
1567 : : /* Builds a qualified variant of T that is either not a typedef variant
1568 : : (the default behavior) or not a typedef variant of a user-facing type
1569 : : (if FLAGS contains STF_USER_FACING). If T is not a type, then this
1570 : : just dispatches to strip_typedefs_expr.
1571 : :
1572 : : E.g. consider the following declarations:
1573 : : typedef const int ConstInt;
1574 : : typedef ConstInt* PtrConstInt;
1575 : : If T is PtrConstInt, this function returns a type representing
1576 : : const int*.
1577 : : In other words, if T is a typedef, the function returns the underlying type.
1578 : : The cv-qualification and attributes of the type returned match the
1579 : : input type.
1580 : : They will always be compatible types.
1581 : : The returned type is built so that all of its subtypes
1582 : : recursively have their typedefs stripped as well.
1583 : :
1584 : : This is different from just returning TYPE_CANONICAL (T)
1585 : : Because of several reasons:
1586 : : * If T is a type that needs structural equality
1587 : : its TYPE_CANONICAL (T) will be NULL.
1588 : : * TYPE_CANONICAL (T) desn't carry type attributes
1589 : : and loses template parameter names.
1590 : :
1591 : : If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1592 : : affect type identity, and set the referent to true if any were
1593 : : stripped. */
1594 : :
1595 : : tree
1596 : 2055264467 : strip_typedefs (tree t, bool *remove_attributes /* = NULL */,
1597 : : unsigned int flags /* = 0 */)
1598 : : {
1599 : 2055264467 : tree result = NULL, type = NULL, t0 = NULL;
1600 : :
1601 : 2055264467 : if (!t || t == error_mark_node)
1602 : : return t;
1603 : :
1604 : 2029069401 : if (!TYPE_P (t))
1605 : 141896605 : return strip_typedefs_expr (t, remove_attributes, flags);
1606 : :
1607 : 1887172796 : if (t == TYPE_CANONICAL (t))
1608 : : return t;
1609 : :
1610 : 658567987 : if (typedef_variant_p (t))
1611 : : {
1612 : 170871109 : if ((flags & STF_USER_VISIBLE)
1613 : 170871109 : && !user_facing_original_type_p (t))
1614 : : return t;
1615 : :
1616 : 170869932 : if (dependent_opaque_alias_p (t))
1617 : : return t;
1618 : :
1619 : 170869867 : if (alias_template_specialization_p (t, nt_opaque))
1620 : : {
1621 : 44831620 : if (dependent_alias_template_spec_p (t, nt_opaque)
1622 : 44831620 : && !(flags & STF_STRIP_DEPENDENT))
1623 : : /* DR 1558: However, if the template-id is dependent, subsequent
1624 : : template argument substitution still applies to the template-id. */
1625 : : return t;
1626 : : }
1627 : : else
1628 : : /* If T is a non-template alias or typedef, we can assume that
1629 : : instantiating its definition will hit any substitution failure,
1630 : : so we don't need to retain it here as well. */
1631 : 126038247 : flags |= STF_STRIP_DEPENDENT;
1632 : :
1633 : 164381572 : result = strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t)),
1634 : : remove_attributes, flags);
1635 : 164381572 : goto stripped;
1636 : : }
1637 : :
1638 : 487696878 : switch (TREE_CODE (t))
1639 : : {
1640 : 9355655 : case POINTER_TYPE:
1641 : 9355655 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1642 : 9355655 : result = build_pointer_type_for_mode (type, TYPE_MODE (t), false);
1643 : 9355655 : break;
1644 : 42318608 : case REFERENCE_TYPE:
1645 : 42318608 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1646 : 42318608 : result = cp_build_reference_type_for_mode (type, TYPE_MODE (t), TYPE_REF_IS_RVALUE (t));
1647 : 42318608 : break;
1648 : 317176 : case OFFSET_TYPE:
1649 : 317176 : t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t), remove_attributes, flags);
1650 : 317176 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1651 : 317176 : result = build_offset_type (t0, type);
1652 : 317176 : break;
1653 : 21836123 : case RECORD_TYPE:
1654 : 21836123 : if (TYPE_PTRMEMFUNC_P (t))
1655 : : {
1656 : 1841754 : t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t),
1657 : : remove_attributes, flags);
1658 : 1841754 : result = build_ptrmemfunc_type (t0);
1659 : : }
1660 : : break;
1661 : 1290461 : case ARRAY_TYPE:
1662 : 1290461 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1663 : 1290461 : t0 = strip_typedefs (TYPE_DOMAIN (t), remove_attributes, flags);
1664 : 1290461 : gcc_checking_assert (TYPE_DEPENDENT_P_VALID (t)
1665 : : || !dependent_type_p (t));
1666 : 1290461 : result = build_cplus_array_type (type, t0, TYPE_DEPENDENT_P (t));
1667 : 1290461 : break;
1668 : 4838936 : case FUNCTION_TYPE:
1669 : 4838936 : case METHOD_TYPE:
1670 : 4838936 : {
1671 : 4838936 : tree arg_types = NULL, arg_node, arg_node2, arg_type;
1672 : 4838936 : bool changed;
1673 : :
1674 : : /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1675 : : around the compiler (e.g. cp_parser_late_parsing_default_args), we
1676 : : can't expect that re-hashing a function type will find a previous
1677 : : equivalent type, so try to reuse the input type if nothing has
1678 : : changed. If the type is itself a variant, that will change. */
1679 : 4838936 : bool is_variant = typedef_variant_p (t);
1680 : 4838936 : if (remove_attributes
1681 : 4838936 : && (TYPE_ATTRIBUTES (t) || TYPE_USER_ALIGN (t)))
1682 : : is_variant = true;
1683 : :
1684 : 4838936 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1685 : 4838936 : tree canon_spec = (flag_noexcept_type
1686 : 4838936 : ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t))
1687 : 4838936 : : NULL_TREE);
1688 : 8001534 : changed = (type != TREE_TYPE (t) || is_variant
1689 : 8001143 : || TYPE_RAISES_EXCEPTIONS (t) != canon_spec);
1690 : :
1691 : 4838936 : for (arg_node = TYPE_ARG_TYPES (t);
1692 : 10244619 : arg_node;
1693 : 5405683 : arg_node = TREE_CHAIN (arg_node))
1694 : : {
1695 : 9292140 : if (arg_node == void_list_node)
1696 : : break;
1697 : 5405683 : arg_type = strip_typedefs (TREE_VALUE (arg_node),
1698 : : remove_attributes, flags);
1699 : 5405683 : gcc_assert (arg_type);
1700 : 5405683 : if (arg_type == TREE_VALUE (arg_node) && !changed)
1701 : 5146818 : continue;
1702 : :
1703 : 258865 : if (!changed)
1704 : : {
1705 : 39611 : changed = true;
1706 : 39611 : for (arg_node2 = TYPE_ARG_TYPES (t);
1707 : 50599 : arg_node2 != arg_node;
1708 : 10988 : arg_node2 = TREE_CHAIN (arg_node2))
1709 : 10988 : arg_types
1710 : 10988 : = tree_cons (TREE_PURPOSE (arg_node2),
1711 : 10988 : TREE_VALUE (arg_node2), arg_types);
1712 : : }
1713 : :
1714 : 258865 : arg_types
1715 : 258865 : = tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1716 : : }
1717 : :
1718 : 4838936 : if (!changed)
1719 : : return t;
1720 : :
1721 : 1716676 : if (arg_types)
1722 : 60252 : arg_types = nreverse (arg_types);
1723 : :
1724 : : /* A list of parameters not ending with an ellipsis
1725 : : must end with void_list_node. */
1726 : 1716676 : if (arg_node)
1727 : 1716632 : arg_types = chainon (arg_types, void_list_node);
1728 : :
1729 : 1716676 : if (TREE_CODE (t) == METHOD_TYPE)
1730 : : {
1731 : 28386 : tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1732 : 28386 : gcc_assert (class_type);
1733 : 28386 : result =
1734 : 28386 : build_method_type_directly (class_type, type,
1735 : 28386 : TREE_CHAIN (arg_types));
1736 : : }
1737 : : else
1738 : : {
1739 : 1688290 : result = build_function_type (type, arg_types);
1740 : 1688290 : result = apply_memfn_quals (result, type_memfn_quals (t));
1741 : : }
1742 : :
1743 : 5150028 : result = build_cp_fntype_variant (result,
1744 : : type_memfn_rqual (t), canon_spec,
1745 : 1716676 : TYPE_HAS_LATE_RETURN_TYPE (t));
1746 : : }
1747 : 1716676 : break;
1748 : 40448935 : case TYPENAME_TYPE:
1749 : 40448935 : {
1750 : 40448935 : bool changed = false;
1751 : 40448935 : tree fullname = TYPENAME_TYPE_FULLNAME (t);
1752 : 40448935 : if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
1753 : 40448935 : && TREE_OPERAND (fullname, 1))
1754 : : {
1755 : 1892214 : tree args = TREE_OPERAND (fullname, 1);
1756 : 1892214 : tree new_args = copy_node (args);
1757 : 5106447 : for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
1758 : : {
1759 : 3214233 : tree arg = TREE_VEC_ELT (args, i);
1760 : 3214233 : tree strip_arg = strip_typedefs (arg, remove_attributes, flags);
1761 : 3214233 : TREE_VEC_ELT (new_args, i) = strip_arg;
1762 : 3214233 : if (strip_arg != arg)
1763 : 99102 : changed = true;
1764 : : }
1765 : 1892214 : if (changed)
1766 : : {
1767 : 99102 : NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)
1768 : 99102 : = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
1769 : 99102 : fullname
1770 : 99102 : = lookup_template_function (TREE_OPERAND (fullname, 0),
1771 : : new_args);
1772 : : }
1773 : : else
1774 : 1793112 : ggc_free (new_args);
1775 : : }
1776 : 40448935 : tree ctx = strip_typedefs (TYPE_CONTEXT (t), remove_attributes, flags);
1777 : 40448935 : if (!changed && ctx == TYPE_CONTEXT (t) && !typedef_variant_p (t))
1778 : : return t;
1779 : 2900884 : tree name = fullname;
1780 : 2900884 : if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
1781 : 138318 : name = TREE_OPERAND (fullname, 0);
1782 : : /* Use build_typename_type rather than make_typename_type because we
1783 : : don't want to resolve it here, just strip typedefs. */
1784 : 2900884 : result = build_typename_type (ctx, name, fullname, typename_type);
1785 : : }
1786 : 2900884 : break;
1787 : 4721567 : case DECLTYPE_TYPE:
1788 : 4721567 : result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t),
1789 : : remove_attributes, flags);
1790 : 4721567 : if (result == DECLTYPE_TYPE_EXPR (t))
1791 : : result = NULL_TREE;
1792 : : else
1793 : 121862 : result = (finish_decltype_type
1794 : 121862 : (result,
1795 : 121862 : DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
1796 : : tf_none));
1797 : : break;
1798 : 760939 : case TRAIT_TYPE:
1799 : 760939 : {
1800 : 760939 : tree type1 = strip_typedefs (TRAIT_TYPE_TYPE1 (t),
1801 : : remove_attributes, flags);
1802 : 760939 : tree type2 = strip_typedefs (TRAIT_TYPE_TYPE2 (t),
1803 : : remove_attributes, flags);
1804 : 760939 : if (type1 == TRAIT_TYPE_TYPE1 (t) && type2 == TRAIT_TYPE_TYPE2 (t))
1805 : : result = NULL_TREE;
1806 : : else
1807 : 0 : result = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2,
1808 : : tf_warning_or_error);
1809 : : }
1810 : : break;
1811 : 21864699 : case TYPE_PACK_EXPANSION:
1812 : 21864699 : {
1813 : 21864699 : tree pat = PACK_EXPANSION_PATTERN (t);
1814 : 21864699 : if (TYPE_P (pat))
1815 : : {
1816 : 21864699 : type = strip_typedefs (pat, remove_attributes, flags);
1817 : 21864699 : if (type != pat)
1818 : : {
1819 : 115598 : result = build_distinct_type_copy (t);
1820 : 115598 : PACK_EXPANSION_PATTERN (result) = type;
1821 : : }
1822 : : }
1823 : : }
1824 : : break;
1825 : : default:
1826 : : break;
1827 : : }
1828 : :
1829 : 59978674 : if (!result)
1830 : 387047893 : result = TYPE_MAIN_VARIANT (t);
1831 : :
1832 : 59978674 : stripped:
1833 : : /*gcc_assert (!typedef_variant_p (result)
1834 : : || dependent_alias_template_spec_p (result, nt_opaque)
1835 : : || ((flags & STF_USER_VISIBLE)
1836 : : && !user_facing_original_type_p (result)));*/
1837 : :
1838 : 611408139 : if (COMPLETE_TYPE_P (result) && !COMPLETE_TYPE_P (t))
1839 : : /* If RESULT is complete and T isn't, it's likely the case that T
1840 : : is a variant of RESULT which hasn't been updated yet. Skip the
1841 : : attribute handling. */;
1842 : : else
1843 : : {
1844 : 611408133 : if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1845 : 611408133 : || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1846 : : {
1847 : 18 : gcc_assert (TYPE_USER_ALIGN (t));
1848 : 18 : if (remove_attributes)
1849 : 9 : *remove_attributes = true;
1850 : : else
1851 : : {
1852 : 9 : if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1853 : 0 : result = build_variant_type_copy (result);
1854 : : else
1855 : 9 : result = build_aligned_type (result, TYPE_ALIGN (t));
1856 : 9 : TYPE_USER_ALIGN (result) = true;
1857 : : }
1858 : : }
1859 : :
1860 : 611408133 : if (TYPE_ATTRIBUTES (t))
1861 : : {
1862 : 3414960 : if (remove_attributes)
1863 : 3405313 : result = apply_identity_attributes (result, TYPE_ATTRIBUTES (t),
1864 : : remove_attributes);
1865 : : else
1866 : 9647 : result = cp_build_type_attribute_variant (result,
1867 : 9647 : TYPE_ATTRIBUTES (t));
1868 : : }
1869 : : }
1870 : :
1871 : 611408139 : return cp_build_qualified_type (result, cp_type_quals (t));
1872 : : }
1873 : :
1874 : : /* Like strip_typedefs above, but works on expressions (and other
1875 : : non-types such as TREE_VEC), so that in
1876 : :
1877 : : template<class T> struct A
1878 : : {
1879 : : typedef T TT;
1880 : : B<sizeof(TT)> b;
1881 : : };
1882 : :
1883 : : sizeof(TT) is replaced by sizeof(T). */
1884 : :
1885 : : tree
1886 : 277329529 : strip_typedefs_expr (tree t, bool *remove_attributes, unsigned int flags)
1887 : : {
1888 : 277329529 : unsigned i,n;
1889 : 277329529 : tree r, type, *ops;
1890 : 277329529 : enum tree_code code;
1891 : :
1892 : 277329529 : if (t == NULL_TREE || t == error_mark_node)
1893 : : return t;
1894 : :
1895 : 277329529 : STRIP_ANY_LOCATION_WRAPPER (t);
1896 : :
1897 : 277329529 : if (DECL_P (t) || CONSTANT_CLASS_P (t))
1898 : : return t;
1899 : :
1900 : 164613090 : code = TREE_CODE (t);
1901 : 164613090 : switch (code)
1902 : : {
1903 : : case IDENTIFIER_NODE:
1904 : : case TEMPLATE_PARM_INDEX:
1905 : : case OVERLOAD:
1906 : : case BASELINK:
1907 : : case ARGUMENT_PACK_SELECT:
1908 : : return t;
1909 : :
1910 : 2063575 : case TRAIT_EXPR:
1911 : 2063575 : {
1912 : 2063575 : tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t),
1913 : : remove_attributes, flags);
1914 : 2063575 : tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t),
1915 : : remove_attributes, flags);
1916 : 2063575 : if (type1 == TRAIT_EXPR_TYPE1 (t)
1917 : 2063575 : && type2 == TRAIT_EXPR_TYPE2 (t))
1918 : : return t;
1919 : 73468 : r = copy_node (t);
1920 : 73468 : TRAIT_EXPR_TYPE1 (r) = type1;
1921 : 73468 : TRAIT_EXPR_TYPE2 (r) = type2;
1922 : 73468 : return r;
1923 : : }
1924 : :
1925 : 938318 : case TREE_LIST:
1926 : 938318 : {
1927 : 938318 : bool changed = false;
1928 : 938318 : auto_vec<tree_pair, 4> vec;
1929 : 938318 : r = t;
1930 : 1973539 : for (; t; t = TREE_CHAIN (t))
1931 : : {
1932 : 1035221 : tree purpose = strip_typedefs (TREE_PURPOSE (t),
1933 : 1035221 : remove_attributes, flags);
1934 : 1035221 : tree value = strip_typedefs (TREE_VALUE (t),
1935 : 1035221 : remove_attributes, flags);
1936 : 1035221 : if (purpose != TREE_PURPOSE (t) || value != TREE_VALUE (t))
1937 : : changed = true;
1938 : 1035221 : vec.safe_push ({purpose, value});
1939 : : }
1940 : 938318 : if (changed)
1941 : : {
1942 : 219828 : r = NULL_TREE;
1943 : 703741 : for (int i = vec.length () - 1; i >= 0; i--)
1944 : 264085 : r = tree_cons (vec[i].first, vec[i].second, r);
1945 : : }
1946 : 938318 : return r;
1947 : 938318 : }
1948 : :
1949 : 12408530 : case TREE_VEC:
1950 : 12408530 : {
1951 : 12408530 : bool changed = false;
1952 : 12408530 : releasing_vec vec;
1953 : 12408530 : n = TREE_VEC_LENGTH (t);
1954 : 12408530 : vec_safe_reserve (vec, n);
1955 : 28775058 : for (i = 0; i < n; ++i)
1956 : : {
1957 : 16366528 : tree op = strip_typedefs (TREE_VEC_ELT (t, i),
1958 : 16366528 : remove_attributes, flags);
1959 : 16366528 : vec->quick_push (op);
1960 : 16366528 : if (op != TREE_VEC_ELT (t, i))
1961 : 77636 : changed = true;
1962 : : }
1963 : 12408530 : if (changed)
1964 : : {
1965 : 77636 : r = copy_node (t);
1966 : 232911 : for (i = 0; i < n; ++i)
1967 : 77639 : TREE_VEC_ELT (r, i) = (*vec)[i];
1968 : 155272 : NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)
1969 : 155272 : = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
1970 : : }
1971 : : else
1972 : : r = t;
1973 : 12408530 : return r;
1974 : 12408530 : }
1975 : :
1976 : 154004 : case CONSTRUCTOR:
1977 : 154004 : {
1978 : 154004 : bool changed = false;
1979 : 154004 : vec<constructor_elt, va_gc> *vec
1980 : 154004 : = vec_safe_copy (CONSTRUCTOR_ELTS (t));
1981 : 154004 : n = CONSTRUCTOR_NELTS (t);
1982 : 154004 : type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
1983 : 173615 : for (i = 0; i < n; ++i)
1984 : : {
1985 : 19611 : constructor_elt *e = &(*vec)[i];
1986 : 19611 : tree op = strip_typedefs (e->value, remove_attributes, flags);
1987 : 19611 : if (op != e->value)
1988 : : {
1989 : 6 : changed = true;
1990 : 6 : e->value = op;
1991 : : }
1992 : 19611 : gcc_checking_assert
1993 : : (e->index == strip_typedefs (e->index, remove_attributes,
1994 : : flags));
1995 : : }
1996 : :
1997 : 154004 : if (!changed && type == TREE_TYPE (t))
1998 : : {
1999 : 132191 : vec_free (vec);
2000 : 132191 : return t;
2001 : : }
2002 : : else
2003 : : {
2004 : 21813 : r = copy_node (t);
2005 : 21813 : TREE_TYPE (r) = type;
2006 : 21813 : CONSTRUCTOR_ELTS (r) = vec;
2007 : 21813 : return r;
2008 : : }
2009 : : }
2010 : :
2011 : : case LAMBDA_EXPR:
2012 : : return t;
2013 : :
2014 : 3 : case STATEMENT_LIST:
2015 : 3 : error ("statement-expression in a constant expression");
2016 : 3 : return error_mark_node;
2017 : :
2018 : 89597062 : default:
2019 : 89597062 : break;
2020 : : }
2021 : :
2022 : 89597062 : gcc_assert (EXPR_P (t));
2023 : :
2024 : 89597062 : n = cp_tree_operand_length (t);
2025 : 89597062 : ops = XALLOCAVEC (tree, n);
2026 : 89597062 : type = TREE_TYPE (t);
2027 : :
2028 : 89597062 : switch (code)
2029 : : {
2030 : 6534220 : CASE_CONVERT:
2031 : 6534220 : case IMPLICIT_CONV_EXPR:
2032 : 6534220 : case DYNAMIC_CAST_EXPR:
2033 : 6534220 : case STATIC_CAST_EXPR:
2034 : 6534220 : case CONST_CAST_EXPR:
2035 : 6534220 : case REINTERPRET_CAST_EXPR:
2036 : 6534220 : case CAST_EXPR:
2037 : 6534220 : case NEW_EXPR:
2038 : 6534220 : type = strip_typedefs (type, remove_attributes, flags);
2039 : : /* fallthrough */
2040 : :
2041 : 89597062 : default:
2042 : 280017842 : for (i = 0; i < n; ++i)
2043 : 190420780 : ops[i] = strip_typedefs (TREE_OPERAND (t, i),
2044 : : remove_attributes, flags);
2045 : : break;
2046 : : }
2047 : :
2048 : : /* If nothing changed, return t. */
2049 : 274548564 : for (i = 0; i < n; ++i)
2050 : 188194238 : if (ops[i] != TREE_OPERAND (t, i))
2051 : : break;
2052 : 89597062 : if (i == n && type == TREE_TYPE (t))
2053 : : return t;
2054 : :
2055 : 3479356 : r = copy_node (t);
2056 : 3479356 : TREE_TYPE (r) = type;
2057 : 10851168 : for (i = 0; i < n; ++i)
2058 : 7371812 : TREE_OPERAND (r, i) = ops[i];
2059 : : return r;
2060 : : }
2061 : :
2062 : : /* Makes a copy of BINFO and TYPE, which is to be inherited into a
2063 : : graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
2064 : : and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
2065 : : VIRT indicates whether TYPE is inherited virtually or not.
2066 : : IGO_PREV points at the previous binfo of the inheritance graph
2067 : : order chain. The newly copied binfo's TREE_CHAIN forms this
2068 : : ordering.
2069 : :
2070 : : The CLASSTYPE_VBASECLASSES vector of T is constructed in the
2071 : : correct order. That is in the order the bases themselves should be
2072 : : constructed in.
2073 : :
2074 : : The BINFO_INHERITANCE of a virtual base class points to the binfo
2075 : : of the most derived type. ??? We could probably change this so that
2076 : : BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
2077 : : remove a field. They currently can only differ for primary virtual
2078 : : virtual bases. */
2079 : :
2080 : : tree
2081 : 32015903 : copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
2082 : : {
2083 : 32015903 : tree new_binfo;
2084 : :
2085 : 32015903 : if (virt)
2086 : : {
2087 : : /* See if we've already made this virtual base. */
2088 : 290704 : new_binfo = binfo_for_vbase (type, t);
2089 : 290704 : if (new_binfo)
2090 : : return new_binfo;
2091 : : }
2092 : :
2093 : 57465390 : new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
2094 : 31946021 : BINFO_TYPE (new_binfo) = type;
2095 : :
2096 : : /* Chain it into the inheritance graph. */
2097 : 31946021 : TREE_CHAIN (*igo_prev) = new_binfo;
2098 : 31946021 : *igo_prev = new_binfo;
2099 : :
2100 : 57465390 : if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
2101 : : {
2102 : 25519366 : int ix;
2103 : 25519366 : tree base_binfo;
2104 : :
2105 : 25519366 : gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
2106 : :
2107 : 25519366 : BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
2108 : 25519366 : BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
2109 : :
2110 : : /* We do not need to copy the accesses, as they are read only. */
2111 : 25519366 : BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
2112 : :
2113 : : /* Recursively copy base binfos of BINFO. */
2114 : 29742505 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2115 : : {
2116 : 4223139 : tree new_base_binfo;
2117 : 4223139 : new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
2118 : : t, igo_prev,
2119 : 4223139 : BINFO_VIRTUAL_P (base_binfo));
2120 : :
2121 : 4223139 : if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
2122 : 4001248 : BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
2123 : 4223139 : BINFO_BASE_APPEND (new_binfo, new_base_binfo);
2124 : : }
2125 : : }
2126 : : else
2127 : 6426655 : BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
2128 : :
2129 : 31946021 : if (virt)
2130 : : {
2131 : : /* Push it onto the list after any virtual bases it contains
2132 : : will have been pushed. */
2133 : 220822 : CLASSTYPE_VBASECLASSES (t)->quick_push (new_binfo);
2134 : 220822 : BINFO_VIRTUAL_P (new_binfo) = 1;
2135 : 220822 : BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
2136 : : }
2137 : :
2138 : : return new_binfo;
2139 : : }
2140 : :
2141 : : /* Hashing of lists so that we don't make duplicates.
2142 : : The entry point is `list_hash_canon'. */
2143 : :
2144 : : struct list_proxy
2145 : : {
2146 : : tree purpose;
2147 : : tree value;
2148 : : tree chain;
2149 : : };
2150 : :
2151 : : struct list_hasher : ggc_ptr_hash<tree_node>
2152 : : {
2153 : : typedef list_proxy *compare_type;
2154 : :
2155 : : static hashval_t hash (tree);
2156 : : static bool equal (tree, list_proxy *);
2157 : : };
2158 : :
2159 : : /* Now here is the hash table. When recording a list, it is added
2160 : : to the slot whose index is the hash code mod the table size.
2161 : : Note that the hash table is used for several kinds of lists.
2162 : : While all these live in the same table, they are completely independent,
2163 : : and the hash code is computed differently for each of these. */
2164 : :
2165 : : static GTY (()) hash_table<list_hasher> *list_hash_table;
2166 : :
2167 : : /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2168 : : for a node we are thinking about adding). */
2169 : :
2170 : : bool
2171 : 1810262945 : list_hasher::equal (tree t, list_proxy *proxy)
2172 : : {
2173 : 1810262945 : return (TREE_VALUE (t) == proxy->value
2174 : 134047903 : && TREE_PURPOSE (t) == proxy->purpose
2175 : 1942508251 : && TREE_CHAIN (t) == proxy->chain);
2176 : : }
2177 : :
2178 : : /* Compute a hash code for a list (chain of TREE_LIST nodes
2179 : : with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2180 : : TREE_COMMON slots), by adding the hash codes of the individual entries. */
2181 : :
2182 : : static hashval_t
2183 : 1656915566 : list_hash_pieces (tree purpose, tree value, tree chain)
2184 : : {
2185 : 1656915566 : hashval_t hashcode = 0;
2186 : :
2187 : 1656915566 : if (chain)
2188 : 1656380453 : hashcode += TREE_HASH (chain);
2189 : :
2190 : 1656915566 : if (value)
2191 : 1656915566 : hashcode += TREE_HASH (value);
2192 : : else
2193 : 0 : hashcode += 1007;
2194 : 1656915566 : if (purpose)
2195 : 120977665 : hashcode += TREE_HASH (purpose);
2196 : : else
2197 : 1535937901 : hashcode += 1009;
2198 : 1656915566 : return hashcode;
2199 : : }
2200 : :
2201 : : /* Hash an already existing TREE_LIST. */
2202 : :
2203 : : hashval_t
2204 : 1409852530 : list_hasher::hash (tree t)
2205 : : {
2206 : 1409852530 : return list_hash_pieces (TREE_PURPOSE (t),
2207 : 1409852530 : TREE_VALUE (t),
2208 : 1409852530 : TREE_CHAIN (t));
2209 : : }
2210 : :
2211 : : /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2212 : : object for an identical list if one already exists. Otherwise, build a
2213 : : new one, and record it as the canonical object. */
2214 : :
2215 : : tree
2216 : 247063036 : hash_tree_cons (tree purpose, tree value, tree chain)
2217 : : {
2218 : 247063036 : int hashcode = 0;
2219 : 247063036 : tree *slot;
2220 : 247063036 : struct list_proxy proxy;
2221 : :
2222 : : /* Hash the list node. */
2223 : 247063036 : hashcode = list_hash_pieces (purpose, value, chain);
2224 : : /* Create a proxy for the TREE_LIST we would like to create. We
2225 : : don't actually create it so as to avoid creating garbage. */
2226 : 247063036 : proxy.purpose = purpose;
2227 : 247063036 : proxy.value = value;
2228 : 247063036 : proxy.chain = chain;
2229 : : /* See if it is already in the table. */
2230 : 247063036 : slot = list_hash_table->find_slot_with_hash (&proxy, hashcode, INSERT);
2231 : : /* If not, create a new node. */
2232 : 247063036 : if (!*slot)
2233 : 120592967 : *slot = tree_cons (purpose, value, chain);
2234 : 247063036 : return (tree) *slot;
2235 : : }
2236 : :
2237 : : /* Constructor for hashed lists. */
2238 : :
2239 : : tree
2240 : 2148228 : hash_tree_chain (tree value, tree chain)
2241 : : {
2242 : 2148228 : return hash_tree_cons (NULL_TREE, value, chain);
2243 : : }
2244 : :
2245 : : void
2246 : 0 : debug_binfo (tree elem)
2247 : : {
2248 : 0 : HOST_WIDE_INT n;
2249 : 0 : tree virtuals;
2250 : :
2251 : 0 : fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2252 : : "\nvtable type:\n",
2253 : 0 : TYPE_NAME_STRING (BINFO_TYPE (elem)),
2254 : 0 : TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
2255 : 0 : debug_tree (BINFO_TYPE (elem));
2256 : 0 : if (BINFO_VTABLE (elem))
2257 : 0 : fprintf (stderr, "vtable decl \"%s\"\n",
2258 : 0 : IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
2259 : : else
2260 : 0 : fprintf (stderr, "no vtable decl yet\n");
2261 : 0 : fprintf (stderr, "virtuals:\n");
2262 : 0 : virtuals = BINFO_VIRTUALS (elem);
2263 : 0 : n = 0;
2264 : :
2265 : 0 : while (virtuals)
2266 : : {
2267 : 0 : tree fndecl = TREE_VALUE (virtuals);
2268 : 0 : fprintf (stderr, "%s [" HOST_WIDE_INT_PRINT_DEC " =? "
2269 : : HOST_WIDE_INT_PRINT_DEC "]\n",
2270 : 0 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
2271 : 0 : n, TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
2272 : 0 : ++n;
2273 : 0 : virtuals = TREE_CHAIN (virtuals);
2274 : : }
2275 : 0 : }
2276 : :
2277 : : /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2278 : : the type of the result expression, if known, or NULL_TREE if the
2279 : : resulting expression is type-dependent. If TEMPLATE_P is true,
2280 : : NAME is known to be a template because the user explicitly used the
2281 : : "template" keyword after the "::".
2282 : :
2283 : : All SCOPE_REFs should be built by use of this function. */
2284 : :
2285 : : tree
2286 : 145775214 : build_qualified_name (tree type, tree scope, tree name, bool template_p)
2287 : : {
2288 : 145775214 : tree t;
2289 : 145775214 : if (type == error_mark_node
2290 : 145775214 : || scope == error_mark_node
2291 : 145775211 : || name == error_mark_node)
2292 : : return error_mark_node;
2293 : 145775211 : gcc_assert (TREE_CODE (name) != SCOPE_REF);
2294 : 145775211 : t = build2 (SCOPE_REF, type, scope, name);
2295 : 145775211 : QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
2296 : 145775211 : PTRMEM_OK_P (t) = true;
2297 : 145775211 : if (type)
2298 : 9739064 : t = convert_from_reference (t);
2299 : : return t;
2300 : : }
2301 : :
2302 : : /* Like check_qualified_type, but also check ref-qualifier, exception
2303 : : specification, and whether the return type was specified after the
2304 : : parameters. */
2305 : :
2306 : : static bool
2307 : 1007758189 : cp_check_qualified_type (const_tree cand, const_tree base, int type_quals,
2308 : : cp_ref_qualifier rqual, tree raises, bool late)
2309 : : {
2310 : 1007758189 : return (TYPE_QUALS (cand) == type_quals
2311 : 1007712282 : && check_base_type (cand, base)
2312 : 1007676377 : && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (cand),
2313 : : ce_exact)
2314 : 497482379 : && TYPE_HAS_LATE_RETURN_TYPE (cand) == late
2315 : 1472663714 : && type_memfn_rqual (cand) == rqual);
2316 : : }
2317 : :
2318 : : /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2319 : :
2320 : : tree
2321 : 560068 : build_ref_qualified_type (tree type, cp_ref_qualifier rqual)
2322 : : {
2323 : 560068 : tree raises = TYPE_RAISES_EXCEPTIONS (type);
2324 : 560068 : bool late = TYPE_HAS_LATE_RETURN_TYPE (type);
2325 : 560068 : return build_cp_fntype_variant (type, rqual, raises, late);
2326 : : }
2327 : :
2328 : : tree
2329 : 288232 : make_binding_vec (tree name, unsigned clusters MEM_STAT_DECL)
2330 : : {
2331 : : /* Stored in an unsigned short, but we're limited to the number of
2332 : : modules anyway. */
2333 : 288232 : gcc_checking_assert (clusters <= (unsigned short)(~0));
2334 : 288232 : size_t length = (offsetof (tree_binding_vec, vec)
2335 : 288232 : + clusters * sizeof (binding_cluster));
2336 : 288232 : tree vec = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2337 : 288232 : TREE_SET_CODE (vec, BINDING_VECTOR);
2338 : 288232 : BINDING_VECTOR_NAME (vec) = name;
2339 : 288232 : BINDING_VECTOR_ALLOC_CLUSTERS (vec) = clusters;
2340 : 288232 : BINDING_VECTOR_NUM_CLUSTERS (vec) = 0;
2341 : :
2342 : 288232 : return vec;
2343 : : }
2344 : :
2345 : : /* Make a raw overload node containing FN. */
2346 : :
2347 : : tree
2348 : 281351549 : ovl_make (tree fn, tree next)
2349 : : {
2350 : 281351549 : tree result = make_node (OVERLOAD);
2351 : :
2352 : 281351549 : if (TREE_CODE (fn) == OVERLOAD)
2353 : 9241874 : OVL_NESTED_P (result) = true;
2354 : :
2355 : 379838689 : TREE_TYPE (result) = (next || TREE_CODE (fn) == TEMPLATE_DECL
2356 : 379838689 : ? unknown_type_node : TREE_TYPE (fn));
2357 : 281351549 : if (next && TREE_CODE (next) == OVERLOAD && OVL_DEDUP_P (next))
2358 : 12944704 : OVL_DEDUP_P (result) = true;
2359 : 281351549 : OVL_FUNCTION (result) = fn;
2360 : 281351549 : OVL_CHAIN (result) = next;
2361 : 281351549 : return result;
2362 : : }
2363 : :
2364 : : /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN is > 0
2365 : : if this is a using-decl. It is > 1 if we're revealing the using decl.
2366 : : It is > 2 if we're also exporting it. USING_OR_HIDDEN is < 0, if FN is
2367 : : hidden. (A decl cannot be both using and hidden.) We keep the hidden
2368 : : decls first, but remaining ones are unordered. */
2369 : :
2370 : : tree
2371 : 585461747 : ovl_insert (tree fn, tree maybe_ovl, int using_or_hidden)
2372 : : {
2373 : 585461747 : tree result = maybe_ovl;
2374 : 585461747 : tree insert_after = NULL_TREE;
2375 : :
2376 : : /* Skip hidden. */
2377 : 794822591 : for (; maybe_ovl && TREE_CODE (maybe_ovl) == OVERLOAD
2378 : 803386509 : && OVL_HIDDEN_P (maybe_ovl);
2379 : 54423184 : maybe_ovl = OVL_CHAIN (maybe_ovl))
2380 : : {
2381 : 54423184 : gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl));
2382 : 54423184 : insert_after = maybe_ovl;
2383 : : }
2384 : :
2385 : 585461747 : if (maybe_ovl || using_or_hidden || TREE_CODE (fn) == TEMPLATE_DECL)
2386 : : {
2387 : 251704157 : maybe_ovl = ovl_make (fn, maybe_ovl);
2388 : :
2389 : 251704157 : if (using_or_hidden < 0)
2390 : 69305293 : OVL_HIDDEN_P (maybe_ovl) = true;
2391 : 251704157 : if (using_or_hidden > 0)
2392 : : {
2393 : 10477521 : OVL_DEDUP_P (maybe_ovl) = OVL_USING_P (maybe_ovl) = true;
2394 : 10477521 : if (using_or_hidden > 1)
2395 : 14506 : OVL_PURVIEW_P (maybe_ovl) = true;
2396 : 14506 : if (using_or_hidden > 2)
2397 : 14467 : OVL_EXPORT_P (maybe_ovl) = true;
2398 : : }
2399 : : }
2400 : : else
2401 : : maybe_ovl = fn;
2402 : :
2403 : 585461747 : if (insert_after)
2404 : : {
2405 : 7926033 : OVL_CHAIN (insert_after) = maybe_ovl;
2406 : 7926033 : TREE_TYPE (insert_after) = unknown_type_node;
2407 : : }
2408 : : else
2409 : : result = maybe_ovl;
2410 : :
2411 : 585461747 : return result;
2412 : : }
2413 : :
2414 : : /* Skip any hidden names at the beginning of OVL. */
2415 : :
2416 : : tree
2417 : 1495370633 : ovl_skip_hidden (tree ovl)
2418 : : {
2419 : 2261925646 : while (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl))
2420 : 766555013 : ovl = OVL_CHAIN (ovl);
2421 : :
2422 : 1495370633 : return ovl;
2423 : : }
2424 : :
2425 : : /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2426 : :
2427 : : tree
2428 : 3747013 : ovl_iterator::reveal_node (tree overload, tree node)
2429 : : {
2430 : : /* We cannot have returned NODE as part of a lookup overload, so we
2431 : : don't have to worry about preserving that. */
2432 : :
2433 : 3747013 : OVL_HIDDEN_P (node) = false;
2434 : 3747013 : if (tree chain = OVL_CHAIN (node))
2435 : 173937 : if (TREE_CODE (chain) == OVERLOAD)
2436 : : {
2437 : 164503 : if (OVL_HIDDEN_P (chain))
2438 : : {
2439 : : /* The node needs moving, and the simplest way is to remove it
2440 : : and reinsert. */
2441 : 75308 : overload = remove_node (overload, node);
2442 : 75308 : overload = ovl_insert (OVL_FUNCTION (node), overload);
2443 : : }
2444 : 89195 : else if (OVL_DEDUP_P (chain))
2445 : 9 : OVL_DEDUP_P (node) = true;
2446 : : }
2447 : 3747013 : return overload;
2448 : : }
2449 : :
2450 : : /* NODE is on the overloads of OVL. Remove it.
2451 : : The removed node is unaltered and may continue to be iterated
2452 : : from (i.e. it is safe to remove a node from an overload one is
2453 : : currently iterating over). */
2454 : :
2455 : : tree
2456 : 230291 : ovl_iterator::remove_node (tree overload, tree node)
2457 : : {
2458 : 230291 : tree *slot = &overload;
2459 : 1515532 : while (*slot != node)
2460 : : {
2461 : 1285241 : tree probe = *slot;
2462 : 1285241 : gcc_checking_assert (!OVL_LOOKUP_P (probe));
2463 : :
2464 : 1285241 : slot = &OVL_CHAIN (probe);
2465 : : }
2466 : :
2467 : : /* Stitch out NODE. We don't have to worry about now making a
2468 : : singleton overload (and consequently maybe setting its type),
2469 : : because all uses of this function will be followed by inserting a
2470 : : new node that must follow the place we've cut this out from. */
2471 : 230291 : if (TREE_CODE (node) != OVERLOAD)
2472 : : /* Cloned inherited ctors don't mark themselves as via_using. */
2473 : 108927 : *slot = NULL_TREE;
2474 : : else
2475 : 121364 : *slot = OVL_CHAIN (node);
2476 : :
2477 : 230291 : return overload;
2478 : : }
2479 : :
2480 : : /* Mark or unmark a lookup set. */
2481 : :
2482 : : void
2483 : 88581188 : lookup_mark (tree ovl, bool val)
2484 : : {
2485 : 950140265 : for (lkp_iterator iter (ovl); iter; ++iter)
2486 : : {
2487 : 861559077 : gcc_checking_assert (LOOKUP_SEEN_P (*iter) != val);
2488 : 861559077 : LOOKUP_SEEN_P (*iter) = val;
2489 : : }
2490 : 88581188 : }
2491 : :
2492 : : /* Add a set of new FNS into a lookup. */
2493 : :
2494 : : tree
2495 : 482093674 : lookup_add (tree fns, tree lookup)
2496 : : {
2497 : 482093674 : if (fns == error_mark_node || lookup == error_mark_node)
2498 : : return error_mark_node;
2499 : :
2500 : 482093662 : if (lookup || TREE_CODE (fns) == TEMPLATE_DECL)
2501 : : {
2502 : 26098267 : lookup = ovl_make (fns, lookup);
2503 : 26098267 : OVL_LOOKUP_P (lookup) = true;
2504 : : }
2505 : : else
2506 : : lookup = fns;
2507 : :
2508 : : return lookup;
2509 : : }
2510 : :
2511 : : /* FNS is a new overload set, add them to LOOKUP, if they are not
2512 : : already present there. */
2513 : :
2514 : : tree
2515 : 482390135 : lookup_maybe_add (tree fns, tree lookup, bool deduping)
2516 : : {
2517 : 482390135 : if (deduping)
2518 : 528552477 : for (tree next, probe = fns; probe; probe = next)
2519 : : {
2520 : 478035444 : tree fn = probe;
2521 : 478035444 : next = NULL_TREE;
2522 : :
2523 : 478035444 : if (TREE_CODE (probe) == OVERLOAD)
2524 : : {
2525 : 466756797 : fn = OVL_FUNCTION (probe);
2526 : 466756797 : next = OVL_CHAIN (probe);
2527 : : }
2528 : :
2529 : 478035444 : if (!LOOKUP_SEEN_P (fn))
2530 : 351166511 : LOOKUP_SEEN_P (fn) = true;
2531 : : else
2532 : : {
2533 : : /* This function was already seen. Insert all the
2534 : : predecessors onto the lookup. */
2535 : 136111515 : for (; fns != probe; fns = OVL_CHAIN (fns))
2536 : : {
2537 : : /* Propagate OVL_USING, but OVL_HIDDEN &
2538 : : OVL_DEDUP_P don't matter. */
2539 : 9242582 : if (OVL_USING_P (fns))
2540 : : {
2541 : 9897 : lookup = ovl_make (OVL_FUNCTION (fns), lookup);
2542 : 9897 : OVL_USING_P (lookup) = true;
2543 : : }
2544 : : else
2545 : 9232685 : lookup = lookup_add (OVL_FUNCTION (fns), lookup);
2546 : : }
2547 : :
2548 : : /* And now skip this function. */
2549 : : fns = next;
2550 : : }
2551 : : }
2552 : :
2553 : 482390135 : if (fns)
2554 : : /* We ended in a set of new functions. Add them all in one go. */
2555 : 472285696 : lookup = lookup_add (fns, lookup);
2556 : :
2557 : 482390135 : return lookup;
2558 : : }
2559 : :
2560 : : /* Returns nonzero if X is an expression for a (possibly overloaded)
2561 : : function. If "f" is a function or function template, "f", "c->f",
2562 : : "c.f", "C::f", and "f<int>" will all be considered possibly
2563 : : overloaded functions. Returns 2 if the function is actually
2564 : : overloaded, i.e., if it is impossible to know the type of the
2565 : : function without performing overload resolution. */
2566 : :
2567 : : int
2568 : 5132755377 : is_overloaded_fn (tree x)
2569 : : {
2570 : 5132755377 : STRIP_ANY_LOCATION_WRAPPER (x);
2571 : :
2572 : : /* A baselink is also considered an overloaded function. */
2573 : 5132755377 : if (TREE_CODE (x) == OFFSET_REF
2574 : 5132689555 : || TREE_CODE (x) == COMPONENT_REF)
2575 : 230737519 : x = TREE_OPERAND (x, 1);
2576 : 5132755377 : x = MAYBE_BASELINK_FUNCTIONS (x);
2577 : 5132755377 : if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
2578 : 117895773 : x = TREE_OPERAND (x, 0);
2579 : :
2580 : 5841725973 : if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x))
2581 : 5147822467 : || (TREE_CODE (x) == OVERLOAD && !OVL_SINGLE_P (x)))
2582 : : return 2;
2583 : :
2584 : 5368420126 : return OVL_P (x);
2585 : : }
2586 : :
2587 : : /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2588 : : (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2589 : : NULL_TREE. */
2590 : :
2591 : : tree
2592 : 488702304 : dependent_name (tree x)
2593 : : {
2594 : : /* FIXME a dependent name must be unqualified, but this function doesn't
2595 : : distinguish between qualified and unqualified identifiers. */
2596 : 488702304 : if (identifier_p (x))
2597 : : return x;
2598 : 488342007 : if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
2599 : 184960235 : x = TREE_OPERAND (x, 0);
2600 : 488342007 : if (OVL_P (x))
2601 : 263486823 : return OVL_NAME (x);
2602 : : return NULL_TREE;
2603 : : }
2604 : :
2605 : : /* Like dependent_name, but instead takes a CALL_EXPR and also checks
2606 : : its dependence. */
2607 : :
2608 : : tree
2609 : 513631611 : call_expr_dependent_name (tree x)
2610 : : {
2611 : 513631611 : if (TREE_TYPE (x) != NULL_TREE)
2612 : : /* X isn't dependent, so its callee isn't a dependent name. */
2613 : : return NULL_TREE;
2614 : 487748723 : return dependent_name (CALL_EXPR_FN (x));
2615 : : }
2616 : :
2617 : : /* Returns true iff X is an expression for an overloaded function
2618 : : whose type cannot be known without performing overload
2619 : : resolution. */
2620 : :
2621 : : bool
2622 : 472344672 : really_overloaded_fn (tree x)
2623 : : {
2624 : 472344672 : return is_overloaded_fn (x) == 2;
2625 : : }
2626 : :
2627 : : /* Get the overload set FROM refers to. Returns NULL if it's not an
2628 : : overload set. */
2629 : :
2630 : : tree
2631 : 3669260835 : maybe_get_fns (tree from)
2632 : : {
2633 : 3669260835 : STRIP_ANY_LOCATION_WRAPPER (from);
2634 : :
2635 : : /* A baselink is also considered an overloaded function. */
2636 : 3669260835 : if (TREE_CODE (from) == OFFSET_REF
2637 : 3669199883 : || TREE_CODE (from) == COMPONENT_REF)
2638 : 124266799 : from = TREE_OPERAND (from, 1);
2639 : 3669260835 : if (BASELINK_P (from))
2640 : 213718496 : from = BASELINK_FUNCTIONS (from);
2641 : 3669260835 : if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
2642 : 114074489 : from = TREE_OPERAND (from, 0);
2643 : :
2644 : 3669260835 : if (OVL_P (from))
2645 : 915434625 : return from;
2646 : :
2647 : : return NULL;
2648 : : }
2649 : :
2650 : : /* FROM refers to an overload set. Return that set (or die). */
2651 : :
2652 : : tree
2653 : 645807201 : get_fns (tree from)
2654 : : {
2655 : 645807201 : tree res = maybe_get_fns (from);
2656 : :
2657 : 645807201 : gcc_assert (res);
2658 : 645807201 : return res;
2659 : : }
2660 : :
2661 : : /* Return the first function of the overload set FROM refers to. */
2662 : :
2663 : : tree
2664 : 444460897 : get_first_fn (tree from)
2665 : : {
2666 : 444460897 : return OVL_FIRST (get_fns (from));
2667 : : }
2668 : :
2669 : : /* Return the scope where the overloaded functions OVL were found. */
2670 : :
2671 : : tree
2672 : 148389248 : ovl_scope (tree ovl)
2673 : : {
2674 : 148389248 : if (TREE_CODE (ovl) == OFFSET_REF
2675 : 148389248 : || TREE_CODE (ovl) == COMPONENT_REF)
2676 : 0 : ovl = TREE_OPERAND (ovl, 1);
2677 : 148389248 : if (TREE_CODE (ovl) == BASELINK)
2678 : 38391077 : return BINFO_TYPE (BASELINK_BINFO (ovl));
2679 : 109998171 : if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
2680 : 34979213 : ovl = TREE_OPERAND (ovl, 0);
2681 : : /* Skip using-declarations. */
2682 : 109998171 : lkp_iterator iter (ovl);
2683 : 116281871 : do
2684 : 116281871 : ovl = *iter;
2685 : 226280042 : while (iter.using_p () && ++iter);
2686 : :
2687 : 109998171 : return CP_DECL_CONTEXT (ovl);
2688 : : }
2689 : :
2690 : : #define PRINT_RING_SIZE 4
2691 : :
2692 : : static const char *
2693 : 110534 : cxx_printable_name_internal (tree decl, int v, bool translate)
2694 : : {
2695 : 110534 : static unsigned int uid_ring[PRINT_RING_SIZE];
2696 : 110534 : static char *print_ring[PRINT_RING_SIZE];
2697 : 110534 : static bool trans_ring[PRINT_RING_SIZE];
2698 : 110534 : static int ring_counter;
2699 : 110534 : int i;
2700 : :
2701 : : /* Only cache functions. */
2702 : 110534 : if (v < 2
2703 : 43355 : || TREE_CODE (decl) != FUNCTION_DECL
2704 : 150609 : || DECL_LANG_SPECIFIC (decl) == 0)
2705 : 71654 : return lang_decl_name (decl, v, translate);
2706 : :
2707 : : /* See if this print name is lying around. */
2708 : 174182 : for (i = 0; i < PRINT_RING_SIZE; i++)
2709 : 143696 : if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
2710 : : /* yes, so return it. */
2711 : 8394 : return print_ring[i];
2712 : :
2713 : 30486 : if (++ring_counter == PRINT_RING_SIZE)
2714 : 5168 : ring_counter = 0;
2715 : :
2716 : 30486 : if (current_function_decl != NULL_TREE)
2717 : : {
2718 : : /* There may be both translated and untranslated versions of the
2719 : : name cached. */
2720 : 73746 : for (i = 0; i < 2; i++)
2721 : : {
2722 : 49164 : if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
2723 : 67 : ring_counter += 1;
2724 : 49164 : if (ring_counter == PRINT_RING_SIZE)
2725 : 4 : ring_counter = 0;
2726 : : }
2727 : 24582 : gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
2728 : : }
2729 : :
2730 : 30486 : free (print_ring[ring_counter]);
2731 : :
2732 : 30486 : print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
2733 : 30486 : uid_ring[ring_counter] = DECL_UID (decl);
2734 : 30486 : trans_ring[ring_counter] = translate;
2735 : 30486 : return print_ring[ring_counter];
2736 : : }
2737 : :
2738 : : const char *
2739 : 110534 : cxx_printable_name (tree decl, int v)
2740 : : {
2741 : 110534 : return cxx_printable_name_internal (decl, v, false);
2742 : : }
2743 : :
2744 : : const char *
2745 : 0 : cxx_printable_name_translate (tree decl, int v)
2746 : : {
2747 : 0 : return cxx_printable_name_internal (decl, v, true);
2748 : : }
2749 : :
2750 : : /* Return the canonical version of exception-specification RAISES for a C++17
2751 : : function type, for use in type comparison and building TYPE_CANONICAL. */
2752 : :
2753 : : tree
2754 : 163676864 : canonical_eh_spec (tree raises)
2755 : : {
2756 : 163676864 : if (raises == NULL_TREE)
2757 : : return raises;
2758 : 147494442 : else if (DEFERRED_NOEXCEPT_SPEC_P (raises)
2759 : 123215199 : || UNPARSED_NOEXCEPT_SPEC_P (raises)
2760 : 117445191 : || uses_template_parms (raises)
2761 : 117445191 : || uses_template_parms (TREE_PURPOSE (raises)))
2762 : : /* Keep a dependent or deferred exception specification. */
2763 : 31916779 : return raises;
2764 : 115577663 : else if (nothrow_spec_p (raises))
2765 : : /* throw() -> noexcept. */
2766 : 115196220 : return noexcept_true_spec;
2767 : : else
2768 : : /* For C++17 type matching, anything else -> nothing. */
2769 : : return NULL_TREE;
2770 : : }
2771 : :
2772 : : tree
2773 : 608459047 : build_cp_fntype_variant (tree type, cp_ref_qualifier rqual,
2774 : : tree raises, bool late)
2775 : : {
2776 : 608459047 : cp_cv_quals type_quals = TYPE_QUALS (type);
2777 : :
2778 : 608459047 : if (cp_check_qualified_type (type, type, type_quals, rqual, raises, late))
2779 : : return type;
2780 : :
2781 : 252440411 : tree v = TYPE_MAIN_VARIANT (type);
2782 : 544718702 : for (; v; v = TYPE_NEXT_VARIANT (v))
2783 : 399299142 : if (cp_check_qualified_type (v, type, type_quals, rqual, raises, late))
2784 : 107020851 : return v;
2785 : :
2786 : : /* Need to build a new variant. */
2787 : 145419560 : v = build_variant_type_copy (type);
2788 : 145419560 : if (!TYPE_DEPENDENT_P (v))
2789 : : /* We no longer know that it's not type-dependent. */
2790 : 144725317 : TYPE_DEPENDENT_P_VALID (v) = false;
2791 : 145419560 : TYPE_RAISES_EXCEPTIONS (v) = raises;
2792 : 145419560 : TYPE_HAS_LATE_RETURN_TYPE (v) = late;
2793 : 145419560 : switch (rqual)
2794 : : {
2795 : 726073 : case REF_QUAL_RVALUE:
2796 : 726073 : FUNCTION_RVALUE_QUALIFIED (v) = 1;
2797 : 726073 : FUNCTION_REF_QUALIFIED (v) = 1;
2798 : 726073 : break;
2799 : 724991 : case REF_QUAL_LVALUE:
2800 : 724991 : FUNCTION_RVALUE_QUALIFIED (v) = 0;
2801 : 724991 : FUNCTION_REF_QUALIFIED (v) = 1;
2802 : 724991 : break;
2803 : 143968496 : default:
2804 : 143968496 : FUNCTION_REF_QUALIFIED (v) = 0;
2805 : 143968496 : break;
2806 : : }
2807 : :
2808 : : /* Canonicalize the exception specification. */
2809 : 145419560 : tree cr = flag_noexcept_type ? canonical_eh_spec (raises) : NULL_TREE;
2810 : 138320177 : bool complex_eh_spec_p = (cr && cr != noexcept_true_spec
2811 : 175446046 : && !UNPARSED_NOEXCEPT_SPEC_P (cr));
2812 : :
2813 : 120124825 : if (!complex_eh_spec_p && TYPE_RAISES_EXCEPTIONS (type))
2814 : : /* We want to consider structural equality of the exception-less
2815 : : variant since we'll be replacing the exception specification. */
2816 : 3976294 : type = build_cp_fntype_variant (type, rqual, /*raises=*/NULL_TREE, late);
2817 : 145419560 : if (TYPE_STRUCTURAL_EQUALITY_P (type) || complex_eh_spec_p)
2818 : : /* Propagate structural equality. And always use structural equality
2819 : : for function types with a complex noexcept-spec since their identity
2820 : : may depend on e.g. whether comparing_specializations is set. */
2821 : 35919906 : SET_TYPE_STRUCTURAL_EQUALITY (v);
2822 : 109499654 : else if (TYPE_CANONICAL (type) != type || cr != raises || late)
2823 : : /* Build the underlying canonical type, since it is different
2824 : : from TYPE. */
2825 : 47203380 : TYPE_CANONICAL (v) = build_cp_fntype_variant (TYPE_CANONICAL (type),
2826 : : rqual, cr, false);
2827 : : else
2828 : : /* T is its own canonical type. */
2829 : 62296274 : TYPE_CANONICAL (v) = v;
2830 : :
2831 : : return v;
2832 : : }
2833 : :
2834 : : /* TYPE is a function or method type with a deferred exception
2835 : : specification that has been parsed to RAISES. Fixup all the type
2836 : : variants that are affected in place. Via decltype &| noexcept
2837 : : tricks, the unparsed spec could have escaped into the type system. */
2838 : :
2839 : : void
2840 : 2392823 : fixup_deferred_exception_variants (tree type, tree raises)
2841 : : {
2842 : 2392823 : tree original = TYPE_RAISES_EXCEPTIONS (type);
2843 : :
2844 : 4785646 : gcc_checking_assert (UNPARSED_NOEXCEPT_SPEC_P (original));
2845 : :
2846 : 2392823 : for (tree variant = TYPE_MAIN_VARIANT (type);
2847 : 7988228 : variant; variant = TYPE_NEXT_VARIANT (variant))
2848 : 5595405 : if (TYPE_RAISES_EXCEPTIONS (variant) == original)
2849 : : {
2850 : 2650621 : gcc_checking_assert (variant != TYPE_MAIN_VARIANT (type));
2851 : :
2852 : 2650621 : SET_TYPE_STRUCTURAL_EQUALITY (variant);
2853 : 2650621 : TYPE_RAISES_EXCEPTIONS (variant) = raises;
2854 : :
2855 : 2650621 : if (!TYPE_DEPENDENT_P (variant))
2856 : : /* We no longer know that it's not type-dependent. */
2857 : 257990 : TYPE_DEPENDENT_P_VALID (variant) = false;
2858 : : }
2859 : 2392823 : }
2860 : :
2861 : : /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2862 : : listed in RAISES. */
2863 : :
2864 : : tree
2865 : 146566366 : build_exception_variant (tree type, tree raises)
2866 : : {
2867 : 146566366 : cp_ref_qualifier rqual = type_memfn_rqual (type);
2868 : 146566366 : bool late = TYPE_HAS_LATE_RETURN_TYPE (type);
2869 : 146566366 : return build_cp_fntype_variant (type, rqual, raises, late);
2870 : : }
2871 : :
2872 : : /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2873 : : BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2874 : : arguments. */
2875 : :
2876 : : tree
2877 : 234422 : bind_template_template_parm (tree t, tree newargs)
2878 : : {
2879 : 234422 : tree decl = TYPE_NAME (t);
2880 : 234422 : tree t2;
2881 : :
2882 : 234422 : t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
2883 : 234422 : decl = build_decl (input_location,
2884 : 234422 : TYPE_DECL, DECL_NAME (decl), NULL_TREE);
2885 : 234422 : SET_DECL_TEMPLATE_PARM_P (decl);
2886 : :
2887 : : /* These nodes have to be created to reflect new TYPE_DECL and template
2888 : : arguments. */
2889 : 234422 : TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
2890 : 234422 : TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
2891 : 234422 : TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
2892 : 468844 : = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
2893 : :
2894 : 234422 : TREE_TYPE (decl) = t2;
2895 : 234422 : TYPE_NAME (t2) = decl;
2896 : 234422 : TYPE_STUB_DECL (t2) = decl;
2897 : 234422 : TYPE_SIZE (t2) = 0;
2898 : :
2899 : 234422 : if (any_template_arguments_need_structural_equality_p (newargs))
2900 : 13 : SET_TYPE_STRUCTURAL_EQUALITY (t2);
2901 : : else
2902 : 234409 : TYPE_CANONICAL (t2) = canonical_type_parameter (t2);
2903 : :
2904 : 234422 : return t2;
2905 : : }
2906 : :
2907 : : /* Called from count_trees via walk_tree. */
2908 : :
2909 : : static tree
2910 : 0 : count_trees_r (tree *tp, int *walk_subtrees, void *data)
2911 : : {
2912 : 0 : ++*((int *) data);
2913 : :
2914 : 0 : if (TYPE_P (*tp))
2915 : 0 : *walk_subtrees = 0;
2916 : :
2917 : 0 : return NULL_TREE;
2918 : : }
2919 : :
2920 : : /* Debugging function for measuring the rough complexity of a tree
2921 : : representation. */
2922 : :
2923 : : int
2924 : 0 : count_trees (tree t)
2925 : : {
2926 : 0 : int n_trees = 0;
2927 : 0 : cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
2928 : 0 : return n_trees;
2929 : : }
2930 : :
2931 : : /* Called from verify_stmt_tree via walk_tree. */
2932 : :
2933 : : static tree
2934 : 456284 : verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data)
2935 : : {
2936 : 456284 : tree t = *tp;
2937 : 456284 : hash_table<nofree_ptr_hash <tree_node> > *statements
2938 : : = static_cast <hash_table<nofree_ptr_hash <tree_node> > *> (data);
2939 : 456284 : tree_node **slot;
2940 : :
2941 : 456284 : if (!STATEMENT_CODE_P (TREE_CODE (t)))
2942 : : return NULL_TREE;
2943 : :
2944 : : /* If this statement is already present in the hash table, then
2945 : : there is a circularity in the statement tree. */
2946 : 24553 : gcc_assert (!statements->find (t));
2947 : :
2948 : 24553 : slot = statements->find_slot (t, INSERT);
2949 : 24553 : *slot = t;
2950 : :
2951 : 24553 : return NULL_TREE;
2952 : : }
2953 : :
2954 : : /* Debugging function to check that the statement T has not been
2955 : : corrupted. For now, this function simply checks that T contains no
2956 : : circularities. */
2957 : :
2958 : : void
2959 : 1292 : verify_stmt_tree (tree t)
2960 : : {
2961 : 1292 : hash_table<nofree_ptr_hash <tree_node> > statements (37);
2962 : 1292 : cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
2963 : 1292 : }
2964 : :
2965 : : /* Check if the type T depends on a type with no linkage and if so,
2966 : : return it. If RELAXED_P then do not consider a class type declared
2967 : : within a vague-linkage function or in a module CMI to have no linkage,
2968 : : since it can still be accessed within a different TU. Remember:
2969 : : no-linkage is not the same as internal-linkage. */
2970 : :
2971 : : tree
2972 : 274188244 : no_linkage_check (tree t, bool relaxed_p)
2973 : : {
2974 : 274188244 : tree r;
2975 : :
2976 : : /* Lambda types that don't have mangling scope have no linkage. We
2977 : : check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2978 : : when we get here from pushtag none of the lambda information is
2979 : : set up yet, so we want to assume that the lambda has linkage and
2980 : : fix it up later if not. We need to check this even in templates so
2981 : : that we properly handle a lambda-expression in the signature. */
2982 : 309240324 : if (LAMBDA_TYPE_P (t)
2983 : 275981959 : && CLASSTYPE_LAMBDA_EXPR (t) != error_mark_node)
2984 : : {
2985 : 1056777 : tree extra = LAMBDA_TYPE_EXTRA_SCOPE (t);
2986 : 1056777 : if (!extra)
2987 : : return t;
2988 : : }
2989 : :
2990 : : /* Otherwise there's no point in checking linkage on template functions; we
2991 : : can't know their complete types. */
2992 : 274185174 : if (processing_template_decl)
2993 : : return NULL_TREE;
2994 : :
2995 : 162508398 : switch (TREE_CODE (t))
2996 : : {
2997 : 82787179 : case RECORD_TYPE:
2998 : 82787179 : if (TYPE_PTRMEMFUNC_P (t))
2999 : 124887 : goto ptrmem;
3000 : : /* Fall through. */
3001 : 83834331 : case UNION_TYPE:
3002 : 83834331 : if (!CLASS_TYPE_P (t))
3003 : : return NULL_TREE;
3004 : : /* Fall through. */
3005 : 87218040 : case ENUMERAL_TYPE:
3006 : : /* Only treat unnamed types as having no linkage if they're at
3007 : : namespace scope. This is core issue 966. */
3008 : 177678374 : if (TYPE_UNNAMED_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
3009 : : return t;
3010 : :
3011 : 86495938 : for (r = CP_TYPE_CONTEXT (t); ; )
3012 : : {
3013 : : /* If we're a nested type of a !TREE_PUBLIC class, we might not
3014 : : have linkage, or we might just be in an anonymous namespace.
3015 : : If we're in a TREE_PUBLIC class, we have linkage. */
3016 : 88613752 : if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
3017 : 79243 : return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
3018 : 88534509 : else if (TREE_CODE (r) == FUNCTION_DECL)
3019 : : {
3020 : 2456283 : if (relaxed_p
3021 : 2456283 : && (vague_linkage_p (r)
3022 : 6122 : || (TREE_PUBLIC (r) && module_maybe_has_cmi_p ())))
3023 : 2117814 : r = CP_DECL_CONTEXT (r);
3024 : : else
3025 : 338469 : return t;
3026 : : }
3027 : : else
3028 : : break;
3029 : : }
3030 : :
3031 : : return NULL_TREE;
3032 : :
3033 : 22111973 : case ARRAY_TYPE:
3034 : 22111973 : case POINTER_TYPE:
3035 : 22111973 : case REFERENCE_TYPE:
3036 : 22111973 : case VECTOR_TYPE:
3037 : 22111973 : return no_linkage_check (TREE_TYPE (t), relaxed_p);
3038 : :
3039 : 128136 : case OFFSET_TYPE:
3040 : 128136 : ptrmem:
3041 : 128136 : r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
3042 : : relaxed_p);
3043 : 128136 : if (r)
3044 : : return r;
3045 : 128136 : return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
3046 : :
3047 : 18730430 : case METHOD_TYPE:
3048 : 18730430 : case FUNCTION_TYPE:
3049 : 18730430 : {
3050 : 18730430 : tree parm = TYPE_ARG_TYPES (t);
3051 : 18730430 : if (TREE_CODE (t) == METHOD_TYPE)
3052 : : /* The 'this' pointer isn't interesting; a method has the same
3053 : : linkage (or lack thereof) as its enclosing class. */
3054 : 9679439 : parm = TREE_CHAIN (parm);
3055 : 24115122 : for (;
3056 : 42845552 : parm && parm != void_list_node;
3057 : 24115122 : parm = TREE_CHAIN (parm))
3058 : : {
3059 : 24441281 : r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
3060 : 24441281 : if (r)
3061 : 326159 : return r;
3062 : : }
3063 : 18404271 : return no_linkage_check (TREE_TYPE (t), relaxed_p);
3064 : : }
3065 : :
3066 : : default:
3067 : : return NULL_TREE;
3068 : : }
3069 : : }
3070 : :
3071 : : extern int depth_reached;
3072 : :
3073 : : void
3074 : 0 : cxx_print_statistics (void)
3075 : : {
3076 : 0 : print_template_statistics ();
3077 : 0 : if (GATHER_STATISTICS)
3078 : : fprintf (stderr, "maximum template instantiation depth reached: %d\n",
3079 : : depth_reached);
3080 : 0 : }
3081 : :
3082 : : /* Return, as an INTEGER_CST node, the number of elements for TYPE
3083 : : (which is an ARRAY_TYPE). This counts only elements of the top
3084 : : array. */
3085 : :
3086 : : tree
3087 : 3719817 : array_type_nelts_top (tree type)
3088 : : {
3089 : 3719817 : return fold_build2_loc (input_location,
3090 : : PLUS_EXPR, sizetype,
3091 : : array_type_nelts (type),
3092 : 3719817 : size_one_node);
3093 : : }
3094 : :
3095 : : /* Return, as an INTEGER_CST node, the number of elements for TYPE
3096 : : (which is an ARRAY_TYPE). This one is a recursive count of all
3097 : : ARRAY_TYPEs that are clumped together. */
3098 : :
3099 : : tree
3100 : 2969 : array_type_nelts_total (tree type)
3101 : : {
3102 : 2969 : tree sz = array_type_nelts_top (type);
3103 : 2969 : type = TREE_TYPE (type);
3104 : 3229 : while (TREE_CODE (type) == ARRAY_TYPE)
3105 : : {
3106 : 260 : tree n = array_type_nelts_top (type);
3107 : 260 : sz = fold_build2_loc (input_location,
3108 : : MULT_EXPR, sizetype, sz, n);
3109 : 260 : type = TREE_TYPE (type);
3110 : : }
3111 : 2969 : return sz;
3112 : : }
3113 : :
3114 : : struct bot_data
3115 : : {
3116 : : splay_tree target_remap;
3117 : : bool clear_location;
3118 : : };
3119 : :
3120 : : /* Called from break_out_target_exprs via mapcar. */
3121 : :
3122 : : static tree
3123 : 20269737 : bot_manip (tree* tp, int* walk_subtrees, void* data_)
3124 : : {
3125 : 20269737 : bot_data &data = *(bot_data*)data_;
3126 : 20269737 : splay_tree target_remap = data.target_remap;
3127 : 20269737 : tree t = *tp;
3128 : :
3129 : 20269737 : if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
3130 : : {
3131 : : /* There can't be any TARGET_EXPRs or their slot variables below this
3132 : : point. But we must make a copy, in case subsequent processing
3133 : : alters any part of it. For example, during gimplification a cast
3134 : : of the form (T) &X::f (where "f" is a member function) will lead
3135 : : to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
3136 : 8506911 : *walk_subtrees = 0;
3137 : 8506911 : *tp = unshare_expr (t);
3138 : 8506911 : return NULL_TREE;
3139 : : }
3140 : 11762826 : if (TREE_CODE (t) == TARGET_EXPR)
3141 : : {
3142 : 362658 : tree u;
3143 : :
3144 : 362658 : if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
3145 : : {
3146 : 287708 : u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
3147 : : tf_warning_or_error);
3148 : 287708 : if (u == error_mark_node)
3149 : : return u;
3150 : 287708 : if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
3151 : 758 : AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
3152 : : }
3153 : : else
3154 : 74950 : u = force_target_expr (TREE_TYPE (t), TREE_OPERAND (t, 1),
3155 : : tf_warning_or_error);
3156 : :
3157 : 362658 : TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
3158 : 362658 : TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
3159 : 362658 : TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
3160 : 362658 : TARGET_EXPR_ELIDING_P (u) = TARGET_EXPR_ELIDING_P (t);
3161 : :
3162 : : /* Map the old variable to the new one. */
3163 : 1087974 : splay_tree_insert (target_remap,
3164 : 362658 : (splay_tree_key) TREE_OPERAND (t, 0),
3165 : 362658 : (splay_tree_value) TREE_OPERAND (u, 0));
3166 : :
3167 : 362658 : TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1),
3168 : 362658 : data.clear_location);
3169 : 362658 : if (TREE_OPERAND (u, 1) == error_mark_node)
3170 : : return error_mark_node;
3171 : :
3172 : 362658 : if (data.clear_location)
3173 : 275638 : SET_EXPR_LOCATION (u, input_location);
3174 : :
3175 : : /* Replace the old expression with the new version. */
3176 : 362658 : *tp = u;
3177 : : /* We don't have to go below this point; the recursive call to
3178 : : break_out_target_exprs will have handled anything below this
3179 : : point. */
3180 : 362658 : *walk_subtrees = 0;
3181 : 362658 : return NULL_TREE;
3182 : : }
3183 : 11400168 : if (TREE_CODE (*tp) == SAVE_EXPR)
3184 : : {
3185 : 99390 : t = *tp;
3186 : 99390 : splay_tree_node n = splay_tree_lookup (target_remap,
3187 : : (splay_tree_key) t);
3188 : 99390 : if (n)
3189 : : {
3190 : 49701 : *tp = (tree)n->value;
3191 : 49701 : *walk_subtrees = 0;
3192 : : }
3193 : : else
3194 : : {
3195 : 49689 : copy_tree_r (tp, walk_subtrees, NULL);
3196 : 49689 : splay_tree_insert (target_remap,
3197 : : (splay_tree_key)t,
3198 : 49689 : (splay_tree_value)*tp);
3199 : : /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3200 : 49689 : splay_tree_insert (target_remap,
3201 : : (splay_tree_key)*tp,
3202 : 49689 : (splay_tree_value)*tp);
3203 : : }
3204 : 99390 : return NULL_TREE;
3205 : : }
3206 : 11300778 : if (TREE_CODE (*tp) == DECL_EXPR
3207 : 25 : && VAR_P (DECL_EXPR_DECL (*tp))
3208 : 25 : && DECL_ARTIFICIAL (DECL_EXPR_DECL (*tp))
3209 : 11300803 : && !TREE_STATIC (DECL_EXPR_DECL (*tp)))
3210 : : {
3211 : 25 : tree t;
3212 : 25 : splay_tree_node n
3213 : 50 : = splay_tree_lookup (target_remap,
3214 : 25 : (splay_tree_key) DECL_EXPR_DECL (*tp));
3215 : 25 : if (n)
3216 : 1 : t = (tree) n->value;
3217 : : else
3218 : : {
3219 : 24 : t = create_temporary_var (TREE_TYPE (DECL_EXPR_DECL (*tp)));
3220 : 24 : DECL_INITIAL (t) = DECL_INITIAL (DECL_EXPR_DECL (*tp));
3221 : 48 : splay_tree_insert (target_remap,
3222 : 24 : (splay_tree_key) DECL_EXPR_DECL (*tp),
3223 : : (splay_tree_value) t);
3224 : : }
3225 : 25 : copy_tree_r (tp, walk_subtrees, NULL);
3226 : 25 : DECL_EXPR_DECL (*tp) = t;
3227 : 25 : if (data.clear_location && EXPR_HAS_LOCATION (*tp))
3228 : 12 : SET_EXPR_LOCATION (*tp, input_location);
3229 : 25 : return NULL_TREE;
3230 : : }
3231 : 11300753 : if (TREE_CODE (*tp) == BIND_EXPR && BIND_EXPR_VARS (*tp))
3232 : : {
3233 : 1 : copy_tree_r (tp, walk_subtrees, NULL);
3234 : 2 : for (tree *p = &BIND_EXPR_VARS (*tp); *p; p = &DECL_CHAIN (*p))
3235 : : {
3236 : 1 : gcc_assert (VAR_P (*p) && DECL_ARTIFICIAL (*p) && !TREE_STATIC (*p));
3237 : 1 : tree t = create_temporary_var (TREE_TYPE (*p));
3238 : 1 : DECL_INITIAL (t) = DECL_INITIAL (*p);
3239 : 1 : DECL_CHAIN (t) = DECL_CHAIN (*p);
3240 : 1 : splay_tree_insert (target_remap, (splay_tree_key) *p,
3241 : : (splay_tree_value) t);
3242 : 1 : *p = t;
3243 : : }
3244 : 1 : if (data.clear_location && EXPR_HAS_LOCATION (*tp))
3245 : 0 : SET_EXPR_LOCATION (*tp, input_location);
3246 : 1 : return NULL_TREE;
3247 : : }
3248 : :
3249 : : /* Make a copy of this node. */
3250 : 11300752 : t = copy_tree_r (tp, walk_subtrees, NULL);
3251 : 11300752 : if (TREE_CODE (*tp) == CALL_EXPR || TREE_CODE (*tp) == AGGR_INIT_EXPR)
3252 : 1571953 : if (!processing_template_decl)
3253 : 1571953 : set_flags_from_callee (*tp);
3254 : 11300752 : if (data.clear_location && EXPR_HAS_LOCATION (*tp))
3255 : 294660 : SET_EXPR_LOCATION (*tp, input_location);
3256 : : return t;
3257 : : }
3258 : :
3259 : : /* Replace all remapped VAR_DECLs in T with their new equivalents.
3260 : : DATA is really a splay-tree mapping old variables to new
3261 : : variables. */
3262 : :
3263 : : static tree
3264 : 30516610 : bot_replace (tree* t, int */*walk_subtrees*/, void* data_)
3265 : : {
3266 : 30516610 : bot_data &data = *(bot_data*)data_;
3267 : 30516610 : splay_tree target_remap = data.target_remap;
3268 : :
3269 : 30516610 : if (VAR_P (*t))
3270 : : {
3271 : 1360673 : splay_tree_node n = splay_tree_lookup (target_remap,
3272 : : (splay_tree_key) *t);
3273 : 1360673 : if (n)
3274 : 969 : *t = (tree) n->value;
3275 : : }
3276 : 29155937 : else if (TREE_CODE (*t) == PARM_DECL
3277 : 2435906 : && DECL_NAME (*t) == this_identifier
3278 : 29975886 : && !DECL_CONTEXT (*t))
3279 : : {
3280 : : /* In an NSDMI we need to replace the 'this' parameter we used for
3281 : : parsing with the real one for this function. */
3282 : 23116 : *t = current_class_ptr;
3283 : : }
3284 : 29132821 : else if (TREE_CODE (*t) == CONVERT_EXPR
3285 : 29132821 : && CONVERT_EXPR_VBASE_PATH (*t))
3286 : : {
3287 : : /* In an NSDMI build_base_path defers building conversions to morally
3288 : : virtual bases, and we handle it here. */
3289 : 63 : tree basetype = TREE_TYPE (*t);
3290 : 63 : *t = convert_to_base (TREE_OPERAND (*t, 0), basetype,
3291 : : /*check_access=*/false, /*nonnull=*/true,
3292 : : tf_warning_or_error);
3293 : : }
3294 : :
3295 : 30516610 : return NULL_TREE;
3296 : : }
3297 : :
3298 : : /* When we parse a default argument expression, we may create
3299 : : temporary variables via TARGET_EXPRs. When we actually use the
3300 : : default-argument expression, we make a copy of the expression
3301 : : and replace the temporaries with appropriate local versions.
3302 : :
3303 : : If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3304 : : input_location. */
3305 : :
3306 : : tree
3307 : 8030317 : break_out_target_exprs (tree t, bool clear_location /* = false */)
3308 : : {
3309 : 8030317 : static int target_remap_count;
3310 : 8030317 : static splay_tree target_remap;
3311 : :
3312 : : /* We shouldn't be called on templated trees, nor do we want to
3313 : : produce them. */
3314 : 8030317 : gcc_checking_assert (!processing_template_decl);
3315 : :
3316 : 8030317 : if (!target_remap_count++)
3317 : 7667659 : target_remap = splay_tree_new (splay_tree_compare_pointers,
3318 : : /*splay_tree_delete_key_fn=*/NULL,
3319 : : /*splay_tree_delete_value_fn=*/NULL);
3320 : 8030317 : bot_data data = { target_remap, clear_location };
3321 : 8030317 : if (cp_walk_tree (&t, bot_manip, &data, NULL) == error_mark_node)
3322 : 0 : t = error_mark_node;
3323 : 8030317 : if (cp_walk_tree (&t, bot_replace, &data, NULL) == error_mark_node)
3324 : 0 : t = error_mark_node;
3325 : :
3326 : 8030317 : if (!--target_remap_count)
3327 : : {
3328 : 7667659 : splay_tree_delete (target_remap);
3329 : 7667659 : target_remap = NULL;
3330 : : }
3331 : :
3332 : 8030317 : return t;
3333 : : }
3334 : :
3335 : : /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3336 : : which we expect to have type TYPE. */
3337 : :
3338 : : tree
3339 : 396977 : build_ctor_subob_ref (tree index, tree type, tree obj)
3340 : : {
3341 : 396977 : if (index == NULL_TREE)
3342 : : /* Can't refer to a particular member of a vector. */
3343 : : obj = NULL_TREE;
3344 : 396977 : else if (TREE_CODE (index) == INTEGER_CST)
3345 : 11338 : obj = cp_build_array_ref (input_location, obj, index, tf_none);
3346 : : else
3347 : 385639 : obj = build_class_member_access_expr (obj, index, NULL_TREE,
3348 : : /*reference*/false, tf_none);
3349 : 396977 : if (obj)
3350 : : {
3351 : 396977 : tree objtype = TREE_TYPE (obj);
3352 : 396977 : if (TREE_CODE (objtype) == ARRAY_TYPE && !TYPE_DOMAIN (objtype))
3353 : : {
3354 : : /* When the destination object refers to a flexible array member
3355 : : verify that it matches the type of the source object except
3356 : : for its domain and qualifiers. */
3357 : 83 : gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),
3358 : : TYPE_MAIN_VARIANT (objtype),
3359 : : COMPARE_REDECLARATION));
3360 : : }
3361 : : else
3362 : 396894 : gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype));
3363 : : }
3364 : :
3365 : 396977 : return obj;
3366 : : }
3367 : :
3368 : : struct replace_placeholders_t
3369 : : {
3370 : : tree obj; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3371 : : tree exp; /* The outermost exp. */
3372 : : bool seen; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3373 : : hash_set<tree> *pset; /* To avoid walking same trees multiple times. */
3374 : : };
3375 : :
3376 : : /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3377 : : build up subexpressions as we go deeper. */
3378 : :
3379 : : static tree
3380 : 15533201 : replace_placeholders_r (tree* t, int* walk_subtrees, void* data_)
3381 : : {
3382 : 15533201 : replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_);
3383 : 15533201 : tree obj = d->obj;
3384 : :
3385 : 15533201 : if (TYPE_P (*t) || TREE_CONSTANT (*t))
3386 : : {
3387 : 5185585 : *walk_subtrees = false;
3388 : 5185585 : return NULL_TREE;
3389 : : }
3390 : :
3391 : 10347616 : switch (TREE_CODE (*t))
3392 : : {
3393 : : case PLACEHOLDER_EXPR:
3394 : : {
3395 : : tree x = obj;
3396 : 531 : for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t),
3397 : 531 : TREE_TYPE (x));
3398 : 77 : x = TREE_OPERAND (x, 0))
3399 : 77 : gcc_assert (handled_component_p (x));
3400 : 454 : *t = unshare_expr (x);
3401 : 454 : *walk_subtrees = false;
3402 : 454 : d->seen = true;
3403 : : }
3404 : 454 : break;
3405 : :
3406 : 247193 : case CONSTRUCTOR:
3407 : 247193 : {
3408 : 247193 : constructor_elt *ce;
3409 : 247193 : vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t);
3410 : : /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3411 : : other than the d->exp one, those have PLACEHOLDER_EXPRs
3412 : : related to another object. */
3413 : 247193 : if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t)
3414 : 511 : && *t != d->exp)
3415 : 247599 : || d->pset->add (*t))
3416 : : {
3417 : 105 : *walk_subtrees = false;
3418 : 105 : return NULL_TREE;
3419 : : }
3420 : 814743 : for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i)
3421 : : {
3422 : 567655 : tree *valp = &ce->value;
3423 : 567655 : tree type = TREE_TYPE (*valp);
3424 : 567655 : tree subob = obj;
3425 : :
3426 : : /* Elements with RANGE_EXPR index shouldn't have any
3427 : : placeholders in them. */
3428 : 567655 : if (ce->index && TREE_CODE (ce->index) == RANGE_EXPR)
3429 : 2 : continue;
3430 : :
3431 : 567653 : if (TREE_CODE (*valp) == CONSTRUCTOR
3432 : 687 : && AGGREGATE_TYPE_P (type))
3433 : : {
3434 : : /* If we're looking at the initializer for OBJ, then build
3435 : : a sub-object reference. If we're looking at an
3436 : : initializer for another object, just pass OBJ down. */
3437 : 673 : if (same_type_ignoring_top_level_qualifiers_p
3438 : 673 : (TREE_TYPE (*t), TREE_TYPE (obj)))
3439 : 643 : subob = build_ctor_subob_ref (ce->index, type, obj);
3440 : 673 : if (TREE_CODE (*valp) == TARGET_EXPR)
3441 : 0 : valp = &TARGET_EXPR_INITIAL (*valp);
3442 : : }
3443 : 567653 : d->obj = subob;
3444 : 567653 : cp_walk_tree (valp, replace_placeholders_r, data_, NULL);
3445 : 567653 : d->obj = obj;
3446 : : }
3447 : 247088 : *walk_subtrees = false;
3448 : 247088 : break;
3449 : : }
3450 : :
3451 : 10099969 : default:
3452 : 10099969 : if (d->pset->add (*t))
3453 : 320134 : *walk_subtrees = false;
3454 : : break;
3455 : : }
3456 : :
3457 : : return NULL_TREE;
3458 : : }
3459 : :
3460 : : /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3461 : : a PLACEHOLDER_EXPR has been encountered. */
3462 : :
3463 : : tree
3464 : 43501492 : replace_placeholders (tree exp, tree obj, bool *seen_p /*= NULL*/)
3465 : : {
3466 : : /* This is only relevant for C++14. */
3467 : 43501492 : if (cxx_dialect < cxx14)
3468 : 846814 : return exp;
3469 : :
3470 : : /* If the object isn't a (member of a) class, do nothing. */
3471 : : tree op0 = obj;
3472 : 43036262 : while (handled_component_p (op0))
3473 : 381584 : op0 = TREE_OPERAND (op0, 0);
3474 : 42654678 : if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0))))
3475 : 39315555 : return exp;
3476 : :
3477 : 3339123 : tree *tp = &exp;
3478 : 3339123 : if (TREE_CODE (exp) == TARGET_EXPR)
3479 : 247568 : tp = &TARGET_EXPR_INITIAL (exp);
3480 : 3339123 : hash_set<tree> pset;
3481 : 3339123 : replace_placeholders_t data = { obj, *tp, false, &pset };
3482 : 3339123 : cp_walk_tree (tp, replace_placeholders_r, &data, NULL);
3483 : 3339123 : if (seen_p)
3484 : 123502 : *seen_p = data.seen;
3485 : 3339123 : return exp;
3486 : 3339123 : }
3487 : :
3488 : : /* Callback function for find_placeholders. */
3489 : :
3490 : : static tree
3491 : 50897 : find_placeholders_r (tree *t, int *walk_subtrees, void *)
3492 : : {
3493 : 50897 : if (TYPE_P (*t) || TREE_CONSTANT (*t))
3494 : : {
3495 : 42438 : *walk_subtrees = false;
3496 : 42438 : return NULL_TREE;
3497 : : }
3498 : :
3499 : 8459 : switch (TREE_CODE (*t))
3500 : : {
3501 : : case PLACEHOLDER_EXPR:
3502 : : return *t;
3503 : :
3504 : 604 : case CONSTRUCTOR:
3505 : 604 : if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t))
3506 : 173 : *walk_subtrees = false;
3507 : : break;
3508 : :
3509 : : default:
3510 : : break;
3511 : : }
3512 : :
3513 : : return NULL_TREE;
3514 : : }
3515 : :
3516 : : /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3517 : : ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3518 : :
3519 : : bool
3520 : 42631 : find_placeholders (tree exp)
3521 : : {
3522 : : /* This is only relevant for C++14. */
3523 : 42631 : if (cxx_dialect < cxx14)
3524 : : return false;
3525 : :
3526 : 42631 : return cp_walk_tree_without_duplicates (&exp, find_placeholders_r, NULL);
3527 : : }
3528 : :
3529 : : /* Similar to `build_nt', but for template definitions of dependent
3530 : : expressions */
3531 : :
3532 : : tree
3533 : 259512180 : build_min_nt_loc (location_t loc, enum tree_code code, ...)
3534 : : {
3535 : 259512180 : tree t;
3536 : 259512180 : int length;
3537 : 259512180 : int i;
3538 : 259512180 : va_list p;
3539 : :
3540 : 259512180 : gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3541 : :
3542 : 259512180 : va_start (p, code);
3543 : :
3544 : 259512180 : t = make_node (code);
3545 : 259512180 : SET_EXPR_LOCATION (t, loc);
3546 : 259512180 : length = TREE_CODE_LENGTH (code);
3547 : :
3548 : 848986785 : for (i = 0; i < length; i++)
3549 : 589474605 : TREE_OPERAND (t, i) = va_arg (p, tree);
3550 : :
3551 : 259512180 : va_end (p);
3552 : 259512180 : return t;
3553 : : }
3554 : :
3555 : : /* Similar to `build', but for template definitions. */
3556 : :
3557 : : tree
3558 : 198385047 : build_min (enum tree_code code, tree tt, ...)
3559 : : {
3560 : 198385047 : tree t;
3561 : 198385047 : int length;
3562 : 198385047 : int i;
3563 : 198385047 : va_list p;
3564 : :
3565 : 198385047 : gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3566 : :
3567 : 198385047 : va_start (p, tt);
3568 : :
3569 : 198385047 : t = make_node (code);
3570 : 198385047 : length = TREE_CODE_LENGTH (code);
3571 : 198385047 : TREE_TYPE (t) = tt;
3572 : :
3573 : 531607933 : for (i = 0; i < length; i++)
3574 : : {
3575 : 333222886 : tree x = va_arg (p, tree);
3576 : 333222886 : TREE_OPERAND (t, i) = x;
3577 : 333222886 : if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
3578 : 1779891 : TREE_SIDE_EFFECTS (t) = 1;
3579 : : }
3580 : :
3581 : 198385047 : va_end (p);
3582 : :
3583 : 198385047 : return t;
3584 : : }
3585 : :
3586 : : /* Similar to `build', but for template definitions of non-dependent
3587 : : expressions. NON_DEP is the non-dependent expression that has been
3588 : : built. */
3589 : :
3590 : : tree
3591 : 99248623 : build_min_non_dep (enum tree_code code, tree non_dep, ...)
3592 : : {
3593 : 99248623 : tree t;
3594 : 99248623 : int length;
3595 : 99248623 : int i;
3596 : 99248623 : va_list p;
3597 : :
3598 : 99248623 : gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3599 : :
3600 : 99248623 : va_start (p, non_dep);
3601 : :
3602 : 99248623 : if (REFERENCE_REF_P (non_dep))
3603 : 399411 : non_dep = TREE_OPERAND (non_dep, 0);
3604 : :
3605 : 99248623 : t = make_node (code);
3606 : 130914245 : SET_EXPR_LOCATION (t, cp_expr_loc_or_input_loc (non_dep));
3607 : 99248623 : length = TREE_CODE_LENGTH (code);
3608 : 99248623 : TREE_TYPE (t) = unlowered_expr_type (non_dep);
3609 : 99248623 : TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3610 : :
3611 : 351814090 : for (i = 0; i < length; i++)
3612 : : {
3613 : 252565467 : tree x = va_arg (p, tree);
3614 : 252565467 : TREE_OPERAND (t, i) = x;
3615 : 252565467 : if (x && !TYPE_P (x))
3616 : 194846402 : TREE_SIDE_EFFECTS (t) |= TREE_SIDE_EFFECTS (x);
3617 : : }
3618 : :
3619 : 99248623 : va_end (p);
3620 : 99248623 : return convert_from_reference (t);
3621 : : }
3622 : :
3623 : : /* Similar to build_min_nt, but call expressions */
3624 : :
3625 : : tree
3626 : 176437683 : build_min_nt_call_vec (tree fn, vec<tree, va_gc> *args)
3627 : : {
3628 : 176437683 : tree ret, t;
3629 : 176437683 : unsigned int ix;
3630 : :
3631 : 352778916 : ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
3632 : 176437683 : CALL_EXPR_FN (ret) = fn;
3633 : 176437683 : CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3634 : 360484497 : FOR_EACH_VEC_SAFE_ELT (args, ix, t)
3635 : 184046814 : CALL_EXPR_ARG (ret, ix) = t;
3636 : :
3637 : 176437683 : return ret;
3638 : : }
3639 : :
3640 : : /* Similar to `build_min_nt_call_vec', but for template definitions of
3641 : : non-dependent expressions. NON_DEP is the non-dependent expression
3642 : : that has been built. */
3643 : :
3644 : : tree
3645 : 11210957 : build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
3646 : : {
3647 : 11210957 : tree t = build_min_nt_call_vec (fn, argvec);
3648 : 11210957 : if (REFERENCE_REF_P (non_dep))
3649 : 6 : non_dep = TREE_OPERAND (non_dep, 0);
3650 : 11210957 : TREE_TYPE (t) = TREE_TYPE (non_dep);
3651 : 11210957 : TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3652 : 11210957 : if (argvec)
3653 : 19305253 : for (tree x : *argvec)
3654 : 8190746 : if (x && !TYPE_P (x))
3655 : 8190746 : TREE_SIDE_EFFECTS (t) |= TREE_SIDE_EFFECTS (x);
3656 : 11210957 : return convert_from_reference (t);
3657 : : }
3658 : :
3659 : : /* Similar to build_min_non_dep, but for expressions that have been resolved to
3660 : : a call to an operator overload. OP is the operator that has been
3661 : : overloaded. NON_DEP is the non-dependent expression that's been built,
3662 : : which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3663 : : the overload that NON_DEP is calling. */
3664 : :
3665 : : tree
3666 : 3595455 : build_min_non_dep_op_overload (enum tree_code op,
3667 : : tree non_dep,
3668 : : tree overload, ...)
3669 : : {
3670 : 3595455 : va_list p;
3671 : 3595455 : int nargs, expected_nargs;
3672 : 3595455 : tree fn, call, obj = NULL_TREE;
3673 : :
3674 : 3595455 : non_dep = extract_call_expr (non_dep);
3675 : :
3676 : 3595455 : nargs = call_expr_nargs (non_dep);
3677 : :
3678 : 3595455 : expected_nargs = cp_tree_code_length (op);
3679 : 6528719 : if (DECL_OBJECT_MEMBER_FUNCTION_P (overload)
3680 : : /* For ARRAY_REF, operator[] is either a non-static member or newly
3681 : : static member, never out of class and for the static member case
3682 : : if user uses single index the operator[] needs to have a single
3683 : : argument as well, but the function is called with 2 - the object
3684 : : it is invoked on and the index. */
3685 : 6527101 : || op == ARRAY_REF)
3686 : 663816 : expected_nargs -= 1;
3687 : 3595455 : if ((op == POSTINCREMENT_EXPR
3688 : 3595455 : || op == POSTDECREMENT_EXPR)
3689 : : /* With -fpermissive non_dep could be operator++(). */
3690 : 10451 : && (!flag_permissive || nargs != expected_nargs))
3691 : 10448 : expected_nargs += 1;
3692 : 3595455 : gcc_assert (nargs == expected_nargs);
3693 : :
3694 : 3595455 : releasing_vec args;
3695 : 3595455 : va_start (p, overload);
3696 : :
3697 : 3595455 : if (!DECL_OBJECT_MEMBER_FUNCTION_P (overload))
3698 : : {
3699 : 2931646 : fn = overload;
3700 : 2931646 : if (op == ARRAY_REF)
3701 : 7 : obj = va_arg (p, tree);
3702 : 8711545 : for (int i = 0; i < nargs; i++)
3703 : : {
3704 : 5779899 : tree arg = va_arg (p, tree);
3705 : 5779899 : vec_safe_push (args, arg);
3706 : : }
3707 : : }
3708 : : else
3709 : : {
3710 : 663809 : tree object = va_arg (p, tree);
3711 : 663809 : tree binfo = TYPE_BINFO (TREE_TYPE (object));
3712 : 663809 : tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
3713 : 663809 : fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
3714 : : object, method, NULL_TREE);
3715 : 1126517 : for (int i = 0; i < nargs; i++)
3716 : : {
3717 : 462708 : tree arg = va_arg (p, tree);
3718 : 462708 : vec_safe_push (args, arg);
3719 : : }
3720 : : }
3721 : :
3722 : 3595455 : va_end (p);
3723 : 3595455 : call = build_min_non_dep_call_vec (non_dep, fn, args);
3724 : :
3725 : 3595455 : tree call_expr = extract_call_expr (call);
3726 : 3595455 : KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
3727 : 3595455 : CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
3728 : 3595455 : CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
3729 : 3595455 : CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
3730 : :
3731 : 3595455 : if (obj)
3732 : 7 : return keep_unused_object_arg (call, obj, overload);
3733 : : return call;
3734 : 3595455 : }
3735 : :
3736 : : /* Similar to above build_min_non_dep_op_overload, but arguments
3737 : : are taken from ARGS vector. */
3738 : :
3739 : : tree
3740 : 22 : build_min_non_dep_op_overload (tree non_dep, tree overload, tree object,
3741 : : vec<tree, va_gc> *args)
3742 : : {
3743 : 22 : non_dep = extract_call_expr (non_dep);
3744 : :
3745 : 22 : unsigned int nargs = call_expr_nargs (non_dep);
3746 : 22 : tree fn = overload;
3747 : 22 : if (DECL_OBJECT_MEMBER_FUNCTION_P (overload))
3748 : : {
3749 : 14 : tree binfo = TYPE_BINFO (TREE_TYPE (object));
3750 : 14 : tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
3751 : 14 : fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
3752 : : object, method, NULL_TREE);
3753 : 14 : object = NULL_TREE;
3754 : : }
3755 : 44 : gcc_assert (vec_safe_length (args) == nargs);
3756 : :
3757 : 22 : tree call = build_min_non_dep_call_vec (non_dep, fn, args);
3758 : :
3759 : 22 : tree call_expr = extract_call_expr (call);
3760 : 22 : KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
3761 : 22 : CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
3762 : 22 : CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
3763 : 22 : CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
3764 : :
3765 : 22 : if (object)
3766 : 8 : return keep_unused_object_arg (call, object, overload);
3767 : : return call;
3768 : : }
3769 : :
3770 : : /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3771 : :
3772 : : vec<tree, va_gc> *
3773 : 38 : vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx)
3774 : : {
3775 : 38 : unsigned len = vec_safe_length (old_vec);
3776 : 38 : gcc_assert (idx <= len);
3777 : :
3778 : 38 : vec<tree, va_gc> *new_vec = NULL;
3779 : 38 : vec_alloc (new_vec, len + 1);
3780 : :
3781 : 38 : unsigned i;
3782 : 123 : for (i = 0; i < len; ++i)
3783 : : {
3784 : 47 : if (i == idx)
3785 : 9 : new_vec->quick_push (elt);
3786 : 47 : new_vec->quick_push ((*old_vec)[i]);
3787 : : }
3788 : 38 : if (i == idx)
3789 : 29 : new_vec->quick_push (elt);
3790 : :
3791 : 38 : return new_vec;
3792 : : }
3793 : :
3794 : : tree
3795 : 93258 : get_type_decl (tree t)
3796 : : {
3797 : 93258 : if (TREE_CODE (t) == TYPE_DECL)
3798 : : return t;
3799 : 93258 : if (TYPE_P (t))
3800 : 93258 : return TYPE_STUB_DECL (t);
3801 : 0 : gcc_assert (t == error_mark_node);
3802 : : return t;
3803 : : }
3804 : :
3805 : : /* Returns the namespace that contains DECL, whether directly or
3806 : : indirectly. */
3807 : :
3808 : : tree
3809 : 858282151 : decl_namespace_context (tree decl)
3810 : : {
3811 : 1782751969 : while (1)
3812 : : {
3813 : 1782751969 : if (TREE_CODE (decl) == NAMESPACE_DECL)
3814 : 858282151 : return decl;
3815 : 924469818 : else if (TYPE_P (decl))
3816 : 590038597 : decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
3817 : : else
3818 : 334431221 : decl = CP_DECL_CONTEXT (decl);
3819 : : }
3820 : : }
3821 : :
3822 : : /* Returns true if decl is within an anonymous namespace, however deeply
3823 : : nested, or false otherwise. */
3824 : :
3825 : : bool
3826 : 23 : decl_anon_ns_mem_p (tree decl)
3827 : : {
3828 : 23 : return !TREE_PUBLIC (decl_namespace_context (decl));
3829 : : }
3830 : :
3831 : : /* Returns true if the enclosing scope of DECL has internal or no linkage. */
3832 : :
3833 : : bool
3834 : 778062481 : decl_internal_context_p (const_tree decl)
3835 : : {
3836 : 1559485772 : while (TREE_CODE (decl) != NAMESPACE_DECL)
3837 : : {
3838 : : /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3839 : 1057189763 : if (TYPE_P (decl))
3840 : 275766472 : return !TREE_PUBLIC (TYPE_MAIN_DECL (decl));
3841 : :
3842 : 781423291 : decl = CP_DECL_CONTEXT (decl);
3843 : : }
3844 : 502296009 : return !TREE_PUBLIC (decl);
3845 : : }
3846 : :
3847 : : /* Subroutine of cp_tree_equal: t1 and t2 are two CALL_EXPRs.
3848 : : Return whether their CALL_EXPR_FNs are equivalent. */
3849 : :
3850 : : static bool
3851 : 40615383 : called_fns_equal (tree t1, tree t2)
3852 : : {
3853 : : /* Core 1321: dependent names are equivalent even if the overload sets
3854 : : are different. But do compare explicit template arguments. */
3855 : 40615383 : tree name1 = call_expr_dependent_name (t1);
3856 : 40615383 : tree name2 = call_expr_dependent_name (t2);
3857 : 40615383 : t1 = CALL_EXPR_FN (t1);
3858 : 40615383 : t2 = CALL_EXPR_FN (t2);
3859 : 40615383 : if (name1 || name2)
3860 : : {
3861 : 16471331 : tree targs1 = NULL_TREE, targs2 = NULL_TREE;
3862 : :
3863 : 16471331 : if (name1 != name2)
3864 : : return false;
3865 : :
3866 : : /* FIXME dependent_name currently returns an unqualified name regardless
3867 : : of whether the function was named with a qualified- or unqualified-id.
3868 : : Until that's fixed, check that we aren't looking at overload sets from
3869 : : different scopes. */
3870 : 16190407 : if (is_overloaded_fn (t1) && is_overloaded_fn (t2)
3871 : 32409879 : && (DECL_CONTEXT (get_first_fn (t1))
3872 : 16190404 : != DECL_CONTEXT (get_first_fn (t2))))
3873 : : return false;
3874 : :
3875 : 16219475 : if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
3876 : 10416260 : targs1 = TREE_OPERAND (t1, 1);
3877 : 16219475 : if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
3878 : 10416260 : targs2 = TREE_OPERAND (t2, 1);
3879 : 16219475 : return cp_tree_equal (targs1, targs2);
3880 : : }
3881 : : else
3882 : 24144052 : return cp_tree_equal (t1, t2);
3883 : : }
3884 : :
3885 : : bool comparing_override_contracts;
3886 : :
3887 : : /* In a component reference, return the innermost object of
3888 : : the postfix-expression. */
3889 : :
3890 : : static tree
3891 : 12 : get_innermost_component (tree t)
3892 : : {
3893 : 12 : gcc_assert (TREE_CODE (t) == COMPONENT_REF);
3894 : 33 : while (TREE_CODE (t) == COMPONENT_REF)
3895 : 21 : t = TREE_OPERAND (t, 0);
3896 : 12 : return t;
3897 : : }
3898 : :
3899 : : /* Returns true if T is a possibly converted 'this' or '*this' expression. */
3900 : :
3901 : : static bool
3902 : 12 : is_this_expression (tree t)
3903 : : {
3904 : 12 : t = get_innermost_component (t);
3905 : : /* See through deferences and no-op conversions. */
3906 : 12 : if (INDIRECT_REF_P (t))
3907 : 12 : t = TREE_OPERAND (t, 0);
3908 : 12 : if (TREE_CODE (t) == NOP_EXPR)
3909 : 12 : t = TREE_OPERAND (t, 0);
3910 : 12 : return is_this_parameter (t);
3911 : : }
3912 : :
3913 : : static bool
3914 : 6 : comparing_this_references (tree t1, tree t2)
3915 : : {
3916 : 6 : return is_this_expression (t1) && is_this_expression (t2);
3917 : : }
3918 : :
3919 : : static bool
3920 : 6 : equivalent_member_references (tree t1, tree t2)
3921 : : {
3922 : 6 : if (!comparing_this_references (t1, t2))
3923 : : return false;
3924 : 6 : t1 = TREE_OPERAND (t1, 1);
3925 : 6 : t2 = TREE_OPERAND (t2, 1);
3926 : 6 : return t1 == t2;
3927 : : }
3928 : :
3929 : : /* Return truthvalue of whether T1 is the same tree structure as T2.
3930 : : Return 1 if they are the same. Return 0 if they are different. */
3931 : :
3932 : : bool
3933 : 1371713811 : cp_tree_equal (tree t1, tree t2)
3934 : : {
3935 : 1373613243 : enum tree_code code1, code2;
3936 : :
3937 : 1373613243 : if (t1 == t2)
3938 : : return true;
3939 : 634007744 : if (!t1 || !t2)
3940 : : return false;
3941 : :
3942 : 633651282 : code1 = TREE_CODE (t1);
3943 : 633651282 : code2 = TREE_CODE (t2);
3944 : :
3945 : 633651282 : if (code1 != code2)
3946 : : return false;
3947 : :
3948 : 496943249 : if (CONSTANT_CLASS_P (t1)
3949 : 496943249 : && !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3950 : : return false;
3951 : :
3952 : 496868003 : switch (code1)
3953 : : {
3954 : 0 : case VOID_CST:
3955 : : /* There's only a single VOID_CST node, so we should never reach
3956 : : here. */
3957 : 0 : gcc_unreachable ();
3958 : :
3959 : 33579641 : case INTEGER_CST:
3960 : 33579641 : return tree_int_cst_equal (t1, t2);
3961 : :
3962 : 97266 : case REAL_CST:
3963 : 97266 : return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
3964 : :
3965 : 25211 : case STRING_CST:
3966 : 25211 : return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3967 : 25211 : && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3968 : 25211 : TREE_STRING_LENGTH (t1));
3969 : :
3970 : 0 : case FIXED_CST:
3971 : 0 : return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
3972 : : TREE_FIXED_CST (t2));
3973 : :
3974 : 1 : case COMPLEX_CST:
3975 : 1 : return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
3976 : 2 : && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
3977 : :
3978 : 3836 : case VECTOR_CST:
3979 : 3836 : return operand_equal_p (t1, t2, OEP_ONLY_CONST);
3980 : :
3981 : 1375687 : case CONSTRUCTOR:
3982 : : /* We need to do this when determining whether or not two
3983 : : non-type pointer to member function template arguments
3984 : : are the same. */
3985 : 1375687 : if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
3986 : 2960304 : || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
3987 : : return false;
3988 : : {
3989 : : tree field, value;
3990 : : unsigned int i;
3991 : 1365405 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
3992 : : {
3993 : 88746 : constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
3994 : 88746 : if (!cp_tree_equal (field, elt2->index)
3995 : 88746 : || !cp_tree_equal (value, elt2->value))
3996 : 24 : return false;
3997 : : }
3998 : : }
3999 : : return true;
4000 : :
4001 : 1120066 : case TREE_LIST:
4002 : 1120066 : if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
4003 : : return false;
4004 : 1120066 : if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
4005 : : return false;
4006 : 34763 : return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
4007 : :
4008 : 649 : case SAVE_EXPR:
4009 : 649 : return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4010 : :
4011 : 40623180 : case CALL_EXPR:
4012 : 40623180 : {
4013 : 40623180 : if (KOENIG_LOOKUP_P (t1) != KOENIG_LOOKUP_P (t2))
4014 : : return false;
4015 : :
4016 : 40615383 : if (!called_fns_equal (t1, t2))
4017 : : return false;
4018 : :
4019 : 12934934 : call_expr_arg_iterator iter1, iter2;
4020 : 12934934 : init_call_expr_arg_iterator (t1, &iter1);
4021 : 12934934 : init_call_expr_arg_iterator (t2, &iter2);
4022 : 12934934 : if (iter1.n != iter2.n)
4023 : : return false;
4024 : :
4025 : 13623357 : while (more_call_expr_args_p (&iter1))
4026 : : {
4027 : 6104001 : tree arg1 = next_call_expr_arg (&iter1);
4028 : 6104001 : tree arg2 = next_call_expr_arg (&iter2);
4029 : :
4030 : 6104001 : gcc_checking_assert (arg1 && arg2);
4031 : 6104001 : if (!cp_tree_equal (arg1, arg2))
4032 : : return false;
4033 : : }
4034 : :
4035 : : return true;
4036 : : }
4037 : :
4038 : 128504 : case TARGET_EXPR:
4039 : 128504 : {
4040 : 128504 : tree o1 = TREE_OPERAND (t1, 0);
4041 : 128504 : tree o2 = TREE_OPERAND (t2, 0);
4042 : :
4043 : : /* Special case: if either target is an unallocated VAR_DECL,
4044 : : it means that it's going to be unified with whatever the
4045 : : TARGET_EXPR is really supposed to initialize, so treat it
4046 : : as being equivalent to anything. */
4047 : 128504 : if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
4048 : 257008 : && !DECL_RTL_SET_P (o1))
4049 : : /*Nop*/;
4050 : 0 : else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
4051 : 0 : && !DECL_RTL_SET_P (o2))
4052 : : /*Nop*/;
4053 : 0 : else if (!cp_tree_equal (o1, o2))
4054 : : return false;
4055 : :
4056 : 128504 : return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4057 : : }
4058 : :
4059 : 464911 : case PARM_DECL:
4060 : : /* For comparing uses of parameters in late-specified return types
4061 : : with an out-of-class definition of the function, but can also come
4062 : : up for expressions that involve 'this' in a member function
4063 : : template. */
4064 : :
4065 : 464911 : if (comparing_specializations
4066 : 464911 : && DECL_CONTEXT (t1) != DECL_CONTEXT (t2))
4067 : : /* When comparing hash table entries, only an exact match is
4068 : : good enough; we don't want to replace 'this' with the
4069 : : version from another function. But be more flexible
4070 : : with parameters with identical contexts. */
4071 : : return false;
4072 : :
4073 : 211226 : if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
4074 : : {
4075 : 139005 : if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
4076 : : return false;
4077 : 139005 : if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2))
4078 : : return false;
4079 : 139005 : if (DECL_ARTIFICIAL (t1)
4080 : 139005 : || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
4081 : 137499 : && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
4082 : : return true;
4083 : : }
4084 : : return false;
4085 : :
4086 : 24491535 : case TEMPLATE_DECL:
4087 : 24491535 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (t1)
4088 : 26569937 : && DECL_TEMPLATE_TEMPLATE_PARM_P (t2))
4089 : 126614 : return cp_tree_equal (TREE_TYPE (t1), TREE_TYPE (t2));
4090 : : /* Fall through. */
4091 : : case VAR_DECL:
4092 : : case CONST_DECL:
4093 : : case FIELD_DECL:
4094 : : case FUNCTION_DECL:
4095 : : case IDENTIFIER_NODE:
4096 : : case SSA_NAME:
4097 : : case USING_DECL:
4098 : : case DEFERRED_PARSE:
4099 : : return false;
4100 : :
4101 : 14183569 : case BASELINK:
4102 : 14183569 : return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
4103 : 13379191 : && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
4104 : 13379191 : && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
4105 : 27562748 : && cp_tree_equal (BASELINK_FUNCTIONS (t1),
4106 : 13379179 : BASELINK_FUNCTIONS (t2)));
4107 : :
4108 : 12554694 : case TEMPLATE_PARM_INDEX:
4109 : 12554694 : return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
4110 : 11916696 : && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
4111 : 11627096 : && (TEMPLATE_PARM_PARAMETER_PACK (t1)
4112 : 11627096 : == TEMPLATE_PARM_PARAMETER_PACK (t2))
4113 : 24174601 : && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
4114 : : TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
4115 : :
4116 : 21554424 : case TEMPLATE_ID_EXPR:
4117 : 21554424 : if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
4118 : : return false;
4119 : 15485603 : if (!comp_template_args (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)))
4120 : : return false;
4121 : : return true;
4122 : :
4123 : 1608485 : case CONSTRAINT_INFO:
4124 : 4825455 : return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1),
4125 : 4825455 : CI_ASSOCIATED_CONSTRAINTS (t2));
4126 : :
4127 : 23548982 : case TREE_VEC:
4128 : : /* These are template args. Really we should be getting the
4129 : : caller to do this as it knows it to be true. */
4130 : 23548982 : if (!comp_template_args (t1, t2))
4131 : : return false;
4132 : : return true;
4133 : :
4134 : 763067 : case SIZEOF_EXPR:
4135 : 763067 : case ALIGNOF_EXPR:
4136 : 763067 : {
4137 : 763067 : tree o1 = TREE_OPERAND (t1, 0);
4138 : 763067 : tree o2 = TREE_OPERAND (t2, 0);
4139 : :
4140 : 763067 : if (code1 == SIZEOF_EXPR)
4141 : : {
4142 : 753597 : if (SIZEOF_EXPR_TYPE_P (t1))
4143 : 0 : o1 = TREE_TYPE (o1);
4144 : 753597 : if (SIZEOF_EXPR_TYPE_P (t2))
4145 : 0 : o2 = TREE_TYPE (o2);
4146 : : }
4147 : 9470 : else if (ALIGNOF_EXPR_STD_P (t1) != ALIGNOF_EXPR_STD_P (t2))
4148 : : return false;
4149 : :
4150 : 763061 : if (TREE_CODE (o1) != TREE_CODE (o2))
4151 : : return false;
4152 : :
4153 : 763055 : if (ARGUMENT_PACK_P (o1))
4154 : 4 : return template_args_equal (o1, o2);
4155 : 763051 : else if (TYPE_P (o1))
4156 : 762717 : return same_type_p (o1, o2);
4157 : : else
4158 : : return cp_tree_equal (o1, o2);
4159 : : }
4160 : :
4161 : 149 : case MODOP_EXPR:
4162 : 149 : {
4163 : 149 : tree t1_op1, t2_op1;
4164 : :
4165 : 149 : if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
4166 : : return false;
4167 : :
4168 : 149 : t1_op1 = TREE_OPERAND (t1, 1);
4169 : 149 : t2_op1 = TREE_OPERAND (t2, 1);
4170 : 149 : if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
4171 : : return false;
4172 : :
4173 : 83 : return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
4174 : : }
4175 : :
4176 : 636 : case PTRMEM_CST:
4177 : : /* Two pointer-to-members are the same if they point to the same
4178 : : field or function in the same class. */
4179 : 636 : if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
4180 : : return false;
4181 : :
4182 : 608 : return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
4183 : :
4184 : 4321668 : case OVERLOAD:
4185 : 4321668 : {
4186 : : /* Two overloads. Must be exactly the same set of decls. */
4187 : 4321668 : lkp_iterator first (t1);
4188 : 4321668 : lkp_iterator second (t2);
4189 : :
4190 : 4333811 : for (; first && second; ++first, ++second)
4191 : 4322675 : if (*first != *second)
4192 : : return false;
4193 : 11136 : return !(first || second);
4194 : : }
4195 : :
4196 : 6322524 : case TRAIT_EXPR:
4197 : 6322524 : if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
4198 : : return false;
4199 : 761039 : return cp_tree_equal (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
4200 : 1448042 : && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
4201 : :
4202 : 265441 : case NON_LVALUE_EXPR:
4203 : 265441 : case VIEW_CONVERT_EXPR:
4204 : : /* Used for location wrappers with possibly NULL types. */
4205 : 265441 : if (!TREE_TYPE (t1) || !TREE_TYPE (t2))
4206 : : {
4207 : 38 : if (TREE_TYPE (t1) || TREE_TYPE (t2))
4208 : : return false;
4209 : : break;
4210 : : }
4211 : : /* FALLTHROUGH */
4212 : :
4213 : 2793322 : case CAST_EXPR:
4214 : 2793322 : case STATIC_CAST_EXPR:
4215 : 2793322 : case REINTERPRET_CAST_EXPR:
4216 : 2793322 : case CONST_CAST_EXPR:
4217 : 2793322 : case DYNAMIC_CAST_EXPR:
4218 : 2793322 : case IMPLICIT_CONV_EXPR:
4219 : 2793322 : case NEW_EXPR:
4220 : 2793322 : case BIT_CAST_EXPR:
4221 : 2793322 : CASE_CONVERT:
4222 : 2793322 : if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
4223 : : return false;
4224 : : /* Now compare operands as usual. */
4225 : : break;
4226 : :
4227 : 0 : case DEFERRED_NOEXCEPT:
4228 : 0 : return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
4229 : 0 : DEFERRED_NOEXCEPT_PATTERN (t2))
4230 : 0 : && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
4231 : 0 : DEFERRED_NOEXCEPT_ARGS (t2)));
4232 : :
4233 : : case LAMBDA_EXPR:
4234 : : /* Two lambda-expressions are never considered equivalent. */
4235 : : return false;
4236 : :
4237 : 242869846 : case TYPE_ARGUMENT_PACK:
4238 : 242869846 : case NONTYPE_ARGUMENT_PACK:
4239 : 242869846 : {
4240 : 242869846 : tree p1 = ARGUMENT_PACK_ARGS (t1);
4241 : 242869846 : tree p2 = ARGUMENT_PACK_ARGS (t2);
4242 : 242869846 : int len = TREE_VEC_LENGTH (p1);
4243 : 242869846 : if (TREE_VEC_LENGTH (p2) != len)
4244 : : return false;
4245 : :
4246 : 338820701 : for (int ix = 0; ix != len; ix++)
4247 : 274533057 : if (!template_args_equal (TREE_VEC_ELT (p1, ix),
4248 : 274533057 : TREE_VEC_ELT (p2, ix)))
4249 : : return false;
4250 : : return true;
4251 : : }
4252 : :
4253 : 151351 : case EXPR_PACK_EXPANSION:
4254 : 151351 : if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1),
4255 : 151351 : PACK_EXPANSION_PATTERN (t2)))
4256 : : return false;
4257 : 24240 : if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1),
4258 : 24240 : PACK_EXPANSION_EXTRA_ARGS (t2)))
4259 : : return false;
4260 : : return true;
4261 : :
4262 : 466793 : case COMPONENT_REF:
4263 : : /* If we're comparing contract conditions of overrides, member references
4264 : : compare equal if they designate the same member. */
4265 : 466793 : if (comparing_override_contracts)
4266 : 6 : return equivalent_member_references (t1, t2);
4267 : : break;
4268 : :
4269 : : default:
4270 : : break;
4271 : : }
4272 : :
4273 : 51878554 : switch (TREE_CODE_CLASS (code1))
4274 : : {
4275 : 45294534 : case tcc_unary:
4276 : 45294534 : case tcc_binary:
4277 : 45294534 : case tcc_comparison:
4278 : 45294534 : case tcc_expression:
4279 : 45294534 : case tcc_vl_exp:
4280 : 45294534 : case tcc_reference:
4281 : 45294534 : case tcc_statement:
4282 : 45294534 : {
4283 : 45294534 : int n = cp_tree_operand_length (t1);
4284 : 45294534 : if (TREE_CODE_CLASS (code1) == tcc_vl_exp
4285 : 45294534 : && n != TREE_OPERAND_LENGTH (t2))
4286 : : return false;
4287 : :
4288 : 88312398 : for (int i = 0; i < n; ++i)
4289 : 65920997 : if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
4290 : : return false;
4291 : :
4292 : : return true;
4293 : : }
4294 : :
4295 : 6584020 : case tcc_type:
4296 : 6584020 : return same_type_p (t1, t2);
4297 : :
4298 : 0 : default:
4299 : 0 : gcc_unreachable ();
4300 : : }
4301 : :
4302 : : /* We can get here with --disable-checking. */
4303 : : return false;
4304 : : }
4305 : :
4306 : : /* The type of ARG when used as an lvalue. */
4307 : :
4308 : : tree
4309 : 591301072 : lvalue_type (tree arg)
4310 : : {
4311 : 591301072 : tree type = TREE_TYPE (arg);
4312 : 591301072 : return type;
4313 : : }
4314 : :
4315 : : /* The type of ARG for printing error messages; denote lvalues with
4316 : : reference types. */
4317 : :
4318 : : tree
4319 : 3488 : error_type (tree arg)
4320 : : {
4321 : 3488 : tree type = TREE_TYPE (arg);
4322 : :
4323 : 3488 : if (TREE_CODE (type) == ARRAY_TYPE)
4324 : : ;
4325 : 3380 : else if (TREE_CODE (type) == ERROR_MARK)
4326 : : ;
4327 : 3380 : else if (lvalue_p (arg))
4328 : 1196 : type = build_reference_type (lvalue_type (arg));
4329 : 2184 : else if (MAYBE_CLASS_TYPE_P (type))
4330 : 735 : type = lvalue_type (arg);
4331 : :
4332 : 3488 : return type;
4333 : : }
4334 : :
4335 : : /* Does FUNCTION use a variable-length argument list? */
4336 : :
4337 : : int
4338 : 244799 : varargs_function_p (const_tree function)
4339 : : {
4340 : 244799 : return stdarg_p (TREE_TYPE (function));
4341 : : }
4342 : :
4343 : : /* Returns 1 if decl is a member of a class. */
4344 : :
4345 : : int
4346 : 9894 : member_p (const_tree decl)
4347 : : {
4348 : 9894 : const_tree const ctx = DECL_CONTEXT (decl);
4349 : 9894 : return (ctx && TYPE_P (ctx));
4350 : : }
4351 : :
4352 : : /* Create a placeholder for member access where we don't actually have an
4353 : : object that the access is against. For a general declval<T> equivalent,
4354 : : use build_stub_object instead. */
4355 : :
4356 : : tree
4357 : 56624774 : build_dummy_object (tree type)
4358 : : {
4359 : 56624774 : tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node);
4360 : 56624774 : return cp_build_fold_indirect_ref (decl);
4361 : : }
4362 : :
4363 : : /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4364 : : or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4365 : : binfo path from current_class_type to TYPE, or 0. */
4366 : :
4367 : : tree
4368 : 91204103 : maybe_dummy_object (tree type, tree* binfop)
4369 : : {
4370 : 91204103 : tree decl, context;
4371 : 91204103 : tree binfo;
4372 : 91204103 : tree current = current_nonlambda_class_type ();
4373 : :
4374 : 91204103 : if (current
4375 : 91204103 : && (binfo = lookup_base (current, type, ba_any, NULL,
4376 : : tf_warning_or_error)))
4377 : : context = current;
4378 : : else
4379 : : {
4380 : : /* Reference from a nested class member function. */
4381 : 11175235 : context = type;
4382 : 11175235 : binfo = TYPE_BINFO (type);
4383 : : }
4384 : :
4385 : 91204103 : if (binfop)
4386 : 107291 : *binfop = binfo;
4387 : :
4388 : : /* current_class_ref might not correspond to current_class_type if
4389 : : we're in tsubst_default_argument or a lambda-declarator; in either
4390 : : case, we want to use current_class_ref if it matches CONTEXT. */
4391 : 91204103 : tree ctype = current_class_ref ? TREE_TYPE (current_class_ref) : NULL_TREE;
4392 : 84652225 : if (ctype
4393 : 84652225 : && same_type_ignoring_top_level_qualifiers_p (ctype, context))
4394 : 77585861 : decl = current_class_ref;
4395 : : else
4396 : : {
4397 : : /* Return a dummy object whose cv-quals are consistent with (the
4398 : : non-lambda) 'this' if available. */
4399 : 13618242 : if (ctype)
4400 : : {
4401 : 7066364 : int quals = TYPE_UNQUALIFIED;
4402 : 7066364 : if (tree lambda = CLASSTYPE_LAMBDA_EXPR (ctype))
4403 : : {
4404 : 247364 : if (tree cap = lambda_expr_this_capture (lambda, false))
4405 : 242614 : quals = cp_type_quals (TREE_TYPE (TREE_TYPE (cap)));
4406 : : }
4407 : : else
4408 : 6819000 : quals = cp_type_quals (ctype);
4409 : 7066364 : context = cp_build_qualified_type (context, quals);
4410 : : }
4411 : 13618242 : decl = build_dummy_object (context);
4412 : : }
4413 : :
4414 : 91204103 : return decl;
4415 : : }
4416 : :
4417 : : /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4418 : :
4419 : : bool
4420 : 395987302 : is_dummy_object (const_tree ob)
4421 : : {
4422 : 395987302 : if (INDIRECT_REF_P (ob))
4423 : 313760760 : ob = TREE_OPERAND (ob, 0);
4424 : 395987302 : return (TREE_CODE (ob) == CONVERT_EXPR
4425 : 395987302 : && TREE_OPERAND (ob, 0) == void_node);
4426 : : }
4427 : :
4428 : : /* Returns true if TYPE is char, unsigned char, or std::byte. */
4429 : :
4430 : : bool
4431 : 22634989 : is_byte_access_type (tree type)
4432 : : {
4433 : 22634989 : type = TYPE_MAIN_VARIANT (type);
4434 : 22634989 : if (type == char_type_node
4435 : 4335816 : || type == unsigned_char_type_node)
4436 : : return true;
4437 : :
4438 : 4217256 : return (TREE_CODE (type) == ENUMERAL_TYPE
4439 : 6781 : && TYPE_CONTEXT (type) == std_node
4440 : 4221450 : && !strcmp ("byte", TYPE_NAME_STRING (type)));
4441 : : }
4442 : :
4443 : : /* Returns true if TYPE is unsigned char or std::byte. */
4444 : :
4445 : : bool
4446 : 2110 : is_byte_access_type_not_plain_char (tree type)
4447 : : {
4448 : 2110 : type = TYPE_MAIN_VARIANT (type);
4449 : 2110 : if (type == char_type_node)
4450 : : return false;
4451 : :
4452 : 1862 : return is_byte_access_type (type);
4453 : : }
4454 : :
4455 : : /* Returns 1 iff type T is something we want to treat as a scalar type for
4456 : : the purpose of deciding whether it is trivial/POD/standard-layout. */
4457 : :
4458 : : bool
4459 : 50666213 : scalarish_type_p (const_tree t)
4460 : : {
4461 : 50666213 : if (t == error_mark_node)
4462 : : return 1;
4463 : :
4464 : 50666014 : return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t));
4465 : : }
4466 : :
4467 : : /* Returns true iff T requires non-trivial default initialization. */
4468 : :
4469 : : bool
4470 : 0 : type_has_nontrivial_default_init (const_tree t)
4471 : : {
4472 : 0 : t = strip_array_types (CONST_CAST_TREE (t));
4473 : :
4474 : 0 : if (CLASS_TYPE_P (t))
4475 : 0 : return TYPE_HAS_COMPLEX_DFLT (t);
4476 : : else
4477 : : return 0;
4478 : : }
4479 : :
4480 : : /* Track classes with only deleted copy/move constructors so that we can warn
4481 : : if they are used in call/return by value. */
4482 : :
4483 : : static GTY(()) hash_set<tree>* deleted_copy_types;
4484 : : static void
4485 : 1041 : remember_deleted_copy (const_tree t)
4486 : : {
4487 : 1041 : if (!deleted_copy_types)
4488 : 231 : deleted_copy_types = hash_set<tree>::create_ggc(37);
4489 : 1041 : deleted_copy_types->add (CONST_CAST_TREE (t));
4490 : 1041 : }
4491 : : void
4492 : 290871155 : maybe_warn_parm_abi (tree t, location_t loc)
4493 : : {
4494 : 290871155 : if (!deleted_copy_types
4495 : 290871155 : || !deleted_copy_types->contains (t))
4496 : 290871117 : return;
4497 : :
4498 : 38 : if ((flag_abi_version == 12 || warn_abi_version == 12)
4499 : 44 : && classtype_has_non_deleted_move_ctor (t))
4500 : : {
4501 : 6 : bool w;
4502 : 6 : auto_diagnostic_group d;
4503 : 6 : if (flag_abi_version > 12)
4504 : 0 : w = warning_at (loc, OPT_Wabi, "%<-fabi-version=13%> (GCC 8.2) fixes "
4505 : : "the calling convention for %qT, which was "
4506 : : "accidentally changed in 8.1", t);
4507 : : else
4508 : 6 : w = warning_at (loc, OPT_Wabi, "%<-fabi-version=12%> (GCC 8.1) "
4509 : : "accidentally changes the calling convention for %qT",
4510 : : t);
4511 : 6 : if (w)
4512 : 6 : inform (location_of (t), " declared here");
4513 : 6 : return;
4514 : 6 : }
4515 : :
4516 : 38 : auto_diagnostic_group d;
4517 : 38 : if (warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
4518 : : "%<-fabi-version=13%> (GCC 8.2)", t))
4519 : 30 : inform (location_of (t), " because all of its copy and move "
4520 : : "constructors are deleted");
4521 : 38 : }
4522 : :
4523 : : /* Returns true iff copying an object of type T (including via move
4524 : : constructor) is non-trivial. That is, T has no non-trivial copy
4525 : : constructors and no non-trivial move constructors, and not all copy/move
4526 : : constructors are deleted. This function implements the ABI notion of
4527 : : non-trivial copy, which has diverged from the one in the standard. */
4528 : :
4529 : : bool
4530 : 41268423 : type_has_nontrivial_copy_init (const_tree type)
4531 : : {
4532 : 41268423 : tree t = strip_array_types (CONST_CAST_TREE (type));
4533 : :
4534 : 41268423 : if (CLASS_TYPE_P (t))
4535 : : {
4536 : 40795403 : gcc_assert (COMPLETE_TYPE_P (t));
4537 : :
4538 : 40795403 : if (TYPE_HAS_COMPLEX_COPY_CTOR (t)
4539 : 40795403 : || TYPE_HAS_COMPLEX_MOVE_CTOR (t))
4540 : : /* Nontrivial. */
4541 : : return true;
4542 : :
4543 : 37319323 : if (cxx_dialect < cxx11)
4544 : : /* No deleted functions before C++11. */
4545 : : return false;
4546 : :
4547 : : /* Before ABI v12 we did a bitwise copy of types with only deleted
4548 : : copy/move constructors. */
4549 : 37218517 : if (!abi_version_at_least (12)
4550 : 8120 : && !(warn_abi && abi_version_crosses (12)))
4551 : : return false;
4552 : :
4553 : 37210627 : bool saw_copy = false;
4554 : 37210627 : bool saw_non_deleted = false;
4555 : 37210627 : bool saw_non_deleted_move = false;
4556 : :
4557 : 37210627 : if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4558 : : saw_copy = saw_non_deleted = true;
4559 : 3528414 : else if (CLASSTYPE_LAZY_COPY_CTOR (t))
4560 : : {
4561 : 481026 : saw_copy = true;
4562 : 481026 : if (classtype_has_move_assign_or_move_ctor_p (t, true))
4563 : : /* [class.copy]/8 If the class definition declares a move
4564 : : constructor or move assignment operator, the implicitly declared
4565 : : copy constructor is defined as deleted.... */;
4566 : : else
4567 : : /* Any other reason the implicitly-declared function would be
4568 : : deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4569 : : set. */
4570 : 34159495 : saw_non_deleted = true;
4571 : : }
4572 : :
4573 : 37210627 : if (!saw_non_deleted)
4574 : 21890158 : for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
4575 : : {
4576 : 12205355 : tree fn = *iter;
4577 : 12205355 : if (copy_fn_p (fn))
4578 : : {
4579 : 3047389 : saw_copy = true;
4580 : 3047389 : if (!DECL_DELETED_FN (fn))
4581 : : {
4582 : : /* Not deleted, therefore trivial. */
4583 : : saw_non_deleted = true;
4584 : : break;
4585 : : }
4586 : : }
4587 : 9157966 : else if (move_fn_p (fn))
4588 : 2159320 : if (!DECL_DELETED_FN (fn))
4589 : 2155104 : saw_non_deleted_move = true;
4590 : : }
4591 : :
4592 : 37210627 : gcc_assert (saw_copy);
4593 : :
4594 : : /* ABI v12 buggily ignored move constructors. */
4595 : 37210627 : bool v11nontriv = false;
4596 : 37210627 : bool v12nontriv = !saw_non_deleted;
4597 : 37210627 : bool v13nontriv = !saw_non_deleted && !saw_non_deleted_move;
4598 : 37210751 : bool nontriv = (abi_version_at_least (13) ? v13nontriv
4599 : 124 : : flag_abi_version == 12 ? v12nontriv
4600 : 37210627 : : v11nontriv);
4601 : 37381288 : bool warn_nontriv = (warn_abi_version >= 13 ? v13nontriv
4602 : 170661 : : warn_abi_version == 12 ? v12nontriv
4603 : : : v11nontriv);
4604 : 37210627 : if (nontriv != warn_nontriv)
4605 : 1041 : remember_deleted_copy (t);
4606 : :
4607 : 37210627 : return nontriv;
4608 : : }
4609 : : else
4610 : : return 0;
4611 : : }
4612 : :
4613 : : /* Returns 1 iff type T is a trivially copyable type, as defined in
4614 : : [basic.types] and [class]. */
4615 : :
4616 : : bool
4617 : 76501 : trivially_copyable_p (const_tree t)
4618 : : {
4619 : 76501 : t = strip_array_types (CONST_CAST_TREE (t));
4620 : :
4621 : 76501 : if (CLASS_TYPE_P (t))
4622 : 36922 : return ((!TYPE_HAS_COPY_CTOR (t)
4623 : 36922 : || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
4624 : 35749 : && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
4625 : 35697 : && (!TYPE_HAS_COPY_ASSIGN (t)
4626 : 35697 : || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
4627 : 34875 : && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
4628 : 71627 : && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
4629 : : else
4630 : : /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4631 : 39579 : return scalarish_type_p (t);
4632 : : }
4633 : :
4634 : : /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4635 : : [class]. */
4636 : :
4637 : : bool
4638 : 124259 : trivial_type_p (const_tree t)
4639 : : {
4640 : 124259 : t = strip_array_types (CONST_CAST_TREE (t));
4641 : :
4642 : 124259 : if (CLASS_TYPE_P (t))
4643 : : /* A trivial class is a class that is trivially copyable and has one or
4644 : : more eligible default constructors, all of which are trivial. */
4645 : 26265 : return (type_has_non_deleted_trivial_default_ctor (CONST_CAST_TREE (t))
4646 : 26265 : && trivially_copyable_p (t));
4647 : : else
4648 : 97994 : return scalarish_type_p (t);
4649 : : }
4650 : :
4651 : : /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4652 : :
4653 : : bool
4654 : 11416 : pod_type_p (const_tree t)
4655 : : {
4656 : : /* This CONST_CAST is okay because strip_array_types returns its
4657 : : argument unmodified and we assign it to a const_tree. */
4658 : 11416 : t = strip_array_types (CONST_CAST_TREE(t));
4659 : :
4660 : 11416 : if (!CLASS_TYPE_P (t))
4661 : 651 : return scalarish_type_p (t);
4662 : 10765 : else if (cxx_dialect > cxx98)
4663 : : /* [class]/10: A POD struct is a class that is both a trivial class and a
4664 : : standard-layout class, and has no non-static data members of type
4665 : : non-POD struct, non-POD union (or array of such types).
4666 : :
4667 : : We don't need to check individual members because if a member is
4668 : : non-std-layout or non-trivial, the class will be too. */
4669 : 10444 : return (std_layout_type_p (t) && trivial_type_p (t));
4670 : : else
4671 : : /* The C++98 definition of POD is different. */
4672 : 321 : return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4673 : : }
4674 : :
4675 : : /* Returns true iff T is POD for the purpose of layout, as defined in the
4676 : : C++ ABI. */
4677 : :
4678 : : bool
4679 : 14668368 : layout_pod_type_p (const_tree t)
4680 : : {
4681 : 14668368 : t = strip_array_types (CONST_CAST_TREE (t));
4682 : :
4683 : 14668368 : if (CLASS_TYPE_P (t))
4684 : 2599355 : return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4685 : : else
4686 : 12069013 : return scalarish_type_p (t);
4687 : : }
4688 : :
4689 : : /* Returns true iff T is a standard-layout type, as defined in
4690 : : [basic.types]. */
4691 : :
4692 : : bool
4693 : 14728041 : std_layout_type_p (const_tree t)
4694 : : {
4695 : 14728041 : t = strip_array_types (CONST_CAST_TREE (t));
4696 : :
4697 : 14728041 : if (CLASS_TYPE_P (t))
4698 : 2611980 : return !CLASSTYPE_NON_STD_LAYOUT (t);
4699 : : else
4700 : 12116061 : return scalarish_type_p (t);
4701 : : }
4702 : :
4703 : : static bool record_has_unique_obj_representations (const_tree, const_tree);
4704 : :
4705 : : /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4706 : : as defined in [meta.unary.prop]. */
4707 : :
4708 : : bool
4709 : 13888 : type_has_unique_obj_representations (const_tree t)
4710 : : {
4711 : 13936 : bool ret;
4712 : :
4713 : 13936 : t = strip_array_types (CONST_CAST_TREE (t));
4714 : :
4715 : 13936 : if (!trivially_copyable_p (t))
4716 : : return false;
4717 : :
4718 : 13923 : if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t))
4719 : 66 : return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t);
4720 : :
4721 : 13857 : switch (TREE_CODE (t))
4722 : : {
4723 : : case INTEGER_TYPE:
4724 : : case POINTER_TYPE:
4725 : : case REFERENCE_TYPE:
4726 : : /* If some backend has any paddings in these types, we should add
4727 : : a target hook for this and handle it there. */
4728 : : return true;
4729 : :
4730 : : case BOOLEAN_TYPE:
4731 : : /* For bool values other than 0 and 1 should only appear with
4732 : : undefined behavior. */
4733 : : return true;
4734 : :
4735 : 30 : case ENUMERAL_TYPE:
4736 : 30 : return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t));
4737 : :
4738 : : case REAL_TYPE:
4739 : : /* XFmode certainly contains padding on x86, which the CPU doesn't store
4740 : : when storing long double values, so for that we have to return false.
4741 : : Other kinds of floating point values are questionable due to +.0/-.0
4742 : : and NaNs, let's play safe for now. */
4743 : : return false;
4744 : :
4745 : : case FIXED_POINT_TYPE:
4746 : : return false;
4747 : :
4748 : : case OFFSET_TYPE:
4749 : : return true;
4750 : :
4751 : 18 : case COMPLEX_TYPE:
4752 : 18 : case VECTOR_TYPE:
4753 : 18 : return type_has_unique_obj_representations (TREE_TYPE (t));
4754 : :
4755 : 71 : case RECORD_TYPE:
4756 : 71 : ret = record_has_unique_obj_representations (t, TYPE_SIZE (t));
4757 : 71 : if (CLASS_TYPE_P (t))
4758 : : {
4759 : 68 : CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4760 : 68 : CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4761 : : }
4762 : : return ret;
4763 : :
4764 : 9 : case UNION_TYPE:
4765 : 9 : ret = true;
4766 : 9 : bool any_fields;
4767 : 9 : any_fields = false;
4768 : 24 : for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4769 : 21 : if (TREE_CODE (field) == FIELD_DECL)
4770 : : {
4771 : 18 : any_fields = true;
4772 : 18 : if (!type_has_unique_obj_representations (TREE_TYPE (field))
4773 : 18 : || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1)
4774 : : {
4775 : : ret = false;
4776 : : break;
4777 : : }
4778 : : }
4779 : 9 : if (!any_fields && !integer_zerop (TYPE_SIZE (t)))
4780 : : ret = false;
4781 : 9 : if (CLASS_TYPE_P (t))
4782 : : {
4783 : 9 : CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4784 : 9 : CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4785 : : }
4786 : : return ret;
4787 : :
4788 : : case NULLPTR_TYPE:
4789 : : return false;
4790 : :
4791 : : case ERROR_MARK:
4792 : : return false;
4793 : :
4794 : 0 : default:
4795 : 0 : gcc_unreachable ();
4796 : : }
4797 : : }
4798 : :
4799 : : /* Helper function for type_has_unique_obj_representations. */
4800 : :
4801 : : static bool
4802 : 76 : record_has_unique_obj_representations (const_tree t, const_tree sz)
4803 : : {
4804 : 504 : for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4805 : 434 : if (TREE_CODE (field) != FIELD_DECL)
4806 : : ;
4807 : : /* For bases, can't use type_has_unique_obj_representations here, as in
4808 : : struct S { int i : 24; S (); };
4809 : : struct T : public S { int j : 8; T (); };
4810 : : S doesn't have unique obj representations, but T does. */
4811 : 111 : else if (DECL_FIELD_IS_BASE (field))
4812 : : {
4813 : 5 : if (!record_has_unique_obj_representations (TREE_TYPE (field),
4814 : 5 : DECL_SIZE (field)))
4815 : : return false;
4816 : : }
4817 : 106 : else if (DECL_C_BIT_FIELD (field) && !DECL_UNNAMED_BIT_FIELD (field))
4818 : : {
4819 : 37 : tree btype = DECL_BIT_FIELD_TYPE (field);
4820 : 37 : if (!type_has_unique_obj_representations (btype))
4821 : : return false;
4822 : : }
4823 : 69 : else if (!type_has_unique_obj_representations (TREE_TYPE (field)))
4824 : : return false;
4825 : :
4826 : 70 : offset_int cur = 0;
4827 : 461 : for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4828 : 408 : if (TREE_CODE (field) == FIELD_DECL && !DECL_UNNAMED_BIT_FIELD (field))
4829 : : {
4830 : 93 : offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field));
4831 : 93 : offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
4832 : 93 : fld = fld * BITS_PER_UNIT + bitpos;
4833 : 93 : if (cur != fld)
4834 : 17 : return false;
4835 : 76 : if (DECL_SIZE (field))
4836 : : {
4837 : 73 : offset_int size = wi::to_offset (DECL_SIZE (field));
4838 : 73 : cur += size;
4839 : : }
4840 : : }
4841 : 53 : if (cur != wi::to_offset (sz))
4842 : : return false;
4843 : :
4844 : : return true;
4845 : : }
4846 : :
4847 : : /* Nonzero iff type T is a class template implicit specialization. */
4848 : :
4849 : : bool
4850 : 96484346 : class_tmpl_impl_spec_p (const_tree t)
4851 : : {
4852 : 96484346 : return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
4853 : : }
4854 : :
4855 : : /* Returns 1 iff zero initialization of type T means actually storing
4856 : : zeros in it. */
4857 : :
4858 : : int
4859 : 16533255 : zero_init_p (const_tree t)
4860 : : {
4861 : : /* This CONST_CAST is okay because strip_array_types returns its
4862 : : argument unmodified and we assign it to a const_tree. */
4863 : 16533255 : t = strip_array_types (CONST_CAST_TREE(t));
4864 : :
4865 : 16533255 : if (t == error_mark_node)
4866 : : return 1;
4867 : :
4868 : : /* NULL pointers to data members are initialized with -1. */
4869 : 16533255 : if (TYPE_PTRDATAMEM_P (t))
4870 : : return 0;
4871 : :
4872 : : /* Classes that contain types that can't be zero-initialized, cannot
4873 : : be zero-initialized themselves. */
4874 : 16532706 : if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
4875 : 120 : return 0;
4876 : :
4877 : : return 1;
4878 : : }
4879 : :
4880 : : /* Returns true if the expression or initializer T is the result of
4881 : : zero-initialization for its type, taking pointers to members
4882 : : into consideration. */
4883 : :
4884 : : bool
4885 : 16350 : zero_init_expr_p (tree t)
4886 : : {
4887 : 16350 : tree type = TREE_TYPE (t);
4888 : 16350 : if (!type || uses_template_parms (type))
4889 : 0 : return false;
4890 : 16350 : if (TYPE_PTRMEM_P (type))
4891 : 1041 : return null_member_pointer_value_p (t);
4892 : 15309 : if (TREE_CODE (t) == CONSTRUCTOR)
4893 : : {
4894 : 9970 : if (COMPOUND_LITERAL_P (t)
4895 : 9970 : || BRACE_ENCLOSED_INITIALIZER_P (t))
4896 : : /* Undigested, conversions might change the zeroness. */
4897 : : return false;
4898 : 22497 : for (constructor_elt &elt : CONSTRUCTOR_ELTS (t))
4899 : : {
4900 : 6540 : if (TREE_CODE (type) == UNION_TYPE
4901 : 6540 : && elt.index != first_field (type))
4902 : : return false;
4903 : 6531 : if (!zero_init_expr_p (elt.value))
4904 : : return false;
4905 : : }
4906 : : return true;
4907 : : }
4908 : 5339 : if (zero_init_p (type))
4909 : 5339 : return initializer_zerop (t);
4910 : : return false;
4911 : : }
4912 : :
4913 : : /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4914 : : non-type template parameter. If EXPLAIN, explain why not. */
4915 : :
4916 : : bool
4917 : 4999 : structural_type_p (tree t, bool explain)
4918 : : {
4919 : : /* A structural type is one of the following: */
4920 : :
4921 : : /* a scalar type, or */
4922 : 4999 : if (SCALAR_TYPE_P (t))
4923 : : return true;
4924 : : /* an lvalue reference type, or */
4925 : 2235 : if (TYPE_REF_P (t) && !TYPE_REF_IS_RVALUE (t))
4926 : : return true;
4927 : : /* a literal class type with the following properties:
4928 : : - all base classes and non-static data members are public and non-mutable
4929 : : and
4930 : : - the types of all bases classes and non-static data members are
4931 : : structural types or (possibly multi-dimensional) array thereof. */
4932 : 2228 : if (!CLASS_TYPE_P (t))
4933 : : return false;
4934 : 2226 : if (!literal_type_p (t))
4935 : : {
4936 : 7 : if (explain)
4937 : 3 : explain_non_literal_class (t);
4938 : 7 : return false;
4939 : : }
4940 : 5140 : for (tree m = next_aggregate_field (TYPE_FIELDS (t)); m;
4941 : 2921 : m = next_aggregate_field (DECL_CHAIN (m)))
4942 : : {
4943 : 2930 : if (TREE_PRIVATE (m) || TREE_PROTECTED (m))
4944 : : {
4945 : 9 : if (explain)
4946 : : {
4947 : 3 : if (DECL_FIELD_IS_BASE (m))
4948 : 3 : inform (location_of (m), "base class %qT is not public",
4949 : 3 : TREE_TYPE (m));
4950 : : else
4951 : 0 : inform (location_of (m), "%qD is not public", m);
4952 : : }
4953 : 9 : return false;
4954 : : }
4955 : 2921 : if (DECL_MUTABLE_P (m))
4956 : : {
4957 : 0 : if (explain)
4958 : 0 : inform (location_of (m), "%qD is mutable", m);
4959 : 0 : return false;
4960 : : }
4961 : 2921 : tree mtype = strip_array_types (TREE_TYPE (m));
4962 : 2921 : if (!structural_type_p (mtype))
4963 : : {
4964 : 0 : if (explain)
4965 : : {
4966 : 0 : inform (location_of (m), "%qD has a non-structural type", m);
4967 : 0 : structural_type_p (mtype, true);
4968 : : }
4969 : 0 : return false;
4970 : : }
4971 : : }
4972 : : return true;
4973 : : }
4974 : :
4975 : : /* Partially handle the C++11 [[carries_dependency]] attribute.
4976 : : Just emit a different diagnostics when it is used on something the
4977 : : spec doesn't allow vs. where it allows and we just choose to ignore
4978 : : it. */
4979 : :
4980 : : static tree
4981 : 15 : handle_carries_dependency_attribute (tree *node, tree name,
4982 : : tree ARG_UNUSED (args),
4983 : : int ARG_UNUSED (flags),
4984 : : bool *no_add_attrs)
4985 : : {
4986 : 15 : if (TREE_CODE (*node) != FUNCTION_DECL
4987 : 9 : && TREE_CODE (*node) != PARM_DECL)
4988 : : {
4989 : 3 : warning (OPT_Wattributes, "%qE attribute can only be applied to "
4990 : : "functions or parameters", name);
4991 : 3 : *no_add_attrs = true;
4992 : : }
4993 : : else
4994 : : {
4995 : 12 : warning (OPT_Wattributes, "%qE attribute ignored", name);
4996 : 12 : *no_add_attrs = true;
4997 : : }
4998 : 15 : return NULL_TREE;
4999 : : }
5000 : :
5001 : : /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
5002 : : warn_unused_result attribute. */
5003 : :
5004 : : static tree
5005 : 10063124 : handle_nodiscard_attribute (tree *node, tree name, tree args,
5006 : : int /*flags*/, bool *no_add_attrs)
5007 : : {
5008 : 10063259 : if (args && TREE_CODE (TREE_VALUE (args)) != STRING_CST)
5009 : : {
5010 : 3 : error ("%qE attribute argument must be a string constant", name);
5011 : 3 : *no_add_attrs = true;
5012 : : }
5013 : 10063124 : if (TREE_CODE (*node) == FUNCTION_DECL)
5014 : : {
5015 : 10061098 : if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node)))
5016 : 10164378 : && !DECL_CONSTRUCTOR_P (*node))
5017 : 6 : warning_at (DECL_SOURCE_LOCATION (*node),
5018 : : OPT_Wattributes, "%qE attribute applied to %qD with void "
5019 : : "return type", name, *node);
5020 : : }
5021 : 2026 : else if (OVERLOAD_TYPE_P (*node))
5022 : : /* OK */;
5023 : : else
5024 : : {
5025 : 6 : warning (OPT_Wattributes, "%qE attribute can only be applied to "
5026 : : "functions or to class or enumeration types", name);
5027 : 6 : *no_add_attrs = true;
5028 : : }
5029 : 10063124 : return NULL_TREE;
5030 : : }
5031 : :
5032 : : /* Handle a C++20 "no_unique_address" attribute; arguments as in
5033 : : struct attribute_spec.handler. */
5034 : : static tree
5035 : 143500 : handle_no_unique_addr_attribute (tree* node,
5036 : : tree name,
5037 : : tree /*args*/,
5038 : : int /*flags*/,
5039 : : bool* no_add_attrs)
5040 : : {
5041 : 143500 : if (TREE_CODE (*node) == VAR_DECL)
5042 : : {
5043 : 12 : DECL_MERGEABLE (*node) = true;
5044 : 12 : if (pedantic)
5045 : 6 : warning (OPT_Wattributes, "%qE attribute can only be applied to "
5046 : : "non-static data members", name);
5047 : : }
5048 : 143488 : else if (TREE_CODE (*node) != FIELD_DECL)
5049 : : {
5050 : 6 : warning (OPT_Wattributes, "%qE attribute can only be applied to "
5051 : : "non-static data members", name);
5052 : 6 : *no_add_attrs = true;
5053 : : }
5054 : 143482 : else if (DECL_C_BIT_FIELD (*node))
5055 : : {
5056 : 0 : warning (OPT_Wattributes, "%qE attribute cannot be applied to "
5057 : : "a bit-field", name);
5058 : 0 : *no_add_attrs = true;
5059 : : }
5060 : :
5061 : 143500 : return NULL_TREE;
5062 : : }
5063 : :
5064 : : /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
5065 : : hot/cold attributes. */
5066 : :
5067 : : static tree
5068 : 42 : handle_likeliness_attribute (tree *node, tree name, tree args,
5069 : : int flags, bool *no_add_attrs)
5070 : : {
5071 : 42 : *no_add_attrs = true;
5072 : 42 : if (TREE_CODE (*node) == LABEL_DECL
5073 : 42 : || TREE_CODE (*node) == FUNCTION_DECL)
5074 : : {
5075 : 42 : if (args)
5076 : 0 : warning (OPT_Wattributes, "%qE attribute takes no arguments", name);
5077 : 42 : tree bname = (is_attribute_p ("likely", name)
5078 : 42 : ? get_identifier ("hot") : get_identifier ("cold"));
5079 : 42 : if (TREE_CODE (*node) == FUNCTION_DECL)
5080 : 3 : warning (OPT_Wattributes, "ISO C++ %qE attribute does not apply to "
5081 : : "functions; treating as %<[[gnu::%E]]%>", name, bname);
5082 : 42 : tree battr = build_tree_list (bname, NULL_TREE);
5083 : 42 : decl_attributes (node, battr, flags);
5084 : 42 : return NULL_TREE;
5085 : : }
5086 : : else
5087 : 0 : return error_mark_node;
5088 : : }
5089 : :
5090 : : /* Table of valid C++ attributes. */
5091 : : static const attribute_spec cxx_gnu_attributes[] =
5092 : : {
5093 : : /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5094 : : affects_type_identity, handler, exclude } */
5095 : : { "init_priority", 1, 1, true, false, false, false,
5096 : : handle_init_priority_attribute, NULL },
5097 : : { "abi_tag", 1, -1, false, false, false, true,
5098 : : handle_abi_tag_attribute, NULL },
5099 : : { "no_dangling", 0, 1, false, true, false, false,
5100 : : handle_no_dangling_attribute, NULL },
5101 : : };
5102 : :
5103 : : const scoped_attribute_specs cxx_gnu_attribute_table =
5104 : : {
5105 : : "gnu", { cxx_gnu_attributes }
5106 : : };
5107 : :
5108 : : /* Table of C++ standard attributes. */
5109 : : static const attribute_spec std_attributes[] =
5110 : : {
5111 : : /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
5112 : : affects_type_identity, handler, exclude } */
5113 : : { "maybe_unused", 0, 0, false, false, false, false,
5114 : : handle_unused_attribute, NULL },
5115 : : { "nodiscard", 0, 1, false, false, false, false,
5116 : : handle_nodiscard_attribute, NULL },
5117 : : { "no_unique_address", 0, 0, true, false, false, false,
5118 : : handle_no_unique_addr_attribute, NULL },
5119 : : { "likely", 0, 0, false, false, false, false,
5120 : : handle_likeliness_attribute, attr_cold_hot_exclusions },
5121 : : { "unlikely", 0, 0, false, false, false, false,
5122 : : handle_likeliness_attribute, attr_cold_hot_exclusions },
5123 : : { "noreturn", 0, 0, true, false, false, false,
5124 : : handle_noreturn_attribute, attr_noreturn_exclusions },
5125 : : { "carries_dependency", 0, 0, true, false, false, false,
5126 : : handle_carries_dependency_attribute, NULL },
5127 : : { "pre", 0, -1, false, false, false, false,
5128 : : handle_contract_attribute, NULL },
5129 : : { "post", 0, -1, false, false, false, false,
5130 : : handle_contract_attribute, NULL }
5131 : : };
5132 : :
5133 : : const scoped_attribute_specs std_attribute_table =
5134 : : {
5135 : : nullptr, { std_attributes }
5136 : : };
5137 : :
5138 : : /* Handle an "init_priority" attribute; arguments as in
5139 : : struct attribute_spec.handler. */
5140 : : static tree
5141 : 25 : handle_init_priority_attribute (tree* node,
5142 : : tree name,
5143 : : tree args,
5144 : : int /*flags*/,
5145 : : bool* no_add_attrs)
5146 : : {
5147 : 25 : if (!SUPPORTS_INIT_PRIORITY)
5148 : : /* Treat init_priority as an unrecognized attribute (mirroring
5149 : : __has_attribute) if the target doesn't support init priorities. */
5150 : : return error_mark_node;
5151 : :
5152 : 25 : tree initp_expr = TREE_VALUE (args);
5153 : 25 : tree decl = *node;
5154 : 25 : tree type = TREE_TYPE (decl);
5155 : 25 : int pri;
5156 : :
5157 : 25 : STRIP_NOPS (initp_expr);
5158 : 25 : initp_expr = default_conversion (initp_expr);
5159 : 25 : if (initp_expr)
5160 : 25 : initp_expr = maybe_constant_value (initp_expr);
5161 : :
5162 : 25 : if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
5163 : : {
5164 : 0 : error ("requested %<init_priority%> is not an integer constant");
5165 : 0 : cxx_constant_value (initp_expr);
5166 : 0 : *no_add_attrs = true;
5167 : 0 : return NULL_TREE;
5168 : : }
5169 : :
5170 : 25 : pri = TREE_INT_CST_LOW (initp_expr);
5171 : :
5172 : 25 : type = strip_array_types (type);
5173 : :
5174 : 25 : if (decl == NULL_TREE
5175 : : || !VAR_P (decl)
5176 : 25 : || !TREE_STATIC (decl)
5177 : 25 : || DECL_EXTERNAL (decl)
5178 : 25 : || (TREE_CODE (type) != RECORD_TYPE
5179 : 25 : && TREE_CODE (type) != UNION_TYPE)
5180 : : /* Static objects in functions are initialized the
5181 : : first time control passes through that
5182 : : function. This is not precise enough to pin down an
5183 : : init_priority value, so don't allow it. */
5184 : 50 : || current_function_decl)
5185 : : {
5186 : 0 : error ("can only use %qE attribute on file-scope definitions "
5187 : : "of objects of class type", name);
5188 : 0 : *no_add_attrs = true;
5189 : 0 : return NULL_TREE;
5190 : : }
5191 : :
5192 : 25 : if (pri > MAX_INIT_PRIORITY || pri <= 0)
5193 : : {
5194 : 0 : error ("requested %<init_priority%> %i is out of range [0, %i]",
5195 : : pri, MAX_INIT_PRIORITY);
5196 : 0 : *no_add_attrs = true;
5197 : 0 : return NULL_TREE;
5198 : : }
5199 : :
5200 : : /* Check for init_priorities that are reserved for
5201 : : language and runtime support implementations.*/
5202 : 25 : if (pri <= MAX_RESERVED_INIT_PRIORITY)
5203 : : {
5204 : 2 : warning
5205 : 2 : (0, "requested %<init_priority%> %i is reserved for internal use",
5206 : : pri);
5207 : : }
5208 : :
5209 : 25 : SET_DECL_INIT_PRIORITY (decl, pri);
5210 : 25 : DECL_HAS_INIT_PRIORITY_P (decl) = 1;
5211 : 25 : return NULL_TREE;
5212 : : }
5213 : :
5214 : : /* DECL is being redeclared; the old declaration had the abi tags in OLD,
5215 : : and the new one has the tags in NEW_. Give an error if there are tags
5216 : : in NEW_ that weren't in OLD. */
5217 : :
5218 : : bool
5219 : 9996863 : check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
5220 : : {
5221 : 10028910 : if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
5222 : : old = TREE_VALUE (old);
5223 : 10019084 : if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
5224 : : new_ = TREE_VALUE (new_);
5225 : 9996863 : bool err = false;
5226 : 9996863 : auto_diagnostic_group d;
5227 : 10019084 : for (const_tree t = new_; t; t = TREE_CHAIN (t))
5228 : : {
5229 : 22221 : tree str = TREE_VALUE (t);
5230 : 22221 : for (const_tree in = old; in; in = TREE_CHAIN (in))
5231 : : {
5232 : 22215 : tree ostr = TREE_VALUE (in);
5233 : 22215 : if (cp_tree_equal (str, ostr))
5234 : 22215 : goto found;
5235 : : }
5236 : 6 : error ("redeclaration of %qD adds abi tag %qE", decl, str);
5237 : 6 : err = true;
5238 : 22221 : found:;
5239 : : }
5240 : 9996863 : if (err)
5241 : : {
5242 : 6 : inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
5243 : 6 : return false;
5244 : : }
5245 : : return true;
5246 : 9996863 : }
5247 : :
5248 : : /* The abi_tag attribute with the name NAME was given ARGS. If they are
5249 : : ill-formed, give an error and return false; otherwise, return true. */
5250 : :
5251 : : bool
5252 : 375590 : check_abi_tag_args (tree args, tree name)
5253 : : {
5254 : 375590 : if (!args)
5255 : : {
5256 : 0 : error ("the %qE attribute requires arguments", name);
5257 : 0 : return false;
5258 : : }
5259 : 751180 : for (tree arg = args; arg; arg = TREE_CHAIN (arg))
5260 : : {
5261 : 375602 : tree elt = TREE_VALUE (arg);
5262 : 375602 : if (TREE_CODE (elt) != STRING_CST
5263 : 751198 : || (!same_type_ignoring_top_level_qualifiers_p
5264 : 375596 : (strip_array_types (TREE_TYPE (elt)),
5265 : : char_type_node)))
5266 : : {
5267 : 9 : error ("arguments to the %qE attribute must be narrow string "
5268 : : "literals", name);
5269 : 9 : return false;
5270 : : }
5271 : 375593 : const char *begin = TREE_STRING_POINTER (elt);
5272 : 375593 : const char *end = begin + TREE_STRING_LENGTH (elt);
5273 : 2640671 : for (const char *p = begin; p != end; ++p)
5274 : : {
5275 : 2265081 : char c = *p;
5276 : 2265081 : if (p == begin)
5277 : : {
5278 : 375593 : if (!ISALPHA (c) && c != '_')
5279 : : {
5280 : 3 : auto_diagnostic_group d;
5281 : 3 : error ("arguments to the %qE attribute must contain valid "
5282 : : "identifiers", name);
5283 : 3 : inform (input_location, "%<%c%> is not a valid first "
5284 : : "character for an identifier", c);
5285 : 3 : return false;
5286 : 3 : }
5287 : : }
5288 : 1889488 : else if (p == end - 1)
5289 : 375590 : gcc_assert (c == 0);
5290 : : else
5291 : : {
5292 : 1513898 : if (!ISALNUM (c) && c != '_')
5293 : : {
5294 : 0 : auto_diagnostic_group d;
5295 : 0 : error ("arguments to the %qE attribute must contain valid "
5296 : : "identifiers", name);
5297 : 0 : inform (input_location, "%<%c%> is not a valid character "
5298 : : "in an identifier", c);
5299 : 0 : return false;
5300 : 0 : }
5301 : : }
5302 : : }
5303 : : }
5304 : : return true;
5305 : : }
5306 : :
5307 : : /* Handle an "abi_tag" attribute; arguments as in
5308 : : struct attribute_spec.handler. */
5309 : :
5310 : : static tree
5311 : 330466 : handle_abi_tag_attribute (tree* node, tree name, tree args,
5312 : : int flags, bool* no_add_attrs)
5313 : : {
5314 : 330466 : if (!check_abi_tag_args (args, name))
5315 : 12 : goto fail;
5316 : :
5317 : 330454 : if (TYPE_P (*node))
5318 : : {
5319 : 11281 : if (!OVERLOAD_TYPE_P (*node))
5320 : : {
5321 : 0 : error ("%qE attribute applied to non-class, non-enum type %qT",
5322 : : name, *node);
5323 : 0 : goto fail;
5324 : : }
5325 : 11281 : else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
5326 : : {
5327 : 0 : error ("%qE attribute applied to %qT after its definition",
5328 : : name, *node);
5329 : 0 : goto fail;
5330 : : }
5331 : 11278 : else if (CLASS_TYPE_P (*node)
5332 : 22559 : && CLASSTYPE_TEMPLATE_INSTANTIATION (*node))
5333 : : {
5334 : 3 : warning (OPT_Wattributes, "ignoring %qE attribute applied to "
5335 : : "template instantiation %qT", name, *node);
5336 : 3 : goto fail;
5337 : : }
5338 : 11275 : else if (CLASS_TYPE_P (*node)
5339 : 22553 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node))
5340 : : {
5341 : 3 : warning (OPT_Wattributes, "ignoring %qE attribute applied to "
5342 : : "template specialization %qT", name, *node);
5343 : 3 : goto fail;
5344 : : }
5345 : :
5346 : 11275 : tree attributes = TYPE_ATTRIBUTES (*node);
5347 : 11275 : tree decl = TYPE_NAME (*node);
5348 : :
5349 : : /* Make sure all declarations have the same abi tags. */
5350 : 11275 : if (DECL_SOURCE_LOCATION (decl) != input_location)
5351 : : {
5352 : 3 : if (!check_abi_tag_redeclaration (decl,
5353 : 3 : lookup_attribute ("abi_tag",
5354 : : attributes),
5355 : : args))
5356 : 3 : goto fail;
5357 : : }
5358 : : }
5359 : : else
5360 : : {
5361 : 319173 : if (!VAR_OR_FUNCTION_DECL_P (*node))
5362 : : {
5363 : 0 : error ("%qE attribute applied to non-function, non-variable %qD",
5364 : : name, *node);
5365 : 0 : goto fail;
5366 : : }
5367 : 319173 : else if (DECL_LANGUAGE (*node) == lang_c)
5368 : : {
5369 : 0 : error ("%qE attribute applied to extern \"C\" declaration %qD",
5370 : : name, *node);
5371 : 0 : goto fail;
5372 : : }
5373 : : }
5374 : :
5375 : : return NULL_TREE;
5376 : :
5377 : 21 : fail:
5378 : 21 : *no_add_attrs = true;
5379 : 21 : return NULL_TREE;
5380 : : }
5381 : :
5382 : : /* Perform checking for contract attributes. */
5383 : :
5384 : : tree
5385 : 665 : handle_contract_attribute (tree *ARG_UNUSED (node), tree ARG_UNUSED (name),
5386 : : tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5387 : : bool *ARG_UNUSED (no_add_attrs))
5388 : : {
5389 : : /* TODO: Is there any checking we could do here? */
5390 : 665 : return NULL_TREE;
5391 : : }
5392 : :
5393 : : /* Handle a "no_dangling" attribute; arguments as in
5394 : : struct attribute_spec.handler. */
5395 : :
5396 : : tree
5397 : 96 : handle_no_dangling_attribute (tree *node, tree name, tree args, int,
5398 : : bool *no_add_attrs)
5399 : : {
5400 : 147 : if (args && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5401 : : {
5402 : 3 : error ("%qE attribute argument must be an expression that evaluates "
5403 : : "to true or false", name);
5404 : 3 : *no_add_attrs = true;
5405 : : }
5406 : 93 : else if (!FUNC_OR_METHOD_TYPE_P (*node)
5407 : 51 : && !RECORD_OR_UNION_TYPE_P (*node))
5408 : : {
5409 : 18 : warning (OPT_Wattributes, "%qE attribute ignored", name);
5410 : 18 : *no_add_attrs = true;
5411 : : }
5412 : :
5413 : 96 : return NULL_TREE;
5414 : : }
5415 : :
5416 : : /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
5417 : : thing pointed to by the constant. */
5418 : :
5419 : : tree
5420 : 63751 : make_ptrmem_cst (tree type, tree member)
5421 : : {
5422 : 63751 : tree ptrmem_cst = make_node (PTRMEM_CST);
5423 : 63751 : TREE_TYPE (ptrmem_cst) = type;
5424 : 63751 : PTRMEM_CST_MEMBER (ptrmem_cst) = member;
5425 : 63751 : PTRMEM_CST_LOCATION (ptrmem_cst) = input_location;
5426 : 63751 : return ptrmem_cst;
5427 : : }
5428 : :
5429 : : /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5430 : : return an existing type if an appropriate type already exists. */
5431 : :
5432 : : tree
5433 : 15107961 : cp_build_type_attribute_variant (tree type, tree attributes)
5434 : : {
5435 : 15107961 : tree new_type;
5436 : :
5437 : 15107961 : new_type = build_type_attribute_variant (type, attributes);
5438 : 15107961 : if (FUNC_OR_METHOD_TYPE_P (new_type))
5439 : 15045976 : gcc_checking_assert (cxx_type_hash_eq (type, new_type));
5440 : :
5441 : : /* Making a new main variant of a class type is broken. */
5442 : 15107961 : gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
5443 : :
5444 : 15107961 : return new_type;
5445 : : }
5446 : :
5447 : : /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5448 : : Called only after doing all language independent checks. */
5449 : :
5450 : : bool
5451 : 280085254 : cxx_type_hash_eq (const_tree typea, const_tree typeb)
5452 : : {
5453 : 280085254 : gcc_assert (FUNC_OR_METHOD_TYPE_P (typea));
5454 : :
5455 : 280085254 : if (type_memfn_rqual (typea) != type_memfn_rqual (typeb))
5456 : : return false;
5457 : 280075905 : if (TYPE_HAS_LATE_RETURN_TYPE (typea) != TYPE_HAS_LATE_RETURN_TYPE (typeb))
5458 : : return false;
5459 : 280075497 : return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
5460 : 560150994 : TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
5461 : : }
5462 : :
5463 : : /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5464 : : C++, these are the exception-specifier and ref-qualifier. */
5465 : :
5466 : : tree
5467 : 23479868 : cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb)
5468 : : {
5469 : 23479868 : tree type = CONST_CAST_TREE (typea);
5470 : 23479868 : if (FUNC_OR_METHOD_TYPE_P (type))
5471 : 23479120 : type = build_cp_fntype_variant (type, type_memfn_rqual (typeb),
5472 : 23479120 : TYPE_RAISES_EXCEPTIONS (typeb),
5473 : 23479120 : TYPE_HAS_LATE_RETURN_TYPE (typeb));
5474 : 23479868 : return type;
5475 : : }
5476 : :
5477 : : /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5478 : : traversal. Called from walk_tree. */
5479 : :
5480 : : tree
5481 : 13115315756 : cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
5482 : : void *data, hash_set<tree> *pset)
5483 : : {
5484 : 13115315756 : tree t = *tp;
5485 : 13115315756 : enum tree_code code = TREE_CODE (t);
5486 : 13115315756 : tree result;
5487 : :
5488 : : #define WALK_SUBTREE(NODE) \
5489 : : do \
5490 : : { \
5491 : : result = cp_walk_tree (&(NODE), func, data, pset); \
5492 : : if (result) goto out; \
5493 : : } \
5494 : : while (0)
5495 : :
5496 : 13115315756 : if (TYPE_P (t))
5497 : : {
5498 : : /* If *WALK_SUBTREES_P is 1, we're interested in the syntactic form of
5499 : : the argument, so don't look through typedefs, but do walk into
5500 : : template arguments for alias templates (and non-typedefed classes).
5501 : :
5502 : : If *WALK_SUBTREES_P > 1, we're interested in type identity or
5503 : : equivalence, so look through typedefs, ignoring template arguments for
5504 : : alias templates, and walk into template args of classes.
5505 : :
5506 : : See find_abi_tags_r for an example of setting *WALK_SUBTREES_P to 2
5507 : : when that's the behavior the walk_tree_fn wants. */
5508 : 4878315003 : if (*walk_subtrees_p == 1 && typedef_variant_p (t))
5509 : : {
5510 : 6315468 : if (tree ti = TYPE_ALIAS_TEMPLATE_INFO (t))
5511 : 4942943 : WALK_SUBTREE (TI_ARGS (ti));
5512 : 6201529 : *walk_subtrees_p = 0;
5513 : 6201529 : return NULL_TREE;
5514 : : }
5515 : :
5516 : 4871999535 : if (tree ti = TYPE_TEMPLATE_INFO (t))
5517 : 480069018 : WALK_SUBTREE (TI_ARGS (ti));
5518 : : }
5519 : :
5520 : : /* Not one of the easy cases. We must explicitly go through the
5521 : : children. */
5522 : 13108885260 : result = NULL_TREE;
5523 : 13108885260 : switch (code)
5524 : : {
5525 : 1428959447 : case TEMPLATE_TYPE_PARM:
5526 : 1428959447 : if (template_placeholder_p (t))
5527 : 358499 : WALK_SUBTREE (CLASS_PLACEHOLDER_TEMPLATE (t));
5528 : : /* Fall through. */
5529 : 1551294766 : case DEFERRED_PARSE:
5530 : 1551294766 : case TEMPLATE_TEMPLATE_PARM:
5531 : 1551294766 : case BOUND_TEMPLATE_TEMPLATE_PARM:
5532 : 1551294766 : case UNBOUND_CLASS_TEMPLATE:
5533 : 1551294766 : case TEMPLATE_PARM_INDEX:
5534 : 1551294766 : case TYPEOF_TYPE:
5535 : : /* None of these have subtrees other than those already walked
5536 : : above. */
5537 : 1551294766 : *walk_subtrees_p = 0;
5538 : 1551294766 : break;
5539 : :
5540 : 128875776 : case TYPENAME_TYPE:
5541 : 128875776 : WALK_SUBTREE (TYPE_CONTEXT (t));
5542 : 128834042 : WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t));
5543 : 128831808 : *walk_subtrees_p = 0;
5544 : 128831808 : break;
5545 : :
5546 : 64605251 : case BASELINK:
5547 : 64605251 : if (BASELINK_QUALIFIED_P (t))
5548 : 5132331 : WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (t)));
5549 : 64605251 : WALK_SUBTREE (BASELINK_FUNCTIONS (t));
5550 : 64585151 : *walk_subtrees_p = 0;
5551 : 64585151 : break;
5552 : :
5553 : 37380 : case PTRMEM_CST:
5554 : 37380 : WALK_SUBTREE (TREE_TYPE (t));
5555 : 37380 : *walk_subtrees_p = 0;
5556 : 37380 : break;
5557 : :
5558 : 192981868 : case TREE_LIST:
5559 : 192981868 : WALK_SUBTREE (TREE_PURPOSE (t));
5560 : : break;
5561 : :
5562 : 223486777 : case OVERLOAD:
5563 : 223486777 : WALK_SUBTREE (OVL_FUNCTION (t));
5564 : 223486775 : WALK_SUBTREE (OVL_CHAIN (t));
5565 : 223486775 : *walk_subtrees_p = 0;
5566 : 223486775 : break;
5567 : :
5568 : 2497843 : case USING_DECL:
5569 : 2497843 : WALK_SUBTREE (DECL_NAME (t));
5570 : 2497843 : WALK_SUBTREE (USING_DECL_SCOPE (t));
5571 : 2497840 : WALK_SUBTREE (USING_DECL_DECLS (t));
5572 : 2497840 : *walk_subtrees_p = 0;
5573 : 2497840 : break;
5574 : :
5575 : 549839117 : case RECORD_TYPE:
5576 : 549839117 : if (TYPE_PTRMEMFUNC_P (t))
5577 : 5768168 : WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (t));
5578 : : break;
5579 : :
5580 : 105453358 : case TYPE_ARGUMENT_PACK:
5581 : 105453358 : case NONTYPE_ARGUMENT_PACK:
5582 : 105453358 : {
5583 : 105453358 : tree args = ARGUMENT_PACK_ARGS (t);
5584 : 281367017 : for (tree arg : tree_vec_range (args))
5585 : 176097020 : WALK_SUBTREE (arg);
5586 : : }
5587 : 105269997 : break;
5588 : :
5589 : 23066220 : case TYPE_PACK_EXPANSION:
5590 : 23066220 : WALK_SUBTREE (TREE_TYPE (t));
5591 : 23053872 : WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t));
5592 : 23053872 : *walk_subtrees_p = 0;
5593 : 23053872 : break;
5594 : :
5595 : 3188065 : case EXPR_PACK_EXPANSION:
5596 : 3188065 : WALK_SUBTREE (TREE_OPERAND (t, 0));
5597 : 3187988 : WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (t));
5598 : 3187988 : *walk_subtrees_p = 0;
5599 : 3187988 : break;
5600 : :
5601 : 75433134 : case CAST_EXPR:
5602 : 75433134 : case REINTERPRET_CAST_EXPR:
5603 : 75433134 : case STATIC_CAST_EXPR:
5604 : 75433134 : case CONST_CAST_EXPR:
5605 : 75433134 : case DYNAMIC_CAST_EXPR:
5606 : 75433134 : case IMPLICIT_CONV_EXPR:
5607 : 75433134 : case BIT_CAST_EXPR:
5608 : 75433134 : if (TREE_TYPE (t))
5609 : 75433134 : WALK_SUBTREE (TREE_TYPE (t));
5610 : : break;
5611 : :
5612 : 51337335 : case CONSTRUCTOR:
5613 : 51337335 : if (COMPOUND_LITERAL_P (t))
5614 : 4431169 : WALK_SUBTREE (TREE_TYPE (t));
5615 : : break;
5616 : :
5617 : 11822935 : case TRAIT_EXPR:
5618 : 11822935 : WALK_SUBTREE (TRAIT_EXPR_TYPE1 (t));
5619 : 11822923 : WALK_SUBTREE (TRAIT_EXPR_TYPE2 (t));
5620 : 11822923 : *walk_subtrees_p = 0;
5621 : 11822923 : break;
5622 : :
5623 : 1210004 : case TRAIT_TYPE:
5624 : 1210004 : WALK_SUBTREE (TRAIT_TYPE_TYPE1 (t));
5625 : 1210004 : WALK_SUBTREE (TRAIT_TYPE_TYPE2 (t));
5626 : 1210004 : *walk_subtrees_p = 0;
5627 : 1210004 : break;
5628 : :
5629 : 6163473 : case DECLTYPE_TYPE:
5630 : 6163473 : {
5631 : 6163473 : cp_unevaluated u;
5632 : 6163473 : WALK_SUBTREE (DECLTYPE_TYPE_EXPR (t));
5633 : 6090780 : *walk_subtrees_p = 0;
5634 : 6090780 : break;
5635 : 6163473 : }
5636 : :
5637 : 16247417 : case ALIGNOF_EXPR:
5638 : 16247417 : case SIZEOF_EXPR:
5639 : 16247417 : case NOEXCEPT_EXPR:
5640 : 16247417 : {
5641 : 16247417 : cp_unevaluated u;
5642 : 16247417 : WALK_SUBTREE (TREE_OPERAND (t, 0));
5643 : 14344516 : *walk_subtrees_p = 0;
5644 : 14344516 : break;
5645 : 16247417 : }
5646 : :
5647 : 3125810 : case REQUIRES_EXPR:
5648 : 3125810 : {
5649 : 3125810 : cp_unevaluated u;
5650 : 5372523 : for (tree parm = REQUIRES_EXPR_PARMS (t); parm; parm = DECL_CHAIN (parm))
5651 : : /* Walk the types of each parameter, but not the parameter itself,
5652 : : since doing so would cause false positives in the unexpanded pack
5653 : : checker if the requires-expr introduces a function parameter pack,
5654 : : e.g. requires (Ts... ts) { }. */
5655 : 2246713 : WALK_SUBTREE (TREE_TYPE (parm));
5656 : 3125810 : WALK_SUBTREE (REQUIRES_EXPR_REQS (t));
5657 : 3123594 : *walk_subtrees_p = 0;
5658 : 3123594 : break;
5659 : 3125810 : }
5660 : :
5661 : 53005784 : case DECL_EXPR:
5662 : : /* User variables should be mentioned in BIND_EXPR_VARS
5663 : : and their initializers and sizes walked when walking
5664 : : the containing BIND_EXPR. Compiler temporaries are
5665 : : handled here. And also normal variables in templates,
5666 : : since do_poplevel doesn't build a BIND_EXPR then. */
5667 : 53005784 : if (VAR_P (TREE_OPERAND (t, 0))
5668 : 53005784 : && (processing_template_decl
5669 : 49345736 : || (DECL_ARTIFICIAL (TREE_OPERAND (t, 0))
5670 : 2533753 : && !TREE_STATIC (TREE_OPERAND (t, 0)))))
5671 : : {
5672 : 5350459 : tree decl = TREE_OPERAND (t, 0);
5673 : 5350459 : WALK_SUBTREE (DECL_INITIAL (decl));
5674 : 5350429 : WALK_SUBTREE (DECL_SIZE (decl));
5675 : 5350429 : WALK_SUBTREE (DECL_SIZE_UNIT (decl));
5676 : : }
5677 : : break;
5678 : :
5679 : 755225 : case LAMBDA_EXPR:
5680 : : /* Don't walk into the body of the lambda, but the capture initializers
5681 : : are part of the enclosing context. */
5682 : 1667543 : for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (t); cap;
5683 : 912318 : cap = TREE_CHAIN (cap))
5684 : 912318 : WALK_SUBTREE (TREE_VALUE (cap));
5685 : : break;
5686 : :
5687 : 4876 : case CO_YIELD_EXPR:
5688 : 4876 : if (TREE_OPERAND (t, 1))
5689 : : /* Operand 1 is the tree for the relevant co_await which has any
5690 : : interesting sub-trees. */
5691 : 489 : WALK_SUBTREE (TREE_OPERAND (t, 1));
5692 : : break;
5693 : :
5694 : 22596 : case CO_AWAIT_EXPR:
5695 : 22596 : if (TREE_OPERAND (t, 1))
5696 : : /* Operand 1 is frame variable. */
5697 : 22440 : WALK_SUBTREE (TREE_OPERAND (t, 1));
5698 : 22596 : if (TREE_OPERAND (t, 2))
5699 : : /* Operand 2 has the initialiser, and we need to walk any subtrees
5700 : : there. */
5701 : 4499 : WALK_SUBTREE (TREE_OPERAND (t, 2));
5702 : : break;
5703 : :
5704 : 836 : case CO_RETURN_EXPR:
5705 : 836 : if (TREE_OPERAND (t, 0))
5706 : : {
5707 : 735 : if (VOID_TYPE_P (TREE_OPERAND (t, 0)))
5708 : : /* For void expressions, operand 1 is a trivial call, and any
5709 : : interesting subtrees will be part of operand 0. */
5710 : 0 : WALK_SUBTREE (TREE_OPERAND (t, 0));
5711 : 735 : else if (TREE_OPERAND (t, 1))
5712 : : /* Interesting sub-trees will be in the return_value () call
5713 : : arguments. */
5714 : 687 : WALK_SUBTREE (TREE_OPERAND (t, 1));
5715 : : }
5716 : : break;
5717 : :
5718 : 295220 : case STATIC_ASSERT:
5719 : 295220 : WALK_SUBTREE (STATIC_ASSERT_CONDITION (t));
5720 : 295220 : WALK_SUBTREE (STATIC_ASSERT_MESSAGE (t));
5721 : : break;
5722 : :
5723 : : default:
5724 : : return NULL_TREE;
5725 : : }
5726 : :
5727 : : /* We didn't find what we were looking for. */
5728 : : out:
5729 : : return result;
5730 : :
5731 : : #undef WALK_SUBTREE
5732 : : }
5733 : :
5734 : : /* Like save_expr, but for C++. */
5735 : :
5736 : : tree
5737 : 108466 : cp_save_expr (tree expr)
5738 : : {
5739 : : /* There is no reason to create a SAVE_EXPR within a template; if
5740 : : needed, we can create the SAVE_EXPR when instantiating the
5741 : : template. Furthermore, the middle-end cannot handle C++-specific
5742 : : tree codes. */
5743 : 108466 : if (processing_template_decl)
5744 : : return expr;
5745 : :
5746 : : /* TARGET_EXPRs are only expanded once. */
5747 : 34076 : if (TREE_CODE (expr) == TARGET_EXPR)
5748 : : return expr;
5749 : :
5750 : 34076 : return save_expr (expr);
5751 : : }
5752 : :
5753 : : /* Initialize tree.cc. */
5754 : :
5755 : : void
5756 : 92069 : init_tree (void)
5757 : : {
5758 : 92069 : list_hash_table = hash_table<list_hasher>::create_ggc (61);
5759 : 92069 : }
5760 : :
5761 : : /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5762 : : is. Note that sfk_none is zero, so this function can be used as a
5763 : : predicate to test whether or not DECL is a special function. */
5764 : :
5765 : : special_function_kind
5766 : 170387027 : special_function_p (const_tree decl)
5767 : : {
5768 : : /* Rather than doing all this stuff with magic names, we should
5769 : : probably have a field of type `special_function_kind' in
5770 : : DECL_LANG_SPECIFIC. */
5771 : 340774054 : if (DECL_INHERITED_CTOR (decl))
5772 : : return sfk_inheriting_constructor;
5773 : 340256044 : if (DECL_COPY_CONSTRUCTOR_P (decl))
5774 : : return sfk_copy_constructor;
5775 : 320055550 : if (DECL_MOVE_CONSTRUCTOR_P (decl))
5776 : : return sfk_move_constructor;
5777 : 305967846 : if (DECL_CONSTRUCTOR_P (decl))
5778 : : return sfk_constructor;
5779 : 134923369 : if (DECL_ASSIGNMENT_OPERATOR_P (decl)
5780 : 134923369 : && DECL_OVERLOADED_OPERATOR_IS (decl, NOP_EXPR))
5781 : : {
5782 : 8657462 : if (copy_fn_p (decl))
5783 : : return sfk_copy_assignment;
5784 : 3294144 : if (move_fn_p (decl))
5785 : : return sfk_move_assignment;
5786 : : }
5787 : 126654054 : if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
5788 : : return sfk_destructor;
5789 : 91920736 : if (DECL_COMPLETE_DESTRUCTOR_P (decl))
5790 : : return sfk_complete_destructor;
5791 : 75629732 : if (DECL_BASE_DESTRUCTOR_P (decl))
5792 : : return sfk_base_destructor;
5793 : 73989183 : if (DECL_DELETING_DESTRUCTOR_P (decl))
5794 : : return sfk_deleting_destructor;
5795 : 62737799 : if (DECL_CONV_FN_P (decl))
5796 : : return sfk_conversion;
5797 : 62145346 : if (deduction_guide_p (decl))
5798 : : return sfk_deduction_guide;
5799 : 62123118 : if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) >= OVL_OP_EQ_EXPR
5800 : 62123118 : && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) <= OVL_OP_SPACESHIP_EXPR)
5801 : 3026382 : return sfk_comparison;
5802 : :
5803 : : return sfk_none;
5804 : : }
5805 : :
5806 : : /* As above, but only if DECL is a special member function as per 11.3.3
5807 : : [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5808 : :
5809 : : special_function_kind
5810 : 49112152 : special_memfn_p (const_tree decl)
5811 : : {
5812 : 49112152 : switch (special_function_kind sfk = special_function_p (decl))
5813 : : {
5814 : 5885433 : case sfk_constructor:
5815 : 5885433 : if (!default_ctor_p (decl))
5816 : : break;
5817 : : gcc_fallthrough();
5818 : : case sfk_copy_constructor:
5819 : : case sfk_copy_assignment:
5820 : : case sfk_move_assignment:
5821 : : case sfk_move_constructor:
5822 : : case sfk_destructor:
5823 : : return sfk;
5824 : :
5825 : : default:
5826 : : break;
5827 : : }
5828 : : return sfk_none;
5829 : : }
5830 : :
5831 : : /* Returns nonzero if TYPE is a character type, including wchar_t. */
5832 : :
5833 : : int
5834 : 8988061 : char_type_p (tree type)
5835 : : {
5836 : 8988061 : return (same_type_p (type, char_type_node)
5837 : 7999645 : || same_type_p (type, unsigned_char_type_node)
5838 : 7944605 : || same_type_p (type, signed_char_type_node)
5839 : 7944288 : || same_type_p (type, char8_type_node)
5840 : 7944214 : || same_type_p (type, char16_type_node)
5841 : 7943714 : || same_type_p (type, char32_type_node)
5842 : 16900808 : || same_type_p (type, wchar_type_node));
5843 : : }
5844 : :
5845 : : /* Returns the kind of linkage associated with the indicated DECL. Th
5846 : : value returned is as specified by the language standard; it is
5847 : : independent of implementation details regarding template
5848 : : instantiation, etc. For example, it is possible that a declaration
5849 : : to which this function assigns external linkage would not show up
5850 : : as a global symbol when you run `nm' on the resulting object file. */
5851 : :
5852 : : linkage_kind
5853 : 382587865 : decl_linkage (tree decl)
5854 : : {
5855 : : /* This function doesn't attempt to calculate the linkage from first
5856 : : principles as given in [basic.link]. Instead, it makes use of
5857 : : the fact that we have already set TREE_PUBLIC appropriately, and
5858 : : then handles a few special cases. Ideally, we would calculate
5859 : : linkage first, and then transform that into a concrete
5860 : : implementation. */
5861 : :
5862 : : /* Things that don't have names have no linkage. */
5863 : 382587901 : if (!DECL_NAME (decl))
5864 : : return lk_none;
5865 : :
5866 : : /* Fields have no linkage. */
5867 : 379067766 : if (TREE_CODE (decl) == FIELD_DECL)
5868 : : return lk_none;
5869 : :
5870 : : /* Things in local scope do not have linkage. */
5871 : 379067763 : if (decl_function_context (decl))
5872 : : return lk_none;
5873 : :
5874 : : /* Things that are TREE_PUBLIC have external linkage. */
5875 : 376547627 : if (TREE_PUBLIC (decl))
5876 : : return lk_external;
5877 : :
5878 : : /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5879 : : check one of the "clones" for the real linkage. */
5880 : 244098531 : if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)
5881 : 1511 : && DECL_CHAIN (decl)
5882 : 122049937 : && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)))
5883 : 36 : return decl_linkage (DECL_CHAIN (decl));
5884 : :
5885 : 122049865 : if (TREE_CODE (decl) == NAMESPACE_DECL)
5886 : 184147 : return lk_external;
5887 : :
5888 : : /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5889 : : type. */
5890 : : if (TREE_CODE (decl) == CONST_DECL)
5891 : 0 : return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
5892 : :
5893 : : /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5894 : : are considered to have external linkage for language purposes, as do
5895 : : template instantiations on targets without weak symbols. DECLs really
5896 : : meant to have internal linkage have DECL_THIS_STATIC set. */
5897 : : if (TREE_CODE (decl) == TYPE_DECL)
5898 : 905410 : return lk_external;
5899 : : if (VAR_OR_FUNCTION_DECL_P (decl))
5900 : : {
5901 : 75878897 : if (!DECL_THIS_STATIC (decl))
5902 : : return lk_external;
5903 : :
5904 : : /* Static data members and static member functions from classes
5905 : : in anonymous namespace also don't have TREE_PUBLIC set. */
5906 : 356149 : if (DECL_CLASS_CONTEXT (decl))
5907 : 8474 : return lk_external;
5908 : : }
5909 : :
5910 : : /* Everything else has internal linkage. */
5911 : : return lk_internal;
5912 : : }
5913 : :
5914 : : /* Returns the storage duration of the object or reference associated with
5915 : : the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5916 : :
5917 : : duration_kind
5918 : 40860946 : decl_storage_duration (tree decl)
5919 : : {
5920 : 40860946 : if (TREE_CODE (decl) == PARM_DECL)
5921 : : return dk_auto;
5922 : 40860946 : if (TREE_CODE (decl) == FUNCTION_DECL)
5923 : : return dk_static;
5924 : 40860946 : gcc_assert (VAR_P (decl));
5925 : 40860946 : if (!TREE_STATIC (decl)
5926 : 40860946 : && !DECL_EXTERNAL (decl))
5927 : : return dk_auto;
5928 : 19321623 : if (CP_DECL_THREAD_LOCAL_P (decl))
5929 : 20371 : return dk_thread;
5930 : : return dk_static;
5931 : : }
5932 : :
5933 : : /* EXP is an expression that we want to pre-evaluate. Returns (in
5934 : : *INITP) an expression that will perform the pre-evaluation. The
5935 : : value returned by this function is a side-effect free expression
5936 : : equivalent to the pre-evaluated expression. Callers must ensure
5937 : : that *INITP is evaluated before EXP.
5938 : :
5939 : : Note that if EXPR is a glvalue, the return value is a glvalue denoting the
5940 : : same address; this function does not guard against modification of the
5941 : : stored value like save_expr or get_target_expr do. */
5942 : :
5943 : : tree
5944 : 4304853 : stabilize_expr (tree exp, tree* initp)
5945 : : {
5946 : 4304853 : tree init_expr;
5947 : :
5948 : 4304853 : if (!TREE_SIDE_EFFECTS (exp))
5949 : : init_expr = NULL_TREE;
5950 : 480435 : else if (VOID_TYPE_P (TREE_TYPE (exp)))
5951 : : {
5952 : 0 : init_expr = exp;
5953 : 0 : exp = void_node;
5954 : : }
5955 : : /* There are no expressions with REFERENCE_TYPE, but there can be call
5956 : : arguments with such a type; just treat it as a pointer. */
5957 : 480435 : else if (TYPE_REF_P (TREE_TYPE (exp))
5958 : 480329 : || SCALAR_TYPE_P (TREE_TYPE (exp))
5959 : 480481 : || !glvalue_p (exp))
5960 : : {
5961 : 480429 : init_expr = get_target_expr (exp);
5962 : 480429 : exp = TARGET_EXPR_SLOT (init_expr);
5963 : 480429 : if (CLASS_TYPE_P (TREE_TYPE (exp)))
5964 : 9 : exp = move (exp);
5965 : : else
5966 : 480420 : exp = rvalue (exp);
5967 : : }
5968 : : else
5969 : : {
5970 : 6 : bool xval = !lvalue_p (exp);
5971 : 6 : exp = cp_build_addr_expr (exp, tf_warning_or_error);
5972 : 6 : init_expr = get_target_expr (exp);
5973 : 6 : exp = TARGET_EXPR_SLOT (init_expr);
5974 : 6 : exp = cp_build_fold_indirect_ref (exp);
5975 : 6 : if (xval)
5976 : 0 : exp = move (exp);
5977 : : }
5978 : 4304853 : *initp = init_expr;
5979 : :
5980 : 4304853 : gcc_assert (!TREE_SIDE_EFFECTS (exp) || TREE_THIS_VOLATILE (exp));
5981 : 4304853 : return exp;
5982 : : }
5983 : :
5984 : : /* Add NEW_EXPR, an expression whose value we don't care about, after the
5985 : : similar expression ORIG. */
5986 : :
5987 : : tree
5988 : 451886 : add_stmt_to_compound (tree orig, tree new_expr)
5989 : : {
5990 : 451886 : if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
5991 : : return orig;
5992 : 229899 : if (!orig || !TREE_SIDE_EFFECTS (orig))
5993 : : return new_expr;
5994 : 11397 : return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
5995 : : }
5996 : :
5997 : : /* Like stabilize_expr, but for a call whose arguments we want to
5998 : : pre-evaluate. CALL is modified in place to use the pre-evaluated
5999 : : arguments, while, upon return, *INITP contains an expression to
6000 : : compute the arguments. */
6001 : :
6002 : : void
6003 : 219066 : stabilize_call (tree call, tree *initp)
6004 : : {
6005 : 219066 : tree inits = NULL_TREE;
6006 : 219066 : int i;
6007 : 219066 : int nargs = call_expr_nargs (call);
6008 : :
6009 : 219066 : if (call == error_mark_node || processing_template_decl)
6010 : : {
6011 : 31 : *initp = NULL_TREE;
6012 : 31 : return;
6013 : : }
6014 : :
6015 : 219035 : gcc_assert (TREE_CODE (call) == CALL_EXPR);
6016 : :
6017 : 657159 : for (i = 0; i < nargs; i++)
6018 : : {
6019 : 438124 : tree init;
6020 : 438124 : CALL_EXPR_ARG (call, i) =
6021 : 438124 : stabilize_expr (CALL_EXPR_ARG (call, i), &init);
6022 : 438124 : inits = add_stmt_to_compound (inits, init);
6023 : : }
6024 : :
6025 : 219035 : *initp = inits;
6026 : : }
6027 : :
6028 : : /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
6029 : : to pre-evaluate. CALL is modified in place to use the pre-evaluated
6030 : : arguments, while, upon return, *INITP contains an expression to
6031 : : compute the arguments. */
6032 : :
6033 : : static void
6034 : 0 : stabilize_aggr_init (tree call, tree *initp)
6035 : : {
6036 : 0 : tree inits = NULL_TREE;
6037 : 0 : int i;
6038 : 0 : int nargs = aggr_init_expr_nargs (call);
6039 : :
6040 : 0 : if (call == error_mark_node)
6041 : : return;
6042 : :
6043 : 0 : gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
6044 : :
6045 : 0 : for (i = 0; i < nargs; i++)
6046 : : {
6047 : 0 : tree init;
6048 : 0 : AGGR_INIT_EXPR_ARG (call, i) =
6049 : 0 : stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
6050 : 0 : inits = add_stmt_to_compound (inits, init);
6051 : : }
6052 : :
6053 : 0 : *initp = inits;
6054 : : }
6055 : :
6056 : : /* Like stabilize_expr, but for an initialization.
6057 : :
6058 : : If the initialization is for an object of class type, this function
6059 : : takes care not to introduce additional temporaries.
6060 : :
6061 : : Returns TRUE iff the expression was successfully pre-evaluated,
6062 : : i.e., if INIT is now side-effect free, except for, possibly, a
6063 : : single call to a constructor. */
6064 : :
6065 : : bool
6066 : 0 : stabilize_init (tree init, tree *initp)
6067 : : {
6068 : 0 : tree t = init;
6069 : :
6070 : 0 : *initp = NULL_TREE;
6071 : :
6072 : 0 : if (t == error_mark_node || processing_template_decl)
6073 : : return true;
6074 : :
6075 : 0 : if (TREE_CODE (t) == INIT_EXPR)
6076 : 0 : t = TREE_OPERAND (t, 1);
6077 : 0 : if (TREE_CODE (t) == TARGET_EXPR)
6078 : 0 : t = TARGET_EXPR_INITIAL (t);
6079 : :
6080 : : /* If the RHS can be stabilized without breaking copy elision, stabilize
6081 : : it. We specifically don't stabilize class prvalues here because that
6082 : : would mean an extra copy, but they might be stabilized below. */
6083 : 0 : if (TREE_CODE (init) == INIT_EXPR
6084 : 0 : && TREE_CODE (t) != CONSTRUCTOR
6085 : 0 : && TREE_CODE (t) != AGGR_INIT_EXPR
6086 : 0 : && (SCALAR_TYPE_P (TREE_TYPE (t))
6087 : 0 : || glvalue_p (t)))
6088 : : {
6089 : 0 : TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
6090 : 0 : return true;
6091 : : }
6092 : :
6093 : 0 : if (TREE_CODE (t) == COMPOUND_EXPR
6094 : 0 : && TREE_CODE (init) == INIT_EXPR)
6095 : : {
6096 : 0 : tree last = expr_last (t);
6097 : : /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
6098 : 0 : if (!TREE_SIDE_EFFECTS (last))
6099 : : {
6100 : 0 : *initp = t;
6101 : 0 : TREE_OPERAND (init, 1) = last;
6102 : 0 : return true;
6103 : : }
6104 : : }
6105 : :
6106 : 0 : if (TREE_CODE (t) == CONSTRUCTOR)
6107 : : {
6108 : : /* Aggregate initialization: stabilize each of the field
6109 : : initializers. */
6110 : 0 : unsigned i;
6111 : 0 : constructor_elt *ce;
6112 : 0 : bool good = true;
6113 : 0 : vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
6114 : 0 : for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
6115 : : {
6116 : 0 : tree type = TREE_TYPE (ce->value);
6117 : 0 : tree subinit;
6118 : 0 : if (TYPE_REF_P (type)
6119 : 0 : || SCALAR_TYPE_P (type))
6120 : 0 : ce->value = stabilize_expr (ce->value, &subinit);
6121 : 0 : else if (!stabilize_init (ce->value, &subinit))
6122 : 0 : good = false;
6123 : 0 : *initp = add_stmt_to_compound (*initp, subinit);
6124 : : }
6125 : 0 : return good;
6126 : : }
6127 : :
6128 : 0 : if (TREE_CODE (t) == CALL_EXPR)
6129 : : {
6130 : 0 : stabilize_call (t, initp);
6131 : 0 : return true;
6132 : : }
6133 : :
6134 : 0 : if (TREE_CODE (t) == AGGR_INIT_EXPR)
6135 : : {
6136 : 0 : stabilize_aggr_init (t, initp);
6137 : 0 : return true;
6138 : : }
6139 : :
6140 : : /* The initialization is being performed via a bitwise copy -- and
6141 : : the item copied may have side effects. */
6142 : 0 : return !TREE_SIDE_EFFECTS (init);
6143 : : }
6144 : :
6145 : : /* Returns true if a cast to TYPE may appear in an integral constant
6146 : : expression. */
6147 : :
6148 : : bool
6149 : 78808574 : cast_valid_in_integral_constant_expression_p (tree type)
6150 : : {
6151 : 78808574 : return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
6152 : 58611169 : || cxx_dialect >= cxx11
6153 : 327770 : || dependent_type_p (type)
6154 : 79032809 : || type == error_mark_node);
6155 : : }
6156 : :
6157 : : /* Return true if we need to fix linkage information of DECL. */
6158 : :
6159 : : static bool
6160 : 2100992 : cp_fix_function_decl_p (tree decl)
6161 : : {
6162 : : /* Skip if DECL is not externally visible. */
6163 : 2100992 : if (!TREE_PUBLIC (decl))
6164 : : return false;
6165 : :
6166 : : /* We need to fix DECL if it a appears to be exported but with no
6167 : : function body. Thunks do not have CFGs and we may need to
6168 : : handle them specially later. */
6169 : 2098699 : if (!gimple_has_body_p (decl)
6170 : 2055930 : && !DECL_THUNK_P (decl)
6171 : 4154098 : && !DECL_EXTERNAL (decl))
6172 : : {
6173 : 11665 : struct cgraph_node *node = cgraph_node::get (decl);
6174 : :
6175 : : /* Don't fix same_body aliases. Although they don't have their own
6176 : : CFG, they share it with what they alias to. */
6177 : 11665 : if (!node || !node->alias || !node->num_references ())
6178 : : return true;
6179 : : }
6180 : :
6181 : : return false;
6182 : : }
6183 : :
6184 : : /* Clean the C++ specific parts of the tree T. */
6185 : :
6186 : : void
6187 : 3618863 : cp_free_lang_data (tree t)
6188 : : {
6189 : 3618863 : if (FUNC_OR_METHOD_TYPE_P (t))
6190 : : {
6191 : : /* Default args are not interesting anymore. */
6192 : 684456 : tree argtypes = TYPE_ARG_TYPES (t);
6193 : 2555185 : while (argtypes)
6194 : : {
6195 : 1870729 : TREE_PURPOSE (argtypes) = 0;
6196 : 1870729 : argtypes = TREE_CHAIN (argtypes);
6197 : : }
6198 : : }
6199 : 2934407 : else if (TREE_CODE (t) == FUNCTION_DECL
6200 : 2934407 : && cp_fix_function_decl_p (t))
6201 : : {
6202 : : /* If T is used in this translation unit at all, the definition
6203 : : must exist somewhere else since we have decided to not emit it
6204 : : in this TU. So make it an external reference. */
6205 : 6021 : DECL_EXTERNAL (t) = 1;
6206 : 6021 : TREE_STATIC (t) = 0;
6207 : : }
6208 : 3618863 : if (TREE_CODE (t) == NAMESPACE_DECL)
6209 : : /* We do not need the leftover chaining of namespaces from the
6210 : : binding level. */
6211 : 3595 : DECL_CHAIN (t) = NULL_TREE;
6212 : 3618863 : }
6213 : :
6214 : : /* Stub for c-common. Please keep in sync with c-decl.cc.
6215 : : FIXME: If address space support is target specific, then this
6216 : : should be a C target hook. But currently this is not possible,
6217 : : because this function is called via REGISTER_TARGET_PRAGMAS. */
6218 : : void
6219 : 184138 : c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
6220 : : {
6221 : 184138 : }
6222 : :
6223 : : /* Return the number of operands in T that we care about for things like
6224 : : mangling. */
6225 : :
6226 : : int
6227 : 1833441410 : cp_tree_operand_length (const_tree t)
6228 : : {
6229 : 1833441410 : enum tree_code code = TREE_CODE (t);
6230 : :
6231 : 1833441410 : if (TREE_CODE_CLASS (code) == tcc_vl_exp)
6232 : 20309909 : return VL_EXP_OPERAND_LENGTH (t);
6233 : :
6234 : 1813131501 : return cp_tree_code_length (code);
6235 : : }
6236 : :
6237 : : /* Like cp_tree_operand_length, but takes a tree_code CODE. */
6238 : :
6239 : : int
6240 : 1816726956 : cp_tree_code_length (enum tree_code code)
6241 : : {
6242 : 1816726956 : gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
6243 : :
6244 : 1816726956 : switch (code)
6245 : : {
6246 : : case PREINCREMENT_EXPR:
6247 : : case PREDECREMENT_EXPR:
6248 : : case POSTINCREMENT_EXPR:
6249 : : case POSTDECREMENT_EXPR:
6250 : : return 1;
6251 : :
6252 : 245728 : case ARRAY_REF:
6253 : 245728 : return 2;
6254 : :
6255 : : case EXPR_PACK_EXPANSION:
6256 : : return 1;
6257 : :
6258 : 1814671526 : default:
6259 : 1814671526 : return TREE_CODE_LENGTH (code);
6260 : : }
6261 : : }
6262 : :
6263 : : /* Implement -Wzero_as_null_pointer_constant. Return true if the
6264 : : conditions for the warning hold, false otherwise. */
6265 : : bool
6266 : 5274450 : maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
6267 : : {
6268 : 5274450 : if (c_inhibit_evaluation_warnings == 0
6269 : 10054121 : && !null_node_p (expr) && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
6270 : : {
6271 : 2032405 : warning_at (loc, OPT_Wzero_as_null_pointer_constant,
6272 : : "zero as null pointer constant");
6273 : 2032405 : return true;
6274 : : }
6275 : : return false;
6276 : : }
6277 : :
6278 : : /* FNDECL is a function declaration whose type may have been altered by
6279 : : adding extra parameters such as this, in-charge, or VTT. When this
6280 : : takes place, the positional arguments supplied by the user (as in the
6281 : : 'format' attribute arguments) may refer to the wrong argument. This
6282 : : function returns an integer indicating how many arguments should be
6283 : : skipped. */
6284 : :
6285 : : int
6286 : 22029490 : maybe_adjust_arg_pos_for_attribute (const_tree fndecl)
6287 : : {
6288 : 22029490 : if (!fndecl)
6289 : : return 0;
6290 : 6735469 : int n = num_artificial_parms_for (fndecl);
6291 : : /* The manual states that it's the user's responsibility to account
6292 : : for the implicit this parameter. */
6293 : 6735469 : return n > 0 ? n - 1 : 0;
6294 : : }
6295 : :
6296 : :
6297 : : /* Release memory we no longer need after parsing. */
6298 : : void
6299 : 90704 : cp_tree_c_finish_parsing ()
6300 : : {
6301 : 90704 : if (previous_class_level)
6302 : 64041 : invalidate_class_lookup_cache ();
6303 : 90704 : deleted_copy_types = NULL;
6304 : 90704 : }
6305 : :
6306 : : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6307 : : /* Complain that some language-specific thing hanging off a tree
6308 : : node has been accessed improperly. */
6309 : :
6310 : : void
6311 : 0 : lang_check_failed (const char* file, int line, const char* function)
6312 : : {
6313 : 0 : internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
6314 : : function, trim_filename (file), line);
6315 : : }
6316 : : #endif /* ENABLE_TREE_CHECKING */
6317 : :
6318 : : #if CHECKING_P
6319 : :
6320 : : namespace selftest {
6321 : :
6322 : : /* Verify that lvalue_kind () works, for various expressions,
6323 : : and that location wrappers don't affect the results. */
6324 : :
6325 : : static void
6326 : 1 : test_lvalue_kind ()
6327 : : {
6328 : 1 : location_t loc = BUILTINS_LOCATION;
6329 : :
6330 : : /* Verify constants and parameters, without and with
6331 : : location wrappers. */
6332 : 1 : tree int_cst = build_int_cst (integer_type_node, 42);
6333 : 1 : ASSERT_EQ (clk_none, lvalue_kind (int_cst));
6334 : :
6335 : 1 : tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
6336 : 1 : ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
6337 : 1 : ASSERT_EQ (clk_none, lvalue_kind (wrapped_int_cst));
6338 : :
6339 : 1 : tree string_lit = build_string (4, "foo");
6340 : 1 : TREE_TYPE (string_lit) = char_array_type_node;
6341 : 1 : string_lit = fix_string_type (string_lit);
6342 : 1 : ASSERT_EQ (clk_ordinary, lvalue_kind (string_lit));
6343 : :
6344 : 1 : tree wrapped_string_lit = maybe_wrap_with_location (string_lit, loc);
6345 : 1 : ASSERT_TRUE (location_wrapper_p (wrapped_string_lit));
6346 : 1 : ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_string_lit));
6347 : :
6348 : 1 : tree parm = build_decl (UNKNOWN_LOCATION, PARM_DECL,
6349 : : get_identifier ("some_parm"),
6350 : : integer_type_node);
6351 : 1 : ASSERT_EQ (clk_ordinary, lvalue_kind (parm));
6352 : :
6353 : 1 : tree wrapped_parm = maybe_wrap_with_location (parm, loc);
6354 : 1 : ASSERT_TRUE (location_wrapper_p (wrapped_parm));
6355 : 1 : ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_parm));
6356 : :
6357 : : /* Verify that lvalue_kind of std::move on a parm isn't
6358 : : affected by location wrappers. */
6359 : 1 : tree rvalue_ref_of_parm = move (parm);
6360 : 1 : ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_parm));
6361 : 1 : tree rvalue_ref_of_wrapped_parm = move (wrapped_parm);
6362 : 1 : ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_wrapped_parm));
6363 : :
6364 : : /* Verify lvalue_p. */
6365 : 1 : ASSERT_FALSE (lvalue_p (int_cst));
6366 : 1 : ASSERT_FALSE (lvalue_p (wrapped_int_cst));
6367 : 1 : ASSERT_TRUE (lvalue_p (parm));
6368 : 1 : ASSERT_TRUE (lvalue_p (wrapped_parm));
6369 : 1 : ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm));
6370 : 1 : ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm));
6371 : 1 : }
6372 : :
6373 : : /* Run all of the selftests within this file. */
6374 : :
6375 : : void
6376 : 1 : cp_tree_cc_tests ()
6377 : : {
6378 : 1 : test_lvalue_kind ();
6379 : 1 : }
6380 : :
6381 : : } // namespace selftest
6382 : :
6383 : : #endif /* #if CHECKING_P */
6384 : :
6385 : :
6386 : : #include "gt-cp-tree.h"
|
