Branch data Line data Source code
1 : : /* Perform the semantic phase of parsing, i.e., the process of
2 : : building tree structure, checking semantic consistency, and
3 : : building RTL. These routines are used both during actual parsing
4 : : and during the instantiation of template functions.
5 : :
6 : : Copyright (C) 1998-2024 Free Software Foundation, Inc.
7 : : Written by Mark Mitchell (mmitchell@usa.net) based on code found
8 : : formerly in parse.y and pt.cc.
9 : :
10 : : This file is part of GCC.
11 : :
12 : : GCC is free software; you can redistribute it and/or modify it
13 : : under the terms of the GNU General Public License as published by
14 : : the Free Software Foundation; either version 3, or (at your option)
15 : : any later version.
16 : :
17 : : GCC is distributed in the hope that it will be useful, but
18 : : WITHOUT ANY WARRANTY; without even the implied warranty of
19 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 : : General Public License for more details.
21 : :
22 : : You should have received a copy of the GNU General Public License
23 : : along with GCC; see the file COPYING3. If not see
24 : : <http://www.gnu.org/licenses/>. */
25 : :
26 : : #include "config.h"
27 : : #include "system.h"
28 : : #include "coretypes.h"
29 : : #include "target.h"
30 : : #include "bitmap.h"
31 : : #include "cp-tree.h"
32 : : #include "stringpool.h"
33 : : #include "cgraph.h"
34 : : #include "stmt.h"
35 : : #include "varasm.h"
36 : : #include "stor-layout.h"
37 : : #include "c-family/c-objc.h"
38 : : #include "tree-inline.h"
39 : : #include "intl.h"
40 : : #include "tree-iterator.h"
41 : : #include "omp-general.h"
42 : : #include "convert.h"
43 : : #include "stringpool.h"
44 : : #include "attribs.h"
45 : : #include "gomp-constants.h"
46 : : #include "predict.h"
47 : : #include "memmodel.h"
48 : :
49 : : /* There routines provide a modular interface to perform many parsing
50 : : operations. They may therefore be used during actual parsing, or
51 : : during template instantiation, which may be regarded as a
52 : : degenerate form of parsing. */
53 : :
54 : : static tree maybe_convert_cond (tree);
55 : : static tree finalize_nrv_r (tree *, int *, void *);
56 : :
57 : : /* Used for OpenMP non-static data member privatization. */
58 : :
59 : : static hash_map<tree, tree> *omp_private_member_map;
60 : : static vec<tree> omp_private_member_vec;
61 : : static bool omp_private_member_ignore_next;
62 : :
63 : :
64 : : /* Deferred Access Checking Overview
65 : : ---------------------------------
66 : :
67 : : Most C++ expressions and declarations require access checking
68 : : to be performed during parsing. However, in several cases,
69 : : this has to be treated differently.
70 : :
71 : : For member declarations, access checking has to be deferred
72 : : until more information about the declaration is known. For
73 : : example:
74 : :
75 : : class A {
76 : : typedef int X;
77 : : public:
78 : : X f();
79 : : };
80 : :
81 : : A::X A::f();
82 : : A::X g();
83 : :
84 : : When we are parsing the function return type `A::X', we don't
85 : : really know if this is allowed until we parse the function name.
86 : :
87 : : Furthermore, some contexts require that access checking is
88 : : never performed at all. These include class heads, and template
89 : : instantiations.
90 : :
91 : : Typical use of access checking functions is described here:
92 : :
93 : : 1. When we enter a context that requires certain access checking
94 : : mode, the function `push_deferring_access_checks' is called with
95 : : DEFERRING argument specifying the desired mode. Access checking
96 : : may be performed immediately (dk_no_deferred), deferred
97 : : (dk_deferred), or not performed (dk_no_check).
98 : :
99 : : 2. When a declaration such as a type, or a variable, is encountered,
100 : : the function `perform_or_defer_access_check' is called. It
101 : : maintains a vector of all deferred checks.
102 : :
103 : : 3. The global `current_class_type' or `current_function_decl' is then
104 : : setup by the parser. `enforce_access' relies on these information
105 : : to check access.
106 : :
107 : : 4. Upon exiting the context mentioned in step 1,
108 : : `perform_deferred_access_checks' is called to check all declaration
109 : : stored in the vector. `pop_deferring_access_checks' is then
110 : : called to restore the previous access checking mode.
111 : :
112 : : In case of parsing error, we simply call `pop_deferring_access_checks'
113 : : without `perform_deferred_access_checks'. */
114 : :
115 : : struct GTY(()) deferred_access {
116 : : /* A vector representing name-lookups for which we have deferred
117 : : checking access controls. We cannot check the accessibility of
118 : : names used in a decl-specifier-seq until we know what is being
119 : : declared because code like:
120 : :
121 : : class A {
122 : : class B {};
123 : : B* f();
124 : : }
125 : :
126 : : A::B* A::f() { return 0; }
127 : :
128 : : is valid, even though `A::B' is not generally accessible. */
129 : : vec<deferred_access_check, va_gc> *deferred_access_checks;
130 : :
131 : : /* The current mode of access checks. */
132 : : enum deferring_kind deferring_access_checks_kind;
133 : : };
134 : :
135 : : /* Data for deferred access checking. */
136 : : static GTY(()) vec<deferred_access, va_gc> *deferred_access_stack;
137 : : static GTY(()) unsigned deferred_access_no_check;
138 : :
139 : : /* Save the current deferred access states and start deferred
140 : : access checking iff DEFER_P is true. */
141 : :
142 : : void
143 : 18198617860 : push_deferring_access_checks (deferring_kind deferring)
144 : : {
145 : : /* For context like template instantiation, access checking
146 : : disabling applies to all nested context. */
147 : 18198617860 : if (deferred_access_no_check || deferring == dk_no_check)
148 : 264098117 : deferred_access_no_check++;
149 : : else
150 : : {
151 : 17934519743 : deferred_access e = {NULL, deferring};
152 : 17934519743 : vec_safe_push (deferred_access_stack, e);
153 : : }
154 : 18198617860 : }
155 : :
156 : : /* Save the current deferred access states and start deferred access
157 : : checking, continuing the set of deferred checks in CHECKS. */
158 : :
159 : : void
160 : 277423342 : reopen_deferring_access_checks (vec<deferred_access_check, va_gc> * checks)
161 : : {
162 : 277423342 : push_deferring_access_checks (dk_deferred);
163 : 277423342 : if (!deferred_access_no_check)
164 : 270890728 : deferred_access_stack->last().deferred_access_checks = checks;
165 : 277423342 : }
166 : :
167 : : /* Resume deferring access checks again after we stopped doing
168 : : this previously. */
169 : :
170 : : void
171 : 155497161 : resume_deferring_access_checks (void)
172 : : {
173 : 155497161 : if (!deferred_access_no_check)
174 : 155479444 : deferred_access_stack->last().deferring_access_checks_kind = dk_deferred;
175 : 155497161 : }
176 : :
177 : : /* Stop deferring access checks. */
178 : :
179 : : void
180 : 424883655 : stop_deferring_access_checks (void)
181 : : {
182 : 424883655 : if (!deferred_access_no_check)
183 : 424831435 : deferred_access_stack->last().deferring_access_checks_kind = dk_no_deferred;
184 : 424883655 : }
185 : :
186 : : /* Discard the current deferred access checks and restore the
187 : : previous states. */
188 : :
189 : : void
190 : 10985551009 : pop_deferring_access_checks (void)
191 : : {
192 : 10985551009 : if (deferred_access_no_check)
193 : 194510403 : deferred_access_no_check--;
194 : : else
195 : 10791040606 : deferred_access_stack->pop ();
196 : 10985551009 : }
197 : :
198 : : /* Returns a TREE_LIST representing the deferred checks.
199 : : The TREE_PURPOSE of each node is the type through which the
200 : : access occurred; the TREE_VALUE is the declaration named.
201 : : */
202 : :
203 : : vec<deferred_access_check, va_gc> *
204 : 960654028 : get_deferred_access_checks (void)
205 : : {
206 : 960654028 : if (deferred_access_no_check)
207 : : return NULL;
208 : : else
209 : 947720276 : return (deferred_access_stack->last().deferred_access_checks);
210 : : }
211 : :
212 : : /* Take current deferred checks and combine with the
213 : : previous states if we also defer checks previously.
214 : : Otherwise perform checks now. */
215 : :
216 : : void
217 : 7212937871 : pop_to_parent_deferring_access_checks (void)
218 : : {
219 : 7212937871 : if (deferred_access_no_check)
220 : 69587708 : deferred_access_no_check--;
221 : : else
222 : : {
223 : 7143350163 : vec<deferred_access_check, va_gc> *checks;
224 : 7143350163 : deferred_access *ptr;
225 : :
226 : 7143350163 : checks = (deferred_access_stack->last ().deferred_access_checks);
227 : :
228 : 7143350163 : deferred_access_stack->pop ();
229 : 7143350163 : ptr = &deferred_access_stack->last ();
230 : 7143350163 : if (ptr->deferring_access_checks_kind == dk_no_deferred)
231 : : {
232 : : /* Check access. */
233 : 452858991 : perform_access_checks (checks, tf_warning_or_error);
234 : : }
235 : : else
236 : : {
237 : : /* Merge with parent. */
238 : : int i, j;
239 : : deferred_access_check *chk, *probe;
240 : :
241 : 6847369544 : FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
242 : : {
243 : 85990077 : FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, j, probe)
244 : : {
245 : 8228203 : if (probe->binfo == chk->binfo &&
246 : 6567089 : probe->decl == chk->decl &&
247 : 677370 : probe->diag_decl == chk->diag_decl)
248 : 677312 : goto found;
249 : : }
250 : : /* Insert into parent's checks. */
251 : 77761874 : vec_safe_push (ptr->deferred_access_checks, *chk);
252 : 78439186 : found:;
253 : : }
254 : : }
255 : : }
256 : 7212937871 : }
257 : :
258 : : /* Called from enforce_access. A class has attempted (but failed) to access
259 : : DECL. It is already established that a baseclass of that class,
260 : : PARENT_BINFO, has private access to DECL. Examine certain special cases
261 : : to find a decl that accurately describes the source of the problem. If
262 : : none of the special cases apply, simply return DECL as the source of the
263 : : problem. */
264 : :
265 : : static tree
266 : 179 : get_class_access_diagnostic_decl (tree parent_binfo, tree decl)
267 : : {
268 : : /* When a class is denied access to a decl in a baseclass, most of the
269 : : time it is because the decl itself was declared as private at the point
270 : : of declaration.
271 : :
272 : : However, in C++, there are (at least) two situations in which a decl
273 : : can be private even though it was not originally defined as such.
274 : : These two situations only apply if a baseclass had private access to
275 : : DECL (this function is only called if that is the case). */
276 : :
277 : : /* We should first check whether the reason the parent had private access
278 : : to DECL was simply because DECL was created and declared as private in
279 : : the parent. If it was, then DECL is definitively the source of the
280 : : problem. */
281 : 179 : if (SAME_BINFO_TYPE_P (context_for_name_lookup (decl),
282 : : BINFO_TYPE (parent_binfo)))
283 : : return decl;
284 : :
285 : : /* 1. If the "using" keyword is used to inherit DECL within the parent,
286 : : this may cause DECL to be private, so we should return the using
287 : : statement as the source of the problem.
288 : :
289 : : Scan the fields of PARENT_BINFO and see if there are any using decls. If
290 : : there are, see if they inherit DECL. If they do, that's where DECL must
291 : : have been declared private. */
292 : :
293 : 66 : for (tree parent_field = TYPE_FIELDS (BINFO_TYPE (parent_binfo));
294 : 326 : parent_field;
295 : 260 : parent_field = DECL_CHAIN (parent_field))
296 : : /* Not necessary, but also check TREE_PRIVATE for the sake of
297 : : eliminating obviously non-relevant using decls. */
298 : 278 : if (TREE_CODE (parent_field) == USING_DECL
299 : 278 : && TREE_PRIVATE (parent_field))
300 : : {
301 : 78 : tree decl_stripped = strip_using_decl (parent_field);
302 : :
303 : : /* The using statement might be overloaded. If so, we need to
304 : : check all of the overloads. */
305 : 180 : for (ovl_iterator iter (decl_stripped); iter; ++iter)
306 : : /* If equal, the using statement inherits DECL, and so is the
307 : : source of the access failure, so return it. */
308 : 99 : if (*iter == decl)
309 : 18 : return parent_field;
310 : : }
311 : :
312 : : /* 2. If DECL was privately inherited by the parent class, then DECL will
313 : : be inaccessible, even though it may originally have been accessible to
314 : : deriving classes. In that case, the fault lies with the parent, since it
315 : : used a private inheritance, so we return the parent as the source of the
316 : : problem.
317 : :
318 : : Since this is the last check, we just assume it's true. At worst, it
319 : : will simply point to the class that failed to give access, which is
320 : : technically true. */
321 : 48 : return TYPE_NAME (BINFO_TYPE (parent_binfo));
322 : : }
323 : :
324 : : /* If the current scope isn't allowed to access DECL along
325 : : BASETYPE_PATH, give an error, or if we're parsing a function or class
326 : : template, defer the access check to be performed at instantiation time.
327 : : The most derived class in BASETYPE_PATH is the one used to qualify DECL.
328 : : DIAG_DECL is the declaration to use in the error diagnostic. */
329 : :
330 : : static bool
331 : 265860581 : enforce_access (tree basetype_path, tree decl, tree diag_decl,
332 : : tsubst_flags_t complain, access_failure_info *afi = NULL)
333 : : {
334 : 265860581 : gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
335 : :
336 : 265860581 : if (flag_new_inheriting_ctors
337 : 344243006 : && DECL_INHERITED_CTOR (decl))
338 : : {
339 : : /* 7.3.3/18: The additional constructors are accessible if they would be
340 : : accessible when used to construct an object of the corresponding base
341 : : class. */
342 : 37074 : decl = strip_inheriting_ctors (decl);
343 : 37074 : basetype_path = lookup_base (basetype_path, DECL_CONTEXT (decl),
344 : : ba_any, NULL, complain);
345 : : }
346 : :
347 : 265860581 : tree cs = current_scope ();
348 : 265860581 : if (in_template_context
349 : 265860581 : && (CLASS_TYPE_P (cs) || TREE_CODE (cs) == FUNCTION_DECL))
350 : 36077307 : if (tree template_info = get_template_info (cs))
351 : : {
352 : : /* When parsing a function or class template, we in general need to
353 : : defer access checks until template instantiation time, since a friend
354 : : declaration may grant access only to a particular specialization of
355 : : the template. */
356 : :
357 : 35869469 : if (accessible_p (basetype_path, decl, /*consider_local_p=*/true))
358 : : /* But if the member is deemed accessible at parse time, then we can
359 : : assume it'll be accessible at instantiation time. */
360 : : return true;
361 : :
362 : : /* Access of a dependent decl should be rechecked after tsubst'ing
363 : : into the user of the decl, rather than explicitly deferring the
364 : : check here. */
365 : 141 : gcc_assert (!uses_template_parms (decl));
366 : 141 : if (TREE_CODE (decl) == FIELD_DECL)
367 : 6 : gcc_assert (!uses_template_parms (DECL_CONTEXT (decl)));
368 : :
369 : : /* Defer this access check until instantiation time. */
370 : 141 : deferred_access_check access_check;
371 : 141 : access_check.binfo = basetype_path;
372 : 141 : access_check.decl = decl;
373 : 141 : access_check.diag_decl = diag_decl;
374 : 141 : access_check.loc = input_location;
375 : 141 : vec_safe_push (TI_DEFERRED_ACCESS_CHECKS (template_info), access_check);
376 : 141 : return true;
377 : : }
378 : :
379 : 229991112 : if (!accessible_p (basetype_path, decl, /*consider_local_p=*/true))
380 : : {
381 : 22064 : if (flag_new_inheriting_ctors)
382 : 22034 : diag_decl = strip_inheriting_ctors (diag_decl);
383 : 22064 : if (complain & tf_error)
384 : : {
385 : 1105 : access_kind access_failure_reason = ak_none;
386 : :
387 : : /* By default, using the decl as the source of the problem will
388 : : usually give correct results. */
389 : 1105 : tree diag_location = diag_decl;
390 : :
391 : : /* However, if a parent of BASETYPE_PATH had private access to decl,
392 : : then it actually might be the case that the source of the problem
393 : : is not DECL. */
394 : 1105 : tree parent_binfo = get_parent_with_private_access (decl,
395 : : basetype_path);
396 : :
397 : : /* So if a parent did have private access, then we need to do
398 : : special checks to obtain the best diagnostic location decl. */
399 : 1105 : if (parent_binfo != NULL_TREE)
400 : : {
401 : 179 : diag_location = get_class_access_diagnostic_decl (parent_binfo,
402 : : diag_decl);
403 : :
404 : : /* We also at this point know that the reason access failed was
405 : : because decl was private. */
406 : 179 : access_failure_reason = ak_private;
407 : : }
408 : :
409 : : /* Finally, generate an error message. */
410 : 1105 : complain_about_access (decl, diag_decl, diag_location, true,
411 : : access_failure_reason);
412 : : }
413 : 22064 : if (afi)
414 : 406 : afi->record_access_failure (basetype_path, decl, diag_decl);
415 : 22064 : return false;
416 : : }
417 : :
418 : : return true;
419 : : }
420 : :
421 : : /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
422 : : is the BINFO indicating the qualifying scope used to access the
423 : : DECL node stored in the TREE_VALUE of the node. If CHECKS is empty
424 : : or we aren't in SFINAE context or all the checks succeed return TRUE,
425 : : otherwise FALSE. */
426 : :
427 : : bool
428 : 844995605 : perform_access_checks (vec<deferred_access_check, va_gc> *checks,
429 : : tsubst_flags_t complain)
430 : : {
431 : 844995605 : int i;
432 : 844995605 : deferred_access_check *chk;
433 : 844995605 : location_t loc = input_location;
434 : 844995605 : bool ok = true;
435 : :
436 : 844995605 : if (!checks)
437 : : return true;
438 : :
439 : 92442627 : FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
440 : : {
441 : 52305566 : input_location = chk->loc;
442 : 52305566 : ok &= enforce_access (chk->binfo, chk->decl, chk->diag_decl, complain);
443 : : }
444 : :
445 : 40137061 : input_location = loc;
446 : 40137061 : return (complain & tf_error) ? true : ok;
447 : : }
448 : :
449 : : /* Perform the deferred access checks.
450 : :
451 : : After performing the checks, we still have to keep the list
452 : : `deferred_access_stack->deferred_access_checks' since we may want
453 : : to check access for them again later in a different context.
454 : : For example:
455 : :
456 : : class A {
457 : : typedef int X;
458 : : static X a;
459 : : };
460 : : A::X A::a, x; // No error for `A::a', error for `x'
461 : :
462 : : We have to perform deferred access of `A::X', first with `A::a',
463 : : next with `x'. Return value like perform_access_checks above. */
464 : :
465 : : bool
466 : 215584279 : perform_deferred_access_checks (tsubst_flags_t complain)
467 : : {
468 : 215584279 : return perform_access_checks (get_deferred_access_checks (), complain);
469 : : }
470 : :
471 : : /* Defer checking the accessibility of DECL, when looked up in
472 : : BINFO. DIAG_DECL is the declaration to use to print diagnostics.
473 : : Return value like perform_access_checks above.
474 : : If non-NULL, report failures to AFI. */
475 : :
476 : : bool
477 : 419979542 : perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl,
478 : : tsubst_flags_t complain,
479 : : access_failure_info *afi)
480 : : {
481 : 419979542 : int i;
482 : 419979542 : deferred_access *ptr;
483 : 419979542 : deferred_access_check *chk;
484 : :
485 : : /* Exit if we are in a context that no access checking is performed. */
486 : 419979542 : if (deferred_access_no_check)
487 : : return true;
488 : :
489 : 400510791 : gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
490 : :
491 : 400510791 : ptr = &deferred_access_stack->last ();
492 : :
493 : : /* If we are not supposed to defer access checks, just check now. */
494 : 400510791 : if (ptr->deferring_access_checks_kind == dk_no_deferred)
495 : : {
496 : 213555015 : bool ok = enforce_access (binfo, decl, diag_decl, complain, afi);
497 : 356781470 : return (complain & tf_error) ? true : ok;
498 : : }
499 : :
500 : : /* See if we are already going to perform this check. */
501 : 224283290 : FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, i, chk)
502 : : {
503 : 48825626 : if (chk->decl == decl && chk->binfo == binfo &&
504 : 11498280 : chk->diag_decl == diag_decl)
505 : : {
506 : : return true;
507 : : }
508 : : }
509 : : /* If not, record the check. */
510 : 175457664 : deferred_access_check new_access = {binfo, decl, diag_decl, input_location};
511 : 175457664 : vec_safe_push (ptr->deferred_access_checks, new_access);
512 : :
513 : 175457664 : return true;
514 : : }
515 : :
516 : : /* Returns nonzero if the current statement is a full expression,
517 : : i.e. temporaries created during that statement should be destroyed
518 : : at the end of the statement. */
519 : :
520 : : int
521 : 1062480549 : stmts_are_full_exprs_p (void)
522 : : {
523 : 1062480549 : return current_stmt_tree ()->stmts_are_full_exprs_p;
524 : : }
525 : :
526 : : /* T is a statement. Add it to the statement-tree. This is the C++
527 : : version. The C/ObjC frontends have a slightly different version of
528 : : this function. */
529 : :
530 : : tree
531 : 977490541 : add_stmt (tree t)
532 : : {
533 : 977490541 : enum tree_code code = TREE_CODE (t);
534 : :
535 : 977490541 : if (EXPR_P (t) && code != LABEL_EXPR)
536 : : {
537 : 937428712 : if (!EXPR_HAS_LOCATION (t))
538 : 157103312 : SET_EXPR_LOCATION (t, input_location);
539 : :
540 : : /* When we expand a statement-tree, we must know whether or not the
541 : : statements are full-expressions. We record that fact here. */
542 : 937428712 : if (STATEMENT_CODE_P (TREE_CODE (t)))
543 : 239308479 : STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
544 : : }
545 : :
546 : 977490541 : if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
547 : 3091231 : STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
548 : :
549 : : /* Add T to the statement-tree. Non-side-effect statements need to be
550 : : recorded during statement expressions. */
551 : 977490541 : gcc_checking_assert (!stmt_list_stack->is_empty ());
552 : 977490541 : append_to_statement_list_force (t, &cur_stmt_list);
553 : :
554 : 977490541 : return t;
555 : : }
556 : :
557 : : /* Returns the stmt_tree to which statements are currently being added. */
558 : :
559 : : stmt_tree
560 : 5719928758 : current_stmt_tree (void)
561 : : {
562 : 5719928758 : return (cfun
563 : 5706099179 : ? &cfun->language->base.x_stmt_tree
564 : 5719928758 : : &scope_chain->x_stmt_tree);
565 : : }
566 : :
567 : : /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
568 : :
569 : : static tree
570 : 289977 : maybe_cleanup_point_expr (tree expr)
571 : : {
572 : 289977 : if (!processing_template_decl && stmts_are_full_exprs_p ())
573 : 283321 : expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
574 : 289977 : return expr;
575 : : }
576 : :
577 : : /* Like maybe_cleanup_point_expr except have the type of the new expression be
578 : : void so we don't need to create a temporary variable to hold the inner
579 : : expression. The reason why we do this is because the original type might be
580 : : an aggregate and we cannot create a temporary variable for that type. */
581 : :
582 : : tree
583 : 241447355 : maybe_cleanup_point_expr_void (tree expr)
584 : : {
585 : 241447355 : if (!processing_template_decl && stmts_are_full_exprs_p ())
586 : 88971280 : expr = fold_build_cleanup_point_expr (void_type_node, expr);
587 : 241447355 : return expr;
588 : : }
589 : :
590 : :
591 : :
592 : : /* Create a declaration statement for the declaration given by the DECL. */
593 : :
594 : : void
595 : 78021401 : add_decl_expr (tree decl)
596 : : {
597 : 78021401 : tree r = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
598 : 78021401 : if (DECL_INITIAL (decl)
599 : 78021401 : || (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
600 : 6082305 : r = maybe_cleanup_point_expr_void (r);
601 : 78021401 : add_stmt (r);
602 : 78021401 : }
603 : :
604 : : /* Set EXPR_LOCATION of the cleanups of any CLEANUP_STMT in STMTS to LOC. */
605 : :
606 : : static void
607 : 924302559 : set_cleanup_locs (tree stmts, location_t loc)
608 : : {
609 : 929348825 : if (TREE_CODE (stmts) == CLEANUP_STMT)
610 : : {
611 : 5046266 : tree t = CLEANUP_EXPR (stmts);
612 : 5046266 : if (t && TREE_CODE (t) != POSTCONDITION_STMT)
613 : 5046266 : protected_set_expr_location (t, loc);
614 : : /* Avoid locus differences for C++ cdtor calls depending on whether
615 : : cdtor_returns_this: a conversion to void is added to discard the return
616 : : value, and this conversion ends up carrying the location, and when it
617 : : gets discarded, the location is lost. So hold it in the call as
618 : : well. */
619 : 5046266 : if (TREE_CODE (t) == NOP_EXPR
620 : 0 : && TREE_TYPE (t) == void_type_node
621 : 5046266 : && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR)
622 : 0 : protected_set_expr_location (TREE_OPERAND (t, 0), loc);
623 : 5046266 : set_cleanup_locs (CLEANUP_BODY (stmts), loc);
624 : : }
625 : 924302559 : else if (TREE_CODE (stmts) == STATEMENT_LIST)
626 : 828381267 : for (tree stmt : tsi_range (stmts))
627 : 636602457 : set_cleanup_locs (stmt, loc);
628 : 924302559 : }
629 : :
630 : : /* True iff the innermost block scope is a try block. */
631 : :
632 : : static bool
633 : 287700102 : at_try_scope ()
634 : : {
635 : 287700102 : cp_binding_level *b = current_binding_level;
636 : 287700552 : while (b && b->kind == sk_cleanup)
637 : 450 : b = b->level_chain;
638 : 287700102 : return b && b->kind == sk_try;
639 : : }
640 : :
641 : : /* Finish a scope. */
642 : :
643 : : tree
644 : 287700102 : do_poplevel (tree stmt_list)
645 : : {
646 : 287700102 : tree block = NULL;
647 : :
648 : 287700102 : bool was_try = at_try_scope ();
649 : :
650 : 287700102 : if (stmts_are_full_exprs_p ())
651 : 287681894 : block = poplevel (kept_level_p (), 1, 0);
652 : :
653 : : /* This needs to come after poplevel merges sk_cleanup statement_lists. */
654 : 287700102 : maybe_splice_retval_cleanup (stmt_list, was_try);
655 : :
656 : 287700102 : stmt_list = pop_stmt_list (stmt_list);
657 : :
658 : : /* input_location is the last token of the scope, usually a }. */
659 : 287700102 : set_cleanup_locs (stmt_list, input_location);
660 : :
661 : 287700102 : if (!processing_template_decl)
662 : : {
663 : 88454766 : stmt_list = c_build_bind_expr (input_location, block, stmt_list);
664 : : /* ??? See c_end_compound_stmt re statement expressions. */
665 : : }
666 : :
667 : 287700102 : return stmt_list;
668 : : }
669 : :
670 : : /* Begin a new scope. */
671 : :
672 : : static tree
673 : 287692171 : do_pushlevel (scope_kind sk)
674 : : {
675 : 287692171 : tree ret = push_stmt_list ();
676 : 287692171 : if (stmts_are_full_exprs_p ())
677 : 287681933 : begin_scope (sk, NULL);
678 : 287692171 : return ret;
679 : : }
680 : :
681 : : /* Queue a cleanup. CLEANUP is an expression/statement to be executed
682 : : when the current scope is exited. EH_ONLY is true when this is not
683 : : meant to apply to normal control flow transfer. DECL is the VAR_DECL
684 : : being cleaned up, if any, or null for temporaries or subobjects. */
685 : :
686 : : void
687 : 5046189 : push_cleanup (tree decl, tree cleanup, bool eh_only)
688 : : {
689 : 5046189 : tree stmt = build_stmt (input_location, CLEANUP_STMT, NULL, cleanup, decl);
690 : 5046189 : CLEANUP_EH_ONLY (stmt) = eh_only;
691 : 5046189 : add_stmt (stmt);
692 : 5046189 : CLEANUP_BODY (stmt) = push_stmt_list ();
693 : 5046189 : }
694 : :
695 : : /* Simple infinite loop tracking for -Wreturn-type. We keep a stack of all
696 : : the current loops, represented by 'NULL_TREE' if we've seen a possible
697 : : exit, and 'error_mark_node' if not. This is currently used only to
698 : : suppress the warning about a function with no return statements, and
699 : : therefore we don't bother noting returns as possible exits. We also
700 : : don't bother with gotos. */
701 : :
702 : : static void
703 : 14478825 : begin_maybe_infinite_loop (tree cond)
704 : : {
705 : : /* Only track this while parsing a function, not during instantiation. */
706 : 14478825 : if (!cfun || (DECL_TEMPLATE_INSTANTIATION (current_function_decl)
707 : 2054212 : && !processing_template_decl))
708 : : return;
709 : 12424110 : bool maybe_infinite = true;
710 : 12424110 : if (cond)
711 : : {
712 : 12209200 : cond = fold_non_dependent_expr (cond);
713 : 12209200 : maybe_infinite = integer_nonzerop (cond);
714 : : }
715 : 24633310 : vec_safe_push (cp_function_chain->infinite_loops,
716 : 12424110 : maybe_infinite ? error_mark_node : NULL_TREE);
717 : :
718 : : }
719 : :
720 : : /* A break is a possible exit for the current loop. */
721 : :
722 : : void
723 : 1332764 : break_maybe_infinite_loop (void)
724 : : {
725 : 1332764 : if (!cfun)
726 : : return;
727 : 1332764 : cp_function_chain->infinite_loops->last() = NULL_TREE;
728 : : }
729 : :
730 : : /* If we reach the end of the loop without seeing a possible exit, we have
731 : : an infinite loop. */
732 : :
733 : : static void
734 : 14478825 : end_maybe_infinite_loop (tree cond)
735 : : {
736 : 14478825 : if (!cfun || (DECL_TEMPLATE_INSTANTIATION (current_function_decl)
737 : 2054212 : && !processing_template_decl))
738 : : return;
739 : 12424110 : tree current = cp_function_chain->infinite_loops->pop();
740 : 12424110 : if (current != NULL_TREE)
741 : : {
742 : 3796559 : cond = fold_non_dependent_expr (cond);
743 : 3796559 : if (integer_nonzerop (cond))
744 : 199074 : current_function_infinite_loop = 1;
745 : : }
746 : : }
747 : :
748 : : /* Begin a conditional that might contain a declaration. When generating
749 : : normal code, we want the declaration to appear before the statement
750 : : containing the conditional. When generating template code, we want the
751 : : conditional to be rendered as the raw DECL_EXPR. */
752 : :
753 : : static void
754 : 63057876 : begin_cond (tree *cond_p)
755 : : {
756 : 63057876 : if (processing_template_decl)
757 : 44321093 : *cond_p = push_stmt_list ();
758 : 63057876 : }
759 : :
760 : : /* Finish such a conditional. */
761 : :
762 : : static void
763 : 63057876 : finish_cond (tree *cond_p, tree expr)
764 : : {
765 : 63057876 : if (processing_template_decl)
766 : : {
767 : 44321093 : tree cond = pop_stmt_list (*cond_p);
768 : :
769 : 44321093 : if (expr == NULL_TREE)
770 : : /* Empty condition in 'for'. */
771 : 206979 : gcc_assert (empty_expr_stmt_p (cond));
772 : 44114114 : else if (check_for_bare_parameter_packs (expr))
773 : 0 : expr = error_mark_node;
774 : 44114114 : else if (!empty_expr_stmt_p (cond))
775 : 526851 : expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), cond, expr);
776 : : }
777 : 63057876 : *cond_p = expr;
778 : 63057876 : }
779 : :
780 : : /* If *COND_P specifies a conditional with a declaration, transform the
781 : : loop such that
782 : : while (A x = 42) { }
783 : : for (; A x = 42;) { }
784 : : becomes
785 : : while (true) { A x = 42; if (!x) break; }
786 : : for (;;) { A x = 42; if (!x) break; }
787 : : The statement list for BODY will be empty if the conditional did
788 : : not declare anything. */
789 : :
790 : : static void
791 : 10025743 : simplify_loop_decl_cond (tree *cond_p, tree body)
792 : : {
793 : 10025743 : tree cond, if_stmt;
794 : :
795 : 10025743 : if (!TREE_SIDE_EFFECTS (body))
796 : 10016139 : return;
797 : :
798 : 9604 : cond = *cond_p;
799 : 9604 : *cond_p = boolean_true_node;
800 : :
801 : 9604 : if_stmt = begin_if_stmt ();
802 : 9604 : cond_p = &cond;
803 : 19214 : while (TREE_CODE (*cond_p) == ANNOTATE_EXPR)
804 : 6 : cond_p = &TREE_OPERAND (*cond_p, 0);
805 : 9604 : *cond_p = cp_build_unary_op (TRUTH_NOT_EXPR, *cond_p, false,
806 : : tf_warning_or_error);
807 : 9604 : finish_if_stmt_cond (cond, if_stmt);
808 : 9604 : finish_break_stmt ();
809 : 9604 : finish_then_clause (if_stmt);
810 : 9604 : finish_if_stmt (if_stmt);
811 : : }
812 : :
813 : : /* Finish a goto-statement. */
814 : :
815 : : tree
816 : 1485 : finish_goto_stmt (tree destination)
817 : : {
818 : 1485 : if (identifier_p (destination))
819 : 1363 : destination = lookup_label (destination);
820 : :
821 : : /* We warn about unused labels with -Wunused. That means we have to
822 : : mark the used labels as used. */
823 : 1485 : if (TREE_CODE (destination) == LABEL_DECL)
824 : 1363 : TREE_USED (destination) = 1;
825 : : else
826 : : {
827 : 122 : destination = mark_rvalue_use (destination);
828 : 122 : if (!processing_template_decl)
829 : : {
830 : 102 : destination = cp_convert (ptr_type_node, destination,
831 : : tf_warning_or_error);
832 : 102 : if (error_operand_p (destination))
833 : : return NULL_TREE;
834 : 93 : destination
835 : 93 : = fold_build_cleanup_point_expr (TREE_TYPE (destination),
836 : : destination);
837 : : }
838 : : }
839 : :
840 : 1476 : check_goto (destination);
841 : :
842 : 1476 : add_stmt (build_predict_expr (PRED_GOTO, NOT_TAKEN));
843 : 1476 : return add_stmt (build_stmt (input_location, GOTO_EXPR, destination));
844 : : }
845 : :
846 : : /* Returns true if T corresponds to an assignment operator expression. */
847 : :
848 : : static bool
849 : 739329 : is_assignment_op_expr_p (tree t)
850 : : {
851 : 739329 : if (t == NULL_TREE)
852 : : return false;
853 : :
854 : 739329 : if (TREE_CODE (t) == MODIFY_EXPR
855 : 739329 : || (TREE_CODE (t) == MODOP_EXPR
856 : 329 : && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR))
857 : : return true;
858 : :
859 : 738745 : tree call = extract_call_expr (t);
860 : 738745 : if (call == NULL_TREE
861 : 139619 : || call == error_mark_node
862 : 878364 : || !CALL_EXPR_OPERATOR_SYNTAX (call))
863 : : return false;
864 : :
865 : 4277 : tree fndecl = cp_get_callee_fndecl_nofold (call);
866 : 4277 : return fndecl != NULL_TREE
867 : 4249 : && DECL_ASSIGNMENT_OPERATOR_P (fndecl)
868 : 4328 : && DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR);
869 : : }
870 : :
871 : : /* Return true if TYPE is a class type that is convertible to
872 : : and assignable from bool. */
873 : :
874 : : static GTY((deletable)) hash_map<tree, bool> *boolish_class_type_p_cache;
875 : :
876 : : static bool
877 : 60 : boolish_class_type_p (tree type)
878 : : {
879 : 60 : type = TYPE_MAIN_VARIANT (type);
880 : 60 : if (!CLASS_TYPE_P (type) || !COMPLETE_TYPE_P (type))
881 : : return false;
882 : :
883 : 77 : if (bool *r = hash_map_safe_get (boolish_class_type_p_cache, type))
884 : 26 : return *r;
885 : :
886 : 19 : tree ops;
887 : 19 : bool has_bool_assignment = false;
888 : 19 : bool has_bool_conversion = false;
889 : :
890 : 19 : ops = lookup_fnfields (type, assign_op_identifier, /*protect=*/0, tf_none);
891 : 58 : for (tree op : ovl_range (BASELINK_FUNCTIONS (ops)))
892 : : {
893 : 31 : op = STRIP_TEMPLATE (op);
894 : 31 : if (TREE_CODE (op) != FUNCTION_DECL)
895 : 0 : continue;
896 : 31 : tree parm = DECL_CHAIN (DECL_ARGUMENTS (op));
897 : 31 : tree parm_type = non_reference (TREE_TYPE (parm));
898 : 31 : if (TREE_CODE (parm_type) == BOOLEAN_TYPE)
899 : : {
900 : : has_bool_assignment = true;
901 : : break;
902 : : }
903 : : }
904 : :
905 : 19 : if (has_bool_assignment)
906 : : {
907 : 4 : ops = lookup_conversions (type);
908 : 4 : for (; ops; ops = TREE_CHAIN (ops))
909 : : {
910 : 4 : tree op = TREE_VALUE (ops);
911 : 4 : if (!DECL_NONCONVERTING_P (op)
912 : 4 : && TREE_CODE (DECL_CONV_FN_TYPE (op)) == BOOLEAN_TYPE)
913 : : {
914 : : has_bool_conversion = true;
915 : : break;
916 : : }
917 : : }
918 : : }
919 : :
920 : 19 : bool boolish = has_bool_assignment && has_bool_conversion;
921 : 19 : hash_map_safe_put<true> (boolish_class_type_p_cache, type, boolish);
922 : 19 : return boolish;
923 : : }
924 : :
925 : :
926 : : /* Maybe warn about an unparenthesized 'a = b' (appearing in a
927 : : boolean context where 'a == b' might have been intended).
928 : : NESTED_P is true if T is the RHS of another assignment. */
929 : :
930 : : void
931 : 60270674 : maybe_warn_unparenthesized_assignment (tree t, bool nested_p,
932 : : tsubst_flags_t complain)
933 : : {
934 : 60270674 : tree type = TREE_TYPE (t);
935 : 60270674 : t = STRIP_REFERENCE_REF (t);
936 : :
937 : 60270674 : if ((complain & tf_warning)
938 : 60235656 : && warn_parentheses
939 : 739329 : && is_assignment_op_expr_p (t)
940 : : /* A parenthesized expression would've had this warning
941 : : suppressed by finish_parenthesized_expr. */
942 : 635 : && !warning_suppressed_p (t, OPT_Wparentheses)
943 : : /* In c = a = b, don't warn if a has type bool or bool-like class. */
944 : 60270925 : && (!nested_p
945 : 80 : || (TREE_CODE (type) != BOOLEAN_TYPE
946 : 60 : && !boolish_class_type_p (type))))
947 : : {
948 : 219 : warning_at (cp_expr_loc_or_input_loc (t), OPT_Wparentheses,
949 : : "suggest parentheses around assignment used as truth value");
950 : 219 : suppress_warning (t, OPT_Wparentheses);
951 : : }
952 : 60270674 : }
953 : :
954 : : /* COND is the condition-expression for an if, while, etc.,
955 : : statement. Convert it to a boolean value, if appropriate.
956 : : In addition, verify sequence points if -Wsequence-point is enabled. */
957 : :
958 : : static tree
959 : 66900228 : maybe_convert_cond (tree cond)
960 : : {
961 : : /* Empty conditions remain empty. */
962 : 66900228 : if (!cond)
963 : : return NULL_TREE;
964 : :
965 : : /* Wait until we instantiate templates before doing conversion. */
966 : 66630460 : if (type_dependent_expression_p (cond))
967 : : return cond;
968 : :
969 : : /* For structured binding used in condition, the conversion needs to be
970 : : evaluated before the individual variables are initialized in the
971 : : std::tuple_{size,elemenet} case. cp_finish_decomp saved the conversion
972 : : result in a TARGET_EXPR, pick it up from there. */
973 : 331609 : if (DECL_DECOMPOSITION_P (cond)
974 : 171 : && DECL_DECOMP_IS_BASE (cond)
975 : 171 : && DECL_DECOMP_BASE (cond)
976 : 40394972 : && TREE_CODE (DECL_DECOMP_BASE (cond)) == TARGET_EXPR)
977 : 42 : cond = TARGET_EXPR_SLOT (DECL_DECOMP_BASE (cond));
978 : :
979 : 40394804 : if (warn_sequence_point && !processing_template_decl)
980 : 304188 : verify_sequence_points (cond);
981 : :
982 : 40394804 : maybe_warn_unparenthesized_assignment (cond, /*nested_p=*/false,
983 : : tf_warning_or_error);
984 : :
985 : : /* Do the conversion. */
986 : 40394804 : cond = convert_from_reference (cond);
987 : 40394804 : return condition_conversion (cond);
988 : : }
989 : :
990 : : /* Finish an expression-statement, whose EXPRESSION is as indicated. */
991 : :
992 : : tree
993 : 132380432 : finish_expr_stmt (tree expr)
994 : : {
995 : 132380432 : tree r = NULL_TREE;
996 : 132380432 : location_t loc = EXPR_LOCATION (expr);
997 : :
998 : 132197942 : if (expr != NULL_TREE)
999 : : {
1000 : : /* If we ran into a problem, make sure we complained. */
1001 : 132379677 : gcc_assert (expr != error_mark_node || seen_error ());
1002 : :
1003 : 132379677 : if (!processing_template_decl)
1004 : : {
1005 : 51936417 : if (warn_sequence_point)
1006 : 799178 : verify_sequence_points (expr);
1007 : 51936417 : expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
1008 : : }
1009 : 80443260 : else if (!type_dependent_expression_p (expr))
1010 : 17231357 : convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
1011 : :
1012 : 132379674 : if (check_for_bare_parameter_packs (expr))
1013 : 24 : expr = error_mark_node;
1014 : :
1015 : : /* Simplification of inner statement expressions, compound exprs,
1016 : : etc can result in us already having an EXPR_STMT. */
1017 : 132379674 : if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1018 : : {
1019 : 132379501 : if (TREE_CODE (expr) != EXPR_STMT)
1020 : 130737972 : expr = build_stmt (loc, EXPR_STMT, expr);
1021 : 132379501 : expr = maybe_cleanup_point_expr_void (expr);
1022 : : }
1023 : :
1024 : 132379674 : r = add_stmt (expr);
1025 : : }
1026 : :
1027 : 132380429 : return r;
1028 : : }
1029 : :
1030 : :
1031 : : /* Begin an if-statement. Returns a newly created IF_STMT if
1032 : : appropriate. */
1033 : :
1034 : : tree
1035 : 52614567 : begin_if_stmt (void)
1036 : : {
1037 : 52614567 : tree r, scope;
1038 : 52614567 : scope = do_pushlevel (sk_cond);
1039 : 52614567 : r = build_stmt (input_location, IF_STMT, NULL_TREE,
1040 : : NULL_TREE, NULL_TREE, scope);
1041 : 52614567 : current_binding_level->this_entity = r;
1042 : 52614567 : begin_cond (&IF_COND (r));
1043 : 52614567 : return r;
1044 : : }
1045 : :
1046 : : /* Returns true if FN, a CALL_EXPR, is a call to
1047 : : std::is_constant_evaluated or __builtin_is_constant_evaluated. */
1048 : :
1049 : : static bool
1050 : 228076 : is_std_constant_evaluated_p (tree fn)
1051 : : {
1052 : : /* std::is_constant_evaluated takes no arguments. */
1053 : 228076 : if (call_expr_nargs (fn) != 0)
1054 : : return false;
1055 : :
1056 : 76573 : tree fndecl = cp_get_callee_fndecl_nofold (fn);
1057 : 76573 : if (fndecl == NULL_TREE)
1058 : : return false;
1059 : :
1060 : 18817 : if (fndecl_built_in_p (fndecl, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
1061 : : BUILT_IN_FRONTEND))
1062 : : return true;
1063 : :
1064 : 18792 : if (!decl_in_std_namespace_p (fndecl))
1065 : : return false;
1066 : :
1067 : 6195 : tree name = DECL_NAME (fndecl);
1068 : 6195 : return name && id_equal (name, "is_constant_evaluated");
1069 : : }
1070 : :
1071 : : /* Callback function for maybe_warn_for_constant_evaluated that looks
1072 : : for calls to std::is_constant_evaluated in TP. */
1073 : :
1074 : : static tree
1075 : 4240482 : find_std_constant_evaluated_r (tree *tp, int *walk_subtrees, void *)
1076 : : {
1077 : 4240482 : tree t = *tp;
1078 : :
1079 : 4240482 : if (TYPE_P (t) || TREE_CONSTANT (t))
1080 : : {
1081 : 732586 : *walk_subtrees = false;
1082 : 732586 : return NULL_TREE;
1083 : : }
1084 : :
1085 : 3507896 : switch (TREE_CODE (t))
1086 : : {
1087 : 228076 : case CALL_EXPR:
1088 : 228076 : if (is_std_constant_evaluated_p (t))
1089 : : return t;
1090 : : break;
1091 : 6 : case EXPR_STMT:
1092 : : /* Don't warn in statement expressions. */
1093 : 6 : *walk_subtrees = false;
1094 : 6 : return NULL_TREE;
1095 : : default:
1096 : : break;
1097 : : }
1098 : :
1099 : : return NULL_TREE;
1100 : : }
1101 : :
1102 : : /* In certain contexts, std::is_constant_evaluated() is always true (for
1103 : : instance, in a consteval function or in a constexpr if), or always false
1104 : : (e.g., in a non-constexpr non-consteval function) so give the user a clue. */
1105 : :
1106 : : static void
1107 : 52690580 : maybe_warn_for_constant_evaluated (tree cond, bool constexpr_if,
1108 : : bool trivial_infinite)
1109 : : {
1110 : 52690580 : if (!warn_tautological_compare)
1111 : : return;
1112 : :
1113 : : /* Suppress warning for std::is_constant_evaluated if the conditional
1114 : : comes from a macro. */
1115 : 1265314 : if (from_macro_expansion_at (EXPR_LOCATION (cond)))
1116 : : return;
1117 : :
1118 : 521447 : cond = cp_walk_tree_without_duplicates (&cond, find_std_constant_evaluated_r,
1119 : : NULL);
1120 : 521447 : if (cond)
1121 : : {
1122 : 746 : if (constexpr_if)
1123 : 32 : warning_at (EXPR_LOCATION (cond), OPT_Wtautological_compare,
1124 : : "%<std::is_constant_evaluated%> always evaluates to "
1125 : : "true in %<if constexpr%>");
1126 : 714 : else if (trivial_infinite)
1127 : : {
1128 : 8 : auto_diagnostic_group d;
1129 : 8 : if (warning_at (EXPR_LOCATION (cond), OPT_Wtautological_compare,
1130 : : "%<std::is_constant_evaluated%> evaluates to "
1131 : : "true when checking if trivially empty iteration "
1132 : : "statement is trivial infinite loop")
1133 : 8 : && !maybe_constexpr_fn (current_function_decl))
1134 : 8 : inform (EXPR_LOCATION (cond),
1135 : : "and evaluates to false when actually evaluating "
1136 : : "the condition in non-%<constexpr%> function");
1137 : 8 : }
1138 : 706 : else if (!maybe_constexpr_fn (current_function_decl))
1139 : 22 : warning_at (EXPR_LOCATION (cond), OPT_Wtautological_compare,
1140 : : "%<std::is_constant_evaluated%> always evaluates to "
1141 : : "false in a non-%<constexpr%> function");
1142 : 1368 : else if (DECL_IMMEDIATE_FUNCTION_P (current_function_decl))
1143 : 3 : warning_at (EXPR_LOCATION (cond), OPT_Wtautological_compare,
1144 : : "%<std::is_constant_evaluated%> always evaluates to "
1145 : : "true in a %<consteval%> function");
1146 : : }
1147 : : }
1148 : :
1149 : : /* Process the COND of an if-statement, which may be given by
1150 : : IF_STMT. */
1151 : :
1152 : : tree
1153 : 52614567 : finish_if_stmt_cond (tree orig_cond, tree if_stmt)
1154 : : {
1155 : 52614567 : tree cond = maybe_convert_cond (orig_cond);
1156 : 52614567 : maybe_warn_for_constant_evaluated (cond, IF_STMT_CONSTEXPR_P (if_stmt),
1157 : : /*trivial_infinite=*/false);
1158 : 52614567 : if (IF_STMT_CONSTEXPR_P (if_stmt)
1159 : 5887890 : && !type_dependent_expression_p (cond)
1160 : 3919283 : && require_constant_expression (cond)
1161 : 3919256 : && !instantiation_dependent_expression_p (cond)
1162 : : /* Wait until instantiation time, since only then COND has been
1163 : : converted to bool. */
1164 : 55046397 : && TYPE_MAIN_VARIANT (TREE_TYPE (cond)) == boolean_type_node)
1165 : : {
1166 : 2431830 : cond = instantiate_non_dependent_expr (cond);
1167 : 2431830 : cond = cxx_constant_value (cond);
1168 : : }
1169 : 50182737 : else if (processing_template_decl)
1170 : 35917020 : cond = orig_cond;
1171 : 52614567 : finish_cond (&IF_COND (if_stmt), cond);
1172 : 52614567 : add_stmt (if_stmt);
1173 : 52614567 : THEN_CLAUSE (if_stmt) = push_stmt_list ();
1174 : 52614567 : return cond;
1175 : : }
1176 : :
1177 : : /* Finish the then-clause of an if-statement, which may be given by
1178 : : IF_STMT. */
1179 : :
1180 : : tree
1181 : 52607521 : finish_then_clause (tree if_stmt)
1182 : : {
1183 : 52607521 : THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
1184 : 52607521 : return if_stmt;
1185 : : }
1186 : :
1187 : : /* Begin the else-clause of an if-statement. */
1188 : :
1189 : : void
1190 : 17625710 : begin_else_clause (tree if_stmt)
1191 : : {
1192 : 17625710 : ELSE_CLAUSE (if_stmt) = push_stmt_list ();
1193 : 17625710 : }
1194 : :
1195 : : /* Finish the else-clause of an if-statement, which may be given by
1196 : : IF_STMT. */
1197 : :
1198 : : void
1199 : 17625710 : finish_else_clause (tree if_stmt)
1200 : : {
1201 : 17625710 : ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
1202 : 17625710 : }
1203 : :
1204 : : /* Callback for cp_walk_tree to mark all {VAR,PARM}_DECLs in a tree as
1205 : : read. */
1206 : :
1207 : : static tree
1208 : 283327494 : maybe_mark_exp_read_r (tree *tp, int *, void *)
1209 : : {
1210 : 283327494 : tree t = *tp;
1211 : 283327494 : if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
1212 : 17832468 : mark_exp_read (t);
1213 : 283327494 : return NULL_TREE;
1214 : : }
1215 : :
1216 : : /* Finish an if-statement. */
1217 : :
1218 : : void
1219 : 52604248 : finish_if_stmt (tree if_stmt)
1220 : : {
1221 : 52604248 : tree scope = IF_SCOPE (if_stmt);
1222 : 52604248 : IF_SCOPE (if_stmt) = NULL;
1223 : 52604248 : if (IF_STMT_CONSTEXPR_P (if_stmt))
1224 : : {
1225 : : /* Prevent various -Wunused warnings. We might not instantiate
1226 : : either of these branches, so we would not mark the variables
1227 : : used in that branch as read. */
1228 : 5880844 : cp_walk_tree_without_duplicates (&THEN_CLAUSE (if_stmt),
1229 : : maybe_mark_exp_read_r, NULL);
1230 : 5880844 : cp_walk_tree_without_duplicates (&ELSE_CLAUSE (if_stmt),
1231 : : maybe_mark_exp_read_r, NULL);
1232 : : }
1233 : 52604248 : add_stmt (do_poplevel (scope));
1234 : 52604248 : }
1235 : :
1236 : : /* Determine if iteration statement with *CONDP condition and
1237 : : loop BODY is trivially empty iteration statement or even
1238 : : trivial infinite loop. In the latter case for -ffinite-loops
1239 : : add ANNOTATE_EXPR to mark the loop as maybe validly infinite.
1240 : : Also, emit -Wtautological-compare warning for std::is_constant_evaluated ()
1241 : : calls in the condition when needed. */
1242 : :
1243 : : static void
1244 : 14013375 : finish_loop_cond (tree *condp, tree body)
1245 : : {
1246 : 14013375 : if (TREE_CODE (*condp) == INTEGER_CST)
1247 : : return;
1248 : 10294486 : bool trivially_empty = expr_first (body) == NULL_TREE;
1249 : 10294486 : bool trivial_infinite = false;
1250 : 10294486 : if (trivially_empty)
1251 : : {
1252 : 71391 : tree c = fold_non_dependent_expr (*condp, tf_none,
1253 : : /*manifestly_const_eval=*/true);
1254 : 71391 : trivial_infinite = c && integer_nonzerop (c);
1255 : : }
1256 : 10294486 : if (warn_tautological_compare)
1257 : : {
1258 : 76171 : tree cond = *condp;
1259 : 76171 : while (TREE_CODE (cond) == ANNOTATE_EXPR)
1260 : 0 : cond = TREE_OPERAND (cond, 0);
1261 : 76171 : if (trivial_infinite
1262 : 76235 : && !DECL_IMMEDIATE_FUNCTION_P (current_function_decl))
1263 : 64 : maybe_warn_for_constant_evaluated (cond, /*constexpr_if=*/false,
1264 : : /*trivial_infinite=*/true);
1265 : 76107 : else if (!trivially_empty
1266 : 313 : || !processing_template_decl
1267 : 76423 : || DECL_IMMEDIATE_FUNCTION_P (current_function_decl))
1268 : 75949 : maybe_warn_for_constant_evaluated (cond, /*constexpr_if=*/false,
1269 : : /*trivial_infinite=*/false);
1270 : : }
1271 : 10294486 : if (trivial_infinite && flag_finite_loops && !processing_template_decl)
1272 : 64 : *condp = build3 (ANNOTATE_EXPR, TREE_TYPE (*condp), *condp,
1273 : : build_int_cst (integer_type_node,
1274 : 64 : annot_expr_maybe_infinite_kind),
1275 : : integer_zero_node);
1276 : : }
1277 : :
1278 : : /* Begin a while-statement. Returns a newly created WHILE_STMT if
1279 : : appropriate. */
1280 : :
1281 : : tree
1282 : 3580501 : begin_while_stmt (void)
1283 : : {
1284 : 3580501 : tree r;
1285 : 3580501 : r = build_stmt (input_location, WHILE_STMT, NULL_TREE, NULL_TREE);
1286 : 3580501 : add_stmt (r);
1287 : 3580501 : WHILE_BODY (r) = do_pushlevel (sk_block);
1288 : 3580501 : begin_cond (&WHILE_COND (r));
1289 : 3580501 : return r;
1290 : : }
1291 : :
1292 : : /* Process the COND of a while-statement, which may be given by
1293 : : WHILE_STMT. */
1294 : :
1295 : : void
1296 : 3580501 : finish_while_stmt_cond (tree cond, tree while_stmt, bool ivdep,
1297 : : tree unroll, bool novector)
1298 : : {
1299 : 3580501 : cond = maybe_convert_cond (cond);
1300 : 3580501 : finish_cond (&WHILE_COND (while_stmt), cond);
1301 : 3580501 : begin_maybe_infinite_loop (cond);
1302 : 3580501 : if (ivdep && cond != error_mark_node)
1303 : 24 : WHILE_COND (while_stmt) = build3 (ANNOTATE_EXPR,
1304 : 12 : TREE_TYPE (WHILE_COND (while_stmt)),
1305 : 12 : WHILE_COND (while_stmt),
1306 : : build_int_cst (integer_type_node,
1307 : 12 : annot_expr_ivdep_kind),
1308 : : integer_zero_node);
1309 : 3580501 : if (unroll && cond != error_mark_node)
1310 : 18 : WHILE_COND (while_stmt) = build3 (ANNOTATE_EXPR,
1311 : 9 : TREE_TYPE (WHILE_COND (while_stmt)),
1312 : 9 : WHILE_COND (while_stmt),
1313 : : build_int_cst (integer_type_node,
1314 : 9 : annot_expr_unroll_kind),
1315 : : unroll);
1316 : 3580501 : if (novector && cond != error_mark_node)
1317 : 36 : WHILE_COND (while_stmt) = build3 (ANNOTATE_EXPR,
1318 : 18 : TREE_TYPE (WHILE_COND (while_stmt)),
1319 : 18 : WHILE_COND (while_stmt),
1320 : : build_int_cst (integer_type_node,
1321 : 18 : annot_expr_no_vector_kind),
1322 : : integer_zero_node);
1323 : 3580501 : simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
1324 : 3580501 : }
1325 : :
1326 : : /* Finish a while-statement, which may be given by WHILE_STMT. */
1327 : :
1328 : : void
1329 : 3580501 : finish_while_stmt (tree while_stmt)
1330 : : {
1331 : 3580501 : end_maybe_infinite_loop (boolean_true_node);
1332 : 3580501 : WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
1333 : 3580501 : finish_loop_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
1334 : 3580501 : }
1335 : :
1336 : : /* Begin a do-statement. Returns a newly created DO_STMT if
1337 : : appropriate. */
1338 : :
1339 : : tree
1340 : 4257400 : begin_do_stmt (void)
1341 : : {
1342 : 4257400 : tree r = build_stmt (input_location, DO_STMT, NULL_TREE, NULL_TREE);
1343 : 4257400 : begin_maybe_infinite_loop (boolean_true_node);
1344 : 4257400 : add_stmt (r);
1345 : 4257400 : DO_BODY (r) = push_stmt_list ();
1346 : 4257400 : return r;
1347 : : }
1348 : :
1349 : : /* Finish the body of a do-statement, which may be given by DO_STMT. */
1350 : :
1351 : : void
1352 : 4257400 : finish_do_body (tree do_stmt)
1353 : : {
1354 : 4257400 : tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
1355 : :
1356 : 4257400 : if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
1357 : 417847 : body = STATEMENT_LIST_TAIL (body)->stmt;
1358 : :
1359 : 4257400 : if (IS_EMPTY_STMT (body))
1360 : 28 : warning (OPT_Wempty_body,
1361 : : "suggest explicit braces around empty body in %<do%> statement");
1362 : 4257400 : }
1363 : :
1364 : : /* Finish a do-statement, which may be given by DO_STMT, and whose
1365 : : COND is as indicated. */
1366 : :
1367 : : void
1368 : 4257400 : finish_do_stmt (tree cond, tree do_stmt, bool ivdep, tree unroll,
1369 : : bool novector)
1370 : : {
1371 : 4257400 : cond = maybe_convert_cond (cond);
1372 : 4257400 : end_maybe_infinite_loop (cond);
1373 : : /* Unlike other iteration statements, the condition may not contain
1374 : : a declaration, so we don't call finish_cond which checks for
1375 : : unexpanded parameter packs. */
1376 : 4257400 : if (check_for_bare_parameter_packs (cond))
1377 : 3 : cond = error_mark_node;
1378 : 4257400 : if (ivdep && cond != error_mark_node)
1379 : 3 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
1380 : 3 : build_int_cst (integer_type_node, annot_expr_ivdep_kind),
1381 : : integer_zero_node);
1382 : 4257400 : if (unroll && cond != error_mark_node)
1383 : 9 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
1384 : 9 : build_int_cst (integer_type_node, annot_expr_unroll_kind),
1385 : : unroll);
1386 : 4257400 : if (novector && cond != error_mark_node)
1387 : 0 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
1388 : 0 : build_int_cst (integer_type_node, annot_expr_no_vector_kind),
1389 : : integer_zero_node);
1390 : 4257400 : DO_COND (do_stmt) = cond;
1391 : 4257400 : tree do_body = DO_BODY (do_stmt);
1392 : 4257372 : if (CONVERT_EXPR_P (do_body)
1393 : 28 : && integer_zerop (TREE_OPERAND (do_body, 0))
1394 : 4257428 : && VOID_TYPE_P (TREE_TYPE (do_body)))
1395 : : do_body = NULL_TREE;
1396 : 4257400 : finish_loop_cond (&DO_COND (do_stmt), do_body);
1397 : 4257400 : }
1398 : :
1399 : : /* Finish a return-statement. The EXPRESSION returned, if any, is as
1400 : : indicated. */
1401 : :
1402 : : tree
1403 : 96828312 : finish_return_stmt (tree expr)
1404 : : {
1405 : 96828312 : tree r;
1406 : 96828312 : bool no_warning;
1407 : 96828312 : bool dangling;
1408 : :
1409 : 96828312 : expr = check_return_expr (expr, &no_warning, &dangling);
1410 : :
1411 : 96828312 : if (error_operand_p (expr)
1412 : 96828312 : || (flag_openmp && !check_omp_return ()))
1413 : : {
1414 : : /* Suppress -Wreturn-type for this function. */
1415 : 1110 : if (warn_return_type)
1416 : 1104 : suppress_warning (current_function_decl, OPT_Wreturn_type);
1417 : 1110 : return error_mark_node;
1418 : : }
1419 : :
1420 : 96827202 : if (!processing_template_decl)
1421 : : {
1422 : 33753071 : if (warn_sequence_point)
1423 : 984104 : verify_sequence_points (expr);
1424 : : }
1425 : :
1426 : 96827202 : r = build_stmt (input_location, RETURN_EXPR, expr);
1427 : 96827202 : RETURN_EXPR_LOCAL_ADDR_P (r) = dangling;
1428 : 96827202 : if (no_warning)
1429 : 29 : suppress_warning (r, OPT_Wreturn_type);
1430 : 96827202 : r = maybe_cleanup_point_expr_void (r);
1431 : 96827202 : r = add_stmt (r);
1432 : :
1433 : 96827202 : return r;
1434 : : }
1435 : :
1436 : : /* Begin the scope of a for-statement or a range-for-statement.
1437 : : Both the returned trees are to be used in a call to
1438 : : begin_for_stmt or begin_range_for_stmt. */
1439 : :
1440 : : tree
1441 : 6640924 : begin_for_scope (tree *init)
1442 : : {
1443 : 6640924 : tree scope = do_pushlevel (sk_for);
1444 : :
1445 : 6640924 : if (processing_template_decl)
1446 : 5325660 : *init = push_stmt_list ();
1447 : : else
1448 : 1315264 : *init = NULL_TREE;
1449 : :
1450 : 6640924 : return scope;
1451 : : }
1452 : :
1453 : : /* Begin a for-statement. Returns a new FOR_STMT.
1454 : : SCOPE and INIT should be the return of begin_for_scope,
1455 : : or both NULL_TREE */
1456 : :
1457 : : tree
1458 : 6445242 : begin_for_stmt (tree scope, tree init)
1459 : : {
1460 : 6445242 : tree r;
1461 : :
1462 : 6445242 : r = build_stmt (input_location, FOR_STMT, NULL_TREE, NULL_TREE,
1463 : : NULL_TREE, NULL_TREE, NULL_TREE);
1464 : :
1465 : 6445242 : if (scope == NULL_TREE)
1466 : : {
1467 : 1120842 : gcc_assert (!init);
1468 : 1120842 : scope = begin_for_scope (&init);
1469 : : }
1470 : :
1471 : 6445242 : FOR_INIT_STMT (r) = init;
1472 : 6445242 : FOR_SCOPE (r) = scope;
1473 : :
1474 : 6445242 : return r;
1475 : : }
1476 : :
1477 : : /* Finish the init-statement of a for-statement, which may be
1478 : : given by FOR_STMT. */
1479 : :
1480 : : void
1481 : 6445242 : finish_init_stmt (tree for_stmt)
1482 : : {
1483 : 6445242 : if (processing_template_decl)
1484 : 5129978 : FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
1485 : 6445242 : add_stmt (for_stmt);
1486 : 6445242 : FOR_BODY (for_stmt) = do_pushlevel (sk_block);
1487 : 6445242 : begin_cond (&FOR_COND (for_stmt));
1488 : 6445242 : }
1489 : :
1490 : : /* Finish the COND of a for-statement, which may be given by
1491 : : FOR_STMT. */
1492 : :
1493 : : void
1494 : 6445242 : finish_for_cond (tree cond, tree for_stmt, bool ivdep, tree unroll,
1495 : : bool novector)
1496 : : {
1497 : 6445242 : cond = maybe_convert_cond (cond);
1498 : 6445242 : finish_cond (&FOR_COND (for_stmt), cond);
1499 : 6445242 : begin_maybe_infinite_loop (cond);
1500 : 6445242 : if (ivdep && cond != error_mark_node)
1501 : 68 : FOR_COND (for_stmt) = build3 (ANNOTATE_EXPR,
1502 : 34 : TREE_TYPE (FOR_COND (for_stmt)),
1503 : 34 : FOR_COND (for_stmt),
1504 : : build_int_cst (integer_type_node,
1505 : 34 : annot_expr_ivdep_kind),
1506 : : integer_zero_node);
1507 : 6445242 : if (unroll && cond != error_mark_node)
1508 : 396 : FOR_COND (for_stmt) = build3 (ANNOTATE_EXPR,
1509 : 198 : TREE_TYPE (FOR_COND (for_stmt)),
1510 : 198 : FOR_COND (for_stmt),
1511 : : build_int_cst (integer_type_node,
1512 : 198 : annot_expr_unroll_kind),
1513 : : unroll);
1514 : 6445242 : if (novector && cond && cond != error_mark_node)
1515 : 268 : FOR_COND (for_stmt) = build3 (ANNOTATE_EXPR,
1516 : 134 : TREE_TYPE (FOR_COND (for_stmt)),
1517 : 134 : FOR_COND (for_stmt),
1518 : : build_int_cst (integer_type_node,
1519 : 134 : annot_expr_no_vector_kind),
1520 : : integer_zero_node);
1521 : 6445242 : simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
1522 : 6445242 : }
1523 : :
1524 : : /* Finish the increment-EXPRESSION in a for-statement, which may be
1525 : : given by FOR_STMT. */
1526 : :
1527 : : void
1528 : 6440123 : finish_for_expr (tree expr, tree for_stmt)
1529 : : {
1530 : 6440123 : if (!expr)
1531 : : return;
1532 : : /* If EXPR is an overloaded function, issue an error; there is no
1533 : : context available to use to perform overload resolution. */
1534 : 6081513 : if (type_unknown_p (expr))
1535 : : {
1536 : 6 : cxx_incomplete_type_error (expr, TREE_TYPE (expr));
1537 : 6 : expr = error_mark_node;
1538 : : }
1539 : 6081513 : if (!processing_template_decl)
1540 : : {
1541 : 1247641 : if (warn_sequence_point)
1542 : 13352 : verify_sequence_points (expr);
1543 : 1247641 : expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
1544 : : tf_warning_or_error);
1545 : : }
1546 : 4833872 : else if (!type_dependent_expression_p (expr))
1547 : 1875592 : convert_to_void (expr, ICV_THIRD_IN_FOR, tf_warning_or_error);
1548 : 6081513 : expr = maybe_cleanup_point_expr_void (expr);
1549 : 6081513 : if (check_for_bare_parameter_packs (expr))
1550 : 0 : expr = error_mark_node;
1551 : 6081513 : FOR_EXPR (for_stmt) = expr;
1552 : : }
1553 : :
1554 : : /* Finish the body of a for-statement, which may be given by
1555 : : FOR_STMT. The increment-EXPR for the loop must be
1556 : : provided.
1557 : : It can also finish RANGE_FOR_STMT. */
1558 : :
1559 : : void
1560 : 6640924 : finish_for_stmt (tree for_stmt)
1561 : : {
1562 : 6640924 : end_maybe_infinite_loop (boolean_true_node);
1563 : :
1564 : 6640924 : if (TREE_CODE (for_stmt) == RANGE_FOR_STMT)
1565 : 195682 : RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt));
1566 : : else
1567 : : {
1568 : 6445242 : FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
1569 : 6445242 : if (FOR_COND (for_stmt))
1570 : 6175474 : finish_loop_cond (&FOR_COND (for_stmt),
1571 : 6175474 : FOR_EXPR (for_stmt) ? integer_one_node
1572 : 129553 : : FOR_BODY (for_stmt));
1573 : : }
1574 : :
1575 : : /* Pop the scope for the body of the loop. */
1576 : 6640924 : tree *scope_ptr = (TREE_CODE (for_stmt) == RANGE_FOR_STMT
1577 : 6640924 : ? &RANGE_FOR_SCOPE (for_stmt)
1578 : 6445242 : : &FOR_SCOPE (for_stmt));
1579 : 6640924 : tree scope = *scope_ptr;
1580 : 6640924 : *scope_ptr = NULL;
1581 : :
1582 : : /* During parsing of the body, range for uses "__for_{range,begin,end} "
1583 : : decl names to make those unaccessible by code in the body.
1584 : : Change it to ones with underscore instead of space, so that it can
1585 : : be inspected in the debugger. */
1586 : 6640924 : tree range_for_decl[3] = { NULL_TREE, NULL_TREE, NULL_TREE };
1587 : 6640924 : gcc_assert (CPTI_FOR_BEGIN__IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 1
1588 : : && CPTI_FOR_END__IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 2
1589 : : && CPTI_FOR_RANGE_IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 3
1590 : : && CPTI_FOR_BEGIN_IDENTIFIER == CPTI_FOR_BEGIN__IDENTIFIER + 3
1591 : : && CPTI_FOR_END_IDENTIFIER == CPTI_FOR_END__IDENTIFIER + 3);
1592 : 26563696 : for (int i = 0; i < 3; i++)
1593 : : {
1594 : 19922772 : tree id = cp_global_trees[CPTI_FOR_RANGE__IDENTIFIER + i];
1595 : 19922772 : if (IDENTIFIER_BINDING (id)
1596 : 19922772 : && IDENTIFIER_BINDING (id)->scope == current_binding_level)
1597 : : {
1598 : 154567 : range_for_decl[i] = IDENTIFIER_BINDING (id)->value;
1599 : 154567 : gcc_assert (VAR_P (range_for_decl[i])
1600 : : && DECL_ARTIFICIAL (range_for_decl[i]));
1601 : : }
1602 : : }
1603 : :
1604 : 6640924 : add_stmt (do_poplevel (scope));
1605 : :
1606 : : /* If we're being called from build_vec_init, don't mess with the names of
1607 : : the variables for an enclosing range-for. */
1608 : 6640924 : if (!stmts_are_full_exprs_p ())
1609 : 5119 : return;
1610 : :
1611 : 26543220 : for (int i = 0; i < 3; i++)
1612 : 19907415 : if (range_for_decl[i])
1613 : 154564 : DECL_NAME (range_for_decl[i])
1614 : 154564 : = cp_global_trees[CPTI_FOR_RANGE_IDENTIFIER + i];
1615 : : }
1616 : :
1617 : : /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
1618 : : SCOPE and INIT should be the return of begin_for_scope,
1619 : : or both NULL_TREE .
1620 : : To finish it call finish_for_stmt(). */
1621 : :
1622 : : tree
1623 : 195682 : begin_range_for_stmt (tree scope, tree init)
1624 : : {
1625 : 195682 : begin_maybe_infinite_loop (boolean_false_node);
1626 : :
1627 : 195682 : tree r = build_stmt (input_location, RANGE_FOR_STMT, NULL_TREE, NULL_TREE,
1628 : : NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
1629 : :
1630 : 195682 : if (scope == NULL_TREE)
1631 : : {
1632 : 6 : gcc_assert (!init);
1633 : 6 : scope = begin_for_scope (&init);
1634 : : }
1635 : :
1636 : : /* Since C++20, RANGE_FOR_STMTs can use the init tree, so save it. */
1637 : 195682 : RANGE_FOR_INIT_STMT (r) = init;
1638 : 195682 : RANGE_FOR_SCOPE (r) = scope;
1639 : :
1640 : 195682 : return r;
1641 : : }
1642 : :
1643 : : /* Finish the head of a range-based for statement, which may
1644 : : be given by RANGE_FOR_STMT. DECL must be the declaration
1645 : : and EXPR must be the loop expression. */
1646 : :
1647 : : void
1648 : 195682 : finish_range_for_decl (tree range_for_stmt, tree decl, tree expr)
1649 : : {
1650 : 195682 : if (processing_template_decl)
1651 : 391364 : RANGE_FOR_INIT_STMT (range_for_stmt)
1652 : 391364 : = pop_stmt_list (RANGE_FOR_INIT_STMT (range_for_stmt));
1653 : 195682 : RANGE_FOR_DECL (range_for_stmt) = decl;
1654 : 195682 : RANGE_FOR_EXPR (range_for_stmt) = expr;
1655 : 195682 : add_stmt (range_for_stmt);
1656 : 195682 : RANGE_FOR_BODY (range_for_stmt) = do_pushlevel (sk_block);
1657 : 195682 : }
1658 : :
1659 : : /* Finish a break-statement. */
1660 : :
1661 : : tree
1662 : 3309383 : finish_break_stmt (void)
1663 : : {
1664 : : /* In switch statements break is sometimes stylistically used after
1665 : : a return statement. This can lead to spurious warnings about
1666 : : control reaching the end of a non-void function when it is
1667 : : inlined. Note that we are calling block_may_fallthru with
1668 : : language specific tree nodes; this works because
1669 : : block_may_fallthru returns true when given something it does not
1670 : : understand. */
1671 : 3309383 : if (!block_may_fallthru (cur_stmt_list))
1672 : 965 : return void_node;
1673 : 3308418 : note_break_stmt ();
1674 : 3308418 : return add_stmt (build_stmt (input_location, BREAK_STMT));
1675 : : }
1676 : :
1677 : : /* Finish a continue-statement. */
1678 : :
1679 : : tree
1680 : 142391 : finish_continue_stmt (void)
1681 : : {
1682 : 142391 : return add_stmt (build_stmt (input_location, CONTINUE_STMT));
1683 : : }
1684 : :
1685 : : /* Begin a switch-statement. Returns a new SWITCH_STMT if
1686 : : appropriate. */
1687 : :
1688 : : tree
1689 : 417566 : begin_switch_stmt (void)
1690 : : {
1691 : 417566 : tree r, scope;
1692 : :
1693 : 417566 : scope = do_pushlevel (sk_cond);
1694 : 417566 : r = build_stmt (input_location, SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE, scope);
1695 : :
1696 : 417566 : begin_cond (&SWITCH_STMT_COND (r));
1697 : :
1698 : 417566 : return r;
1699 : : }
1700 : :
1701 : : /* Finish the cond of a switch-statement. */
1702 : :
1703 : : void
1704 : 417566 : finish_switch_cond (tree cond, tree switch_stmt)
1705 : : {
1706 : 417566 : tree orig_type = NULL;
1707 : :
1708 : 417566 : if (!processing_template_decl)
1709 : : {
1710 : : /* Convert the condition to an integer or enumeration type. */
1711 : 268109 : tree orig_cond = cond;
1712 : : /* For structured binding used in condition, the conversion needs to be
1713 : : evaluated before the individual variables are initialized in the
1714 : : std::tuple_{size,elemenet} case. cp_finish_decomp saved the
1715 : : conversion result in a TARGET_EXPR, pick it up from there. */
1716 : 122 : if (DECL_DECOMPOSITION_P (cond)
1717 : 57 : && DECL_DECOMP_IS_BASE (cond)
1718 : 57 : && DECL_DECOMP_BASE (cond)
1719 : 268163 : && TREE_CODE (DECL_DECOMP_BASE (cond)) == TARGET_EXPR)
1720 : 18 : cond = TARGET_EXPR_SLOT (DECL_DECOMP_BASE (cond));
1721 : 268109 : cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
1722 : 268109 : if (cond == NULL_TREE)
1723 : : {
1724 : 42 : error_at (cp_expr_loc_or_input_loc (orig_cond),
1725 : : "switch quantity not an integer");
1726 : 27 : cond = error_mark_node;
1727 : : }
1728 : : /* We want unlowered type here to handle enum bit-fields. */
1729 : 268109 : orig_type = unlowered_expr_type (cond);
1730 : 268109 : if (TREE_CODE (orig_type) != ENUMERAL_TYPE)
1731 : 160095 : orig_type = TREE_TYPE (cond);
1732 : 268109 : if (cond != error_mark_node)
1733 : : {
1734 : : /* [stmt.switch]
1735 : :
1736 : : Integral promotions are performed. */
1737 : 268076 : cond = perform_integral_promotions (cond);
1738 : 268076 : cond = maybe_cleanup_point_expr (cond);
1739 : : }
1740 : : }
1741 : 417566 : if (check_for_bare_parameter_packs (cond))
1742 : 0 : cond = error_mark_node;
1743 : 417566 : else if (!processing_template_decl && warn_sequence_point)
1744 : 2389 : verify_sequence_points (cond);
1745 : :
1746 : 417566 : finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
1747 : 417566 : SWITCH_STMT_TYPE (switch_stmt) = orig_type;
1748 : 417566 : add_stmt (switch_stmt);
1749 : 417566 : push_switch (switch_stmt);
1750 : 417566 : SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
1751 : 417566 : }
1752 : :
1753 : : /* Finish the body of a switch-statement, which may be given by
1754 : : SWITCH_STMT. The COND to switch on is indicated. */
1755 : :
1756 : : void
1757 : 414051 : finish_switch_stmt (tree switch_stmt)
1758 : : {
1759 : 414051 : tree scope;
1760 : :
1761 : 828102 : SWITCH_STMT_BODY (switch_stmt) =
1762 : 414051 : pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
1763 : 414051 : pop_switch ();
1764 : :
1765 : 414051 : scope = SWITCH_STMT_SCOPE (switch_stmt);
1766 : 414051 : SWITCH_STMT_SCOPE (switch_stmt) = NULL;
1767 : 414051 : add_stmt (do_poplevel (scope));
1768 : 414051 : }
1769 : :
1770 : : /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1771 : : appropriate. */
1772 : :
1773 : : tree
1774 : 1118878 : begin_try_block (void)
1775 : : {
1776 : 1118878 : tree r = build_stmt (input_location, TRY_BLOCK, NULL_TREE, NULL_TREE);
1777 : 1118878 : add_stmt (r);
1778 : 1118878 : TRY_STMTS (r) = push_stmt_list ();
1779 : 1118878 : return r;
1780 : : }
1781 : :
1782 : : /* Likewise, for a function-try-block. The block returned in
1783 : : *COMPOUND_STMT is an artificial outer scope, containing the
1784 : : function-try-block. */
1785 : :
1786 : : tree
1787 : 331 : begin_function_try_block (tree *compound_stmt)
1788 : : {
1789 : 331 : tree r;
1790 : : /* This outer scope does not exist in the C++ standard, but we need
1791 : : a place to put __FUNCTION__ and similar variables. */
1792 : 331 : *compound_stmt = begin_compound_stmt (0);
1793 : 331 : current_binding_level->artificial = 1;
1794 : 331 : r = begin_try_block ();
1795 : 331 : FN_TRY_BLOCK_P (r) = 1;
1796 : 331 : return r;
1797 : : }
1798 : :
1799 : : /* Finish a try-block, which may be given by TRY_BLOCK. */
1800 : :
1801 : : void
1802 : 1118878 : finish_try_block (tree try_block)
1803 : : {
1804 : 1118878 : TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1805 : 1118878 : TRY_HANDLERS (try_block) = push_stmt_list ();
1806 : 1118878 : }
1807 : :
1808 : : /* Finish the body of a cleanup try-block, which may be given by
1809 : : TRY_BLOCK. */
1810 : :
1811 : : void
1812 : 0 : finish_cleanup_try_block (tree try_block)
1813 : : {
1814 : 0 : TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1815 : 0 : }
1816 : :
1817 : : /* Finish an implicitly generated try-block, with a cleanup is given
1818 : : by CLEANUP. */
1819 : :
1820 : : void
1821 : 0 : finish_cleanup (tree cleanup, tree try_block)
1822 : : {
1823 : 0 : TRY_HANDLERS (try_block) = cleanup;
1824 : 0 : CLEANUP_P (try_block) = 1;
1825 : 0 : }
1826 : :
1827 : : /* Likewise, for a function-try-block. */
1828 : :
1829 : : void
1830 : 331 : finish_function_try_block (tree try_block)
1831 : : {
1832 : 331 : finish_try_block (try_block);
1833 : : /* FIXME : something queer about CTOR_INITIALIZER somehow following
1834 : : the try block, but moving it inside. */
1835 : 331 : in_function_try_handler = 1;
1836 : 331 : }
1837 : :
1838 : : /* Finish a handler-sequence for a try-block, which may be given by
1839 : : TRY_BLOCK. */
1840 : :
1841 : : void
1842 : 1118878 : finish_handler_sequence (tree try_block)
1843 : : {
1844 : 1118878 : TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
1845 : 1118878 : check_handlers (TRY_HANDLERS (try_block));
1846 : 1118878 : }
1847 : :
1848 : : /* Finish the handler-seq for a function-try-block, given by
1849 : : TRY_BLOCK. COMPOUND_STMT is the outer block created by
1850 : : begin_function_try_block. */
1851 : :
1852 : : void
1853 : 331 : finish_function_handler_sequence (tree try_block, tree compound_stmt)
1854 : : {
1855 : 331 : in_function_try_handler = 0;
1856 : 331 : finish_handler_sequence (try_block);
1857 : 331 : finish_compound_stmt (compound_stmt);
1858 : 331 : }
1859 : :
1860 : : /* Begin a handler. Returns a HANDLER if appropriate. */
1861 : :
1862 : : tree
1863 : 1576755 : begin_handler (void)
1864 : : {
1865 : 1576755 : tree r;
1866 : :
1867 : 1576755 : r = build_stmt (input_location, HANDLER, NULL_TREE, NULL_TREE);
1868 : 1576755 : add_stmt (r);
1869 : :
1870 : : /* Create a binding level for the eh_info and the exception object
1871 : : cleanup. */
1872 : 1576755 : HANDLER_BODY (r) = do_pushlevel (sk_catch);
1873 : :
1874 : 1576755 : return r;
1875 : : }
1876 : :
1877 : : /* Finish the handler-parameters for a handler, which may be given by
1878 : : HANDLER. DECL is the declaration for the catch parameter, or NULL
1879 : : if this is a `catch (...)' clause. */
1880 : :
1881 : : void
1882 : 1576755 : finish_handler_parms (tree decl, tree handler)
1883 : : {
1884 : 1576755 : tree type = NULL_TREE;
1885 : 1576755 : if (processing_template_decl)
1886 : : {
1887 : 1446601 : if (decl)
1888 : : {
1889 : 472650 : decl = pushdecl (decl);
1890 : 472650 : decl = push_template_decl (decl);
1891 : 472650 : HANDLER_PARMS (handler) = decl;
1892 : 472650 : type = TREE_TYPE (decl);
1893 : : }
1894 : : }
1895 : : else
1896 : : {
1897 : 130154 : type = expand_start_catch_block (decl);
1898 : 130154 : if (warn_catch_value
1899 : 2019 : && type != NULL_TREE
1900 : 705 : && type != error_mark_node
1901 : 130859 : && !TYPE_REF_P (TREE_TYPE (decl)))
1902 : : {
1903 : 210 : tree orig_type = TREE_TYPE (decl);
1904 : 210 : if (CLASS_TYPE_P (orig_type))
1905 : : {
1906 : 96 : if (TYPE_POLYMORPHIC_P (orig_type))
1907 : 48 : warning_at (DECL_SOURCE_LOCATION (decl),
1908 : : OPT_Wcatch_value_,
1909 : : "catching polymorphic type %q#T by value",
1910 : : orig_type);
1911 : 48 : else if (warn_catch_value > 1)
1912 : 36 : warning_at (DECL_SOURCE_LOCATION (decl),
1913 : : OPT_Wcatch_value_,
1914 : : "catching type %q#T by value", orig_type);
1915 : : }
1916 : 114 : else if (warn_catch_value > 2)
1917 : 54 : warning_at (DECL_SOURCE_LOCATION (decl),
1918 : : OPT_Wcatch_value_,
1919 : : "catching non-reference type %q#T", orig_type);
1920 : : }
1921 : : }
1922 : 1576755 : HANDLER_TYPE (handler) = type;
1923 : 1576755 : }
1924 : :
1925 : : /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1926 : : the return value from the matching call to finish_handler_parms. */
1927 : :
1928 : : void
1929 : 1576755 : finish_handler (tree handler)
1930 : : {
1931 : 1576755 : if (!processing_template_decl)
1932 : 130154 : expand_end_catch_block ();
1933 : 1576755 : HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
1934 : 1576755 : }
1935 : :
1936 : : /* Begin a compound statement. FLAGS contains some bits that control the
1937 : : behavior and context. If BCS_NO_SCOPE is set, the compound statement
1938 : : does not define a scope. If BCS_FN_BODY is set, this is the outermost
1939 : : block of a function. If BCS_TRY_BLOCK is set, this is the block
1940 : : created on behalf of a TRY statement. Returns a token to be passed to
1941 : : finish_compound_stmt. */
1942 : :
1943 : : tree
1944 : 219708438 : begin_compound_stmt (unsigned int flags)
1945 : : {
1946 : 219708438 : tree r;
1947 : :
1948 : 219708438 : if (flags & BCS_NO_SCOPE)
1949 : : {
1950 : 3548346 : r = push_stmt_list ();
1951 : 3548346 : STATEMENT_LIST_NO_SCOPE (r) = 1;
1952 : :
1953 : : /* Normally, we try hard to keep the BLOCK for a statement-expression.
1954 : : But, if it's a statement-expression with a scopeless block, there's
1955 : : nothing to keep, and we don't want to accidentally keep a block
1956 : : *inside* the scopeless block. */
1957 : 3548346 : keep_next_level (false);
1958 : : }
1959 : : else
1960 : : {
1961 : 216160092 : scope_kind sk = sk_block;
1962 : 216160092 : if (flags & BCS_TRY_BLOCK)
1963 : : sk = sk_try;
1964 : 215041214 : else if (flags & BCS_TRANSACTION)
1965 : : sk = sk_transaction;
1966 : 215040979 : else if (flags & BCS_STMT_EXPR)
1967 : 28930 : sk = sk_stmt_expr;
1968 : 216160092 : r = do_pushlevel (sk);
1969 : : }
1970 : :
1971 : : /* When processing a template, we need to remember where the braces were,
1972 : : so that we can set up identical scopes when instantiating the template
1973 : : later. BIND_EXPR is a handy candidate for this.
1974 : : Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1975 : : result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1976 : : processing templates. */
1977 : 219708438 : if (processing_template_decl)
1978 : : {
1979 : 147952025 : r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
1980 : 147952025 : BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
1981 : 147952025 : BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
1982 : 147952025 : TREE_SIDE_EFFECTS (r) = 1;
1983 : : }
1984 : :
1985 : 219708438 : return r;
1986 : : }
1987 : :
1988 : : /* Finish a compound-statement, which is given by STMT. */
1989 : :
1990 : : void
1991 : 219708402 : finish_compound_stmt (tree stmt)
1992 : : {
1993 : 219708402 : if (TREE_CODE (stmt) == BIND_EXPR)
1994 : : {
1995 : 147952025 : tree body = do_poplevel (BIND_EXPR_BODY (stmt));
1996 : : /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1997 : : discard the BIND_EXPR so it can be merged with the containing
1998 : : STATEMENT_LIST. */
1999 : 147952025 : if (TREE_CODE (body) == STATEMENT_LIST
2000 : 135833792 : && STATEMENT_LIST_HEAD (body) == NULL
2001 : 9823729 : && !BIND_EXPR_BODY_BLOCK (stmt)
2002 : 157343209 : && !BIND_EXPR_TRY_BLOCK (stmt))
2003 : : stmt = body;
2004 : : else
2005 : 138560942 : BIND_EXPR_BODY (stmt) = body;
2006 : : }
2007 : 71756377 : else if (STATEMENT_LIST_NO_SCOPE (stmt))
2008 : 3540376 : stmt = pop_stmt_list (stmt);
2009 : : else
2010 : : {
2011 : : /* Destroy any ObjC "super" receivers that may have been
2012 : : created. */
2013 : 68216001 : objc_clear_super_receiver ();
2014 : :
2015 : 68216001 : stmt = do_poplevel (stmt);
2016 : : }
2017 : :
2018 : : /* ??? See c_end_compound_stmt wrt statement expressions. */
2019 : 219708402 : add_stmt (stmt);
2020 : 219708402 : }
2021 : :
2022 : : /* Finish an asm-statement, whose components are a STRING, some
2023 : : OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
2024 : : LABELS. Also note whether the asm-statement should be
2025 : : considered volatile, and whether it is asm inline. */
2026 : :
2027 : : tree
2028 : 31804 : finish_asm_stmt (location_t loc, int volatile_p, tree string,
2029 : : tree output_operands, tree input_operands, tree clobbers,
2030 : : tree labels, bool inline_p)
2031 : : {
2032 : 31804 : tree r;
2033 : 31804 : tree t;
2034 : 31804 : int ninputs = list_length (input_operands);
2035 : 31804 : int noutputs = list_length (output_operands);
2036 : :
2037 : 31804 : if (!processing_template_decl)
2038 : : {
2039 : 26894 : const char *constraint;
2040 : 26894 : const char **oconstraints;
2041 : 26894 : bool allows_mem, allows_reg, is_inout;
2042 : 26894 : tree operand;
2043 : 26894 : int i;
2044 : :
2045 : 26894 : oconstraints = XALLOCAVEC (const char *, noutputs);
2046 : :
2047 : 26894 : string = resolve_asm_operand_names (string, output_operands,
2048 : : input_operands, labels);
2049 : :
2050 : 46482 : for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
2051 : : {
2052 : 19588 : operand = TREE_VALUE (t);
2053 : :
2054 : : /* ??? Really, this should not be here. Users should be using a
2055 : : proper lvalue, dammit. But there's a long history of using
2056 : : casts in the output operands. In cases like longlong.h, this
2057 : : becomes a primitive form of typechecking -- if the cast can be
2058 : : removed, then the output operand had a type of the proper width;
2059 : : otherwise we'll get an error. Gross, but ... */
2060 : 19588 : STRIP_NOPS (operand);
2061 : :
2062 : 19588 : operand = mark_lvalue_use (operand);
2063 : :
2064 : 19588 : if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
2065 : 0 : operand = error_mark_node;
2066 : :
2067 : 19588 : if (operand != error_mark_node
2068 : 19588 : && (TREE_READONLY (operand)
2069 : 19582 : || CP_TYPE_CONST_P (TREE_TYPE (operand))
2070 : : /* Functions are not modifiable, even though they are
2071 : : lvalues. */
2072 : 19582 : || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (operand))
2073 : : /* If it's an aggregate and any field is const, then it is
2074 : : effectively const. */
2075 : 19582 : || (CLASS_TYPE_P (TREE_TYPE (operand))
2076 : 22 : && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
2077 : 6 : cxx_readonly_error (loc, operand, lv_asm);
2078 : :
2079 : : tree *op = &operand;
2080 : 19595 : while (TREE_CODE (*op) == COMPOUND_EXPR)
2081 : 7 : op = &TREE_OPERAND (*op, 1);
2082 : 19588 : switch (TREE_CODE (*op))
2083 : : {
2084 : 30 : case PREINCREMENT_EXPR:
2085 : 30 : case PREDECREMENT_EXPR:
2086 : 30 : case MODIFY_EXPR:
2087 : 30 : *op = genericize_compound_lvalue (*op);
2088 : 30 : op = &TREE_OPERAND (*op, 1);
2089 : 30 : break;
2090 : : default:
2091 : : break;
2092 : : }
2093 : :
2094 : 19588 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2095 : 19588 : oconstraints[i] = constraint;
2096 : :
2097 : 19588 : if (parse_output_constraint (&constraint, i, ninputs, noutputs,
2098 : : &allows_mem, &allows_reg, &is_inout))
2099 : : {
2100 : : /* If the operand is going to end up in memory,
2101 : : mark it addressable. */
2102 : 19585 : if (!allows_reg && !cxx_mark_addressable (*op))
2103 : 0 : operand = error_mark_node;
2104 : : }
2105 : : else
2106 : 3 : operand = error_mark_node;
2107 : :
2108 : 19588 : TREE_VALUE (t) = operand;
2109 : : }
2110 : :
2111 : 43715 : for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
2112 : : {
2113 : 16821 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2114 : 16821 : bool constraint_parsed
2115 : 16821 : = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
2116 : : oconstraints, &allows_mem, &allows_reg);
2117 : : /* If the operand is going to end up in memory, don't call
2118 : : decay_conversion. */
2119 : 16821 : if (constraint_parsed && !allows_reg && allows_mem)
2120 : 2829 : operand = mark_lvalue_use (TREE_VALUE (t));
2121 : : else
2122 : 13992 : operand = decay_conversion (TREE_VALUE (t), tf_warning_or_error);
2123 : :
2124 : : /* If the type of the operand hasn't been determined (e.g.,
2125 : : because it involves an overloaded function), then issue
2126 : : an error message. There's no context available to
2127 : : resolve the overloading. */
2128 : 16821 : if (TREE_TYPE (operand) == unknown_type_node)
2129 : : {
2130 : 3 : error_at (loc,
2131 : : "type of %<asm%> operand %qE could not be determined",
2132 : 3 : TREE_VALUE (t));
2133 : 3 : operand = error_mark_node;
2134 : : }
2135 : :
2136 : 16821 : if (constraint_parsed)
2137 : : {
2138 : : /* If the operand is going to end up in memory,
2139 : : mark it addressable. */
2140 : 16821 : if (!allows_reg && allows_mem)
2141 : : {
2142 : : /* Strip the nops as we allow this case. FIXME, this really
2143 : : should be rejected or made deprecated. */
2144 : 2829 : STRIP_NOPS (operand);
2145 : :
2146 : 2829 : tree *op = &operand;
2147 : 2836 : while (TREE_CODE (*op) == COMPOUND_EXPR)
2148 : 7 : op = &TREE_OPERAND (*op, 1);
2149 : 2829 : switch (TREE_CODE (*op))
2150 : : {
2151 : 27 : case PREINCREMENT_EXPR:
2152 : 27 : case PREDECREMENT_EXPR:
2153 : 27 : case MODIFY_EXPR:
2154 : 27 : *op = genericize_compound_lvalue (*op);
2155 : 27 : op = &TREE_OPERAND (*op, 1);
2156 : 27 : break;
2157 : : default:
2158 : : break;
2159 : : }
2160 : :
2161 : 2829 : if (!cxx_mark_addressable (*op))
2162 : 0 : operand = error_mark_node;
2163 : : }
2164 : 13992 : else if (!allows_reg && !allows_mem)
2165 : : {
2166 : : /* If constraint allows neither register nor memory,
2167 : : try harder to get a constant. */
2168 : 155 : tree constop = maybe_constant_value (operand);
2169 : 155 : if (TREE_CONSTANT (constop))
2170 : 140 : operand = constop;
2171 : : }
2172 : : }
2173 : : else
2174 : 0 : operand = error_mark_node;
2175 : :
2176 : 16821 : TREE_VALUE (t) = operand;
2177 : : }
2178 : : }
2179 : :
2180 : 31804 : r = build_stmt (loc, ASM_EXPR, string,
2181 : : output_operands, input_operands,
2182 : : clobbers, labels);
2183 : 31804 : ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
2184 : 31804 : ASM_INLINE_P (r) = inline_p;
2185 : 31804 : r = maybe_cleanup_point_expr_void (r);
2186 : 31804 : return add_stmt (r);
2187 : : }
2188 : :
2189 : : /* Finish a label with the indicated NAME. Returns the new label. */
2190 : :
2191 : : tree
2192 : 1841 : finish_label_stmt (tree name)
2193 : : {
2194 : 1841 : tree decl = define_label (input_location, name);
2195 : :
2196 : 1841 : if (decl == error_mark_node)
2197 : : return error_mark_node;
2198 : :
2199 : 1835 : add_stmt (build_stmt (input_location, LABEL_EXPR, decl));
2200 : :
2201 : 1835 : return decl;
2202 : : }
2203 : :
2204 : : /* Finish a series of declarations for local labels. G++ allows users
2205 : : to declare "local" labels, i.e., labels with scope. This extension
2206 : : is useful when writing code involving statement-expressions. */
2207 : :
2208 : : void
2209 : 195 : finish_label_decl (tree name)
2210 : : {
2211 : 195 : if (!at_function_scope_p ())
2212 : : {
2213 : 0 : error ("%<__label__%> declarations are only allowed in function scopes");
2214 : 0 : return;
2215 : : }
2216 : :
2217 : 195 : add_decl_expr (declare_local_label (name));
2218 : : }
2219 : :
2220 : : /* When DECL goes out of scope, make sure that CLEANUP is executed. */
2221 : :
2222 : : void
2223 : 3024463 : finish_decl_cleanup (tree decl, tree cleanup)
2224 : : {
2225 : 3024463 : push_cleanup (decl, cleanup, false);
2226 : 3024463 : }
2227 : :
2228 : : /* If the current scope exits with an exception, run CLEANUP. */
2229 : :
2230 : : void
2231 : 2016695 : finish_eh_cleanup (tree cleanup)
2232 : : {
2233 : 2016695 : push_cleanup (NULL, cleanup, true);
2234 : 2016695 : }
2235 : :
2236 : : /* The MEM_INITS is a list of mem-initializers, in reverse of the
2237 : : order they were written by the user. Each node is as for
2238 : : emit_mem_initializers. */
2239 : :
2240 : : void
2241 : 17189288 : finish_mem_initializers (tree mem_inits)
2242 : : {
2243 : : /* Reorder the MEM_INITS so that they are in the order they appeared
2244 : : in the source program. */
2245 : 17189288 : mem_inits = nreverse (mem_inits);
2246 : :
2247 : 17189288 : if (processing_template_decl)
2248 : : {
2249 : : tree mem;
2250 : :
2251 : 30031387 : for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
2252 : : {
2253 : : /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
2254 : : check for bare parameter packs in the TREE_VALUE, because
2255 : : any parameter packs in the TREE_VALUE have already been
2256 : : bound as part of the TREE_PURPOSE. See
2257 : : make_pack_expansion for more information. */
2258 : 17801756 : if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION
2259 : 17801756 : && check_for_bare_parameter_packs (TREE_VALUE (mem)))
2260 : 3 : TREE_VALUE (mem) = error_mark_node;
2261 : : }
2262 : :
2263 : 12229631 : add_stmt (build_min_nt_loc (UNKNOWN_LOCATION,
2264 : : CTOR_INITIALIZER, mem_inits));
2265 : : }
2266 : : else
2267 : 4959657 : emit_mem_initializers (mem_inits);
2268 : 17189288 : }
2269 : :
2270 : : /* Obfuscate EXPR if it looks like an id-expression or member access so
2271 : : that the call to finish_decltype in do_auto_deduction will give the
2272 : : right result. If EVEN_UNEVAL, do this even in unevaluated context. */
2273 : :
2274 : : tree
2275 : 29777324 : force_paren_expr (tree expr, bool even_uneval /* = false */)
2276 : : {
2277 : : /* This is only needed for decltype(auto) in C++14. */
2278 : 29777324 : if (cxx_dialect < cxx14)
2279 : : return expr;
2280 : :
2281 : : /* If we're in unevaluated context, we can't be deducing a
2282 : : return/initializer type, so we don't need to mess with this. */
2283 : 29150387 : if (cp_unevaluated_operand && !even_uneval)
2284 : : return expr;
2285 : :
2286 : 26736773 : if (TREE_CODE (expr) == COMPONENT_REF
2287 : 26681988 : || TREE_CODE (expr) == SCOPE_REF
2288 : 53414081 : || REFERENCE_REF_P (expr))
2289 : 288348 : REF_PARENTHESIZED_P (expr) = true;
2290 : 26448425 : else if (DECL_P (tree_strip_any_location_wrapper (expr)))
2291 : : {
2292 : 1867277 : location_t loc = cp_expr_location (expr);
2293 : 1867277 : const tree_code code = processing_template_decl ? PAREN_EXPR
2294 : : : VIEW_CONVERT_EXPR;
2295 : 1867277 : expr = build1_loc (loc, code, TREE_TYPE (expr), expr);
2296 : 1867277 : REF_PARENTHESIZED_P (expr) = true;
2297 : : }
2298 : : return expr;
2299 : : }
2300 : :
2301 : : /* If T is an id-expression obfuscated by force_paren_expr, undo the
2302 : : obfuscation and return the underlying id-expression. Otherwise
2303 : : return T. */
2304 : :
2305 : : tree
2306 : 688011713 : maybe_undo_parenthesized_ref (tree t)
2307 : : {
2308 : 688011713 : if (cxx_dialect < cxx14)
2309 : : return t;
2310 : :
2311 : 678280611 : if ((TREE_CODE (t) == PAREN_EXPR || TREE_CODE (t) == VIEW_CONVERT_EXPR)
2312 : 752639779 : && REF_PARENTHESIZED_P (t))
2313 : 262017 : t = TREE_OPERAND (t, 0);
2314 : :
2315 : : return t;
2316 : : }
2317 : :
2318 : : /* Finish a parenthesized expression EXPR. */
2319 : :
2320 : : cp_expr
2321 : 26631014 : finish_parenthesized_expr (cp_expr expr)
2322 : : {
2323 : 26631014 : if (EXPR_P (expr))
2324 : : {
2325 : : /* This inhibits warnings in maybe_warn_unparenthesized_assignment
2326 : : and c_common_truthvalue_conversion. */
2327 : 53007634 : suppress_warning (STRIP_REFERENCE_REF (*expr), OPT_Wparentheses);
2328 : : /* And maybe_warn_sizeof_array_div. */
2329 : 53007634 : suppress_warning (STRIP_REFERENCE_REF (*expr), OPT_Wsizeof_array_div);
2330 : : }
2331 : :
2332 : 26631014 : if (TREE_CODE (expr) == OFFSET_REF
2333 : 26631014 : || TREE_CODE (expr) == SCOPE_REF)
2334 : : /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
2335 : : enclosed in parentheses. */
2336 : 10779 : PTRMEM_OK_P (expr) = 0;
2337 : :
2338 : 26631014 : tree stripped_expr = tree_strip_any_location_wrapper (expr);
2339 : 26631014 : if (TREE_CODE (stripped_expr) == STRING_CST)
2340 : 831146 : PAREN_STRING_LITERAL_P (stripped_expr) = 1;
2341 : :
2342 : 26631014 : expr = cp_expr (force_paren_expr (expr), expr.get_location ());
2343 : :
2344 : 26631014 : return expr;
2345 : : }
2346 : :
2347 : : /* Finish a reference to a non-static data member (DECL) that is not
2348 : : preceded by `.' or `->'. */
2349 : :
2350 : : tree
2351 : 58788473 : finish_non_static_data_member (tree decl, tree object, tree qualifying_scope,
2352 : : tsubst_flags_t complain /* = tf_warning_or_error */)
2353 : : {
2354 : 58788473 : gcc_assert (TREE_CODE (decl) == FIELD_DECL);
2355 : 58788473 : bool try_omp_private = !object && omp_private_member_map;
2356 : 52410910 : tree ret;
2357 : :
2358 : 52410910 : if (!object)
2359 : : {
2360 : 52410910 : tree scope = qualifying_scope;
2361 : 52410910 : if (scope == NULL_TREE)
2362 : : {
2363 : 52367664 : scope = context_for_name_lookup (decl);
2364 : 52367664 : if (!TYPE_P (scope))
2365 : : {
2366 : : /* Can happen during error recovery (c++/85014). */
2367 : 3 : gcc_assert (seen_error ());
2368 : 3 : return error_mark_node;
2369 : : }
2370 : : }
2371 : 52410907 : object = maybe_dummy_object (scope, NULL);
2372 : : }
2373 : :
2374 : 58788470 : object = maybe_resolve_dummy (object, true);
2375 : 58788470 : if (object == error_mark_node)
2376 : : return error_mark_node;
2377 : :
2378 : : /* DR 613/850: Can use non-static data members without an associated
2379 : : object in sizeof/decltype/alignof. */
2380 : 58788467 : if (is_dummy_object (object)
2381 : 34142 : && !cp_unevaluated_operand
2382 : 58788559 : && (!processing_template_decl || !current_class_ref))
2383 : : {
2384 : 77 : if (complain & tf_error)
2385 : : {
2386 : 74 : auto_diagnostic_group d;
2387 : 74 : if (current_function_decl
2388 : 74 : && DECL_STATIC_FUNCTION_P (current_function_decl))
2389 : 3 : error ("invalid use of member %qD in static member function", decl);
2390 : 71 : else if (current_function_decl
2391 : 65 : && processing_contract_condition
2392 : 75 : && DECL_CONSTRUCTOR_P (current_function_decl))
2393 : 1 : error ("invalid use of member %qD in constructor %<pre%> contract", decl);
2394 : 70 : else if (current_function_decl
2395 : 64 : && processing_contract_condition
2396 : 72 : && DECL_DESTRUCTOR_P (current_function_decl))
2397 : 1 : error ("invalid use of member %qD in destructor %<post%> contract", decl);
2398 : : else
2399 : 69 : error ("invalid use of non-static data member %qD", decl);
2400 : 74 : inform (DECL_SOURCE_LOCATION (decl), "declared here");
2401 : 74 : }
2402 : :
2403 : 77 : return error_mark_node;
2404 : : }
2405 : :
2406 : 58788390 : if (current_class_ptr)
2407 : 58736298 : TREE_USED (current_class_ptr) = 1;
2408 : 58788390 : if (processing_template_decl)
2409 : : {
2410 : 47275808 : tree type = TREE_TYPE (decl);
2411 : :
2412 : 47275808 : if (TYPE_REF_P (type))
2413 : : /* Quals on the object don't matter. */;
2414 : 45562208 : else if (PACK_EXPANSION_P (type))
2415 : : /* Don't bother trying to represent this. */
2416 : : type = NULL_TREE;
2417 : 45562128 : else if (WILDCARD_TYPE_P (TREE_TYPE (object)))
2418 : : /* We don't know what the eventual quals will be, so punt until
2419 : : instantiation time.
2420 : :
2421 : : This can happen when called from build_capture_proxy for an explicit
2422 : : object lambda. It's a bit marginal to call this function in that
2423 : : case, since this function is for references to members of 'this',
2424 : : but the deduced type is required to be derived from the closure
2425 : : type, so it works. */
2426 : : type = NULL_TREE;
2427 : : else
2428 : : {
2429 : : /* Set the cv qualifiers. */
2430 : 45557977 : int quals = cp_type_quals (TREE_TYPE (object));
2431 : :
2432 : 45557977 : if (DECL_MUTABLE_P (decl))
2433 : 279883 : quals &= ~TYPE_QUAL_CONST;
2434 : :
2435 : 45557977 : quals |= cp_type_quals (TREE_TYPE (decl));
2436 : 45557977 : type = cp_build_qualified_type (type, quals);
2437 : : }
2438 : :
2439 : 47275808 : if (qualifying_scope)
2440 : : /* Wrap this in a SCOPE_REF for now. */
2441 : 29548 : ret = build_qualified_name (type, qualifying_scope, decl,
2442 : : /*template_p=*/false);
2443 : : else
2444 : 47246260 : ret = (convert_from_reference
2445 : 47246260 : (build_min (COMPONENT_REF, type, object, decl, NULL_TREE)));
2446 : : }
2447 : : /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
2448 : : QUALIFYING_SCOPE is also non-null. */
2449 : : else
2450 : : {
2451 : 11512582 : tree access_type = TREE_TYPE (object);
2452 : :
2453 : 11512582 : if (!perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
2454 : : decl, complain))
2455 : 0 : return error_mark_node;
2456 : :
2457 : : /* If the data member was named `C::M', convert `*this' to `C'
2458 : : first. */
2459 : 11512582 : if (qualifying_scope)
2460 : : {
2461 : 13665 : tree binfo = NULL_TREE;
2462 : 13665 : object = build_scoped_ref (object, qualifying_scope,
2463 : : &binfo);
2464 : : }
2465 : :
2466 : 11512582 : ret = build_class_member_access_expr (object, decl,
2467 : : /*access_path=*/NULL_TREE,
2468 : : /*preserve_reference=*/false,
2469 : : complain);
2470 : : }
2471 : 58788390 : if (try_omp_private)
2472 : : {
2473 : 1650 : tree *v = omp_private_member_map->get (decl);
2474 : 1650 : if (v)
2475 : 1225 : ret = convert_from_reference (*v);
2476 : : }
2477 : : return ret;
2478 : : }
2479 : :
2480 : : /* DECL was the declaration to which a qualified-id resolved. Issue
2481 : : an error message if it is not accessible. If OBJECT_TYPE is
2482 : : non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
2483 : : type of `*x', or `x', respectively. If the DECL was named as
2484 : : `A::B' then NESTED_NAME_SPECIFIER is `A'. Return value is like
2485 : : perform_access_checks above. */
2486 : :
2487 : : bool
2488 : 3713894728 : check_accessibility_of_qualified_id (tree decl,
2489 : : tree object_type,
2490 : : tree nested_name_specifier,
2491 : : tsubst_flags_t complain)
2492 : : {
2493 : : /* If we're not checking, return immediately. */
2494 : 3713894728 : if (deferred_access_no_check)
2495 : : return true;
2496 : :
2497 : : /* Determine the SCOPE of DECL. */
2498 : 3705750806 : tree scope = context_for_name_lookup (decl);
2499 : : /* If the SCOPE is not a type, then DECL is not a member. */
2500 : 3705750806 : if (!TYPE_P (scope)
2501 : : /* If SCOPE is dependent then we can't perform this access check now,
2502 : : and since we'll perform this access check again after substitution
2503 : : there's no need to explicitly defer it. */
2504 : 3705750806 : || dependent_type_p (scope))
2505 : 3415684742 : return true;
2506 : :
2507 : 290066064 : tree qualifying_type = NULL_TREE;
2508 : : /* Compute the scope through which DECL is being accessed. */
2509 : 290066064 : if (object_type
2510 : : /* OBJECT_TYPE might not be a class type; consider:
2511 : :
2512 : : class A { typedef int I; };
2513 : : I *p;
2514 : : p->A::I::~I();
2515 : :
2516 : : In this case, we will have "A::I" as the DECL, but "I" as the
2517 : : OBJECT_TYPE. */
2518 : 74281 : && CLASS_TYPE_P (object_type)
2519 : 290140328 : && DERIVED_FROM_P (scope, object_type))
2520 : : {
2521 : : /* If we are processing a `->' or `.' expression, use the type of the
2522 : : left-hand side. */
2523 : 74255 : if (tree open = currently_open_class (object_type))
2524 : : qualifying_type = open;
2525 : : else
2526 : : qualifying_type = object_type;
2527 : : }
2528 : 289991809 : else if (nested_name_specifier)
2529 : : {
2530 : : /* If the reference is to a non-static member of the
2531 : : current class, treat it as if it were referenced through
2532 : : `this'. */
2533 : 358526143 : if (DECL_NONSTATIC_MEMBER_P (decl)
2534 : 179423860 : && current_class_ptr)
2535 : 151457 : if (tree current = current_nonlambda_class_type ())
2536 : : {
2537 : 151430 : if (dependent_type_p (current))
2538 : : /* In general we can't know whether this access goes through
2539 : : `this' until instantiation time. Punt now, or else we might
2540 : : create a deferred access check that's not relative to `this'
2541 : : when it ought to be. We'll check this access again after
2542 : : substitution, e.g. from tsubst_qualified_id. */
2543 : : return true;
2544 : :
2545 : 15345 : if (DERIVED_FROM_P (scope, current))
2546 : : qualifying_type = current;
2547 : : }
2548 : : /* Otherwise, use the type indicated by the
2549 : : nested-name-specifier. */
2550 : : if (!qualifying_type)
2551 : : qualifying_type = nested_name_specifier;
2552 : : }
2553 : : else
2554 : : /* Otherwise, the name must be from the current class or one of
2555 : : its bases. */
2556 : 110728736 : qualifying_type = currently_open_derived_class (scope);
2557 : :
2558 : 289867236 : if (qualifying_type
2559 : : /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
2560 : : or similar in a default argument value. */
2561 : 289929979 : && CLASS_TYPE_P (qualifying_type))
2562 : 283603334 : return perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
2563 : 283603334 : decl, complain);
2564 : :
2565 : : return true;
2566 : : }
2567 : :
2568 : : /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
2569 : : class named to the left of the "::" operator. DONE is true if this
2570 : : expression is a complete postfix-expression; it is false if this
2571 : : expression is followed by '->', '[', '(', etc. ADDRESS_P is true
2572 : : iff this expression is the operand of '&'. TEMPLATE_P is true iff
2573 : : the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
2574 : : is true iff this qualified name appears as a template argument. */
2575 : :
2576 : : tree
2577 : 60523737 : finish_qualified_id_expr (tree qualifying_class,
2578 : : tree expr,
2579 : : bool done,
2580 : : bool address_p,
2581 : : bool template_p,
2582 : : bool template_arg_p,
2583 : : tsubst_flags_t complain)
2584 : : {
2585 : 60523737 : gcc_assert (TYPE_P (qualifying_class));
2586 : :
2587 : 60523737 : if (error_operand_p (expr))
2588 : 18 : return error_mark_node;
2589 : :
2590 : 60523719 : if (DECL_P (expr)
2591 : : /* Functions are marked after overload resolution; avoid redundant
2592 : : warnings. */
2593 : 51483119 : && TREE_CODE (expr) != FUNCTION_DECL
2594 : 112006814 : && !mark_used (expr, complain))
2595 : 0 : return error_mark_node;
2596 : :
2597 : 60523719 : if (template_p)
2598 : : {
2599 : 3187928 : if (TREE_CODE (expr) == UNBOUND_CLASS_TEMPLATE)
2600 : : {
2601 : : /* cp_parser_lookup_name thought we were looking for a type,
2602 : : but we're actually looking for a declaration. */
2603 : 9 : qualifying_class = TYPE_CONTEXT (expr);
2604 : 9 : expr = TYPE_IDENTIFIER (expr);
2605 : : }
2606 : : else
2607 : 3187919 : check_template_keyword (expr);
2608 : : }
2609 : :
2610 : : /* If EXPR occurs as the operand of '&', use special handling that
2611 : : permits a pointer-to-member. */
2612 : 60523719 : if (address_p && done
2613 : 156422 : && TREE_CODE (qualifying_class) != ENUMERAL_TYPE)
2614 : : {
2615 : 156420 : if (TREE_CODE (expr) == SCOPE_REF)
2616 : 0 : expr = TREE_OPERAND (expr, 1);
2617 : 156420 : expr = build_offset_ref (qualifying_class, expr,
2618 : : /*address_p=*/true, complain);
2619 : 156420 : return expr;
2620 : : }
2621 : :
2622 : : /* No need to check access within an enum. */
2623 : 60367299 : if (TREE_CODE (qualifying_class) == ENUMERAL_TYPE
2624 : 1572075 : && TREE_CODE (expr) != IDENTIFIER_NODE)
2625 : : return expr;
2626 : :
2627 : : /* Within the scope of a class, turn references to non-static
2628 : : members into expression of the form "this->...". */
2629 : 58795227 : if (template_arg_p)
2630 : : /* But, within a template argument, we do not want make the
2631 : : transformation, as there is no "this" pointer. */
2632 : : ;
2633 : 58792716 : else if (TREE_CODE (expr) == FIELD_DECL)
2634 : : {
2635 : 43246 : push_deferring_access_checks (dk_no_check);
2636 : 43246 : expr = finish_non_static_data_member (expr, NULL_TREE,
2637 : : qualifying_class, complain);
2638 : 43246 : pop_deferring_access_checks ();
2639 : : }
2640 : 58749470 : else if (BASELINK_P (expr))
2641 : : {
2642 : : /* See if any of the functions are non-static members. */
2643 : : /* If so, the expression may be relative to 'this'. */
2644 : 8638178 : if (!shared_member_p (expr)
2645 : 193884 : && current_class_ptr
2646 : 8831638 : && DERIVED_FROM_P (qualifying_class,
2647 : : current_nonlambda_class_type ()))
2648 : 193315 : expr = (build_class_member_access_expr
2649 : 193315 : (maybe_dummy_object (qualifying_class, NULL),
2650 : : expr,
2651 : 193315 : BASELINK_ACCESS_BINFO (expr),
2652 : : /*preserve_reference=*/false,
2653 : : complain));
2654 : 8444863 : else if (done)
2655 : : /* The expression is a qualified name whose address is not
2656 : : being taken. */
2657 : 331 : expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false,
2658 : : complain);
2659 : : }
2660 : 50111292 : else if (!template_p
2661 : 49866697 : && TREE_CODE (expr) == TEMPLATE_DECL
2662 : 50111400 : && !DECL_FUNCTION_TEMPLATE_P (expr))
2663 : : {
2664 : 108 : if (complain & tf_error)
2665 : 3 : error ("%qE missing template arguments", expr);
2666 : 108 : return error_mark_node;
2667 : : }
2668 : : else
2669 : : {
2670 : : /* In a template, return a SCOPE_REF for most qualified-ids
2671 : : so that we can check access at instantiation time. But if
2672 : : we're looking at a member of the current instantiation, we
2673 : : know we have access and building up the SCOPE_REF confuses
2674 : : non-type template argument handling. */
2675 : 50111184 : if (processing_template_decl
2676 : 50111184 : && (!currently_open_class (qualifying_class)
2677 : 3188 : || TREE_CODE (expr) == IDENTIFIER_NODE
2678 : 3188 : || TREE_CODE (expr) == TEMPLATE_ID_EXPR
2679 : 85 : || TREE_CODE (expr) == BIT_NOT_EXPR))
2680 : 9956636 : expr = build_qualified_name (TREE_TYPE (expr),
2681 : : qualifying_class, expr,
2682 : : template_p);
2683 : 40154548 : else if (tree wrap = maybe_get_tls_wrapper_call (expr))
2684 : 9 : expr = wrap;
2685 : :
2686 : 50111184 : expr = convert_from_reference (expr);
2687 : : }
2688 : :
2689 : : return expr;
2690 : : }
2691 : :
2692 : : /* Begin a statement-expression. The value returned must be passed to
2693 : : finish_stmt_expr. */
2694 : :
2695 : : tree
2696 : 3570704 : begin_stmt_expr (void)
2697 : : {
2698 : 3570704 : return push_stmt_list ();
2699 : : }
2700 : :
2701 : : /* Process the final expression of a statement expression. EXPR can be
2702 : : NULL, if the final expression is empty. Return a STATEMENT_LIST
2703 : : containing all the statements in the statement-expression, or
2704 : : ERROR_MARK_NODE if there was an error. */
2705 : :
2706 : : tree
2707 : 22095 : finish_stmt_expr_expr (tree expr, tree stmt_expr)
2708 : : {
2709 : 22095 : if (error_operand_p (expr))
2710 : : {
2711 : : /* The type of the statement-expression is the type of the last
2712 : : expression. */
2713 : 3 : TREE_TYPE (stmt_expr) = error_mark_node;
2714 : 3 : return error_mark_node;
2715 : : }
2716 : :
2717 : : /* If the last statement does not have "void" type, then the value
2718 : : of the last statement is the value of the entire expression. */
2719 : 22092 : if (expr)
2720 : : {
2721 : 22077 : tree type = TREE_TYPE (expr);
2722 : :
2723 : 22077 : if (type && type_unknown_p (type))
2724 : : {
2725 : 15 : error ("a statement expression is an insufficient context"
2726 : : " for overload resolution");
2727 : 15 : TREE_TYPE (stmt_expr) = error_mark_node;
2728 : 15 : return error_mark_node;
2729 : : }
2730 : 22062 : else if (processing_template_decl)
2731 : : {
2732 : 130 : expr = build_stmt (input_location, EXPR_STMT, expr);
2733 : 130 : expr = add_stmt (expr);
2734 : : /* Mark the last statement so that we can recognize it as such at
2735 : : template-instantiation time. */
2736 : 130 : EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
2737 : : }
2738 : 21932 : else if (VOID_TYPE_P (type))
2739 : : {
2740 : : /* Just treat this like an ordinary statement. */
2741 : 31 : expr = finish_expr_stmt (expr);
2742 : : }
2743 : : else
2744 : : {
2745 : : /* It actually has a value we need to deal with. First, force it
2746 : : to be an rvalue so that we won't need to build up a copy
2747 : : constructor call later when we try to assign it to something. */
2748 : 21901 : expr = force_rvalue (expr, tf_warning_or_error);
2749 : 21901 : if (error_operand_p (expr))
2750 : 0 : return error_mark_node;
2751 : :
2752 : : /* Update for array-to-pointer decay. */
2753 : 21901 : type = TREE_TYPE (expr);
2754 : :
2755 : : /* This TARGET_EXPR will initialize the outer one added by
2756 : : finish_stmt_expr. */
2757 : 21901 : set_target_expr_eliding (expr);
2758 : :
2759 : : /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
2760 : : normal statement, but don't convert to void or actually add
2761 : : the EXPR_STMT. */
2762 : 21901 : if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
2763 : 21901 : expr = maybe_cleanup_point_expr (expr);
2764 : 21901 : add_stmt (expr);
2765 : : }
2766 : :
2767 : : /* The type of the statement-expression is the type of the last
2768 : : expression. */
2769 : 22062 : TREE_TYPE (stmt_expr) = type;
2770 : : }
2771 : :
2772 : : return stmt_expr;
2773 : : }
2774 : :
2775 : : /* Finish a statement-expression. EXPR should be the value returned
2776 : : by the previous begin_stmt_expr. Returns an expression
2777 : : representing the statement-expression. */
2778 : :
2779 : : tree
2780 : 3570704 : finish_stmt_expr (tree stmt_expr, bool has_no_scope)
2781 : : {
2782 : 3570704 : tree type;
2783 : 3570704 : tree result;
2784 : :
2785 : 3570704 : if (error_operand_p (stmt_expr))
2786 : : {
2787 : 18 : pop_stmt_list (stmt_expr);
2788 : 18 : return error_mark_node;
2789 : : }
2790 : :
2791 : 3570686 : gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
2792 : :
2793 : 3570686 : type = TREE_TYPE (stmt_expr);
2794 : 3570686 : result = pop_stmt_list (stmt_expr);
2795 : 3570686 : TREE_TYPE (result) = type;
2796 : :
2797 : 3570686 : if (processing_template_decl)
2798 : : {
2799 : 8124 : result = build_min (STMT_EXPR, type, result);
2800 : 8124 : TREE_SIDE_EFFECTS (result) = 1;
2801 : 8124 : STMT_EXPR_NO_SCOPE (result) = has_no_scope;
2802 : : }
2803 : 3562562 : else if (CLASS_TYPE_P (type))
2804 : : {
2805 : : /* Wrap the statement-expression in a TARGET_EXPR so that the
2806 : : temporary object created by the final expression is destroyed at
2807 : : the end of the full-expression containing the
2808 : : statement-expression. */
2809 : 97 : result = force_target_expr (type, result, tf_warning_or_error);
2810 : : }
2811 : :
2812 : : return result;
2813 : : }
2814 : :
2815 : : /* Returns the expression which provides the value of STMT_EXPR. */
2816 : :
2817 : : tree
2818 : 145 : stmt_expr_value_expr (tree stmt_expr)
2819 : : {
2820 : 145 : tree t = STMT_EXPR_STMT (stmt_expr);
2821 : :
2822 : 145 : if (TREE_CODE (t) == BIND_EXPR)
2823 : 145 : t = BIND_EXPR_BODY (t);
2824 : :
2825 : 145 : if (TREE_CODE (t) == STATEMENT_LIST && STATEMENT_LIST_TAIL (t))
2826 : 110 : t = STATEMENT_LIST_TAIL (t)->stmt;
2827 : :
2828 : 145 : if (TREE_CODE (t) == EXPR_STMT)
2829 : 125 : t = EXPR_STMT_EXPR (t);
2830 : :
2831 : 145 : return t;
2832 : : }
2833 : :
2834 : : /* Return TRUE iff EXPR_STMT is an empty list of
2835 : : expression statements. */
2836 : :
2837 : : bool
2838 : 44321226 : empty_expr_stmt_p (tree expr_stmt)
2839 : : {
2840 : 44321229 : tree body = NULL_TREE;
2841 : :
2842 : 44321229 : if (expr_stmt == void_node)
2843 : : return true;
2844 : :
2845 : 44321226 : if (expr_stmt)
2846 : : {
2847 : 44321226 : if (TREE_CODE (expr_stmt) == EXPR_STMT)
2848 : 3 : body = EXPR_STMT_EXPR (expr_stmt);
2849 : 44321223 : else if (TREE_CODE (expr_stmt) == STATEMENT_LIST)
2850 : : body = expr_stmt;
2851 : : }
2852 : :
2853 : 3 : if (body)
2854 : : {
2855 : 43794278 : if (TREE_CODE (body) == STATEMENT_LIST)
2856 : 43794275 : return tsi_end_p (tsi_start (body));
2857 : : else
2858 : : return empty_expr_stmt_p (body);
2859 : : }
2860 : : return false;
2861 : : }
2862 : :
2863 : : /* Perform Koenig lookup. FN_EXPR is the postfix-expression representing
2864 : : the function (or functions) to call; ARGS are the arguments to the
2865 : : call. Returns the functions to be considered by overload resolution. */
2866 : :
2867 : : cp_expr
2868 : 17926744 : perform_koenig_lookup (cp_expr fn_expr, vec<tree, va_gc> *args,
2869 : : tsubst_flags_t complain)
2870 : : {
2871 : 17926744 : tree identifier = NULL_TREE;
2872 : 17926744 : tree functions = NULL_TREE;
2873 : 17926744 : tree tmpl_args = NULL_TREE;
2874 : 17926744 : bool template_id = false;
2875 : 17926744 : location_t loc = fn_expr.get_location ();
2876 : 17926744 : tree fn = fn_expr.get_value ();
2877 : :
2878 : 17926744 : STRIP_ANY_LOCATION_WRAPPER (fn);
2879 : :
2880 : 17926744 : if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2881 : : {
2882 : : /* Use a separate flag to handle null args. */
2883 : 1847754 : template_id = true;
2884 : 1847754 : tmpl_args = TREE_OPERAND (fn, 1);
2885 : 1847754 : fn = TREE_OPERAND (fn, 0);
2886 : : }
2887 : :
2888 : : /* Find the name of the overloaded function. */
2889 : 17926744 : if (identifier_p (fn))
2890 : : identifier = fn;
2891 : : else
2892 : : {
2893 : 23788504 : functions = fn;
2894 : 17838938 : identifier = OVL_NAME (functions);
2895 : : }
2896 : :
2897 : : /* A call to a namespace-scope function using an unqualified name.
2898 : :
2899 : : Do Koenig lookup -- unless any of the arguments are
2900 : : type-dependent. */
2901 : 17926744 : if (!any_type_dependent_arguments_p (args)
2902 : 17926744 : && !any_dependent_template_arguments_p (tmpl_args))
2903 : : {
2904 : 17095645 : fn = lookup_arg_dependent (identifier, functions, args);
2905 : 17095645 : if (!fn)
2906 : : {
2907 : : /* The unqualified name could not be resolved. */
2908 : 21005 : if (complain & tf_error)
2909 : 376 : fn = unqualified_fn_lookup_error (cp_expr (identifier, loc));
2910 : : else
2911 : : fn = identifier;
2912 : : }
2913 : : }
2914 : :
2915 : 17926744 : if (fn && template_id && fn != error_mark_node)
2916 : 1847743 : fn = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fn, tmpl_args);
2917 : :
2918 : 17926744 : return cp_expr (fn, loc);
2919 : : }
2920 : :
2921 : : /* Generate an expression for `FN (ARGS)'. This may change the
2922 : : contents of ARGS.
2923 : :
2924 : : If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2925 : : as a virtual call, even if FN is virtual. (This flag is set when
2926 : : encountering an expression where the function name is explicitly
2927 : : qualified. For example a call to `X::f' never generates a virtual
2928 : : call.)
2929 : :
2930 : : Returns code for the call. */
2931 : :
2932 : : tree
2933 : 268510253 : finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
2934 : : bool koenig_p, tsubst_flags_t complain)
2935 : : {
2936 : 268510253 : tree result;
2937 : 268510253 : tree orig_fn;
2938 : 268510253 : vec<tree, va_gc> *orig_args = *args;
2939 : :
2940 : 268510253 : if (fn == error_mark_node)
2941 : : return error_mark_node;
2942 : :
2943 : 268509272 : gcc_assert (!TYPE_P (fn));
2944 : :
2945 : : /* If FN may be a FUNCTION_DECL obfuscated by force_paren_expr, undo
2946 : : it so that we can tell this is a call to a known function. */
2947 : 268509272 : fn = maybe_undo_parenthesized_ref (fn);
2948 : :
2949 : 268509272 : STRIP_ANY_LOCATION_WRAPPER (fn);
2950 : :
2951 : 268509272 : orig_fn = fn;
2952 : :
2953 : 268509272 : if (processing_template_decl)
2954 : : {
2955 : : /* If FN is a local extern declaration (or set thereof) in a template,
2956 : : look it up again at instantiation time. */
2957 : 186306874 : if (is_overloaded_fn (fn))
2958 : : {
2959 : 115608714 : tree ifn = get_first_fn (fn);
2960 : 115608714 : if (TREE_CODE (ifn) == FUNCTION_DECL
2961 : 115608714 : && dependent_local_decl_p (ifn))
2962 : 15650 : orig_fn = DECL_NAME (ifn);
2963 : : }
2964 : :
2965 : : /* If the call expression is dependent, build a CALL_EXPR node
2966 : : with no type; type_dependent_expression_p recognizes
2967 : : expressions with no type as being dependent. */
2968 : 186306874 : if (type_dependent_expression_p (fn)
2969 : 186306874 : || any_type_dependent_arguments_p (*args))
2970 : : {
2971 : 164962988 : result = build_min_nt_call_vec (orig_fn, *args);
2972 : 219488905 : SET_EXPR_LOCATION (result, cp_expr_loc_or_input_loc (fn));
2973 : 164962988 : KOENIG_LOOKUP_P (result) = koenig_p;
2974 : : /* Disable the std::move warnings since this call was dependent
2975 : : (c++/89780, c++/107363). This also suppresses the
2976 : : -Wredundant-move warning. */
2977 : 164962988 : suppress_warning (result, OPT_Wpessimizing_move);
2978 : :
2979 : 164962988 : if (cfun && cp_function_chain && !cp_unevaluated_operand)
2980 : : {
2981 : 142878172 : bool abnormal = true;
2982 : 142975275 : for (lkp_iterator iter (maybe_get_fns (fn)); iter; ++iter)
2983 : : {
2984 : 79511110 : tree fndecl = STRIP_TEMPLATE (*iter);
2985 : 79511110 : if (TREE_CODE (fndecl) != FUNCTION_DECL
2986 : 79511110 : || !TREE_THIS_VOLATILE (fndecl))
2987 : : {
2988 : : abnormal = false;
2989 : : break;
2990 : : }
2991 : : }
2992 : : /* FIXME: Stop warning about falling off end of non-void
2993 : : function. But this is wrong. Even if we only see
2994 : : no-return fns at this point, we could select a
2995 : : future-defined return fn during instantiation. Or
2996 : : vice-versa. */
2997 : 142878172 : if (abnormal)
2998 : 63464165 : current_function_returns_abnormally = 1;
2999 : : }
3000 : 164962988 : if (TREE_CODE (fn) == COMPONENT_REF)
3001 : 81892565 : maybe_generic_this_capture (TREE_OPERAND (fn, 0),
3002 : 81892565 : TREE_OPERAND (fn, 1));
3003 : 164962988 : return result;
3004 : : }
3005 : 21343886 : orig_args = make_tree_vector_copy (*args);
3006 : : }
3007 : :
3008 : 103546284 : if (TREE_CODE (fn) == COMPONENT_REF)
3009 : : {
3010 : 21103537 : tree member = TREE_OPERAND (fn, 1);
3011 : 21103537 : if (BASELINK_P (member))
3012 : : {
3013 : 20927981 : tree object = TREE_OPERAND (fn, 0);
3014 : 41691254 : return build_new_method_call (object, member,
3015 : : args, NULL_TREE,
3016 : : (disallow_virtual
3017 : : ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
3018 : : : LOOKUP_NORMAL),
3019 : : /*fn_p=*/NULL,
3020 : 20927981 : complain);
3021 : : }
3022 : : }
3023 : :
3024 : : /* Per 13.3.1.1, '(&f)(...)' is the same as '(f)(...)'. */
3025 : 82618303 : if (TREE_CODE (fn) == ADDR_EXPR
3026 : 82618303 : && TREE_CODE (TREE_OPERAND (fn, 0)) == OVERLOAD)
3027 : 9 : fn = TREE_OPERAND (fn, 0);
3028 : :
3029 : 82618303 : if (is_overloaded_fn (fn))
3030 : 79039395 : fn = baselink_for_fns (fn);
3031 : :
3032 : 82618303 : result = NULL_TREE;
3033 : 82618303 : if (BASELINK_P (fn))
3034 : : {
3035 : 14578706 : tree object;
3036 : :
3037 : : /* A call to a member function. From [over.call.func]:
3038 : :
3039 : : If the keyword this is in scope and refers to the class of
3040 : : that member function, or a derived class thereof, then the
3041 : : function call is transformed into a qualified function call
3042 : : using (*this) as the postfix-expression to the left of the
3043 : : . operator.... [Otherwise] a contrived object of type T
3044 : : becomes the implied object argument.
3045 : :
3046 : : In this situation:
3047 : :
3048 : : struct A { void f(); };
3049 : : struct B : public A {};
3050 : : struct C : public A { void g() { B::f(); }};
3051 : :
3052 : : "the class of that member function" refers to `A'. But 11.2
3053 : : [class.access.base] says that we need to convert 'this' to B* as
3054 : : part of the access, so we pass 'B' to maybe_dummy_object. */
3055 : :
3056 : 14578706 : if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (get_first_fn (fn)))
3057 : : {
3058 : : /* A constructor call always uses a dummy object. (This constructor
3059 : : call which has the form A::A () is actually invalid and we are
3060 : : going to reject it later in build_new_method_call.) */
3061 : 39 : object = build_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)));
3062 : : }
3063 : : else
3064 : 14578667 : object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
3065 : : NULL);
3066 : :
3067 : 15971051 : result = build_new_method_call (object, fn, args, NULL_TREE,
3068 : : (disallow_virtual
3069 : : ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
3070 : : : LOOKUP_NORMAL),
3071 : : /*fn_p=*/NULL,
3072 : : complain);
3073 : : }
3074 : 68039597 : else if (concept_check_p (fn))
3075 : : {
3076 : 3 : error_at (EXPR_LOC_OR_LOC (fn, input_location),
3077 : : "cannot call a concept as a function");
3078 : 3 : return error_mark_node;
3079 : : }
3080 : 68039594 : else if (is_overloaded_fn (fn))
3081 : : {
3082 : : /* If the function is an overloaded builtin, resolve it. */
3083 : 64460689 : if (TREE_CODE (fn) == FUNCTION_DECL
3084 : 64460689 : && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
3085 : 14399748 : || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
3086 : 10920988 : result = resolve_overloaded_builtin (input_location, fn, *args);
3087 : :
3088 : 10920988 : if (!result)
3089 : : {
3090 : 64232409 : tree alloc_size_attr = NULL_TREE;
3091 : 64232409 : if (warn_calloc_transposed_args
3092 : 565383 : && TREE_CODE (fn) == FUNCTION_DECL
3093 : 64232409 : && (alloc_size_attr
3094 : 421361 : = lookup_attribute ("alloc_size",
3095 : 421361 : TYPE_ATTRIBUTES (TREE_TYPE (fn)))))
3096 : 3049 : if (TREE_VALUE (alloc_size_attr) == NULL_TREE
3097 : 3049 : || TREE_CHAIN (TREE_VALUE (alloc_size_attr)) == NULL_TREE)
3098 : : alloc_size_attr = NULL_TREE;
3099 : 62633747 : if ((warn_sizeof_pointer_memaccess || alloc_size_attr)
3100 : 1598722 : && (complain & tf_warning)
3101 : 1478398 : && !vec_safe_is_empty (*args)
3102 : 65375911 : && !processing_template_decl)
3103 : : {
3104 : : location_t sizeof_arg_loc[6];
3105 : : tree sizeof_arg[6];
3106 : : unsigned int i;
3107 : 8209076 : for (i = 0; i < (alloc_size_attr ? 6 : 3); i++)
3108 : : {
3109 : 3078606 : tree t;
3110 : :
3111 : 3078606 : sizeof_arg_loc[i] = UNKNOWN_LOCATION;
3112 : 3078606 : sizeof_arg[i] = NULL_TREE;
3113 : 3078606 : if (i >= (*args)->length ())
3114 : 611414 : continue;
3115 : 2467192 : t = (**args)[i];
3116 : 2467192 : if (TREE_CODE (t) != SIZEOF_EXPR)
3117 : 2461082 : continue;
3118 : 6110 : if (SIZEOF_EXPR_TYPE_P (t))
3119 : 2252 : sizeof_arg[i] = TREE_TYPE (TREE_OPERAND (t, 0));
3120 : : else
3121 : 3858 : sizeof_arg[i] = TREE_OPERAND (t, 0);
3122 : 6110 : sizeof_arg_loc[i] = EXPR_LOCATION (t);
3123 : : }
3124 : 1026142 : if (warn_sizeof_pointer_memaccess)
3125 : : {
3126 : 1026082 : auto same_p = same_type_ignoring_top_level_qualifiers_p;
3127 : 1026082 : sizeof_pointer_memaccess_warning (sizeof_arg_loc, fn, *args,
3128 : : sizeof_arg, same_p);
3129 : : }
3130 : 1026142 : if (alloc_size_attr)
3131 : 60 : warn_for_calloc (sizeof_arg_loc, fn, *args, sizeof_arg,
3132 : : alloc_size_attr);
3133 : : }
3134 : :
3135 : 64232409 : if ((complain & tf_warning)
3136 : 46227633 : && TREE_CODE (fn) == FUNCTION_DECL
3137 : 23925613 : && fndecl_built_in_p (fn, BUILT_IN_MEMSET)
3138 : 98305 : && vec_safe_length (*args) == 3
3139 : 64330714 : && !any_type_dependent_arguments_p (*args))
3140 : : {
3141 : 98305 : tree arg0 = (*orig_args)[0];
3142 : 98305 : tree arg1 = (*orig_args)[1];
3143 : 98305 : tree arg2 = (*orig_args)[2];
3144 : 98305 : int literal_mask = ((literal_integer_zerop (arg1) << 1)
3145 : 98305 : | (literal_integer_zerop (arg2) << 2));
3146 : 98305 : warn_for_memset (input_location, arg0, arg2, literal_mask);
3147 : : }
3148 : :
3149 : : /* A call to a namespace-scope function. */
3150 : 64232409 : result = build_new_function_call (fn, args, complain);
3151 : : }
3152 : : }
3153 : 3578905 : else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
3154 : : {
3155 : 36452 : if (!vec_safe_is_empty (*args))
3156 : 0 : error ("arguments to destructor are not allowed");
3157 : : /* C++20/DR: If the postfix-expression names a pseudo-destructor (in
3158 : : which case the postfix-expression is a possibly-parenthesized class
3159 : : member access), the function call destroys the object of scalar type
3160 : : denoted by the object expression of the class member access. */
3161 : 36452 : tree ob = TREE_OPERAND (fn, 0);
3162 : 36452 : if (obvalue_p (ob))
3163 : 36434 : result = build_trivial_dtor_call (ob, true);
3164 : : else
3165 : : /* No location to clobber. */
3166 : 18 : result = convert_to_void (ob, ICV_STATEMENT, complain);
3167 : : }
3168 : 3542453 : else if (CLASS_TYPE_P (TREE_TYPE (fn)))
3169 : : /* If the "function" is really an object of class type, it might
3170 : : have an overloaded `operator ()'. */
3171 : 1406032 : result = build_op_call (fn, args, complain);
3172 : :
3173 : 80240081 : if (!result)
3174 : : /* A call where the function is unknown. */
3175 : 2136421 : result = cp_build_function_call_vec (fn, args, complain);
3176 : :
3177 : 82604782 : if (processing_template_decl && result != error_mark_node)
3178 : : {
3179 : 17443594 : if (INDIRECT_REF_P (result))
3180 : 1022883 : result = TREE_OPERAND (result, 0);
3181 : :
3182 : : /* Prune all but the selected function from the original overload
3183 : : set so that we can avoid some duplicate work at instantiation time. */
3184 : 17443594 : if (TREE_CODE (result) == CALL_EXPR
3185 : 17429830 : && really_overloaded_fn (orig_fn))
3186 : : {
3187 : 7155995 : tree sel_fn = CALL_EXPR_FN (result);
3188 : 7155995 : if (TREE_CODE (sel_fn) == COMPONENT_REF)
3189 : : {
3190 : : /* The non-dependent result of build_new_method_call. */
3191 : 2209242 : sel_fn = TREE_OPERAND (sel_fn, 1);
3192 : 2209242 : gcc_assert (BASELINK_P (sel_fn));
3193 : : }
3194 : 4946753 : else if (TREE_CODE (sel_fn) == ADDR_EXPR)
3195 : : /* Our original callee wasn't wrapped in an ADDR_EXPR,
3196 : : so strip this ADDR_EXPR added by build_over_call. */
3197 : 4946753 : sel_fn = TREE_OPERAND (sel_fn, 0);
3198 : : orig_fn = sel_fn;
3199 : : }
3200 : :
3201 : 17443594 : result = build_call_vec (TREE_TYPE (result), orig_fn, orig_args);
3202 : 17443594 : SET_EXPR_LOCATION (result, input_location);
3203 : 17443594 : KOENIG_LOOKUP_P (result) = koenig_p;
3204 : 17443594 : release_tree_vector (orig_args);
3205 : 17443594 : result = convert_from_reference (result);
3206 : : }
3207 : :
3208 : : return result;
3209 : : }
3210 : :
3211 : : /* Finish a call to a postfix increment or decrement or EXPR. (Which
3212 : : is indicated by CODE, which should be POSTINCREMENT_EXPR or
3213 : : POSTDECREMENT_EXPR.) */
3214 : :
3215 : : cp_expr
3216 : 2141500 : finish_increment_expr (cp_expr expr, enum tree_code code)
3217 : : {
3218 : : /* input_location holds the location of the trailing operator token.
3219 : : Build a location of the form:
3220 : : expr++
3221 : : ~~~~^~
3222 : : with the caret at the operator token, ranging from the start
3223 : : of EXPR to the end of the operator token. */
3224 : 2141500 : location_t combined_loc = make_location (input_location,
3225 : : expr.get_start (),
3226 : : get_finish (input_location));
3227 : 2141500 : cp_expr result = build_x_unary_op (combined_loc, code, expr,
3228 : 2141500 : NULL_TREE, tf_warning_or_error);
3229 : : /* TODO: build_x_unary_op doesn't honor the location, so set it here. */
3230 : 2141500 : result.set_location (combined_loc);
3231 : 2141500 : return result;
3232 : : }
3233 : :
3234 : : /* Finish a use of `this'. Returns an expression for `this'. */
3235 : :
3236 : : tree
3237 : 30001910 : finish_this_expr (void)
3238 : : {
3239 : 30001910 : tree result = NULL_TREE;
3240 : :
3241 : 30001910 : if (current_class_ptr)
3242 : : {
3243 : 30001866 : tree type = TREE_TYPE (current_class_ref);
3244 : :
3245 : : /* In a lambda expression, 'this' refers to the captured 'this'. */
3246 : 60003708 : if (LAMBDA_TYPE_P (type))
3247 : 202650 : result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type), true);
3248 : : else
3249 : 29799216 : result = current_class_ptr;
3250 : : }
3251 : :
3252 : 30001866 : if (result)
3253 : : /* The keyword 'this' is a prvalue expression. */
3254 : 30001863 : return rvalue (result);
3255 : :
3256 : 47 : tree fn = current_nonlambda_function ();
3257 : 47 : if (fn && DECL_XOBJ_MEMBER_FUNCTION_P (fn))
3258 : : {
3259 : 4 : auto_diagnostic_group d;
3260 : 4 : error ("%<this%> is unavailable for explicit object member "
3261 : : "functions");
3262 : 4 : tree xobj_parm = DECL_ARGUMENTS (fn);
3263 : 4 : gcc_assert (xobj_parm);
3264 : 4 : tree parm_name = DECL_NAME (xobj_parm);
3265 : :
3266 : 4 : static tree remembered_fn = NULL_TREE;
3267 : : /* Only output this diagnostic once per function. */
3268 : 4 : if (remembered_fn == fn)
3269 : : /* Early escape. */;
3270 : 4 : else if (parm_name)
3271 : 4 : inform (DECL_SOURCE_LOCATION (xobj_parm),
3272 : : "use explicit object parameter %qs instead",
3273 : 2 : IDENTIFIER_POINTER (parm_name));
3274 : : else
3275 : 2 : inform (DECL_SOURCE_LOCATION (xobj_parm),
3276 : : "name the explicit object parameter");
3277 : :
3278 : 4 : remembered_fn = fn;
3279 : 4 : }
3280 : 43 : else if (fn && DECL_STATIC_FUNCTION_P (fn))
3281 : 3 : error ("%<this%> is unavailable for static member functions");
3282 : 40 : else if (fn && processing_contract_condition && DECL_CONSTRUCTOR_P (fn))
3283 : 0 : error ("invalid use of %<this%> before it is valid");
3284 : 40 : else if (fn && processing_contract_condition && DECL_DESTRUCTOR_P (fn))
3285 : 0 : error ("invalid use of %<this%> after it is valid");
3286 : 40 : else if (fn)
3287 : 22 : error ("invalid use of %<this%> in non-member function");
3288 : : else
3289 : 18 : error ("invalid use of %<this%> at top level");
3290 : 47 : return error_mark_node;
3291 : : }
3292 : :
3293 : : /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
3294 : : expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
3295 : : the TYPE for the type given. If SCOPE is non-NULL, the expression
3296 : : was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
3297 : :
3298 : : tree
3299 : 36500 : finish_pseudo_destructor_expr (tree object, tree scope, tree destructor,
3300 : : location_t loc)
3301 : : {
3302 : 36500 : if (object == error_mark_node || destructor == error_mark_node)
3303 : : return error_mark_node;
3304 : :
3305 : 36491 : gcc_assert (TYPE_P (destructor));
3306 : :
3307 : 36491 : if (!processing_template_decl)
3308 : : {
3309 : 36470 : if (scope == error_mark_node)
3310 : : {
3311 : 0 : error_at (loc, "invalid qualifying scope in pseudo-destructor name");
3312 : 0 : return error_mark_node;
3313 : : }
3314 : 36470 : if (is_auto (destructor))
3315 : 3 : destructor = TREE_TYPE (object);
3316 : 36470 : if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
3317 : : {
3318 : 3 : error_at (loc,
3319 : : "qualified type %qT does not match destructor name ~%qT",
3320 : : scope, destructor);
3321 : 3 : return error_mark_node;
3322 : : }
3323 : :
3324 : :
3325 : : /* [expr.pseudo] says both:
3326 : :
3327 : : The type designated by the pseudo-destructor-name shall be
3328 : : the same as the object type.
3329 : :
3330 : : and:
3331 : :
3332 : : The cv-unqualified versions of the object type and of the
3333 : : type designated by the pseudo-destructor-name shall be the
3334 : : same type.
3335 : :
3336 : : We implement the more generous second sentence, since that is
3337 : : what most other compilers do. */
3338 : 36467 : if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
3339 : : destructor))
3340 : : {
3341 : 9 : error_at (loc, "%qE is not of type %qT", object, destructor);
3342 : 9 : return error_mark_node;
3343 : : }
3344 : : }
3345 : :
3346 : 36479 : tree type = (type_dependent_expression_p (object)
3347 : 36479 : ? NULL_TREE : void_type_node);
3348 : :
3349 : 36479 : return build3_loc (loc, PSEUDO_DTOR_EXPR, type, object,
3350 : 36479 : scope, destructor);
3351 : : }
3352 : :
3353 : : /* Finish an expression of the form CODE EXPR. */
3354 : :
3355 : : cp_expr
3356 : 29247375 : finish_unary_op_expr (location_t op_loc, enum tree_code code, cp_expr expr,
3357 : : tsubst_flags_t complain)
3358 : : {
3359 : : /* Build a location of the form:
3360 : : ++expr
3361 : : ^~~~~~
3362 : : with the caret at the operator token, ranging from the start
3363 : : of the operator token to the end of EXPR. */
3364 : 29247375 : location_t combined_loc = make_location (op_loc,
3365 : : op_loc, expr.get_finish ());
3366 : 29247375 : cp_expr result = build_x_unary_op (combined_loc, code, expr,
3367 : 29247375 : NULL_TREE, complain);
3368 : : /* TODO: build_x_unary_op doesn't always honor the location. */
3369 : 29247375 : result.set_location (combined_loc);
3370 : :
3371 : 29247375 : if (result == error_mark_node)
3372 : 362 : return result;
3373 : :
3374 : 29247013 : if (!(complain & tf_warning))
3375 : 0 : return result;
3376 : :
3377 : 29247013 : tree result_ovl = result;
3378 : 29247013 : tree expr_ovl = expr;
3379 : :
3380 : 29247013 : if (!processing_template_decl)
3381 : 2397816 : expr_ovl = cp_fully_fold (expr_ovl);
3382 : :
3383 : 29247013 : if (!CONSTANT_CLASS_P (expr_ovl)
3384 : 29247013 : || TREE_OVERFLOW_P (expr_ovl))
3385 : 29053131 : return result;
3386 : :
3387 : 193882 : if (!processing_template_decl)
3388 : 184125 : result_ovl = cp_fully_fold (result_ovl);
3389 : :
3390 : 193882 : if (CONSTANT_CLASS_P (result_ovl) && TREE_OVERFLOW_P (result_ovl))
3391 : 9 : overflow_warning (combined_loc, result_ovl);
3392 : :
3393 : 193882 : return result;
3394 : : }
3395 : :
3396 : : /* Return true if CONSTRUCTOR EXPR after pack expansion could have no
3397 : : elements. */
3398 : :
3399 : : static bool
3400 : 12 : maybe_zero_constructor_nelts (tree expr)
3401 : : {
3402 : 12 : if (CONSTRUCTOR_NELTS (expr) == 0)
3403 : : return true;
3404 : 12 : if (!processing_template_decl)
3405 : : return false;
3406 : 30 : for (constructor_elt &elt : CONSTRUCTOR_ELTS (expr))
3407 : 21 : if (!PACK_EXPANSION_P (elt.value))
3408 : : return false;
3409 : : return true;
3410 : : }
3411 : :
3412 : : /* Finish a compound-literal expression or C++11 functional cast with aggregate
3413 : : initializer. TYPE is the type to which the CONSTRUCTOR in COMPOUND_LITERAL
3414 : : is being cast. */
3415 : :
3416 : : tree
3417 : 6381256 : finish_compound_literal (tree type, tree compound_literal,
3418 : : tsubst_flags_t complain,
3419 : : fcl_t fcl_context)
3420 : : {
3421 : 6381256 : if (type == error_mark_node)
3422 : : return error_mark_node;
3423 : :
3424 : 6381243 : if (TYPE_REF_P (type))
3425 : : {
3426 : 12 : compound_literal
3427 : 12 : = finish_compound_literal (TREE_TYPE (type), compound_literal,
3428 : : complain, fcl_context);
3429 : : /* The prvalue is then used to direct-initialize the reference. */
3430 : 12 : tree r = (perform_implicit_conversion_flags
3431 : 12 : (type, compound_literal, complain, LOOKUP_NORMAL));
3432 : 12 : return convert_from_reference (r);
3433 : : }
3434 : :
3435 : 6381231 : if (!TYPE_OBJ_P (type))
3436 : : {
3437 : : /* DR2351 */
3438 : 60 : if (VOID_TYPE_P (type) && CONSTRUCTOR_NELTS (compound_literal) == 0)
3439 : : {
3440 : 12 : if (!processing_template_decl)
3441 : 9 : return void_node;
3442 : 3 : TREE_TYPE (compound_literal) = type;
3443 : 3 : TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
3444 : 3 : CONSTRUCTOR_IS_DEPENDENT (compound_literal) = 0;
3445 : 3 : return compound_literal;
3446 : : }
3447 : 21 : else if (VOID_TYPE_P (type)
3448 : 15 : && processing_template_decl
3449 : 33 : && maybe_zero_constructor_nelts (compound_literal))
3450 : : /* If there are only packs in compound_literal, it could
3451 : : be void{} after pack expansion. */;
3452 : : else
3453 : : {
3454 : 12 : if (complain & tf_error)
3455 : 9 : error ("compound literal of non-object type %qT", type);
3456 : 12 : return error_mark_node;
3457 : : }
3458 : : }
3459 : :
3460 : 6381207 : if (template_placeholder_p (type))
3461 : : {
3462 : 40604 : type = do_auto_deduction (type, compound_literal, type, complain,
3463 : : adc_variable_type);
3464 : 40604 : if (type == error_mark_node)
3465 : : return error_mark_node;
3466 : : }
3467 : : /* C++23 auto{x}. */
3468 : 6340603 : else if (is_auto (type)
3469 : 109 : && !AUTO_IS_DECLTYPE (type)
3470 : 6340710 : && CONSTRUCTOR_NELTS (compound_literal) == 1)
3471 : : {
3472 : 101 : if (is_constrained_auto (type))
3473 : : {
3474 : 2 : if (complain & tf_error)
3475 : 2 : error ("%<auto{x}%> cannot be constrained");
3476 : 2 : return error_mark_node;
3477 : : }
3478 : 99 : else if (cxx_dialect < cxx23)
3479 : 1 : pedwarn (input_location, OPT_Wc__23_extensions,
3480 : : "%<auto{x}%> only available with "
3481 : : "%<-std=c++2b%> or %<-std=gnu++2b%>");
3482 : 99 : type = do_auto_deduction (type, compound_literal, type, complain,
3483 : : adc_variable_type);
3484 : 99 : if (type == error_mark_node)
3485 : : return error_mark_node;
3486 : : }
3487 : :
3488 : : /* Used to hold a copy of the compound literal in a template. */
3489 : 6381106 : tree orig_cl = NULL_TREE;
3490 : :
3491 : 6381106 : if (processing_template_decl)
3492 : : {
3493 : 3064365 : const bool dependent_p
3494 : 3064365 : = (instantiation_dependent_expression_p (compound_literal)
3495 : 3064365 : || dependent_type_p (type));
3496 : 592000 : if (dependent_p)
3497 : : /* We're about to return, no need to copy. */
3498 : : orig_cl = compound_literal;
3499 : : else
3500 : : /* We're going to need a copy. */
3501 : 592000 : orig_cl = unshare_constructor (compound_literal);
3502 : 3064365 : TREE_TYPE (orig_cl) = type;
3503 : : /* Mark the expression as a compound literal. */
3504 : 3064365 : TREE_HAS_CONSTRUCTOR (orig_cl) = 1;
3505 : : /* And as instantiation-dependent. */
3506 : 3064365 : CONSTRUCTOR_IS_DEPENDENT (orig_cl) = dependent_p;
3507 : 3064365 : if (fcl_context == fcl_c99)
3508 : 60 : CONSTRUCTOR_C99_COMPOUND_LITERAL (orig_cl) = 1;
3509 : : /* If the compound literal is dependent, we're done for now. */
3510 : 3064365 : if (dependent_p)
3511 : : return orig_cl;
3512 : : /* Otherwise, do go on to e.g. check narrowing. */
3513 : : }
3514 : :
3515 : 3908741 : type = complete_type (type);
3516 : :
3517 : 3908741 : if (TYPE_NON_AGGREGATE_CLASS (type))
3518 : : {
3519 : : /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
3520 : : everywhere that deals with function arguments would be a pain, so
3521 : : just wrap it in a TREE_LIST. The parser set a flag so we know
3522 : : that it came from T{} rather than T({}). */
3523 : 490593 : CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
3524 : 490593 : compound_literal = build_tree_list (NULL_TREE, compound_literal);
3525 : 490593 : return build_functional_cast (input_location, type,
3526 : 490593 : compound_literal, complain);
3527 : : }
3528 : :
3529 : 3418148 : if (TREE_CODE (type) == ARRAY_TYPE
3530 : 3418148 : && check_array_initializer (NULL_TREE, type, compound_literal))
3531 : 9 : return error_mark_node;
3532 : 3418139 : compound_literal = reshape_init (type, compound_literal, complain);
3533 : 3226546 : if (SCALAR_TYPE_P (type)
3534 : 391294 : && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal)
3535 : 3464427 : && !check_narrowing (type, compound_literal, complain))
3536 : 102 : return error_mark_node;
3537 : 3418037 : if (TREE_CODE (type) == ARRAY_TYPE
3538 : 3418037 : && TYPE_DOMAIN (type) == NULL_TREE)
3539 : : {
3540 : 562 : cp_complete_array_type_or_error (&type, compound_literal,
3541 : : false, complain);
3542 : 562 : if (type == error_mark_node)
3543 : : return error_mark_node;
3544 : : }
3545 : 3418034 : compound_literal = digest_init_flags (type, compound_literal,
3546 : : LOOKUP_NORMAL | LOOKUP_NO_NARROWING,
3547 : : complain);
3548 : 3418034 : if (compound_literal == error_mark_node)
3549 : : return error_mark_node;
3550 : :
3551 : : /* If we're in a template, return the original compound literal. */
3552 : 3417485 : if (orig_cl)
3553 : : return orig_cl;
3554 : :
3555 : 2863677 : if (TREE_CODE (compound_literal) == CONSTRUCTOR)
3556 : : {
3557 : 2514393 : TREE_HAS_CONSTRUCTOR (compound_literal) = true;
3558 : 2514393 : if (fcl_context == fcl_c99)
3559 : 32119 : CONSTRUCTOR_C99_COMPOUND_LITERAL (compound_literal) = 1;
3560 : : }
3561 : :
3562 : : /* Put static/constant array temporaries in static variables. */
3563 : : /* FIXME all C99 compound literals should be variables rather than C++
3564 : : temporaries, unless they are used as an aggregate initializer. */
3565 : 3664720 : if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
3566 : 2065467 : && fcl_context == fcl_c99
3567 : 80 : && TREE_CODE (type) == ARRAY_TYPE
3568 : 28 : && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3569 : 2863705 : && initializer_constant_valid_p (compound_literal, type))
3570 : : {
3571 : 28 : tree decl = create_temporary_var (type);
3572 : 28 : DECL_CONTEXT (decl) = NULL_TREE;
3573 : 28 : DECL_INITIAL (decl) = compound_literal;
3574 : 28 : TREE_STATIC (decl) = 1;
3575 : 28 : if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
3576 : : {
3577 : : /* 5.19 says that a constant expression can include an
3578 : : lvalue-rvalue conversion applied to "a glvalue of literal type
3579 : : that refers to a non-volatile temporary object initialized
3580 : : with a constant expression". Rather than try to communicate
3581 : : that this VAR_DECL is a temporary, just mark it constexpr. */
3582 : 24 : DECL_DECLARED_CONSTEXPR_P (decl) = true;
3583 : 24 : DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
3584 : 24 : TREE_CONSTANT (decl) = true;
3585 : : }
3586 : 28 : cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
3587 : 28 : decl = pushdecl_top_level (decl);
3588 : 28 : DECL_NAME (decl) = make_anon_name ();
3589 : 28 : SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
3590 : : /* Make sure the destructor is callable. */
3591 : 28 : tree clean = cxx_maybe_build_cleanup (decl, complain);
3592 : 28 : if (clean == error_mark_node)
3593 : : return error_mark_node;
3594 : 28 : return decl;
3595 : : }
3596 : :
3597 : : /* Represent other compound literals with TARGET_EXPR so we produce
3598 : : a prvalue, and can elide copies. */
3599 : 2863649 : if (!VECTOR_TYPE_P (type)
3600 : 2832017 : && (TREE_CODE (compound_literal) == CONSTRUCTOR
3601 : 349278 : || TREE_CODE (compound_literal) == VEC_INIT_EXPR))
3602 : : {
3603 : : /* The CONSTRUCTOR is now an initializer, not a compound literal. */
3604 : 2482739 : if (TREE_CODE (compound_literal) == CONSTRUCTOR)
3605 : 2482739 : TREE_HAS_CONSTRUCTOR (compound_literal) = false;
3606 : 2482739 : compound_literal = get_target_expr (compound_literal, complain);
3607 : : }
3608 : : else
3609 : : /* For e.g. int{42} just make sure it's a prvalue. */
3610 : 380910 : compound_literal = rvalue (compound_literal);
3611 : :
3612 : : return compound_literal;
3613 : : }
3614 : :
3615 : : /* Return the declaration for the function-name variable indicated by
3616 : : ID. */
3617 : :
3618 : : tree
3619 : 126069 : finish_fname (tree id)
3620 : : {
3621 : 126069 : tree decl;
3622 : :
3623 : 126069 : decl = fname_decl (input_location, C_RID_CODE (id), id);
3624 : 126069 : if (processing_template_decl && current_function_decl
3625 : 61385 : && decl != error_mark_node)
3626 : 61385 : decl = DECL_NAME (decl);
3627 : 126069 : return decl;
3628 : : }
3629 : :
3630 : : /* Finish a translation unit. */
3631 : :
3632 : : void
3633 : 90807 : finish_translation_unit (void)
3634 : : {
3635 : : /* In case there were missing closebraces,
3636 : : get us back to the global binding level. */
3637 : 90807 : pop_everything ();
3638 : 181614 : while (current_namespace != global_namespace)
3639 : 0 : pop_namespace ();
3640 : :
3641 : : /* Do file scope __FUNCTION__ et al. */
3642 : 90807 : finish_fname_decls ();
3643 : :
3644 : 90807 : if (vec_safe_length (scope_chain->omp_declare_target_attribute))
3645 : : {
3646 : 12 : cp_omp_declare_target_attr
3647 : 12 : a = scope_chain->omp_declare_target_attribute->pop ();
3648 : 12 : if (!errorcount)
3649 : 9 : error ("%qs without corresponding %qs",
3650 : : a.device_type >= 0 ? "#pragma omp begin declare target"
3651 : : : "#pragma omp declare target",
3652 : : "#pragma omp end declare target");
3653 : 24 : vec_safe_truncate (scope_chain->omp_declare_target_attribute, 0);
3654 : : }
3655 : 90807 : if (vec_safe_length (scope_chain->omp_begin_assumes))
3656 : : {
3657 : 3 : if (!errorcount)
3658 : 3 : error ("%qs without corresponding %qs",
3659 : : "#pragma omp begin assumes", "#pragma omp end assumes");
3660 : 3 : vec_safe_truncate (scope_chain->omp_begin_assumes, 0);
3661 : : }
3662 : 90807 : }
3663 : :
3664 : : /* Finish a template type parameter, specified as AGGR IDENTIFIER.
3665 : : Returns the parameter. */
3666 : :
3667 : : tree
3668 : 136202879 : finish_template_type_parm (tree aggr, tree identifier)
3669 : : {
3670 : 136202879 : if (aggr != class_type_node)
3671 : : {
3672 : 0 : permerror (input_location, "template type parameters must use the keyword %<class%> or %<typename%>");
3673 : 0 : aggr = class_type_node;
3674 : : }
3675 : :
3676 : 136202879 : return build_tree_list (aggr, identifier);
3677 : : }
3678 : :
3679 : : /* Finish a template template parameter, specified as AGGR IDENTIFIER.
3680 : : Returns the parameter. */
3681 : :
3682 : : tree
3683 : 308092 : finish_template_template_parm (tree aggr, tree identifier)
3684 : : {
3685 : 308092 : tree decl = build_decl (input_location,
3686 : : TYPE_DECL, identifier, NULL_TREE);
3687 : :
3688 : 308092 : tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
3689 : 308092 : DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
3690 : 308092 : DECL_TEMPLATE_RESULT (tmpl) = decl;
3691 : 308092 : DECL_ARTIFICIAL (decl) = 1;
3692 : :
3693 : : /* Associate the constraints with the underlying declaration,
3694 : : not the template. */
3695 : 308092 : tree constr = current_template_constraints ();
3696 : 308092 : set_constraints (decl, constr);
3697 : :
3698 : 308092 : end_template_decl ();
3699 : :
3700 : 308092 : gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
3701 : :
3702 : 308092 : check_default_tmpl_args (decl, DECL_TEMPLATE_PARMS (tmpl),
3703 : : /*is_primary=*/true, /*is_partial=*/false,
3704 : : /*is_friend=*/0);
3705 : :
3706 : 308092 : return finish_template_type_parm (aggr, tmpl);
3707 : : }
3708 : :
3709 : : /* ARGUMENT is the default-argument value for a template template
3710 : : parameter. If ARGUMENT is invalid, issue error messages and return
3711 : : the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
3712 : :
3713 : : tree
3714 : 951 : check_template_template_default_arg (tree argument)
3715 : : {
3716 : 951 : if (TREE_CODE (argument) != TEMPLATE_DECL
3717 : : && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
3718 : : && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
3719 : : {
3720 : : if (TREE_CODE (argument) == TYPE_DECL)
3721 : : {
3722 : 18 : if (tree t = maybe_get_template_decl_from_type_decl (argument))
3723 : 18 : if (TREE_CODE (t) == TEMPLATE_DECL)
3724 : : return t;
3725 : 15 : error ("invalid use of type %qT as a default value for a template "
3726 : 15 : "template-parameter", TREE_TYPE (argument));
3727 : : }
3728 : : else
3729 : 0 : error ("invalid default argument for a template template parameter");
3730 : 15 : return error_mark_node;
3731 : : }
3732 : :
3733 : : return argument;
3734 : : }
3735 : :
3736 : : /* Begin a class definition, as indicated by T. */
3737 : :
3738 : : tree
3739 : 24631900 : begin_class_definition (tree t)
3740 : : {
3741 : 24631900 : if (error_operand_p (t) || error_operand_p (TYPE_MAIN_DECL (t)))
3742 : 39 : return error_mark_node;
3743 : :
3744 : 24631924 : if (processing_template_parmlist && !LAMBDA_TYPE_P (t))
3745 : : {
3746 : 9 : error ("definition of %q#T inside template parameter list", t);
3747 : 9 : return error_mark_node;
3748 : : }
3749 : :
3750 : : /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
3751 : : are passed the same as decimal scalar types. */
3752 : 24631852 : if (TREE_CODE (t) == RECORD_TYPE
3753 : 24204728 : && !processing_template_decl)
3754 : : {
3755 : 8190811 : tree ns = TYPE_CONTEXT (t);
3756 : 8190811 : if (ns && TREE_CODE (ns) == NAMESPACE_DECL
3757 : 6600754 : && DECL_CONTEXT (ns) == std_node
3758 : 746285 : && DECL_NAME (ns)
3759 : 8937076 : && id_equal (DECL_NAME (ns), "decimal"))
3760 : : {
3761 : 150 : const char *n = TYPE_NAME_STRING (t);
3762 : 150 : if ((strcmp (n, "decimal32") == 0)
3763 : 101 : || (strcmp (n, "decimal64") == 0)
3764 : 46 : || (strcmp (n, "decimal128") == 0))
3765 : 147 : TYPE_TRANSPARENT_AGGR (t) = 1;
3766 : : }
3767 : : }
3768 : :
3769 : : /* A non-implicit typename comes from code like:
3770 : :
3771 : : template <typename T> struct A {
3772 : : template <typename U> struct A<T>::B ...
3773 : :
3774 : : This is erroneous. */
3775 : 16441041 : else if (TREE_CODE (t) == TYPENAME_TYPE)
3776 : : {
3777 : 0 : error ("invalid definition of qualified type %qT", t);
3778 : 0 : t = error_mark_node;
3779 : : }
3780 : :
3781 : 24631852 : if (t == error_mark_node || ! MAYBE_CLASS_TYPE_P (t))
3782 : : {
3783 : 0 : t = make_class_type (RECORD_TYPE);
3784 : 0 : pushtag (make_anon_name (), t);
3785 : : }
3786 : :
3787 : 24631852 : if (TYPE_BEING_DEFINED (t))
3788 : : {
3789 : 0 : t = make_class_type (TREE_CODE (t));
3790 : 0 : pushtag (TYPE_IDENTIFIER (t), t);
3791 : : }
3792 : :
3793 : 24631852 : if (modules_p ())
3794 : : {
3795 : 152983 : if (!module_may_redeclare (TYPE_NAME (t)))
3796 : 0 : return error_mark_node;
3797 : 152983 : set_instantiating_module (TYPE_NAME (t));
3798 : 152983 : set_defining_module (TYPE_NAME (t));
3799 : : }
3800 : :
3801 : 24631852 : maybe_process_partial_specialization (t);
3802 : 24631852 : pushclass (t);
3803 : 24631852 : TYPE_BEING_DEFINED (t) = 1;
3804 : 24631852 : class_binding_level->defining_class_p = 1;
3805 : :
3806 : 24631852 : if (flag_pack_struct)
3807 : : {
3808 : 90 : tree v;
3809 : 90 : TYPE_PACKED (t) = 1;
3810 : : /* Even though the type is being defined for the first time
3811 : : here, there might have been a forward declaration, so there
3812 : : might be cv-qualified variants of T. */
3813 : 90 : for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
3814 : 0 : TYPE_PACKED (v) = 1;
3815 : : }
3816 : : /* Reset the interface data, at the earliest possible
3817 : : moment, as it might have been set via a class foo;
3818 : : before. */
3819 : 50661558 : if (! TYPE_UNNAMED_P (t))
3820 : : {
3821 : 23973055 : struct c_fileinfo *finfo = \
3822 : 23973055 : get_fileinfo (LOCATION_FILE (input_location));
3823 : 23973055 : CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
3824 : 23973055 : SET_CLASSTYPE_INTERFACE_UNKNOWN_X
3825 : : (t, finfo->interface_unknown);
3826 : : }
3827 : 24631852 : reset_specialization ();
3828 : :
3829 : : /* Make a declaration for this class in its own scope. */
3830 : 24631852 : build_self_reference ();
3831 : :
3832 : 24631852 : return t;
3833 : : }
3834 : :
3835 : : /* Finish the member declaration given by DECL. */
3836 : :
3837 : : void
3838 : 326723697 : finish_member_declaration (tree decl)
3839 : : {
3840 : 326723697 : if (decl == error_mark_node || decl == NULL_TREE)
3841 : : return;
3842 : :
3843 : 326722772 : if (decl == void_type_node)
3844 : : /* The COMPONENT was a friend, not a member, and so there's
3845 : : nothing for us to do. */
3846 : : return;
3847 : :
3848 : : /* We should see only one DECL at a time. */
3849 : 326722772 : gcc_assert (DECL_CHAIN (decl) == NULL_TREE);
3850 : :
3851 : : /* Don't add decls after definition. */
3852 : 326722787 : gcc_assert (TYPE_BEING_DEFINED (current_class_type)
3853 : : /* We can add lambda types when late parsing default
3854 : : arguments. */
3855 : : || LAMBDA_TYPE_P (TREE_TYPE (decl)));
3856 : :
3857 : : /* Set up access control for DECL. */
3858 : 326722772 : TREE_PRIVATE (decl)
3859 : 326722772 : = (current_access_specifier == access_private_node);
3860 : 326722772 : TREE_PROTECTED (decl)
3861 : 326722772 : = (current_access_specifier == access_protected_node);
3862 : 326722772 : if (TREE_CODE (decl) == TEMPLATE_DECL)
3863 : : {
3864 : 38143485 : TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
3865 : 38143485 : TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
3866 : : }
3867 : :
3868 : : /* Mark the DECL as a member of the current class, unless it's
3869 : : a member of an enumeration. */
3870 : 326722772 : if (TREE_CODE (decl) != CONST_DECL)
3871 : 324591446 : DECL_CONTEXT (decl) = current_class_type;
3872 : :
3873 : : /* Remember the single FIELD_DECL an anonymous aggregate type is used for. */
3874 : 326722772 : if (TREE_CODE (decl) == FIELD_DECL
3875 : 326722772 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
3876 : : {
3877 : 148941 : gcc_assert (!ANON_AGGR_TYPE_FIELD (TYPE_MAIN_VARIANT (TREE_TYPE (decl))));
3878 : 148941 : ANON_AGGR_TYPE_FIELD (TYPE_MAIN_VARIANT (TREE_TYPE (decl))) = decl;
3879 : : }
3880 : :
3881 : 326722772 : if (TREE_CODE (decl) == USING_DECL)
3882 : : /* Avoid debug info for class-scope USING_DECLS for now, we'll
3883 : : call cp_emit_debug_info_for_using later. */
3884 : 2486717 : DECL_IGNORED_P (decl) = 1;
3885 : :
3886 : : /* Check for bare parameter packs in the non-static data member
3887 : : declaration. */
3888 : 326722772 : if (TREE_CODE (decl) == FIELD_DECL)
3889 : : {
3890 : 22973108 : if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
3891 : 9 : TREE_TYPE (decl) = error_mark_node;
3892 : 22973108 : if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl)))
3893 : 0 : DECL_ATTRIBUTES (decl) = NULL_TREE;
3894 : : }
3895 : :
3896 : : /* [dcl.link]
3897 : :
3898 : : A C language linkage is ignored for the names of class members
3899 : : and the member function type of class member functions. */
3900 : 326722772 : if (DECL_LANG_SPECIFIC (decl))
3901 : 298782769 : SET_DECL_LANGUAGE (decl, lang_cplusplus);
3902 : :
3903 : 326722772 : bool add = false;
3904 : :
3905 : : /* Functions and non-functions are added differently. */
3906 : 326722772 : if (DECL_DECLARES_FUNCTION_P (decl))
3907 : 173233795 : add = add_method (current_class_type, decl, false);
3908 : : /* Enter the DECL into the scope of the class, if the class
3909 : : isn't a closure (whose fields are supposed to be unnamed). */
3910 : 153488977 : else if (CLASSTYPE_LAMBDA_EXPR (current_class_type)
3911 : 151684461 : || maybe_push_used_methods (decl)
3912 : 303784969 : || pushdecl_class_level (decl))
3913 : : add = true;
3914 : :
3915 : 173233795 : if (add)
3916 : : {
3917 : : /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
3918 : : go at the beginning. The reason is that
3919 : : legacy_nonfn_member_lookup searches the list in order, and we
3920 : : want a field name to override a type name so that the "struct
3921 : : stat hack" will work. In particular:
3922 : :
3923 : : struct S { enum E { }; static const int E = 5; int ary[S::E]; } s;
3924 : :
3925 : : is valid. */
3926 : :
3927 : 326717747 : if (TREE_CODE (decl) == TYPE_DECL)
3928 : 108987709 : TYPE_FIELDS (current_class_type)
3929 : 217975418 : = chainon (TYPE_FIELDS (current_class_type), decl);
3930 : : else
3931 : : {
3932 : 217730038 : DECL_CHAIN (decl) = TYPE_FIELDS (current_class_type);
3933 : 217730038 : TYPE_FIELDS (current_class_type) = decl;
3934 : : }
3935 : :
3936 : 326717747 : maybe_add_class_template_decl_list (current_class_type, decl,
3937 : : /*friend_p=*/0);
3938 : : }
3939 : : }
3940 : :
3941 : : /* Finish processing a complete template declaration. The PARMS are
3942 : : the template parameters. */
3943 : :
3944 : : void
3945 : 76881839 : finish_template_decl (tree parms)
3946 : : {
3947 : 76881839 : if (parms)
3948 : 76881833 : end_template_decl ();
3949 : : else
3950 : 6 : end_specialization ();
3951 : 76881839 : }
3952 : :
3953 : : // Returns the template type of the class scope being entered. If we're
3954 : : // entering a constrained class scope. TYPE is the class template
3955 : : // scope being entered and we may need to match the intended type with
3956 : : // a constrained specialization. For example:
3957 : : //
3958 : : // template<Object T>
3959 : : // struct S { void f(); }; #1
3960 : : //
3961 : : // template<Object T>
3962 : : // void S<T>::f() { } #2
3963 : : //
3964 : : // We check, in #2, that S<T> refers precisely to the type declared by
3965 : : // #1 (i.e., that the constraints match). Note that the following should
3966 : : // be an error since there is no specialization of S<T> that is
3967 : : // unconstrained, but this is not diagnosed here.
3968 : : //
3969 : : // template<typename T>
3970 : : // void S<T>::f() { }
3971 : : //
3972 : : // We cannot diagnose this problem here since this function also matches
3973 : : // qualified template names that are not part of a definition. For example:
3974 : : //
3975 : : // template<Integral T, Floating_point U>
3976 : : // typename pair<T, U>::first_type void f(T, U);
3977 : : //
3978 : : // Here, it is unlikely that there is a partial specialization of
3979 : : // pair constrained for Integral and Floating_point arguments.
3980 : : //
3981 : : // The general rule is: if a constrained specialization with matching
3982 : : // constraints is found return that type. Also note that if TYPE is not a
3983 : : // class-type (e.g. a typename type), then no fixup is needed.
3984 : :
3985 : : static tree
3986 : 3807688 : fixup_template_type (tree type)
3987 : : {
3988 : : // Find the template parameter list at the a depth appropriate to
3989 : : // the scope we're trying to enter.
3990 : 3807688 : tree parms = current_template_parms;
3991 : 3807688 : int depth = template_class_depth (type);
3992 : 8458399 : for (int n = current_template_depth; n > depth && parms; --n)
3993 : 843023 : parms = TREE_CHAIN (parms);
3994 : 3807688 : if (!parms)
3995 : : return type;
3996 : 3807683 : tree cur_reqs = TEMPLATE_PARMS_CONSTRAINTS (parms);
3997 : 3807683 : tree cur_constr = build_constraints (cur_reqs, NULL_TREE);
3998 : :
3999 : : // Search for a specialization whose type and constraints match.
4000 : 3807683 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
4001 : 3807683 : tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
4002 : 7448361 : while (specs)
4003 : : {
4004 : 3733646 : tree spec_constr = get_constraints (TREE_VALUE (specs));
4005 : :
4006 : : // If the type and constraints match a specialization, then we
4007 : : // are entering that type.
4008 : 3733646 : if (same_type_p (type, TREE_TYPE (specs))
4009 : 3733646 : && equivalent_constraints (cur_constr, spec_constr))
4010 : 92968 : return TREE_TYPE (specs);
4011 : 3640678 : specs = TREE_CHAIN (specs);
4012 : : }
4013 : :
4014 : : // If no specialization matches, then must return the type
4015 : : // previously found.
4016 : : return type;
4017 : : }
4018 : :
4019 : : /* Finish processing a template-id (which names a type) of the form
4020 : : NAME < ARGS >. Return the TYPE_DECL for the type named by the
4021 : : template-id. If ENTERING_SCOPE is nonzero we are about to enter
4022 : : the scope of template-id indicated. */
4023 : :
4024 : : tree
4025 : 156207859 : finish_template_type (tree name, tree args, int entering_scope)
4026 : : {
4027 : 156207859 : tree type;
4028 : :
4029 : 156207859 : type = lookup_template_class (name, args,
4030 : : NULL_TREE, NULL_TREE,
4031 : : tf_warning_or_error | tf_user);
4032 : 156207856 : if (entering_scope)
4033 : 18411423 : type = adjust_type_for_entering_scope (type);
4034 : :
4035 : : /* If we might be entering the scope of a partial specialization,
4036 : : find the one with the right constraints. */
4037 : 156207856 : if (flag_concepts
4038 : 39676227 : && entering_scope
4039 : 3945122 : && CLASS_TYPE_P (type)
4040 : 3913350 : && CLASSTYPE_TEMPLATE_INFO (type)
4041 : 3913344 : && dependent_type_p (type)
4042 : 160015544 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4043 : 3807688 : type = fixup_template_type (type);
4044 : :
4045 : 156207856 : if (type == error_mark_node)
4046 : : return type;
4047 : 156207059 : else if (CLASS_TYPE_P (type) && !alias_type_or_template_p (type))
4048 : 133728626 : return TYPE_STUB_DECL (type);
4049 : : else
4050 : 22478433 : return TYPE_NAME (type);
4051 : : }
4052 : :
4053 : : /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
4054 : : Return a TREE_LIST containing the ACCESS_SPECIFIER and the
4055 : : BASE_CLASS, or NULL_TREE if an error occurred. The
4056 : : ACCESS_SPECIFIER is one of
4057 : : access_{default,public,protected_private}_node. For a virtual base
4058 : : we set TREE_TYPE. */
4059 : :
4060 : : tree
4061 : 10539088 : finish_base_specifier (tree base, tree access, bool virtual_p)
4062 : : {
4063 : 10539088 : tree result;
4064 : :
4065 : 10539088 : if (base == error_mark_node)
4066 : : {
4067 : 0 : error ("invalid base-class specification");
4068 : 0 : result = NULL_TREE;
4069 : : }
4070 : 10539088 : else if (! MAYBE_CLASS_TYPE_P (base))
4071 : : {
4072 : 3 : error ("%qT is not a class type", base);
4073 : 3 : result = NULL_TREE;
4074 : : }
4075 : : else
4076 : : {
4077 : 10539085 : if (cp_type_quals (base) != 0)
4078 : : {
4079 : : /* DR 484: Can a base-specifier name a cv-qualified
4080 : : class type? */
4081 : 12 : base = TYPE_MAIN_VARIANT (base);
4082 : : }
4083 : 10539085 : result = build_tree_list (access, base);
4084 : 10539085 : if (virtual_p)
4085 : 25355 : TREE_TYPE (result) = integer_type_node;
4086 : : }
4087 : :
4088 : 10539088 : return result;
4089 : : }
4090 : :
4091 : : /* If FNS is a member function, a set of member functions, or a
4092 : : template-id referring to one or more member functions, return a
4093 : : BASELINK for FNS, incorporating the current access context.
4094 : : Otherwise, return FNS unchanged. */
4095 : :
4096 : : tree
4097 : 124565643 : baselink_for_fns (tree fns)
4098 : : {
4099 : 124565643 : tree scope;
4100 : 124565643 : tree cl;
4101 : :
4102 : 124565643 : if (BASELINK_P (fns)
4103 : 124565643 : || error_operand_p (fns))
4104 : : return fns;
4105 : :
4106 : 109998043 : scope = ovl_scope (fns);
4107 : 109998043 : if (!CLASS_TYPE_P (scope))
4108 : : return fns;
4109 : :
4110 : 5831727 : cl = currently_open_derived_class (scope);
4111 : 5831727 : if (!cl)
4112 : 4062552 : cl = scope;
4113 : 5831727 : tree access_path = TYPE_BINFO (cl);
4114 : 5831727 : tree conv_path = (cl == scope ? access_path
4115 : 745750 : : lookup_base (cl, scope, ba_any, NULL, tf_none));
4116 : 5831727 : return build_baselink (conv_path, access_path, fns, /*optype=*/NULL_TREE);
4117 : : }
4118 : :
4119 : : /* Returns true iff DECL is a variable from a function outside
4120 : : the current one. */
4121 : :
4122 : : static bool
4123 : 1874051760 : outer_var_p (tree decl)
4124 : : {
4125 : : /* These should have been stripped or otherwise handled by the caller. */
4126 : 1874051760 : gcc_checking_assert (!REFERENCE_REF_P (decl));
4127 : :
4128 : 1202774934 : return ((VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
4129 : 1691935643 : && DECL_FUNCTION_SCOPE_P (decl)
4130 : : /* Don't get confused by temporaries. */
4131 : 1425753722 : && DECL_NAME (decl)
4132 : 3288744680 : && (DECL_CONTEXT (decl) != current_function_decl
4133 : 1409873213 : || parsing_nsdmi ()));
4134 : : }
4135 : :
4136 : : /* As above, but also checks that DECL is automatic. */
4137 : :
4138 : : bool
4139 : 1874051760 : outer_automatic_var_p (tree decl)
4140 : : {
4141 : 1874051760 : return (outer_var_p (decl)
4142 : 1874051760 : && !TREE_STATIC (decl));
4143 : : }
4144 : :
4145 : : /* DECL satisfies outer_automatic_var_p. Possibly complain about it or
4146 : : rewrite it for lambda capture.
4147 : :
4148 : : If ODR_USE is true, we're being called from mark_use, and we complain about
4149 : : use of constant variables. If ODR_USE is false, we're being called for the
4150 : : id-expression, and we do lambda capture. */
4151 : :
4152 : : tree
4153 : 2099288 : process_outer_var_ref (tree decl, tsubst_flags_t complain, bool odr_use)
4154 : : {
4155 : 2099288 : if (cp_unevaluated_operand)
4156 : : {
4157 : 1183971 : tree type = TREE_TYPE (decl);
4158 : 1183971 : if (!dependent_type_p (type)
4159 : 1183971 : && variably_modified_type_p (type, NULL_TREE))
4160 : : /* VLAs are used even in unevaluated context. */;
4161 : : else
4162 : : /* It's not a use (3.2) if we're in an unevaluated context. */
4163 : 1183965 : return decl;
4164 : : }
4165 : 915323 : if (decl == error_mark_node)
4166 : : return decl;
4167 : :
4168 : 915323 : tree context = DECL_CONTEXT (decl);
4169 : 915323 : tree containing_function = current_function_decl;
4170 : 915323 : tree lambda_stack = NULL_TREE;
4171 : 915323 : tree lambda_expr = NULL_TREE;
4172 : 915323 : tree initializer = convert_from_reference (decl);
4173 : :
4174 : : /* Mark it as used now even if the use is ill-formed. */
4175 : 915323 : if (!mark_used (decl, complain))
4176 : 3 : return error_mark_node;
4177 : :
4178 : 915320 : if (parsing_nsdmi ())
4179 : : containing_function = NULL_TREE;
4180 : :
4181 : 1830260 : if (containing_function && LAMBDA_FUNCTION_P (containing_function))
4182 : : {
4183 : : /* Check whether we've already built a proxy. */
4184 : : tree var = decl;
4185 : 917601 : while (is_normal_capture_proxy (var))
4186 : 2549 : var = DECL_CAPTURED_VARIABLE (var);
4187 : 915052 : tree d = retrieve_local_specialization (var);
4188 : :
4189 : 915052 : if (d && d != decl && is_capture_proxy (d))
4190 : : {
4191 : 495225 : if (DECL_CONTEXT (d) == containing_function)
4192 : : /* We already have an inner proxy. */
4193 : : return d;
4194 : : else
4195 : : /* We need to capture an outer proxy. */
4196 : 2531 : return process_outer_var_ref (d, complain, odr_use);
4197 : : }
4198 : : }
4199 : :
4200 : : /* If we are in a lambda function, we can move out until we hit
4201 : : 1. the context,
4202 : : 2. a non-lambda function, or
4203 : : 3. a non-default capturing lambda function. */
4204 : 841940 : while (context != containing_function
4205 : : /* containing_function can be null with invalid generic lambdas. */
4206 : 841940 : && containing_function
4207 : 1264106 : && LAMBDA_FUNCTION_P (containing_function))
4208 : : {
4209 : 422166 : tree closure = DECL_CONTEXT (containing_function);
4210 : 422166 : lambda_expr = CLASSTYPE_LAMBDA_EXPR (closure);
4211 : :
4212 : 422166 : if (TYPE_CLASS_SCOPE_P (closure))
4213 : : /* A lambda in an NSDMI (c++/64496). */
4214 : : break;
4215 : :
4216 : 422163 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_NONE)
4217 : : break;
4218 : :
4219 : 421845 : lambda_stack = tree_cons (NULL_TREE, lambda_expr, lambda_stack);
4220 : :
4221 : 421845 : containing_function = decl_function_context (containing_function);
4222 : : }
4223 : :
4224 : : /* In a lambda within a template, wait until instantiation time to implicitly
4225 : : capture a parameter pack. We want to wait because we don't know if we're
4226 : : capturing the whole pack or a single element, and it's OK to wait because
4227 : : find_parameter_packs_r walks into the lambda body. */
4228 : 420095 : if (context == containing_function
4229 : 420095 : && DECL_PACK_P (decl))
4230 : : return decl;
4231 : :
4232 : 391684 : if (lambda_expr && VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))
4233 : : {
4234 : 6 : if (complain & tf_error)
4235 : 6 : error ("cannot capture member %qD of anonymous union", decl);
4236 : 6 : return error_mark_node;
4237 : : }
4238 : : /* Do lambda capture when processing the id-expression, not when
4239 : : odr-using a variable. */
4240 : 391678 : if (!odr_use && context == containing_function)
4241 : 782178 : decl = add_default_capture (lambda_stack,
4242 : 391089 : /*id=*/DECL_NAME (decl), initializer);
4243 : : /* Only an odr-use of an outer automatic variable causes an
4244 : : error, and a constant variable can decay to a prvalue
4245 : : constant without odr-use. So don't complain yet. */
4246 : 589 : else if (!odr_use && decl_constant_var_p (decl))
4247 : : return decl;
4248 : 252 : else if (lambda_expr)
4249 : : {
4250 : 42 : if (complain & tf_error)
4251 : : {
4252 : 42 : auto_diagnostic_group d;
4253 : 42 : error ("%qD is not captured", decl);
4254 : 42 : tree closure = LAMBDA_EXPR_CLOSURE (lambda_expr);
4255 : 42 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_NONE)
4256 : 39 : inform (location_of (closure),
4257 : : "the lambda has no capture-default");
4258 : 3 : else if (TYPE_CLASS_SCOPE_P (closure))
4259 : 3 : inform (UNKNOWN_LOCATION, "lambda in local class %q+T cannot "
4260 : : "capture variables from the enclosing context",
4261 : 3 : TYPE_CONTEXT (closure));
4262 : 42 : inform (DECL_SOURCE_LOCATION (decl), "%q#D declared here", decl);
4263 : 42 : }
4264 : 42 : return error_mark_node;
4265 : : }
4266 : 210 : else if (processing_contract_condition && (TREE_CODE (decl) == PARM_DECL))
4267 : : /* Use of a parameter in a contract condition is fine. */
4268 : : return decl;
4269 : : else
4270 : : {
4271 : 42 : if (complain & tf_error)
4272 : : {
4273 : 36 : auto_diagnostic_group d;
4274 : 54 : error (VAR_P (decl)
4275 : : ? G_("use of local variable with automatic storage from "
4276 : : "containing function")
4277 : : : G_("use of parameter from containing function"));
4278 : 36 : inform (DECL_SOURCE_LOCATION (decl), "%q#D declared here", decl);
4279 : 36 : }
4280 : 42 : return error_mark_node;
4281 : : }
4282 : 391089 : return decl;
4283 : : }
4284 : :
4285 : : /* ID_EXPRESSION is a representation of parsed, but unprocessed,
4286 : : id-expression. (See cp_parser_id_expression for details.) SCOPE,
4287 : : if non-NULL, is the type or namespace used to explicitly qualify
4288 : : ID_EXPRESSION. DECL is the entity to which that name has been
4289 : : resolved.
4290 : :
4291 : : *CONSTANT_EXPRESSION_P is true if we are presently parsing a
4292 : : constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
4293 : : be set to true if this expression isn't permitted in a
4294 : : constant-expression, but it is otherwise not set by this function.
4295 : : *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
4296 : : constant-expression, but a non-constant expression is also
4297 : : permissible.
4298 : :
4299 : : DONE is true if this expression is a complete postfix-expression;
4300 : : it is false if this expression is followed by '->', '[', '(', etc.
4301 : : ADDRESS_P is true iff this expression is the operand of '&'.
4302 : : TEMPLATE_P is true iff the qualified-id was of the form
4303 : : "A::template B". TEMPLATE_ARG_P is true iff this qualified name
4304 : : appears as a template argument.
4305 : :
4306 : : If an error occurs, and it is the kind of error that might cause
4307 : : the parser to abort a tentative parse, *ERROR_MSG is filled in. It
4308 : : is the caller's responsibility to issue the message. *ERROR_MSG
4309 : : will be a string with static storage duration, so the caller need
4310 : : not "free" it.
4311 : :
4312 : : Return an expression for the entity, after issuing appropriate
4313 : : diagnostics. This function is also responsible for transforming a
4314 : : reference to a non-static member into a COMPONENT_REF that makes
4315 : : the use of "this" explicit.
4316 : :
4317 : : Upon return, *IDK will be filled in appropriately. */
4318 : : static cp_expr
4319 : 585645432 : finish_id_expression_1 (tree id_expression,
4320 : : tree decl,
4321 : : tree scope,
4322 : : cp_id_kind *idk,
4323 : : bool integral_constant_expression_p,
4324 : : bool allow_non_integral_constant_expression_p,
4325 : : bool *non_integral_constant_expression_p,
4326 : : bool template_p,
4327 : : bool done,
4328 : : bool address_p,
4329 : : bool template_arg_p,
4330 : : const char **error_msg,
4331 : : location_t location)
4332 : : {
4333 : 585645432 : decl = strip_using_decl (decl);
4334 : :
4335 : : /* Initialize the output parameters. */
4336 : 585645432 : *idk = CP_ID_KIND_NONE;
4337 : 585645432 : *error_msg = NULL;
4338 : :
4339 : 585645432 : if (id_expression == error_mark_node)
4340 : 12 : return error_mark_node;
4341 : : /* If we have a template-id, then no further lookup is
4342 : : required. If the template-id was for a template-class, we
4343 : : will sometimes have a TYPE_DECL at this point. */
4344 : 585645420 : else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
4345 : 557902565 : || TREE_CODE (decl) == TYPE_DECL)
4346 : : ;
4347 : : /* Look up the name. */
4348 : : else
4349 : : {
4350 : 557901701 : if (decl == error_mark_node)
4351 : : {
4352 : : /* Name lookup failed. */
4353 : 112810 : if (scope
4354 : 112810 : && (!TYPE_P (scope)
4355 : 116 : || (!dependentish_scope_p (scope)
4356 : 112 : && !(identifier_p (id_expression)
4357 : 97 : && IDENTIFIER_CONV_OP_P (id_expression)
4358 : 3 : && dependent_type_p (TREE_TYPE (id_expression))))))
4359 : : {
4360 : : /* If the qualifying type is non-dependent (and the name
4361 : : does not name a conversion operator to a dependent
4362 : : type), issue an error. */
4363 : 357 : qualified_name_lookup_error (scope, id_expression, decl, location);
4364 : 357 : return error_mark_node;
4365 : : }
4366 : 112453 : else if (!scope)
4367 : : {
4368 : : /* It may be resolved via Koenig lookup. */
4369 : 112443 : *idk = CP_ID_KIND_UNQUALIFIED;
4370 : 112443 : return id_expression;
4371 : : }
4372 : : else
4373 : : decl = id_expression;
4374 : : }
4375 : :
4376 : : /* Remember that the name was used in the definition of
4377 : : the current class so that we can check later to see if
4378 : : the meaning would have been different after the class
4379 : : was entirely defined. */
4380 : 557788891 : if (!scope && decl != error_mark_node && identifier_p (id_expression))
4381 : 507132120 : maybe_note_name_used_in_class (id_expression, decl);
4382 : :
4383 : : /* A use in unevaluated operand might not be instantiated appropriately
4384 : : if tsubst_copy builds a dummy parm, or if we never instantiate a
4385 : : generic lambda, so mark it now. */
4386 : 557788901 : if (processing_template_decl && cp_unevaluated_operand)
4387 : 8309951 : mark_type_use (decl);
4388 : :
4389 : : /* Disallow uses of local variables from containing functions, except
4390 : : within lambda-expressions. */
4391 : 557788901 : if (outer_automatic_var_p (decl))
4392 : : {
4393 : 1718804 : decl = process_outer_var_ref (decl, tf_warning_or_error);
4394 : 1718804 : if (decl == error_mark_node)
4395 : 81 : return error_mark_node;
4396 : : }
4397 : :
4398 : : /* Also disallow uses of function parameters outside the function
4399 : : body, except inside an unevaluated context (i.e. decltype). */
4400 : 557788820 : if (TREE_CODE (decl) == PARM_DECL
4401 : 235204356 : && DECL_CONTEXT (decl) == NULL_TREE
4402 : 3852655 : && !cp_unevaluated_operand
4403 : 557789246 : && !processing_contract_condition)
4404 : : {
4405 : 25 : *error_msg = G_("use of parameter outside function body");
4406 : 25 : return error_mark_node;
4407 : : }
4408 : : }
4409 : :
4410 : : /* If we didn't find anything, or what we found was a type,
4411 : : then this wasn't really an id-expression. */
4412 : 585532514 : if (TREE_CODE (decl) == TEMPLATE_DECL
4413 : 585532514 : && !DECL_FUNCTION_TEMPLATE_P (decl))
4414 : : {
4415 : 57 : *error_msg = G_("missing template arguments");
4416 : 57 : return error_mark_node;
4417 : : }
4418 : 585532457 : else if (TREE_CODE (decl) == TYPE_DECL
4419 : 585531593 : || TREE_CODE (decl) == NAMESPACE_DECL)
4420 : : {
4421 : 879 : *error_msg = G_("expected primary-expression");
4422 : 879 : return error_mark_node;
4423 : : }
4424 : :
4425 : : /* If the name resolved to a template parameter, there is no
4426 : : need to look it up again later. */
4427 : 26568364 : if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
4428 : 594832759 : || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
4429 : : {
4430 : 17267183 : tree r;
4431 : :
4432 : 17267183 : *idk = CP_ID_KIND_NONE;
4433 : 17267183 : if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
4434 : 0 : decl = TEMPLATE_PARM_DECL (decl);
4435 : 17267183 : r = DECL_INITIAL (decl);
4436 : 17267183 : if (CLASS_TYPE_P (TREE_TYPE (r)) && !CP_TYPE_CONST_P (TREE_TYPE (r)))
4437 : : {
4438 : : /* If the entity is a template parameter object for a template
4439 : : parameter of type T, the type of the expression is const T. */
4440 : 129 : tree ctype = TREE_TYPE (r);
4441 : 129 : ctype = cp_build_qualified_type (ctype, (cp_type_quals (ctype)
4442 : : | TYPE_QUAL_CONST));
4443 : 129 : r = build1 (VIEW_CONVERT_EXPR, ctype, r);
4444 : : }
4445 : 17267183 : r = convert_from_reference (r);
4446 : 17267183 : if (integral_constant_expression_p
4447 : 2858158 : && !dependent_type_p (TREE_TYPE (decl))
4448 : 19648332 : && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
4449 : : {
4450 : 72 : if (!allow_non_integral_constant_expression_p)
4451 : 6 : error ("template parameter %qD of type %qT is not allowed in "
4452 : : "an integral constant expression because it is not of "
4453 : 6 : "integral or enumeration type", decl, TREE_TYPE (decl));
4454 : 72 : *non_integral_constant_expression_p = true;
4455 : : }
4456 : 17267183 : return r;
4457 : : }
4458 : 568264395 : else if (TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE)
4459 : : {
4460 : 9 : gcc_checking_assert (scope);
4461 : 9 : *idk = CP_ID_KIND_QUALIFIED;
4462 : 9 : cp_warn_deprecated_use_scopes (scope);
4463 : 9 : decl = finish_qualified_id_expr (scope, decl, done, address_p,
4464 : : template_p, template_arg_p,
4465 : : tf_warning_or_error);
4466 : : }
4467 : : else
4468 : : {
4469 : 568264386 : if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
4470 : 27742855 : && variable_template_p (TREE_OPERAND (decl, 0))
4471 : 573417986 : && !concept_check_p (decl))
4472 : : /* Try resolving this variable TEMPLATE_ID_EXPR (which is always
4473 : : considered type-dependent) now, so that the dependence test that
4474 : : follows gives us the right answer: if it represents a non-dependent
4475 : : variable template-id then finish_template_variable will yield the
4476 : : corresponding non-dependent VAR_DECL. */
4477 : 5153600 : decl = finish_template_variable (decl);
4478 : :
4479 : 568264386 : bool dependent_p = type_dependent_expression_p (decl);
4480 : :
4481 : : /* If the declaration was explicitly qualified indicate
4482 : : that. The semantics of `A::f(3)' are different than
4483 : : `f(3)' if `f' is virtual. */
4484 : 1136528772 : *idk = (scope
4485 : 568264386 : ? CP_ID_KIND_QUALIFIED
4486 : 502510932 : : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
4487 : 502510932 : ? CP_ID_KIND_TEMPLATE_ID
4488 : : : (dependent_p
4489 : 489946527 : ? CP_ID_KIND_UNQUALIFIED_DEPENDENT
4490 : : : CP_ID_KIND_UNQUALIFIED)));
4491 : :
4492 : 568264386 : if (dependent_p
4493 : 568264386 : && !scope
4494 : 327985199 : && DECL_P (decl)
4495 : 875160677 : && any_dependent_type_attributes_p (DECL_ATTRIBUTES (decl)))
4496 : : /* Dependent type attributes on the decl mean that the TREE_TYPE is
4497 : : wrong, so just return the identifier. */
4498 : 39 : return id_expression;
4499 : :
4500 : 568264347 : if (DECL_CLASS_TEMPLATE_P (decl))
4501 : : {
4502 : 0 : error ("use of class template %qT as expression", decl);
4503 : 0 : return error_mark_node;
4504 : : }
4505 : :
4506 : 568264347 : if (TREE_CODE (decl) == TREE_LIST)
4507 : : {
4508 : : /* Ambiguous reference to base members. */
4509 : 0 : auto_diagnostic_group d;
4510 : 0 : error ("request for member %qD is ambiguous in "
4511 : : "multiple inheritance lattice", id_expression);
4512 : 0 : print_candidates (decl);
4513 : 0 : return error_mark_node;
4514 : 0 : }
4515 : :
4516 : : /* Mark variable-like entities as used. Functions are similarly
4517 : : marked either below or after overload resolution. */
4518 : 568264347 : if ((VAR_P (decl)
4519 : 414241058 : || TREE_CODE (decl) == PARM_DECL
4520 : 179036733 : || TREE_CODE (decl) == CONST_DECL
4521 : 169735552 : || TREE_CODE (decl) == RESULT_DECL)
4522 : 812769853 : && !mark_used (decl))
4523 : 12 : return error_mark_node;
4524 : :
4525 : : /* Only certain kinds of names are allowed in constant
4526 : : expression. Template parameters have already
4527 : : been handled above. */
4528 : 568264332 : if (! error_operand_p (decl)
4529 : 568264050 : && !dependent_p
4530 : 568264050 : && integral_constant_expression_p
4531 : 54601101 : && !decl_constant_var_p (decl)
4532 : 45281678 : && TREE_CODE (decl) != CONST_DECL
4533 : 39711400 : && !builtin_valid_in_constant_expr_p (decl)
4534 : 607935456 : && !concept_check_p (decl))
4535 : : {
4536 : 39550769 : if (!allow_non_integral_constant_expression_p)
4537 : : {
4538 : 29 : error ("%qD cannot appear in a constant-expression", decl);
4539 : 29 : return error_mark_node;
4540 : : }
4541 : 39550740 : *non_integral_constant_expression_p = true;
4542 : : }
4543 : :
4544 : 568264303 : if (tree wrap = maybe_get_tls_wrapper_call (decl))
4545 : : /* Replace an evaluated use of the thread_local variable with
4546 : : a call to its wrapper. */
4547 : : decl = wrap;
4548 : 568263971 : else if (concept_check_p (decl))
4549 : : {
4550 : : /* Nothing more to do. All of the analysis for concept checks
4551 : : is done by build_conept_id, called from the parser. */
4552 : : }
4553 : 564308280 : else if (scope)
4554 : : {
4555 : 65278150 : if (TREE_CODE (decl) == SCOPE_REF)
4556 : : {
4557 : 4063 : gcc_assert (same_type_p (scope, TREE_OPERAND (decl, 0)));
4558 : 4063 : decl = TREE_OPERAND (decl, 1);
4559 : : }
4560 : :
4561 : 65278150 : decl = (adjust_result_of_qualified_name_lookup
4562 : 65278150 : (decl, scope, current_nonlambda_class_type()));
4563 : :
4564 : 65278150 : cp_warn_deprecated_use_scopes (scope);
4565 : :
4566 : 65278150 : if (TYPE_P (scope))
4567 : 10203297 : decl = finish_qualified_id_expr (scope,
4568 : : decl,
4569 : : done,
4570 : : address_p,
4571 : : template_p,
4572 : : template_arg_p,
4573 : : tf_warning_or_error);
4574 : : else
4575 : 55074853 : decl = convert_from_reference (decl);
4576 : : }
4577 : 499030130 : else if (TREE_CODE (decl) == FIELD_DECL)
4578 : : {
4579 : : /* Since SCOPE is NULL here, this is an unqualified name.
4580 : : Access checking has been performed during name lookup
4581 : : already. Turn off checking to avoid duplicate errors. */
4582 : 52366776 : push_deferring_access_checks (dk_no_check);
4583 : 52366776 : decl = finish_non_static_data_member (decl, NULL_TREE,
4584 : : /*qualifying_scope=*/NULL_TREE);
4585 : 52366776 : pop_deferring_access_checks ();
4586 : : }
4587 : 446663354 : else if (is_overloaded_fn (decl))
4588 : : {
4589 : : /* We only need to look at the first function,
4590 : : because all the fns share the attribute we're
4591 : : concerned with (all member fns or all non-members). */
4592 : 53688037 : tree first_fn = get_first_fn (decl);
4593 : 53688037 : first_fn = STRIP_TEMPLATE (first_fn);
4594 : :
4595 : 53688037 : if (!template_arg_p
4596 : 53688037 : && (TREE_CODE (first_fn) == USING_DECL
4597 : 53686265 : || (TREE_CODE (first_fn) == FUNCTION_DECL
4598 : 53686265 : && DECL_FUNCTION_MEMBER_P (first_fn)
4599 : 29733517 : && !shared_member_p (decl))))
4600 : : {
4601 : : /* A set of member functions. */
4602 : 23913814 : decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
4603 : 23913814 : return finish_class_member_access_expr (decl, id_expression,
4604 : : /*template_p=*/false,
4605 : 23913814 : tf_warning_or_error);
4606 : : }
4607 : :
4608 : 29774223 : decl = baselink_for_fns (decl);
4609 : : }
4610 : : else
4611 : : {
4612 : 388206592 : if (DECL_P (decl) && DECL_NONLOCAL (decl)
4613 : 394291252 : && DECL_CLASS_SCOPE_P (decl))
4614 : : {
4615 : 1315935 : tree context = context_for_name_lookup (decl);
4616 : 1315935 : if (context != current_class_type)
4617 : : {
4618 : 772490 : tree path = currently_open_derived_class (context);
4619 : 772490 : if (!path)
4620 : : /* PATH can be null for using an enum of an unrelated
4621 : : class; we checked its access in lookup_using_decl.
4622 : :
4623 : : ??? Should this case make a clone instead, like
4624 : : handle_using_decl? */
4625 : 10 : gcc_assert (TREE_CODE (decl) == CONST_DECL);
4626 : : else
4627 : 772480 : perform_or_defer_access_check (TYPE_BINFO (path),
4628 : : decl, decl,
4629 : : tf_warning_or_error);
4630 : : }
4631 : : }
4632 : :
4633 : 392975317 : decl = convert_from_reference (decl);
4634 : : }
4635 : : }
4636 : :
4637 : 544350498 : return cp_expr (decl, location);
4638 : : }
4639 : :
4640 : : /* As per finish_id_expression_1, but adding a wrapper node
4641 : : around the result if needed to express LOCATION. */
4642 : :
4643 : : cp_expr
4644 : 585645432 : finish_id_expression (tree id_expression,
4645 : : tree decl,
4646 : : tree scope,
4647 : : cp_id_kind *idk,
4648 : : bool integral_constant_expression_p,
4649 : : bool allow_non_integral_constant_expression_p,
4650 : : bool *non_integral_constant_expression_p,
4651 : : bool template_p,
4652 : : bool done,
4653 : : bool address_p,
4654 : : bool template_arg_p,
4655 : : const char **error_msg,
4656 : : location_t location)
4657 : : {
4658 : 585645432 : cp_expr result
4659 : 585645432 : = finish_id_expression_1 (id_expression, decl, scope, idk,
4660 : : integral_constant_expression_p,
4661 : : allow_non_integral_constant_expression_p,
4662 : : non_integral_constant_expression_p,
4663 : : template_p, done, address_p, template_arg_p,
4664 : : error_msg, location);
4665 : 585645429 : return result.maybe_add_location_wrapper ();
4666 : : }
4667 : :
4668 : : /* Implement the __typeof keyword: Return the type of EXPR, suitable for
4669 : : use as a type-specifier. */
4670 : :
4671 : : tree
4672 : 14845550 : finish_typeof (tree expr)
4673 : : {
4674 : 14845550 : tree type;
4675 : :
4676 : 14845550 : if (type_dependent_expression_p (expr))
4677 : : {
4678 : 14754119 : type = cxx_make_type (TYPEOF_TYPE);
4679 : 14754119 : TYPEOF_TYPE_EXPR (type) = expr;
4680 : 14754119 : SET_TYPE_STRUCTURAL_EQUALITY (type);
4681 : :
4682 : 14754119 : return type;
4683 : : }
4684 : :
4685 : 91431 : expr = mark_type_use (expr);
4686 : :
4687 : 91431 : type = unlowered_expr_type (expr);
4688 : :
4689 : 91431 : if (!type || type == unknown_type_node)
4690 : : {
4691 : 3 : error ("type of %qE is unknown", expr);
4692 : 3 : return error_mark_node;
4693 : : }
4694 : :
4695 : : return type;
4696 : : }
4697 : :
4698 : : /* Implement the __underlying_type keyword: Return the underlying
4699 : : type of TYPE, suitable for use as a type-specifier. */
4700 : :
4701 : : tree
4702 : 39158 : finish_underlying_type (tree type)
4703 : : {
4704 : 39158 : if (!complete_type_or_else (type, NULL_TREE))
4705 : 3 : return error_mark_node;
4706 : :
4707 : 39155 : if (TREE_CODE (type) != ENUMERAL_TYPE)
4708 : : {
4709 : 24 : error ("%qT is not an enumeration type", type);
4710 : 24 : return error_mark_node;
4711 : : }
4712 : :
4713 : 39131 : tree underlying_type = ENUM_UNDERLYING_TYPE (type);
4714 : :
4715 : : /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
4716 : : includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
4717 : : See finish_enum_value_list for details. */
4718 : 39131 : if (!ENUM_FIXED_UNDERLYING_TYPE_P (type))
4719 : 52 : underlying_type
4720 : 52 : = c_common_type_for_mode (TYPE_MODE (underlying_type),
4721 : 52 : TYPE_UNSIGNED (underlying_type));
4722 : :
4723 : : return underlying_type;
4724 : : }
4725 : :
4726 : : /* Implement the __type_pack_element keyword: Return the type
4727 : : at index IDX within TYPES. */
4728 : :
4729 : : static tree
4730 : 81763 : finish_type_pack_element (tree idx, tree types, tsubst_flags_t complain)
4731 : : {
4732 : 81763 : idx = maybe_constant_value (idx);
4733 : 81763 : if (TREE_CODE (idx) != INTEGER_CST || !INTEGRAL_TYPE_P (TREE_TYPE (idx)))
4734 : : {
4735 : 6 : if (complain & tf_error)
4736 : 3 : error ("%<__type_pack_element%> index is not an integral constant");
4737 : 6 : return error_mark_node;
4738 : : }
4739 : 81757 : if (tree_int_cst_sgn (idx) < 0)
4740 : : {
4741 : 3 : if (complain & tf_error)
4742 : 3 : error ("%<__type_pack_element%> index is negative");
4743 : 3 : return error_mark_node;
4744 : : }
4745 : 81754 : if (wi::to_widest (idx) >= TREE_VEC_LENGTH (types))
4746 : : {
4747 : 24 : if (complain & tf_error)
4748 : 18 : error ("%<__type_pack_element%> index is out of range");
4749 : 24 : return error_mark_node;
4750 : : }
4751 : 81730 : return TREE_VEC_ELT (types, tree_to_shwi (idx));
4752 : : }
4753 : :
4754 : : /* Implement the __direct_bases keyword: Return the direct base classes
4755 : : of type. */
4756 : :
4757 : : tree
4758 : 15 : calculate_direct_bases (tree type, tsubst_flags_t complain)
4759 : : {
4760 : 15 : if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)
4761 : 15 : || !NON_UNION_CLASS_TYPE_P (type))
4762 : 8 : return make_tree_vec (0);
4763 : :
4764 : 7 : releasing_vec vector;
4765 : 7 : vec<tree, va_gc> *base_binfos = BINFO_BASE_BINFOS (TYPE_BINFO (type));
4766 : 7 : tree binfo;
4767 : 7 : unsigned i;
4768 : :
4769 : : /* Virtual bases are initialized first */
4770 : 20 : for (i = 0; base_binfos->iterate (i, &binfo); i++)
4771 : 13 : if (BINFO_VIRTUAL_P (binfo))
4772 : 2 : vec_safe_push (vector, binfo);
4773 : :
4774 : : /* Now non-virtuals */
4775 : 20 : for (i = 0; base_binfos->iterate (i, &binfo); i++)
4776 : 13 : if (!BINFO_VIRTUAL_P (binfo))
4777 : 11 : vec_safe_push (vector, binfo);
4778 : :
4779 : 7 : tree bases_vec = make_tree_vec (vector->length ());
4780 : :
4781 : 27 : for (i = 0; i < vector->length (); ++i)
4782 : 13 : TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE ((*vector)[i]);
4783 : :
4784 : 7 : return bases_vec;
4785 : 7 : }
4786 : :
4787 : : /* Implement the __bases keyword: Return the base classes
4788 : : of type */
4789 : :
4790 : : /* Find morally non-virtual base classes by walking binfo hierarchy */
4791 : : /* Virtual base classes are handled separately in finish_bases */
4792 : :
4793 : : static tree
4794 : 73 : dfs_calculate_bases_pre (tree binfo, void * /*data_*/)
4795 : : {
4796 : : /* Don't walk bases of virtual bases */
4797 : 73 : return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
4798 : : }
4799 : :
4800 : : static tree
4801 : 73 : dfs_calculate_bases_post (tree binfo, void *data_)
4802 : : {
4803 : 73 : vec<tree, va_gc> **data = ((vec<tree, va_gc> **) data_);
4804 : 73 : if (!BINFO_VIRTUAL_P (binfo))
4805 : 48 : vec_safe_push (*data, BINFO_TYPE (binfo));
4806 : 73 : return NULL_TREE;
4807 : : }
4808 : :
4809 : : /* Calculates the morally non-virtual base classes of a class */
4810 : : static vec<tree, va_gc> *
4811 : 16 : calculate_bases_helper (tree type)
4812 : : {
4813 : 16 : vec<tree, va_gc> *vector = make_tree_vector ();
4814 : :
4815 : : /* Now add non-virtual base classes in order of construction */
4816 : 16 : if (TYPE_BINFO (type))
4817 : 16 : dfs_walk_all (TYPE_BINFO (type),
4818 : : dfs_calculate_bases_pre, dfs_calculate_bases_post, &vector);
4819 : 16 : return vector;
4820 : : }
4821 : :
4822 : : tree
4823 : 12 : calculate_bases (tree type, tsubst_flags_t complain)
4824 : : {
4825 : 12 : if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)
4826 : 12 : || !NON_UNION_CLASS_TYPE_P (type))
4827 : 5 : return make_tree_vec (0);
4828 : :
4829 : 7 : releasing_vec vector;
4830 : 7 : tree bases_vec = NULL_TREE;
4831 : 7 : unsigned i;
4832 : 7 : vec<tree, va_gc> *vbases;
4833 : 7 : tree binfo;
4834 : :
4835 : : /* First go through virtual base classes */
4836 : 7 : for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
4837 : 16 : vec_safe_iterate (vbases, i, &binfo); i++)
4838 : : {
4839 : 9 : releasing_vec vbase_bases
4840 : 9 : = calculate_bases_helper (BINFO_TYPE (binfo));
4841 : 9 : vec_safe_splice (vector, vbase_bases);
4842 : 9 : }
4843 : :
4844 : : /* Now for the non-virtual bases */
4845 : 7 : releasing_vec nonvbases = calculate_bases_helper (type);
4846 : 7 : vec_safe_splice (vector, nonvbases);
4847 : :
4848 : : /* Note that during error recovery vector->length can even be zero. */
4849 : 7 : if (vector->length () > 1)
4850 : : {
4851 : : /* Last element is entire class, so don't copy */
4852 : 6 : bases_vec = make_tree_vec (vector->length () - 1);
4853 : :
4854 : 53 : for (i = 0; i < vector->length () - 1; ++i)
4855 : 41 : TREE_VEC_ELT (bases_vec, i) = (*vector)[i];
4856 : : }
4857 : : else
4858 : 1 : bases_vec = make_tree_vec (0);
4859 : :
4860 : 7 : return bases_vec;
4861 : 7 : }
4862 : :
4863 : : tree
4864 : 28 : finish_bases (tree type, bool direct)
4865 : : {
4866 : 28 : tree bases = NULL_TREE;
4867 : :
4868 : 28 : if (!processing_template_decl)
4869 : : {
4870 : : /* Parameter packs can only be used in templates */
4871 : 0 : error ("parameter pack %<__bases%> only valid in template declaration");
4872 : 0 : return error_mark_node;
4873 : : }
4874 : :
4875 : 28 : bases = cxx_make_type (BASES);
4876 : 28 : BASES_TYPE (bases) = type;
4877 : 28 : BASES_DIRECT (bases) = direct;
4878 : 28 : SET_TYPE_STRUCTURAL_EQUALITY (bases);
4879 : :
4880 : 28 : return bases;
4881 : : }
4882 : :
4883 : : /* Perform C++-specific checks for __builtin_offsetof before calling
4884 : : fold_offsetof. */
4885 : :
4886 : : tree
4887 : 2352 : finish_offsetof (tree object_ptr, tree expr, location_t loc)
4888 : : {
4889 : : /* If we're processing a template, we can't finish the semantics yet.
4890 : : Otherwise we can fold the entire expression now. */
4891 : 2352 : if (processing_template_decl)
4892 : : {
4893 : 60 : expr = build2 (OFFSETOF_EXPR, size_type_node, expr, object_ptr);
4894 : 60 : SET_EXPR_LOCATION (expr, loc);
4895 : 60 : return expr;
4896 : : }
4897 : :
4898 : 2292 : if (expr == error_mark_node)
4899 : : return error_mark_node;
4900 : :
4901 : 2275 : if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
4902 : : {
4903 : 6 : error ("cannot apply %<offsetof%> to destructor %<~%T%>",
4904 : 6 : TREE_OPERAND (expr, 2));
4905 : 6 : return error_mark_node;
4906 : : }
4907 : 4523 : if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr))
4908 : 4523 : || TREE_TYPE (expr) == unknown_type_node)
4909 : : {
4910 : 30 : while (TREE_CODE (expr) == COMPONENT_REF
4911 : 30 : || TREE_CODE (expr) == COMPOUND_EXPR)
4912 : 12 : expr = TREE_OPERAND (expr, 1);
4913 : :
4914 : 18 : if (DECL_P (expr))
4915 : : {
4916 : 0 : auto_diagnostic_group d;
4917 : 0 : error ("cannot apply %<offsetof%> to member function %qD", expr);
4918 : 0 : inform (DECL_SOURCE_LOCATION (expr), "declared here");
4919 : 0 : }
4920 : : else
4921 : 18 : error ("cannot apply %<offsetof%> to member function");
4922 : 18 : return error_mark_node;
4923 : : }
4924 : 2251 : if (TREE_CODE (expr) == CONST_DECL)
4925 : : {
4926 : 3 : error ("cannot apply %<offsetof%> to an enumerator %qD", expr);
4927 : 3 : return error_mark_node;
4928 : : }
4929 : 2248 : if (REFERENCE_REF_P (expr))
4930 : 9 : expr = TREE_OPERAND (expr, 0);
4931 : 2248 : if (!complete_type_or_else (TREE_TYPE (TREE_TYPE (object_ptr)), object_ptr))
4932 : 3 : return error_mark_node;
4933 : 2245 : if (warn_invalid_offsetof
4934 : 2245 : && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (object_ptr)))
4935 : 2245 : && CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (TREE_TYPE (object_ptr)))
4936 : 2290 : && cp_unevaluated_operand == 0)
4937 : 45 : warning_at (loc, OPT_Winvalid_offsetof, "%<offsetof%> within "
4938 : : "non-standard-layout type %qT is conditionally-supported",
4939 : 45 : TREE_TYPE (TREE_TYPE (object_ptr)));
4940 : 2245 : return fold_offsetof (expr);
4941 : : }
4942 : :
4943 : : /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
4944 : : function is broken out from the above for the benefit of the tree-ssa
4945 : : project. */
4946 : :
4947 : : void
4948 : 306899 : simplify_aggr_init_expr (tree *tp)
4949 : : {
4950 : 306899 : tree aggr_init_expr = *tp;
4951 : :
4952 : : /* Form an appropriate CALL_EXPR. */
4953 : 306899 : tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
4954 : 306899 : tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
4955 : 306899 : tree type = TREE_TYPE (slot);
4956 : :
4957 : 306899 : tree call_expr;
4958 : 306899 : enum style_t { ctor, arg, pcc } style;
4959 : :
4960 : 306899 : if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
4961 : : style = ctor;
4962 : : #ifdef PCC_STATIC_STRUCT_RETURN
4963 : : else if (1)
4964 : : style = pcc;
4965 : : #endif
4966 : : else
4967 : : {
4968 : 68566 : gcc_assert (TREE_ADDRESSABLE (type));
4969 : : style = arg;
4970 : : }
4971 : :
4972 : 306899 : call_expr = build_call_array_loc (input_location,
4973 : 306899 : TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
4974 : : fn,
4975 : 306899 : aggr_init_expr_nargs (aggr_init_expr),
4976 : 306899 : AGGR_INIT_EXPR_ARGP (aggr_init_expr));
4977 : 306899 : TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
4978 : 306899 : CALL_FROM_THUNK_P (call_expr) = AGGR_INIT_FROM_THUNK_P (aggr_init_expr);
4979 : 306899 : CALL_EXPR_OPERATOR_SYNTAX (call_expr)
4980 : 306899 : = CALL_EXPR_OPERATOR_SYNTAX (aggr_init_expr);
4981 : 306899 : CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (aggr_init_expr);
4982 : 306899 : CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (aggr_init_expr);
4983 : 306899 : CALL_EXPR_MUST_TAIL_CALL (call_expr) = AGGR_INIT_EXPR_MUST_TAIL (aggr_init_expr);
4984 : :
4985 : 306899 : if (style == ctor)
4986 : : {
4987 : : /* Replace the first argument to the ctor with the address of the
4988 : : slot. */
4989 : 238333 : cxx_mark_addressable (slot);
4990 : 238333 : CALL_EXPR_ARG (call_expr, 0) =
4991 : 238333 : build1 (ADDR_EXPR, build_pointer_type (type), slot);
4992 : : }
4993 : 68566 : else if (style == arg)
4994 : : {
4995 : : /* Just mark it addressable here, and leave the rest to
4996 : : expand_call{,_inline}. */
4997 : 68566 : cxx_mark_addressable (slot);
4998 : 68566 : CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
4999 : 68566 : call_expr = cp_build_init_expr (slot, call_expr);
5000 : : }
5001 : : else if (style == pcc)
5002 : : {
5003 : : /* If we're using the non-reentrant PCC calling convention, then we
5004 : : need to copy the returned value out of the static buffer into the
5005 : : SLOT. */
5006 : : push_deferring_access_checks (dk_no_check);
5007 : : call_expr = build_aggr_init (slot, call_expr,
5008 : : DIRECT_BIND | LOOKUP_ONLYCONVERTING,
5009 : : tf_warning_or_error);
5010 : : pop_deferring_access_checks ();
5011 : : call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
5012 : : }
5013 : :
5014 : 306899 : if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
5015 : : {
5016 : 3072 : tree init = build_zero_init (type, NULL_TREE,
5017 : : /*static_storage_p=*/false);
5018 : 3072 : init = cp_build_init_expr (slot, init);
5019 : 3072 : call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
5020 : : init, call_expr);
5021 : : }
5022 : :
5023 : 306899 : *tp = call_expr;
5024 : 306899 : }
5025 : :
5026 : : /* Emit all thunks to FN that should be emitted when FN is emitted. */
5027 : :
5028 : : void
5029 : 45950694 : emit_associated_thunks (tree fn)
5030 : : {
5031 : : /* When we use vcall offsets, we emit thunks with the virtual
5032 : : functions to which they thunk. The whole point of vcall offsets
5033 : : is so that you can know statically the entire set of thunks that
5034 : : will ever be needed for a given virtual function, thereby
5035 : : enabling you to output all the thunks with the function itself. */
5036 : 45950694 : if (DECL_VIRTUAL_P (fn)
5037 : : /* Do not emit thunks for extern template instantiations. */
5038 : 45950694 : && ! DECL_REALLY_EXTERN (fn))
5039 : : {
5040 : 860635 : tree thunk;
5041 : :
5042 : 1725462 : for (thunk = DECL_THUNKS (fn); thunk; thunk = DECL_CHAIN (thunk))
5043 : : {
5044 : 4192 : if (!THUNK_ALIAS (thunk))
5045 : : {
5046 : 4192 : use_thunk (thunk, /*emit_p=*/1);
5047 : 4192 : if (DECL_RESULT_THUNK_P (thunk))
5048 : : {
5049 : 178 : tree probe;
5050 : :
5051 : 178 : for (probe = DECL_THUNKS (thunk);
5052 : 327 : probe; probe = DECL_CHAIN (probe))
5053 : 149 : use_thunk (probe, /*emit_p=*/1);
5054 : : }
5055 : : }
5056 : : else
5057 : 0 : gcc_assert (!DECL_THUNKS (thunk));
5058 : : }
5059 : : }
5060 : 45950694 : }
5061 : :
5062 : : /* Generate RTL for FN. */
5063 : :
5064 : : bool
5065 : 132083911 : expand_or_defer_fn_1 (tree fn)
5066 : : {
5067 : : /* When the parser calls us after finishing the body of a template
5068 : : function, we don't really want to expand the body. */
5069 : 132083911 : if (processing_template_decl)
5070 : : {
5071 : : /* Normally, collection only occurs in rest_of_compilation. So,
5072 : : if we don't collect here, we never collect junk generated
5073 : : during the processing of templates until we hit a
5074 : : non-template function. It's not safe to do this inside a
5075 : : nested class, though, as the parser may have local state that
5076 : : is not a GC root. */
5077 : 79742772 : if (!function_depth)
5078 : 79443393 : ggc_collect ();
5079 : 79742772 : return false;
5080 : : }
5081 : :
5082 : 52341139 : gcc_assert (DECL_SAVED_TREE (fn));
5083 : :
5084 : : /* We make a decision about linkage for these functions at the end
5085 : : of the compilation. Until that point, we do not want the back
5086 : : end to output them -- but we do want it to see the bodies of
5087 : : these functions so that it can inline them as appropriate. */
5088 : 52341139 : if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
5089 : : {
5090 : 52092480 : if (DECL_INTERFACE_KNOWN (fn))
5091 : : /* We've already made a decision as to how this function will
5092 : : be handled. */;
5093 : 34942098 : else if (!at_eof
5094 : 12980175 : || DECL_IMMEDIATE_FUNCTION_P (fn)
5095 : 47865780 : || DECL_OMP_DECLARE_REDUCTION_P (fn))
5096 : 22018416 : tentative_decl_linkage (fn);
5097 : : else
5098 : 12923682 : import_export_decl (fn);
5099 : :
5100 : : /* If the user wants us to keep all inline functions, then mark
5101 : : this function as needed so that finish_file will make sure to
5102 : : output it later. Similarly, all dllexport'd functions must
5103 : : be emitted; there may be callers in other DLLs. */
5104 : 52092480 : if (DECL_DECLARED_INLINE_P (fn)
5105 : 50325944 : && !DECL_REALLY_EXTERN (fn)
5106 : 47292919 : && !DECL_IMMEDIATE_FUNCTION_P (fn)
5107 : 47156072 : && !DECL_OMP_DECLARE_REDUCTION_P (fn)
5108 : 99248552 : && (flag_keep_inline_functions
5109 : 47153779 : || (flag_keep_inline_dllexport
5110 : 47153779 : && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn)))))
5111 : : {
5112 : 2293 : mark_needed (fn);
5113 : 2293 : DECL_EXTERNAL (fn) = 0;
5114 : : }
5115 : : }
5116 : :
5117 : : /* If this is a constructor or destructor body, we have to clone
5118 : : it. */
5119 : 52341139 : if (maybe_clone_body (fn))
5120 : : {
5121 : : /* We don't want to process FN again, so pretend we've written
5122 : : it out, even though we haven't. */
5123 : 6382922 : TREE_ASM_WRITTEN (fn) = 1;
5124 : : /* If this is a constexpr function we still need the body to be
5125 : : able to evaluate it. Similarly, with modules we only stream
5126 : : the maybe-in-charge cdtor and regenerate the clones from it on
5127 : : demand, so we also need to keep the body. Otherwise we don't
5128 : : need it anymore. */
5129 : 6382922 : if (!DECL_DECLARED_CONSTEXPR_P (fn)
5130 : 6382922 : && !(modules_p () && vague_linkage_p (fn)))
5131 : 4460671 : DECL_SAVED_TREE (fn) = NULL_TREE;
5132 : 6382922 : return false;
5133 : : }
5134 : :
5135 : : /* There's no reason to do any of the work here if we're only doing
5136 : : semantic analysis; this code just generates RTL. */
5137 : 45958217 : if (flag_syntax_only)
5138 : : {
5139 : : /* Pretend that this function has been written out so that we don't try
5140 : : to expand it again. */
5141 : 7507 : TREE_ASM_WRITTEN (fn) = 1;
5142 : 7507 : return false;
5143 : : }
5144 : :
5145 : 45950710 : if (DECL_OMP_DECLARE_REDUCTION_P (fn))
5146 : : return false;
5147 : :
5148 : : return true;
5149 : : }
5150 : :
5151 : : void
5152 : 125719224 : expand_or_defer_fn (tree fn)
5153 : : {
5154 : 125719224 : if (expand_or_defer_fn_1 (fn))
5155 : : {
5156 : 39586802 : function_depth++;
5157 : :
5158 : : /* Expand or defer, at the whim of the compilation unit manager. */
5159 : 39586802 : cgraph_node::finalize_function (fn, function_depth > 1);
5160 : 39586802 : emit_associated_thunks (fn);
5161 : :
5162 : 39586802 : function_depth--;
5163 : :
5164 : 79173604 : if (DECL_IMMEDIATE_FUNCTION_P (fn))
5165 : : {
5166 : 127354 : if (cgraph_node *node = cgraph_node::get (fn))
5167 : : {
5168 : 127354 : node->body_removed = true;
5169 : 127354 : node->analyzed = false;
5170 : 127354 : node->definition = false;
5171 : 127354 : node->force_output = false;
5172 : : }
5173 : : }
5174 : : }
5175 : 125719224 : }
5176 : :
5177 : 330866 : class nrv_data
5178 : : {
5179 : : public:
5180 : 165433 : nrv_data () : visited (37) {}
5181 : :
5182 : : tree var;
5183 : : tree result;
5184 : : hash_set<tree> visited;
5185 : : bool simple;
5186 : : bool in_nrv_cleanup;
5187 : : };
5188 : :
5189 : : /* Helper function for walk_tree, used by finalize_nrv below. */
5190 : :
5191 : : static tree
5192 : 18002711 : finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
5193 : : {
5194 : 18002711 : class nrv_data *dp = (class nrv_data *)data;
5195 : :
5196 : : /* No need to walk into types. There wouldn't be any need to walk into
5197 : : non-statements, except that we have to consider STMT_EXPRs. */
5198 : 18002711 : if (TYPE_P (*tp))
5199 : 2294 : *walk_subtrees = 0;
5200 : :
5201 : : /* Replace all uses of the NRV with the RESULT_DECL. */
5202 : 18000417 : else if (*tp == dp->var)
5203 : 441368 : *tp = dp->result;
5204 : :
5205 : : /* Avoid walking into the same tree more than once. Unfortunately, we
5206 : : can't just use walk_tree_without duplicates because it would only call
5207 : : us for the first occurrence of dp->var in the function body. */
5208 : 17559049 : else if (dp->visited.add (*tp))
5209 : 3904376 : *walk_subtrees = 0;
5210 : :
5211 : : /* If there's a label, we might need to destroy the NRV on goto (92407). */
5212 : 13654673 : else if (TREE_CODE (*tp) == LABEL_EXPR && !dp->in_nrv_cleanup)
5213 : 3 : dp->simple = false;
5214 : : /* Change NRV returns to just refer to the RESULT_DECL; this is a nop,
5215 : : but differs from using NULL_TREE in that it indicates that we care
5216 : : about the value of the RESULT_DECL. But preserve anything appended
5217 : : by check_return_expr. */
5218 : 13654670 : else if (TREE_CODE (*tp) == RETURN_EXPR)
5219 : : {
5220 : 174312 : tree *p = &TREE_OPERAND (*tp, 0);
5221 : 478687 : while (TREE_CODE (*p) == COMPOUND_EXPR)
5222 : 130063 : p = &TREE_OPERAND (*p, 0);
5223 : 174312 : if (TREE_CODE (*p) == INIT_EXPR
5224 : 174312 : && INIT_EXPR_NRV_P (*p))
5225 : 174260 : *p = dp->result;
5226 : : }
5227 : : /* Change all cleanups for the NRV to only run when not returning. */
5228 : 13480358 : else if (TREE_CODE (*tp) == CLEANUP_STMT
5229 : 13480358 : && CLEANUP_DECL (*tp) == dp->var)
5230 : : {
5231 : 121308 : dp->in_nrv_cleanup = true;
5232 : 121308 : cp_walk_tree (&CLEANUP_BODY (*tp), finalize_nrv_r, data, 0);
5233 : 121308 : dp->in_nrv_cleanup = false;
5234 : 121308 : cp_walk_tree (&CLEANUP_EXPR (*tp), finalize_nrv_r, data, 0);
5235 : 121308 : *walk_subtrees = 0;
5236 : :
5237 : 121308 : if (dp->simple)
5238 : : /* For a simple NRV, just run it on the EH path. */
5239 : 120893 : CLEANUP_EH_ONLY (*tp) = true;
5240 : : else
5241 : : {
5242 : : /* Not simple, we need to check current_retval_sentinel to decide
5243 : : whether to run it. If it's set, we're returning normally and
5244 : : don't want to destroy the NRV. If the sentinel is not set, we're
5245 : : leaving scope some other way, either by flowing off the end of its
5246 : : scope or throwing an exception. */
5247 : 1245 : tree cond = build3 (COND_EXPR, void_type_node,
5248 : 415 : current_retval_sentinel,
5249 : 415 : void_node, CLEANUP_EXPR (*tp));
5250 : 415 : CLEANUP_EXPR (*tp) = cond;
5251 : : }
5252 : :
5253 : : /* If a cleanup might throw, we need to clear current_retval_sentinel on
5254 : : the exception path, both so the check above succeeds and so an outer
5255 : : cleanup added by maybe_splice_retval_cleanup doesn't run. */
5256 : 121308 : if (cp_function_chain->throwing_cleanup)
5257 : : {
5258 : 212 : tree clear = build2 (MODIFY_EXPR, boolean_type_node,
5259 : : current_retval_sentinel,
5260 : : boolean_false_node);
5261 : 212 : if (dp->simple)
5262 : : {
5263 : : /* We're already only on the EH path, just prepend it. */
5264 : 202 : tree &exp = CLEANUP_EXPR (*tp);
5265 : 202 : exp = build2 (COMPOUND_EXPR, void_type_node, clear, exp);
5266 : : }
5267 : : else
5268 : : {
5269 : : /* The cleanup runs on both normal and EH paths, we need another
5270 : : CLEANUP_STMT to clear the flag only on the EH path. */
5271 : 10 : tree &bod = CLEANUP_BODY (*tp);
5272 : 20 : bod = build_stmt (EXPR_LOCATION (*tp), CLEANUP_STMT,
5273 : 10 : bod, clear, current_retval_sentinel);
5274 : 10 : CLEANUP_EH_ONLY (bod) = true;
5275 : : }
5276 : : }
5277 : : }
5278 : : /* Disable maybe_splice_retval_cleanup within the NRV cleanup scope, we don't
5279 : : want to destroy the retval before the variable goes out of scope. */
5280 : 13359050 : else if (TREE_CODE (*tp) == CLEANUP_STMT
5281 : 5724 : && dp->in_nrv_cleanup
5282 : 13364170 : && CLEANUP_DECL (*tp) == dp->result)
5283 : 6 : CLEANUP_EXPR (*tp) = void_node;
5284 : : /* Replace the DECL_EXPR for the NRV with an initialization of the
5285 : : RESULT_DECL, if needed. */
5286 : 13359044 : else if (TREE_CODE (*tp) == DECL_EXPR
5287 : 13359044 : && DECL_EXPR_DECL (*tp) == dp->var)
5288 : : {
5289 : 165435 : tree init;
5290 : 165435 : if (DECL_INITIAL (dp->var)
5291 : 165435 : && DECL_INITIAL (dp->var) != error_mark_node)
5292 : 34359 : init = cp_build_init_expr (dp->result,
5293 : 34359 : DECL_INITIAL (dp->var));
5294 : : else
5295 : 131076 : init = build_empty_stmt (EXPR_LOCATION (*tp));
5296 : 165435 : DECL_INITIAL (dp->var) = NULL_TREE;
5297 : 165435 : SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
5298 : 165435 : *tp = init;
5299 : : }
5300 : :
5301 : : /* Keep iterating. */
5302 : 18002711 : return NULL_TREE;
5303 : : }
5304 : :
5305 : : /* Called from finish_function to implement the named return value
5306 : : optimization by overriding all the RETURN_EXPRs and pertinent
5307 : : CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
5308 : : RESULT_DECL for the function. */
5309 : :
5310 : : void
5311 : 165433 : finalize_nrv (tree fndecl, tree var)
5312 : : {
5313 : 165433 : class nrv_data data;
5314 : 165433 : tree result = DECL_RESULT (fndecl);
5315 : :
5316 : : /* Copy name from VAR to RESULT. */
5317 : 165433 : DECL_NAME (result) = DECL_NAME (var);
5318 : : /* Don't forget that we take its address. */
5319 : 165433 : TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
5320 : : /* Finally set DECL_VALUE_EXPR to avoid assigning
5321 : : a stack slot at -O0 for the original var and debug info
5322 : : uses RESULT location for VAR. */
5323 : 165433 : SET_DECL_VALUE_EXPR (var, result);
5324 : 165433 : DECL_HAS_VALUE_EXPR_P (var) = 1;
5325 : :
5326 : 165433 : data.var = var;
5327 : 165433 : data.result = result;
5328 : 165433 : data.in_nrv_cleanup = false;
5329 : :
5330 : : /* This is simpler for variables declared in the outer scope of
5331 : : the function so we know that their lifetime always ends with a
5332 : : return; see g++.dg/opt/nrv6.C. */
5333 : 165433 : tree outer = outer_curly_brace_block (fndecl);
5334 : 165433 : data.simple = chain_member (var, BLOCK_VARS (outer));
5335 : :
5336 : 165433 : cp_walk_tree (&DECL_SAVED_TREE (fndecl), finalize_nrv_r, &data, 0);
5337 : 165433 : }
5338 : :
5339 : : /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
5340 : :
5341 : : bool
5342 : 2234 : cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
5343 : : bool need_copy_ctor, bool need_copy_assignment,
5344 : : bool need_dtor)
5345 : : {
5346 : 2234 : int save_errorcount = errorcount;
5347 : 2234 : tree info, t;
5348 : :
5349 : : /* Always allocate 3 elements for simplicity. These are the
5350 : : function decls for the ctor, dtor, and assignment op.
5351 : : This layout is known to the three lang hooks,
5352 : : cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
5353 : : and cxx_omp_clause_assign_op. */
5354 : 2234 : info = make_tree_vec (3);
5355 : 2234 : CP_OMP_CLAUSE_INFO (c) = info;
5356 : :
5357 : 2234 : if (need_default_ctor || need_copy_ctor)
5358 : : {
5359 : 1653 : if (need_default_ctor)
5360 : 1254 : t = get_default_ctor (type);
5361 : : else
5362 : 399 : t = get_copy_ctor (type, tf_warning_or_error);
5363 : :
5364 : 1653 : if (t && !trivial_fn_p (t))
5365 : 1400 : TREE_VEC_ELT (info, 0) = t;
5366 : : }
5367 : :
5368 : 2234 : if (need_dtor && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
5369 : 1635 : TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
5370 : :
5371 : 2234 : if (need_copy_assignment)
5372 : : {
5373 : 397 : t = get_copy_assign (type);
5374 : :
5375 : 397 : if (t && !trivial_fn_p (t))
5376 : 344 : TREE_VEC_ELT (info, 2) = t;
5377 : : }
5378 : :
5379 : 2234 : return errorcount != save_errorcount;
5380 : : }
5381 : :
5382 : : /* If DECL is DECL_OMP_PRIVATIZED_MEMBER, return corresponding
5383 : : FIELD_DECL, otherwise return DECL itself. */
5384 : :
5385 : : static tree
5386 : 25520 : omp_clause_decl_field (tree decl)
5387 : : {
5388 : 25520 : if (VAR_P (decl)
5389 : 17554 : && DECL_HAS_VALUE_EXPR_P (decl)
5390 : 359 : && DECL_ARTIFICIAL (decl)
5391 : 359 : && DECL_LANG_SPECIFIC (decl)
5392 : 25855 : && DECL_OMP_PRIVATIZED_MEMBER (decl))
5393 : : {
5394 : 328 : tree f = DECL_VALUE_EXPR (decl);
5395 : 328 : if (INDIRECT_REF_P (f))
5396 : 0 : f = TREE_OPERAND (f, 0);
5397 : 328 : if (TREE_CODE (f) == COMPONENT_REF)
5398 : : {
5399 : 328 : f = TREE_OPERAND (f, 1);
5400 : 328 : gcc_assert (TREE_CODE (f) == FIELD_DECL);
5401 : : return f;
5402 : : }
5403 : : }
5404 : : return NULL_TREE;
5405 : : }
5406 : :
5407 : : /* Adjust DECL if needed for printing using %qE. */
5408 : :
5409 : : static tree
5410 : 187 : omp_clause_printable_decl (tree decl)
5411 : : {
5412 : 0 : tree t = omp_clause_decl_field (decl);
5413 : 187 : if (t)
5414 : 45 : return t;
5415 : : return decl;
5416 : : }
5417 : :
5418 : : /* For a FIELD_DECL F and corresponding DECL_OMP_PRIVATIZED_MEMBER
5419 : : VAR_DECL T that doesn't need a DECL_EXPR added, record it for
5420 : : privatization. */
5421 : :
5422 : : static void
5423 : 219 : omp_note_field_privatization (tree f, tree t)
5424 : : {
5425 : 219 : if (!omp_private_member_map)
5426 : 71 : omp_private_member_map = new hash_map<tree, tree>;
5427 : 219 : tree &v = omp_private_member_map->get_or_insert (f);
5428 : 219 : if (v == NULL_TREE)
5429 : : {
5430 : 146 : v = t;
5431 : 146 : omp_private_member_vec.safe_push (f);
5432 : : /* Signal that we don't want to create DECL_EXPR for this dummy var. */
5433 : 146 : omp_private_member_vec.safe_push (integer_zero_node);
5434 : : }
5435 : 219 : }
5436 : :
5437 : : /* Privatize FIELD_DECL T, return corresponding DECL_OMP_PRIVATIZED_MEMBER
5438 : : dummy VAR_DECL. */
5439 : :
5440 : : tree
5441 : 852 : omp_privatize_field (tree t, bool shared)
5442 : : {
5443 : 852 : tree m = finish_non_static_data_member (t, NULL_TREE, NULL_TREE);
5444 : 852 : if (m == error_mark_node)
5445 : : return error_mark_node;
5446 : 852 : if (!omp_private_member_map && !shared)
5447 : 362 : omp_private_member_map = new hash_map<tree, tree>;
5448 : 852 : if (TYPE_REF_P (TREE_TYPE (t)))
5449 : : {
5450 : 123 : gcc_assert (INDIRECT_REF_P (m));
5451 : 123 : m = TREE_OPERAND (m, 0);
5452 : : }
5453 : 852 : tree vb = NULL_TREE;
5454 : 852 : tree &v = shared ? vb : omp_private_member_map->get_or_insert (t);
5455 : 852 : if (v == NULL_TREE)
5456 : : {
5457 : 764 : v = create_temporary_var (TREE_TYPE (m));
5458 : 764 : retrofit_lang_decl (v);
5459 : 764 : DECL_OMP_PRIVATIZED_MEMBER (v) = 1;
5460 : 764 : SET_DECL_VALUE_EXPR (v, m);
5461 : 764 : DECL_HAS_VALUE_EXPR_P (v) = 1;
5462 : 764 : if (!shared)
5463 : 684 : omp_private_member_vec.safe_push (t);
5464 : : }
5465 : 852 : return v;
5466 : : }
5467 : :
5468 : : /* C++ specialisation of the c_omp_address_inspector class. */
5469 : :
5470 : : class cp_omp_address_inspector : public c_omp_address_inspector
5471 : : {
5472 : : public:
5473 : 29173 : cp_omp_address_inspector (location_t loc, tree t)
5474 : 29173 : : c_omp_address_inspector (loc, t)
5475 : : {
5476 : : }
5477 : :
5478 : 29173 : ~cp_omp_address_inspector ()
5479 : : {
5480 : 21379 : }
5481 : :
5482 : 125215 : bool processing_template_decl_p ()
5483 : : {
5484 : 125215 : return processing_template_decl;
5485 : : }
5486 : :
5487 : 0 : void emit_unmappable_type_notes (tree t)
5488 : : {
5489 : 0 : if (TREE_TYPE (t) != error_mark_node
5490 : 0 : && !COMPLETE_TYPE_P (TREE_TYPE (t)))
5491 : 0 : cxx_incomplete_type_inform (TREE_TYPE (t));
5492 : 0 : }
5493 : :
5494 : 1034 : tree convert_from_reference (tree x)
5495 : : {
5496 : 1034 : return ::convert_from_reference (x);
5497 : : }
5498 : :
5499 : 143 : tree build_array_ref (location_t loc, tree arr, tree idx)
5500 : : {
5501 : 143 : return ::build_array_ref (loc, arr, idx);
5502 : : }
5503 : :
5504 : 21323 : bool check_clause (tree clause)
5505 : : {
5506 : 21323 : if (TREE_CODE (orig) == COMPONENT_REF
5507 : 21323 : && invalid_nonstatic_memfn_p (EXPR_LOCATION (orig), orig,
5508 : : tf_warning_or_error))
5509 : : return false;
5510 : 21320 : if (!c_omp_address_inspector::check_clause (clause))
5511 : : return false;
5512 : : return true;
5513 : : }
5514 : : };
5515 : :
5516 : : /* Helper function for handle_omp_array_sections. Called recursively
5517 : : to handle multiple array-section-subscripts. C is the clause,
5518 : : T current expression (initially OMP_CLAUSE_DECL), which is either
5519 : : a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
5520 : : expression if specified, TREE_VALUE length expression if specified,
5521 : : TREE_CHAIN is what it has been specified after, or some decl.
5522 : : TYPES vector is populated with array section types, MAYBE_ZERO_LEN
5523 : : set to true if any of the array-section-subscript could have length
5524 : : of zero (explicit or implicit), FIRST_NON_ONE is the index of the
5525 : : first array-section-subscript which is known not to have length
5526 : : of one. Given say:
5527 : : map(a[:b][2:1][:c][:2][:d][e:f][2:5])
5528 : : FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
5529 : : all are or may have length of 1, array-section-subscript [:2] is the
5530 : : first one known not to have length 1. For array-section-subscript
5531 : : <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
5532 : : 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
5533 : : can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
5534 : : case though, as some lengths could be zero. */
5535 : :
5536 : : static tree
5537 : 20483 : handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
5538 : : bool &maybe_zero_len, unsigned int &first_non_one,
5539 : : enum c_omp_region_type ort)
5540 : : {
5541 : 20483 : tree ret, low_bound, length, type;
5542 : 20483 : bool openacc = (ort & C_ORT_ACC) != 0;
5543 : 20483 : if (TREE_CODE (t) != OMP_ARRAY_SECTION)
5544 : : {
5545 : 9231 : if (error_operand_p (t))
5546 : 6 : return error_mark_node;
5547 : :
5548 : 9225 : cp_omp_address_inspector ai (OMP_CLAUSE_LOCATION (c), t);
5549 : 9225 : tree t_refto = ai.maybe_unconvert_ref (t);
5550 : :
5551 : 9225 : if (!ai.check_clause (c))
5552 : 0 : return error_mark_node;
5553 : 9225 : else if (ai.component_access_p ()
5554 : 10549 : && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
5555 : 64 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO
5556 : 40 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FROM))
5557 : 1324 : t = ai.get_root_term (true);
5558 : : else
5559 : 7901 : t = ai.unconverted_ref_origin ();
5560 : 9225 : if (t == error_mark_node)
5561 : : return error_mark_node;
5562 : 9225 : ret = t_refto;
5563 : 9225 : if (TREE_CODE (t) == FIELD_DECL)
5564 : 33 : ret = finish_non_static_data_member (t, NULL_TREE, NULL_TREE);
5565 : 9192 : else if (!VAR_P (t)
5566 : 2690 : && (openacc || !EXPR_P (t))
5567 : 2507 : && TREE_CODE (t) != PARM_DECL)
5568 : : {
5569 : 51 : if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
5570 : : return NULL_TREE;
5571 : 33 : if (DECL_P (t))
5572 : 33 : error_at (OMP_CLAUSE_LOCATION (c),
5573 : : "%qD is not a variable in %qs clause", t,
5574 : 33 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5575 : : else
5576 : 0 : error_at (OMP_CLAUSE_LOCATION (c),
5577 : : "%qE is not a variable in %qs clause", t,
5578 : 0 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5579 : 33 : return error_mark_node;
5580 : : }
5581 : 9141 : else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_AFFINITY
5582 : 8811 : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
5583 : 17034 : && VAR_P (t) && CP_DECL_THREAD_LOCAL_P (t))
5584 : : {
5585 : 18 : error_at (OMP_CLAUSE_LOCATION (c),
5586 : : "%qD is threadprivate variable in %qs clause", t,
5587 : 18 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5588 : 18 : return error_mark_node;
5589 : : }
5590 : 9156 : if (type_dependent_expression_p (ret))
5591 : : return NULL_TREE;
5592 : 8502 : ret = convert_from_reference (ret);
5593 : 8502 : return ret;
5594 : 9225 : }
5595 : :
5596 : 11252 : if ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP
5597 : 7355 : && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5598 : 6053 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
5599 : 4769 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
5600 : 13966 : && TREE_CODE (TREE_OPERAND (t, 0)) == FIELD_DECL)
5601 : 43 : TREE_OPERAND (t, 0) = omp_privatize_field (TREE_OPERAND (t, 0), false);
5602 : 11252 : ret = handle_omp_array_sections_1 (c, TREE_OPERAND (t, 0), types,
5603 : : maybe_zero_len, first_non_one, ort);
5604 : 11252 : if (ret == error_mark_node || ret == NULL_TREE)
5605 : : return ret;
5606 : :
5607 : 10248 : type = TREE_TYPE (ret);
5608 : 10248 : low_bound = TREE_OPERAND (t, 1);
5609 : 10248 : length = TREE_OPERAND (t, 2);
5610 : 8337 : if ((low_bound && type_dependent_expression_p (low_bound))
5611 : 18502 : || (length && type_dependent_expression_p (length)))
5612 : 88 : return NULL_TREE;
5613 : :
5614 : 10160 : if (low_bound == error_mark_node || length == error_mark_node)
5615 : : return error_mark_node;
5616 : :
5617 : 10160 : if (low_bound && !INTEGRAL_TYPE_P (TREE_TYPE (low_bound)))
5618 : : {
5619 : 75 : error_at (OMP_CLAUSE_LOCATION (c),
5620 : : "low bound %qE of array section does not have integral type",
5621 : : low_bound);
5622 : 75 : return error_mark_node;
5623 : : }
5624 : 10085 : if (length && !INTEGRAL_TYPE_P (TREE_TYPE (length)))
5625 : : {
5626 : 69 : error_at (OMP_CLAUSE_LOCATION (c),
5627 : : "length %qE of array section does not have integral type",
5628 : : length);
5629 : 69 : return error_mark_node;
5630 : : }
5631 : 10016 : if (low_bound)
5632 : 8165 : low_bound = mark_rvalue_use (low_bound);
5633 : 10016 : if (length)
5634 : 8999 : length = mark_rvalue_use (length);
5635 : : /* We need to reduce to real constant-values for checks below. */
5636 : 8999 : if (length)
5637 : 8999 : length = fold_simple (length);
5638 : 10016 : if (low_bound)
5639 : 8165 : low_bound = fold_simple (low_bound);
5640 : 8165 : if (low_bound
5641 : 8165 : && TREE_CODE (low_bound) == INTEGER_CST
5642 : 15401 : && TYPE_PRECISION (TREE_TYPE (low_bound))
5643 : 7236 : > TYPE_PRECISION (sizetype))
5644 : 0 : low_bound = fold_convert (sizetype, low_bound);
5645 : 10016 : if (length
5646 : 8999 : && TREE_CODE (length) == INTEGER_CST
5647 : 17058 : && TYPE_PRECISION (TREE_TYPE (length))
5648 : 7042 : > TYPE_PRECISION (sizetype))
5649 : 0 : length = fold_convert (sizetype, length);
5650 : 10016 : if (low_bound == NULL_TREE)
5651 : 1851 : low_bound = integer_zero_node;
5652 : :
5653 : 10016 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
5654 : 10016 : && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ATTACH
5655 : 4833 : || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH))
5656 : : {
5657 : 60 : if (length != integer_one_node)
5658 : : {
5659 : 36 : error_at (OMP_CLAUSE_LOCATION (c),
5660 : : "expected single pointer in %qs clause",
5661 : : user_omp_clause_code_name (c, openacc));
5662 : 36 : return error_mark_node;
5663 : : }
5664 : : }
5665 : 9980 : if (length != NULL_TREE)
5666 : : {
5667 : 8987 : if (!integer_nonzerop (length))
5668 : : {
5669 : 2006 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_AFFINITY
5670 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
5671 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5672 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
5673 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
5674 : : {
5675 : 469 : if (integer_zerop (length))
5676 : : {
5677 : 36 : error_at (OMP_CLAUSE_LOCATION (c),
5678 : : "zero length array section in %qs clause",
5679 : 36 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5680 : 36 : return error_mark_node;
5681 : : }
5682 : : }
5683 : : else
5684 : 1537 : maybe_zero_len = true;
5685 : : }
5686 : 8951 : if (first_non_one == types.length ()
5687 : 8951 : && (TREE_CODE (length) != INTEGER_CST || integer_onep (length)))
5688 : 3827 : first_non_one++;
5689 : : }
5690 : 9944 : if (TREE_CODE (type) == ARRAY_TYPE)
5691 : : {
5692 : 5585 : if (length == NULL_TREE
5693 : 5585 : && (TYPE_DOMAIN (type) == NULL_TREE
5694 : 915 : || TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE))
5695 : : {
5696 : 33 : error_at (OMP_CLAUSE_LOCATION (c),
5697 : : "for unknown bound array type length expression must "
5698 : : "be specified");
5699 : 33 : return error_mark_node;
5700 : : }
5701 : 5552 : if (TREE_CODE (low_bound) == INTEGER_CST
5702 : 5552 : && tree_int_cst_sgn (low_bound) == -1)
5703 : : {
5704 : 174 : error_at (OMP_CLAUSE_LOCATION (c),
5705 : : "negative low bound in array section in %qs clause",
5706 : 174 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5707 : 174 : return error_mark_node;
5708 : : }
5709 : 5378 : if (length != NULL_TREE
5710 : 4517 : && TREE_CODE (length) == INTEGER_CST
5711 : 8980 : && tree_int_cst_sgn (length) == -1)
5712 : : {
5713 : 174 : error_at (OMP_CLAUSE_LOCATION (c),
5714 : : "negative length in array section in %qs clause",
5715 : 174 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5716 : 174 : return error_mark_node;
5717 : : }
5718 : 5204 : if (TYPE_DOMAIN (type)
5719 : 5105 : && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
5720 : 10309 : && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
5721 : : == INTEGER_CST)
5722 : : {
5723 : 4709 : tree size
5724 : 4709 : = fold_convert (sizetype, TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
5725 : 4709 : size = size_binop (PLUS_EXPR, size, size_one_node);
5726 : 4709 : if (TREE_CODE (low_bound) == INTEGER_CST)
5727 : : {
5728 : 3940 : if (tree_int_cst_lt (size, low_bound))
5729 : : {
5730 : 60 : error_at (OMP_CLAUSE_LOCATION (c),
5731 : : "low bound %qE above array section size "
5732 : : "in %qs clause", low_bound,
5733 : 60 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5734 : 60 : return error_mark_node;
5735 : : }
5736 : 3880 : if (tree_int_cst_equal (size, low_bound))
5737 : : {
5738 : 21 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_AFFINITY
5739 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
5740 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5741 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
5742 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
5743 : : {
5744 : 21 : error_at (OMP_CLAUSE_LOCATION (c),
5745 : : "zero length array section in %qs clause",
5746 : 21 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5747 : 21 : return error_mark_node;
5748 : : }
5749 : 0 : maybe_zero_len = true;
5750 : : }
5751 : 3859 : else if (length == NULL_TREE
5752 : 1514 : && first_non_one == types.length ()
5753 : 4180 : && tree_int_cst_equal
5754 : 321 : (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
5755 : : low_bound))
5756 : 207 : first_non_one++;
5757 : : }
5758 : 769 : else if (length == NULL_TREE)
5759 : : {
5760 : 22 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_AFFINITY
5761 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
5762 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
5763 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_IN_REDUCTION
5764 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_TASK_REDUCTION)
5765 : 13 : maybe_zero_len = true;
5766 : 44 : if (first_non_one == types.length ())
5767 : 19 : first_non_one++;
5768 : : }
5769 : 4628 : if (length && TREE_CODE (length) == INTEGER_CST)
5770 : : {
5771 : 3308 : if (tree_int_cst_lt (size, length))
5772 : : {
5773 : 63 : error_at (OMP_CLAUSE_LOCATION (c),
5774 : : "length %qE above array section size "
5775 : : "in %qs clause", length,
5776 : 63 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5777 : 63 : return error_mark_node;
5778 : : }
5779 : 3245 : if (TREE_CODE (low_bound) == INTEGER_CST)
5780 : : {
5781 : 2913 : tree lbpluslen
5782 : 2913 : = size_binop (PLUS_EXPR,
5783 : : fold_convert (sizetype, low_bound),
5784 : : fold_convert (sizetype, length));
5785 : 2913 : if (TREE_CODE (lbpluslen) == INTEGER_CST
5786 : 2913 : && tree_int_cst_lt (size, lbpluslen))
5787 : : {
5788 : 60 : error_at (OMP_CLAUSE_LOCATION (c),
5789 : : "high bound %qE above array section size "
5790 : : "in %qs clause", lbpluslen,
5791 : 60 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5792 : 60 : return error_mark_node;
5793 : : }
5794 : : }
5795 : : }
5796 : : }
5797 : 495 : else if (length == NULL_TREE)
5798 : : {
5799 : 1 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_AFFINITY
5800 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
5801 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
5802 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_IN_REDUCTION
5803 : : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_TASK_REDUCTION)
5804 : 0 : maybe_zero_len = true;
5805 : 2 : if (first_non_one == types.length ())
5806 : 1 : first_non_one++;
5807 : : }
5808 : :
5809 : : /* For [lb:] we will need to evaluate lb more than once. */
5810 : 3966 : if (length == NULL_TREE && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
5811 : : {
5812 : 699 : tree lb = cp_save_expr (low_bound);
5813 : 699 : if (lb != low_bound)
5814 : : {
5815 : 11 : TREE_OPERAND (t, 1) = lb;
5816 : 11 : low_bound = lb;
5817 : : }
5818 : : }
5819 : : }
5820 : 4359 : else if (TYPE_PTR_P (type))
5821 : : {
5822 : 4302 : if (length == NULL_TREE)
5823 : : {
5824 : 45 : if (TREE_CODE (ret) == PARM_DECL && DECL_ARRAY_PARAMETER_P (ret))
5825 : 39 : error_at (OMP_CLAUSE_LOCATION (c),
5826 : : "for array function parameter length expression "
5827 : : "must be specified");
5828 : : else
5829 : 6 : error_at (OMP_CLAUSE_LOCATION (c),
5830 : : "for pointer type length expression must be specified");
5831 : 45 : return error_mark_node;
5832 : : }
5833 : 4257 : if (length != NULL_TREE
5834 : 4257 : && TREE_CODE (length) == INTEGER_CST
5835 : 3215 : && tree_int_cst_sgn (length) == -1)
5836 : : {
5837 : 96 : error_at (OMP_CLAUSE_LOCATION (c),
5838 : : "negative length in array section in %qs clause",
5839 : 96 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5840 : 96 : return error_mark_node;
5841 : : }
5842 : : /* If there is a pointer type anywhere but in the very first
5843 : : array-section-subscript, the array section could be non-contiguous. */
5844 : 4161 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_AFFINITY
5845 : 4059 : && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
5846 : 7737 : && TREE_CODE (TREE_OPERAND (t, 0)) == OMP_ARRAY_SECTION)
5847 : : {
5848 : : /* If any prior dimension has a non-one length, then deem this
5849 : : array section as non-contiguous. */
5850 : 77 : for (tree d = TREE_OPERAND (t, 0); TREE_CODE (d) == OMP_ARRAY_SECTION;
5851 : 28 : d = TREE_OPERAND (d, 0))
5852 : : {
5853 : 49 : tree d_length = TREE_OPERAND (d, 2);
5854 : 49 : if (d_length == NULL_TREE || !integer_onep (d_length))
5855 : : {
5856 : 21 : error_at (OMP_CLAUSE_LOCATION (c),
5857 : : "array section is not contiguous in %qs clause",
5858 : 21 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5859 : 21 : return error_mark_node;
5860 : : }
5861 : : }
5862 : : }
5863 : : }
5864 : : else
5865 : : {
5866 : 57 : error_at (OMP_CLAUSE_LOCATION (c),
5867 : : "%qE does not have pointer or array type", ret);
5868 : 57 : return error_mark_node;
5869 : : }
5870 : 9140 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
5871 : 8246 : types.safe_push (TREE_TYPE (ret));
5872 : : /* We will need to evaluate lb more than once. */
5873 : 9140 : tree lb = cp_save_expr (low_bound);
5874 : 9140 : if (lb != low_bound)
5875 : : {
5876 : 718 : TREE_OPERAND (t, 1) = lb;
5877 : 718 : low_bound = lb;
5878 : : }
5879 : : /* Temporarily disable -fstrong-eval-order for array reductions.
5880 : : The SAVE_EXPR and COMPOUND_EXPR added if low_bound has side-effects
5881 : : is something the middle-end can't cope with and more importantly,
5882 : : it needs to be the actual base variable that is privatized, not some
5883 : : temporary assigned previous value of it. That, together with OpenMP
5884 : : saying how many times the side-effects are evaluated is unspecified,
5885 : : makes int *a, *b; ... reduction(+:a[a = b, 3:10]) really unspecified. */
5886 : 9140 : warning_sentinel s (flag_strong_eval_order,
5887 : 9140 : OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5888 : 8043 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
5889 : 18399 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION);
5890 : 9140 : ret = grok_array_decl (OMP_CLAUSE_LOCATION (c), ret, low_bound, NULL,
5891 : : tf_warning_or_error);
5892 : 9140 : return ret;
5893 : 9140 : }
5894 : :
5895 : : /* Handle array sections for clause C. */
5896 : :
5897 : : static bool
5898 : 9231 : handle_omp_array_sections (tree &c, enum c_omp_region_type ort)
5899 : : {
5900 : 9231 : bool maybe_zero_len = false;
5901 : 9231 : unsigned int first_non_one = 0;
5902 : 9231 : auto_vec<tree, 10> types;
5903 : 9231 : tree *tp = &OMP_CLAUSE_DECL (c);
5904 : 9231 : if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
5905 : 8283 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_AFFINITY)
5906 : 1296 : && TREE_CODE (*tp) == TREE_LIST
5907 : 258 : && TREE_PURPOSE (*tp)
5908 : 9489 : && TREE_CODE (TREE_PURPOSE (*tp)) == TREE_VEC)
5909 : 258 : tp = &TREE_VALUE (*tp);
5910 : 9231 : tree first = handle_omp_array_sections_1 (c, *tp, types,
5911 : : maybe_zero_len, first_non_one,
5912 : : ort);
5913 : 9231 : if (first == error_mark_node)
5914 : : return true;
5915 : 8154 : if (first == NULL_TREE)
5916 : : return false;
5917 : 7394 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
5918 : 7394 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_AFFINITY)
5919 : : {
5920 : 906 : tree t = *tp;
5921 : 906 : tree tem = NULL_TREE;
5922 : 906 : if (processing_template_decl)
5923 : : return false;
5924 : : /* Need to evaluate side effects in the length expressions
5925 : : if any. */
5926 : 807 : while (TREE_CODE (t) == TREE_LIST)
5927 : : {
5928 : 0 : if (TREE_VALUE (t) && TREE_SIDE_EFFECTS (TREE_VALUE (t)))
5929 : : {
5930 : 0 : if (tem == NULL_TREE)
5931 : : tem = TREE_VALUE (t);
5932 : : else
5933 : 0 : tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem),
5934 : 0 : TREE_VALUE (t), tem);
5935 : : }
5936 : 0 : t = TREE_CHAIN (t);
5937 : : }
5938 : 807 : if (tem)
5939 : 0 : first = build2 (COMPOUND_EXPR, TREE_TYPE (first), tem, first);
5940 : 807 : *tp = first;
5941 : : }
5942 : : else
5943 : : {
5944 : 6488 : unsigned int num = types.length (), i;
5945 : 6488 : tree t, side_effects = NULL_TREE, size = NULL_TREE;
5946 : 6488 : tree condition = NULL_TREE;
5947 : :
5948 : 6488 : if (int_size_in_bytes (TREE_TYPE (first)) <= 0)
5949 : 3 : maybe_zero_len = true;
5950 : 6488 : if (processing_template_decl && maybe_zero_len)
5951 : : return false;
5952 : :
5953 : 13636 : for (i = num, t = OMP_CLAUSE_DECL (c); i > 0;
5954 : 7226 : t = TREE_OPERAND (t, 0))
5955 : : {
5956 : 7301 : gcc_assert (TREE_CODE (t) == OMP_ARRAY_SECTION);
5957 : :
5958 : 7301 : tree low_bound = TREE_OPERAND (t, 1);
5959 : 7301 : tree length = TREE_OPERAND (t, 2);
5960 : :
5961 : 7301 : i--;
5962 : 7301 : if (low_bound
5963 : 6022 : && TREE_CODE (low_bound) == INTEGER_CST
5964 : 12714 : && TYPE_PRECISION (TREE_TYPE (low_bound))
5965 : 5413 : > TYPE_PRECISION (sizetype))
5966 : 0 : low_bound = fold_convert (sizetype, low_bound);
5967 : 7301 : if (length
5968 : 6769 : && TREE_CODE (length) == INTEGER_CST
5969 : 12234 : && TYPE_PRECISION (TREE_TYPE (length))
5970 : 4933 : > TYPE_PRECISION (sizetype))
5971 : 0 : length = fold_convert (sizetype, length);
5972 : 7301 : if (low_bound == NULL_TREE)
5973 : 1279 : low_bound = integer_zero_node;
5974 : 7301 : if (!maybe_zero_len && i > first_non_one)
5975 : : {
5976 : 639 : if (integer_nonzerop (low_bound))
5977 : 36 : goto do_warn_noncontiguous;
5978 : 603 : if (length != NULL_TREE
5979 : 275 : && TREE_CODE (length) == INTEGER_CST
5980 : 275 : && TYPE_DOMAIN (types[i])
5981 : 275 : && TYPE_MAX_VALUE (TYPE_DOMAIN (types[i]))
5982 : 878 : && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])))
5983 : : == INTEGER_CST)
5984 : : {
5985 : 275 : tree size;
5986 : 275 : size = size_binop (PLUS_EXPR,
5987 : : TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
5988 : : size_one_node);
5989 : 275 : if (!tree_int_cst_equal (length, size))
5990 : : {
5991 : 39 : do_warn_noncontiguous:
5992 : 150 : error_at (OMP_CLAUSE_LOCATION (c),
5993 : : "array section is not contiguous in %qs "
5994 : : "clause",
5995 : 75 : omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
5996 : 75 : return true;
5997 : : }
5998 : : }
5999 : 564 : if (!processing_template_decl
6000 : 394 : && length != NULL_TREE
6001 : 728 : && TREE_SIDE_EFFECTS (length))
6002 : : {
6003 : 0 : if (side_effects == NULL_TREE)
6004 : : side_effects = length;
6005 : : else
6006 : 0 : side_effects = build2 (COMPOUND_EXPR,
6007 : 0 : TREE_TYPE (side_effects),
6008 : : length, side_effects);
6009 : : }
6010 : : }
6011 : 6662 : else if (processing_template_decl)
6012 : 726 : continue;
6013 : : else
6014 : : {
6015 : 5936 : tree l;
6016 : :
6017 : 5936 : if (i > first_non_one
6018 : 5936 : && ((length && integer_nonzerop (length))
6019 : 0 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
6020 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
6021 : : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION))
6022 : 0 : continue;
6023 : 5936 : if (length)
6024 : 5814 : l = fold_convert (sizetype, length);
6025 : : else
6026 : : {
6027 : 122 : l = size_binop (PLUS_EXPR,
6028 : : TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
6029 : : size_one_node);
6030 : 122 : l = size_binop (MINUS_EXPR, l,
6031 : : fold_convert (sizetype, low_bound));
6032 : : }
6033 : 5936 : if (i > first_non_one)
6034 : : {
6035 : 0 : l = fold_build2 (NE_EXPR, boolean_type_node, l,
6036 : : size_zero_node);
6037 : 0 : if (condition == NULL_TREE)
6038 : : condition = l;
6039 : : else
6040 : 0 : condition = fold_build2 (BIT_AND_EXPR, boolean_type_node,
6041 : : l, condition);
6042 : : }
6043 : 5936 : else if (size == NULL_TREE)
6044 : : {
6045 : 5690 : size = size_in_bytes (TREE_TYPE (types[i]));
6046 : 5690 : tree eltype = TREE_TYPE (types[num - 1]);
6047 : 5761 : while (TREE_CODE (eltype) == ARRAY_TYPE)
6048 : 71 : eltype = TREE_TYPE (eltype);
6049 : 5690 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
6050 : 4880 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
6051 : 9817 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
6052 : 1659 : size = size_binop (EXACT_DIV_EXPR, size,
6053 : : size_in_bytes (eltype));
6054 : 5690 : size = size_binop (MULT_EXPR, size, l);
6055 : 5690 : if (condition)
6056 : 0 : size = fold_build3 (COND_EXPR, sizetype, condition,
6057 : : size, size_zero_node);
6058 : : }
6059 : : else
6060 : 246 : size = size_binop (MULT_EXPR, size, l);
6061 : : }
6062 : : }
6063 : 6335 : if (!processing_template_decl)
6064 : : {
6065 : 5690 : if (side_effects)
6066 : 0 : size = build2 (COMPOUND_EXPR, sizetype, side_effects, size);
6067 : 5690 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
6068 : 4880 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
6069 : 9817 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
6070 : : {
6071 : 1659 : size = size_binop (MINUS_EXPR, size, size_one_node);
6072 : 1659 : size = save_expr (size);
6073 : 1659 : tree index_type = build_index_type (size);
6074 : 1659 : tree eltype = TREE_TYPE (first);
6075 : 1688 : while (TREE_CODE (eltype) == ARRAY_TYPE)
6076 : 29 : eltype = TREE_TYPE (eltype);
6077 : 1659 : tree type = build_array_type (eltype, index_type);
6078 : 1659 : tree ptype = build_pointer_type (eltype);
6079 : 1659 : if (TYPE_REF_P (TREE_TYPE (t))
6080 : 1659 : && INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (t))))
6081 : 170 : t = convert_from_reference (t);
6082 : 1489 : else if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6083 : 641 : t = build_fold_addr_expr (t);
6084 : 1659 : tree t2 = build_fold_addr_expr (first);
6085 : 1659 : t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
6086 : : ptrdiff_type_node, t2);
6087 : 1659 : t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
6088 : : ptrdiff_type_node, t2,
6089 : 1659 : fold_convert_loc (OMP_CLAUSE_LOCATION (c),
6090 : : ptrdiff_type_node, t));
6091 : 1659 : if (tree_fits_shwi_p (t2))
6092 : 1321 : t = build2 (MEM_REF, type, t,
6093 : 1321 : build_int_cst (ptype, tree_to_shwi (t2)));
6094 : : else
6095 : : {
6096 : 338 : t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
6097 : : sizetype, t2);
6098 : 338 : t = build2_loc (OMP_CLAUSE_LOCATION (c), POINTER_PLUS_EXPR,
6099 : 338 : TREE_TYPE (t), t, t2);
6100 : 338 : t = build2 (MEM_REF, type, t, build_int_cst (ptype, 0));
6101 : : }
6102 : 1659 : OMP_CLAUSE_DECL (c) = t;
6103 : 7349 : return false;
6104 : : }
6105 : 4031 : OMP_CLAUSE_DECL (c) = first;
6106 : 4031 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_HAS_DEVICE_ADDR)
6107 : : return false;
6108 : 4005 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
6109 : 4005 : || (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_ATTACH
6110 : 3482 : && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_DETACH
6111 : 3470 : && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DETACH))
6112 : 3981 : OMP_CLAUSE_SIZE (c) = size;
6113 : 4005 : if (TREE_CODE (t) == FIELD_DECL)
6114 : 3 : t = finish_non_static_data_member (t, NULL_TREE, NULL_TREE);
6115 : :
6116 : 4005 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
6117 : : return false;
6118 : :
6119 : 3494 : if (TREE_CODE (first) == INDIRECT_REF)
6120 : : {
6121 : : /* Detect and skip adding extra nodes for pointer-to-member
6122 : : mappings. These are unsupported for now. */
6123 : 2258 : tree tmp = TREE_OPERAND (first, 0);
6124 : :
6125 : 2258 : if (TREE_CODE (tmp) == NON_LVALUE_EXPR)
6126 : 1796 : tmp = TREE_OPERAND (tmp, 0);
6127 : :
6128 : 2258 : if (TREE_CODE (tmp) == INDIRECT_REF)
6129 : 140 : tmp = TREE_OPERAND (tmp, 0);
6130 : :
6131 : 2258 : if (TREE_CODE (tmp) == POINTER_PLUS_EXPR)
6132 : : {
6133 : 423 : tree offset = TREE_OPERAND (tmp, 1);
6134 : 423 : STRIP_NOPS (offset);
6135 : 423 : if (TYPE_PTRMEM_P (TREE_TYPE (offset)))
6136 : : {
6137 : 36 : sorry_at (OMP_CLAUSE_LOCATION (c),
6138 : : "pointer-to-member mapping %qE not supported",
6139 : 18 : OMP_CLAUSE_DECL (c));
6140 : 18 : return true;
6141 : : }
6142 : : }
6143 : : }
6144 : :
6145 : : /* FIRST represents the first item of data that we are mapping.
6146 : : E.g. if we're mapping an array, FIRST might resemble
6147 : : "foo.bar.myarray[0]". */
6148 : :
6149 : 3476 : auto_vec<omp_addr_token *, 10> addr_tokens;
6150 : :
6151 : 3476 : if (!omp_parse_expr (addr_tokens, first))
6152 : : return true;
6153 : :
6154 : 3476 : cp_omp_address_inspector ai (OMP_CLAUSE_LOCATION (c), t);
6155 : :
6156 : 3476 : tree nc = ai.expand_map_clause (c, first, addr_tokens, ort);
6157 : 3476 : if (nc != error_mark_node)
6158 : : {
6159 : 3476 : using namespace omp_addr_tokenizer;
6160 : :
6161 : 3476 : if (ai.maybe_zero_length_array_section (c))
6162 : 3452 : OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c) = 1;
6163 : :
6164 : : /* !!! If we're accessing a base decl via chained access
6165 : : methods (e.g. multiple indirections), duplicate clause
6166 : : detection won't work properly. Skip it in that case. */
6167 : 3476 : if ((addr_tokens[0]->type == STRUCTURE_BASE
6168 : 2520 : || addr_tokens[0]->type == ARRAY_BASE)
6169 : 3476 : && addr_tokens[0]->u.structure_base_kind == BASE_DECL
6170 : 3465 : && addr_tokens[1]->type == ACCESS_METHOD
6171 : 6941 : && omp_access_chain_p (addr_tokens, 1))
6172 : 199 : c = nc;
6173 : :
6174 : 3476 : return false;
6175 : : }
6176 : 6952 : }
6177 : : }
6178 : : return false;
6179 : 9231 : }
6180 : :
6181 : : /* Return identifier to look up for omp declare reduction. */
6182 : :
6183 : : tree
6184 : 7045 : omp_reduction_id (enum tree_code reduction_code, tree reduction_id, tree type)
6185 : : {
6186 : 7045 : const char *p = NULL;
6187 : 7045 : const char *m = NULL;
6188 : 7045 : switch (reduction_code)
6189 : : {
6190 : 4188 : case PLUS_EXPR:
6191 : 4188 : case MULT_EXPR:
6192 : 4188 : case MINUS_EXPR:
6193 : 4188 : case BIT_AND_EXPR:
6194 : 4188 : case BIT_XOR_EXPR:
6195 : 4188 : case BIT_IOR_EXPR:
6196 : 4188 : case TRUTH_ANDIF_EXPR:
6197 : 4188 : case TRUTH_ORIF_EXPR:
6198 : 4188 : reduction_id = ovl_op_identifier (false, reduction_code);
6199 : 4188 : break;
6200 : : case MIN_EXPR:
6201 : : p = "min";
6202 : : break;
6203 : : case MAX_EXPR:
6204 : : p = "max";
6205 : : break;
6206 : : default:
6207 : : break;
6208 : : }
6209 : :
6210 : 4188 : if (p == NULL)
6211 : : {
6212 : 6905 : if (TREE_CODE (reduction_id) != IDENTIFIER_NODE)
6213 : 0 : return error_mark_node;
6214 : 6905 : p = IDENTIFIER_POINTER (reduction_id);
6215 : : }
6216 : :
6217 : 7045 : if (type != NULL_TREE)
6218 : 2025 : m = mangle_type_string (TYPE_MAIN_VARIANT (type));
6219 : :
6220 : 7045 : const char prefix[] = "omp declare reduction ";
6221 : 7045 : size_t lenp = sizeof (prefix);
6222 : 7045 : if (strncmp (p, prefix, lenp - 1) == 0)
6223 : 2025 : lenp = 1;
6224 : 7045 : size_t len = strlen (p);
6225 : 7045 : size_t lenm = m ? strlen (m) + 1 : 0;
6226 : 7045 : char *name = XALLOCAVEC (char, lenp + len + lenm);
6227 : 7045 : if (lenp > 1)
6228 : 5020 : memcpy (name, prefix, lenp - 1);
6229 : 7045 : memcpy (name + lenp - 1, p, len + 1);
6230 : 7045 : if (m)
6231 : : {
6232 : 2025 : name[lenp + len - 1] = '~';
6233 : 2025 : memcpy (name + lenp + len, m, lenm);
6234 : : }
6235 : 7045 : return get_identifier (name);
6236 : : }
6237 : :
6238 : : /* Lookup OpenMP UDR ID for TYPE, return the corresponding artificial
6239 : : FUNCTION_DECL or NULL_TREE if not found. */
6240 : :
6241 : : static tree
6242 : 1284 : omp_reduction_lookup (location_t loc, tree id, tree type, tree *baselinkp,
6243 : : vec<tree> *ambiguousp)
6244 : : {
6245 : 1284 : tree orig_id = id;
6246 : 1284 : tree baselink = NULL_TREE;
6247 : 1284 : if (identifier_p (id))
6248 : : {
6249 : 1256 : cp_id_kind idk;
6250 : 1256 : bool nonint_cst_expression_p;
6251 : 1256 : const char *error_msg;
6252 : 1256 : id = omp_reduction_id (ERROR_MARK, id, type);
6253 : 1256 : tree decl = lookup_name (id);
6254 : 1256 : if (decl == NULL_TREE)
6255 : 80 : decl = error_mark_node;
6256 : 1256 : id = finish_id_expression (id, decl, NULL_TREE, &idk, false, true,
6257 : : &nonint_cst_expression_p, false, true, false,
6258 : : false, &error_msg, loc);
6259 : 1256 : if (idk == CP_ID_KIND_UNQUALIFIED
6260 : 1336 : && identifier_p (id))
6261 : : {
6262 : 80 : vec<tree, va_gc> *args = NULL;
6263 : 80 : vec_safe_push (args, build_reference_type (type));
6264 : 80 : id = perform_koenig_lookup (id, args, tf_none);
6265 : : }
6266 : : }
6267 : 28 : else if (TREE_CODE (id) == SCOPE_REF)
6268 : 28 : id = lookup_qualified_name (TREE_OPERAND (id, 0),
6269 : : omp_reduction_id (ERROR_MARK,
6270 : 28 : TREE_OPERAND (id, 1),
6271 : : type),
6272 : : LOOK_want::NORMAL, false);
6273 : 1284 : tree fns = id;
6274 : 1284 : id = NULL_TREE;
6275 : 1284 : if (fns && is_overloaded_fn (fns))
6276 : : {
6277 : 1210 : for (lkp_iterator iter (get_fns (fns)); iter; ++iter)
6278 : : {
6279 : 1210 : tree fndecl = *iter;
6280 : 1210 : if (TREE_CODE (fndecl) == FUNCTION_DECL)
6281 : : {
6282 : 1210 : tree argtype = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
6283 : 1210 : if (same_type_p (TREE_TYPE (argtype), type))
6284 : : {
6285 : 1210 : id = fndecl;
6286 : 1210 : break;
6287 : : }
6288 : : }
6289 : : }
6290 : :
6291 : 1210 : if (id && BASELINK_P (fns))
6292 : : {
6293 : 74 : if (baselinkp)
6294 : 0 : *baselinkp = fns;
6295 : : else
6296 : 74 : baselink = fns;
6297 : : }
6298 : : }
6299 : :
6300 : 1284 : if (!id && CLASS_TYPE_P (type) && TYPE_BINFO (type))
6301 : : {
6302 : 35 : auto_vec<tree> ambiguous;
6303 : 35 : tree binfo = TYPE_BINFO (type), base_binfo, ret = NULL_TREE;
6304 : 35 : unsigned int ix;
6305 : 35 : if (ambiguousp == NULL)
6306 : 19 : ambiguousp = &ambiguous;
6307 : 73 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
6308 : : {
6309 : 52 : id = omp_reduction_lookup (loc, orig_id, BINFO_TYPE (base_binfo),
6310 : : baselinkp ? baselinkp : &baselink,
6311 : : ambiguousp);
6312 : 38 : if (id == NULL_TREE)
6313 : 14 : continue;
6314 : 24 : if (!ambiguousp->is_empty ())
6315 : 3 : ambiguousp->safe_push (id);
6316 : 21 : else if (ret != NULL_TREE)
6317 : : {
6318 : 6 : ambiguousp->safe_push (ret);
6319 : 6 : ambiguousp->safe_push (id);
6320 : 6 : ret = NULL_TREE;
6321 : : }
6322 : : else
6323 : 15 : ret = id;
6324 : : }
6325 : 35 : if (ambiguousp != &ambiguous)
6326 : 16 : return ret;
6327 : 19 : if (!ambiguous.is_empty ())
6328 : : {
6329 : 6 : auto_diagnostic_group d;
6330 : 6 : const char *str = _("candidates are:");
6331 : 6 : unsigned int idx;
6332 : 6 : tree udr;
6333 : 6 : error_at (loc, "user defined reduction lookup is ambiguous");
6334 : 27 : FOR_EACH_VEC_ELT (ambiguous, idx, udr)
6335 : : {
6336 : 15 : inform (DECL_SOURCE_LOCATION (udr), "%s %#qD", str, udr);
6337 : 15 : if (idx == 0)
6338 : 6 : str = get_spaces (str);
6339 : : }
6340 : 6 : ret = error_mark_node;
6341 : 6 : baselink = NULL_TREE;
6342 : 6 : }
6343 : 19 : id = ret;
6344 : 35 : }
6345 : 1268 : if (id && baselink)
6346 : 74 : perform_or_defer_access_check (BASELINK_BINFO (baselink),
6347 : : id, id, tf_warning_or_error);
6348 : : return id;
6349 : : }
6350 : :
6351 : : /* Helper function for cp_parser_omp_declare_reduction_exprs
6352 : : and tsubst_omp_udr.
6353 : : Remove CLEANUP_STMT for data (omp_priv variable).
6354 : : Also append INIT_EXPR for DECL_INITIAL of omp_priv after its
6355 : : DECL_EXPR. */
6356 : :
6357 : : tree
6358 : 4134 : cp_remove_omp_priv_cleanup_stmt (tree *tp, int *walk_subtrees, void *data)
6359 : : {
6360 : 4134 : if (TYPE_P (*tp))
6361 : 14 : *walk_subtrees = 0;
6362 : 4120 : else if (TREE_CODE (*tp) == CLEANUP_STMT && CLEANUP_DECL (*tp) == (tree) data)
6363 : 52 : *tp = CLEANUP_BODY (*tp);
6364 : 4068 : else if (TREE_CODE (*tp) == DECL_EXPR)
6365 : : {
6366 : 298 : tree decl = DECL_EXPR_DECL (*tp);
6367 : 298 : if (!processing_template_decl
6368 : 252 : && decl == (tree) data
6369 : 252 : && DECL_INITIAL (decl)
6370 : 387 : && DECL_INITIAL (decl) != error_mark_node)
6371 : : {
6372 : 89 : tree list = NULL_TREE;
6373 : 89 : append_to_statement_list_force (*tp, &list);
6374 : 89 : tree init_expr = build2 (INIT_EXPR, void_type_node,
6375 : 89 : decl, DECL_INITIAL (decl));
6376 : 89 : DECL_INITIAL (decl) = NULL_TREE;
6377 : 89 : append_to_statement_list_force (init_expr, &list);
6378 : 89 : *tp = list;
6379 : : }
6380 : : }
6381 : 4134 : return NULL_TREE;
6382 : : }
6383 : :
6384 : : /* Data passed from cp_check_omp_declare_reduction to
6385 : : cp_check_omp_declare_reduction_r. */
6386 : :
6387 : : struct cp_check_omp_declare_reduction_data
6388 : : {
6389 : : location_t loc;
6390 : : tree stmts[7];
6391 : : bool combiner_p;
6392 : : };
6393 : :
6394 : : /* Helper function for cp_check_omp_declare_reduction, called via
6395 : : cp_walk_tree. */
6396 : :
6397 : : static tree
6398 : 14389 : cp_check_omp_declare_reduction_r (tree *tp, int *, void *data)
6399 : : {
6400 : 14389 : struct cp_check_omp_declare_reduction_data *udr_data
6401 : : = (struct cp_check_omp_declare_reduction_data *) data;
6402 : 14389 : if (SSA_VAR_P (*tp)
6403 : 2666 : && !DECL_ARTIFICIAL (*tp)
6404 : 225 : && *tp != DECL_EXPR_DECL (udr_data->stmts[udr_data->combiner_p ? 0 : 3])
6405 : 225 : && *tp != DECL_EXPR_DECL (udr_data->stmts[udr_data->combiner_p ? 1 : 4]))
6406 : : {
6407 : 135 : location_t loc = udr_data->loc;
6408 : 135 : if (udr_data->combiner_p)
6409 : 45 : error_at (loc, "%<#pragma omp declare reduction%> combiner refers to "
6410 : : "variable %qD which is not %<omp_out%> nor %<omp_in%>",
6411 : : *tp);
6412 : : else
6413 : 90 : error_at (loc, "%<#pragma omp declare reduction%> initializer refers "
6414 : : "to variable %qD which is not %<omp_priv%> nor "
6415 : : "%<omp_orig%>",
6416 : : *tp);
6417 : 135 : return *tp;
6418 : : }
6419 : : return NULL_TREE;
6420 : : }
6421 : :
6422 : : /* Diagnose violation of OpenMP #pragma omp declare reduction restrictions. */
6423 : :
6424 : : bool
6425 : 1090 : cp_check_omp_declare_reduction (tree udr)
6426 : : {
6427 : 1090 : tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (udr)));
6428 : 1090 : gcc_assert (TYPE_REF_P (type));
6429 : 1090 : type = TREE_TYPE (type);
6430 : 1090 : int i;
6431 : 1090 : location_t loc = DECL_SOURCE_LOCATION (udr);
6432 : :
6433 : 1090 : if (type == error_mark_node)
6434 : : return false;
6435 : 1090 : if (ARITHMETIC_TYPE_P (type))
6436 : : {
6437 : : static enum tree_code predef_codes[]
6438 : : = { PLUS_EXPR, MULT_EXPR, MINUS_EXPR, BIT_AND_EXPR, BIT_XOR_EXPR,
6439 : : BIT_IOR_EXPR, TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR };
6440 : 3276 : for (i = 0; i < 8; i++)
6441 : : {
6442 : 2918 : tree id = omp_reduction_id (predef_codes[i], NULL_TREE, NULL_TREE);
6443 : 2918 : const char *n1 = IDENTIFIER_POINTER (DECL_NAME (udr));
6444 : 2918 : const char *n2 = IDENTIFIER_POINTER (id);
6445 : 2918 : if (strncmp (n1, n2, IDENTIFIER_LENGTH (id)) == 0
6446 : 2918 : && (n1[IDENTIFIER_LENGTH (id)] == '~'
6447 : 0 : || n1[IDENTIFIER_LENGTH (id)] == '\0'))
6448 : : break;
6449 : : }
6450 : :
6451 : 376 : if (i == 8
6452 : 358 : && TREE_CODE (type) != COMPLEX_EXPR)
6453 : : {
6454 : 358 : const char prefix_minmax[] = "omp declare reduction m";
6455 : 358 : size_t prefix_size = sizeof (prefix_minmax) - 1;
6456 : 358 : const char *n = IDENTIFIER_POINTER (DECL_NAME (udr));
6457 : 358 : if (strncmp (IDENTIFIER_POINTER (DECL_NAME (udr)),
6458 : : prefix_minmax, prefix_size) == 0
6459 : 10 : && ((n[prefix_size] == 'i' && n[prefix_size + 1] == 'n')
6460 : 4 : || (n[prefix_size] == 'a' && n[prefix_size + 1] == 'x'))
6461 : 368 : && (n[prefix_size + 2] == '~' || n[prefix_size + 2] == '\0'))
6462 : 6 : i = 0;
6463 : : }
6464 : 376 : if (i < 8)
6465 : : {
6466 : 24 : error_at (loc, "predeclared arithmetic type %qT in "
6467 : : "%<#pragma omp declare reduction%>", type);
6468 : 24 : return false;
6469 : : }
6470 : : }
6471 : : else if (FUNC_OR_METHOD_TYPE_P (type)
6472 : : || TREE_CODE (type) == ARRAY_TYPE)
6473 : : {
6474 : 24 : error_at (loc, "function or array type %qT in "
6475 : : "%<#pragma omp declare reduction%>", type);
6476 : 24 : return false;
6477 : : }
6478 : : else if (TYPE_REF_P (type))
6479 : : {
6480 : 0 : error_at (loc, "reference type %qT in %<#pragma omp declare reduction%>",
6481 : : type);
6482 : 0 : return false;
6483 : : }
6484 : 690 : else if (TYPE_QUALS_NO_ADDR_SPACE (type))
6485 : : {
6486 : 24 : error_at (loc, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
6487 : : "type %qT in %<#pragma omp declare reduction%>", type);
6488 : 24 : return false;
6489 : : }
6490 : :
6491 : 1018 : tree body = DECL_SAVED_TREE (udr);
6492 : 1018 : if (body == NULL_TREE || TREE_CODE (body) != STATEMENT_LIST)
6493 : : return true;
6494 : :
6495 : 835 : tree_stmt_iterator tsi;
6496 : 835 : struct cp_check_omp_declare_reduction_data data;
6497 : 835 : memset (data.stmts, 0, sizeof data.stmts);
6498 : 835 : for (i = 0, tsi = tsi_start (body);
6499 : 4627 : i < 7 && !tsi_end_p (tsi);
6500 : 3792 : i++, tsi_next (&tsi))
6501 : 3792 : data.stmts[i] = tsi_stmt (tsi);
6502 : 835 : data.loc = loc;
6503 : 835 : gcc_assert (tsi_end_p (tsi));
6504 : 835 : if (i >= 3)
6505 : : {
6506 : 835 : gcc_assert (TREE_CODE (data.stmts[0]) == DECL_EXPR
6507 : : && TREE_CODE (data.stmts[1]) == DECL_EXPR);
6508 : 835 : if (warning_suppressed_p (DECL_EXPR_DECL (data.stmts[0]) /* What warning? */))
6509 : : return true;
6510 : 790 : data.combiner_p = true;
6511 : 790 : if (cp_walk_tree (&data.stmts[2], cp_check_omp_declare_reduction_r,
6512 : : &data, NULL))
6513 : 45 : suppress_warning (DECL_EXPR_DECL (data.stmts[0]) /* What warning? */);
6514 : : }
6515 : 790 : if (i >= 6)
6516 : : {
6517 : 330 : gcc_assert (TREE_CODE (data.stmts[3]) == DECL_EXPR
6518 : : && TREE_CODE (data.stmts[4]) == DECL_EXPR);
6519 : 330 : data.combiner_p = false;
6520 : 330 : if (cp_walk_tree (&data.stmts[5], cp_check_omp_declare_reduction_r,
6521 : : &data, NULL)
6522 : 330 : || cp_walk_tree (&DECL_INITIAL (DECL_EXPR_DECL (data.stmts[3])),
6523 : : cp_check_omp_declare_reduction_r, &data, NULL))
6524 : 90 : suppress_warning (DECL_EXPR_DECL (data.stmts[0]) /* Wat warning? */);
6525 : 330 : if (i == 7)
6526 : 192 : gcc_assert (TREE_CODE (data.stmts[6]) == DECL_EXPR);
6527 : : }
6528 : : return true;
6529 : : }
6530 : :
6531 : : /* Helper function of finish_omp_clauses. Clone STMT as if we were making
6532 : : an inline call. But, remap
6533 : : the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
6534 : : and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
6535 : :
6536 : : static tree
6537 : 2191 : clone_omp_udr (tree stmt, tree omp_decl1, tree omp_decl2,
6538 : : tree decl, tree placeholder)
6539 : : {
6540 : 2191 : copy_body_data id;
6541 : 2191 : hash_map<tree, tree> decl_map;
6542 : :
6543 : 2191 : decl_map.put (omp_decl1, placeholder);
6544 : 2191 : decl_map.put (omp_decl2, decl);
6545 : 2191 : memset (&id, 0, sizeof (id));
6546 : 2191 : id.src_fn = DECL_CONTEXT (omp_decl1);
6547 : 2191 : id.dst_fn = current_function_decl;
6548 : 2191 : id.src_cfun = DECL_STRUCT_FUNCTION (id.src_fn);
6549 : 2191 : id.decl_map = &decl_map;
6550 : :
6551 : 2191 : id.copy_decl = copy_decl_no_change;
6552 : 2191 : id.transform_call_graph_edges = CB_CGE_DUPLICATE;
6553 : 2191 : id.transform_new_cfg = true;
6554 : 2191 : id.transform_return_to_modify = false;
6555 : 2191 : id.eh_lp_nr = 0;
6556 : 2191 : walk_tree (&stmt, copy_tree_body_r, &id, NULL);
6557 : 2191 : return stmt;
6558 : 2191 : }
6559 : :
6560 : : /* Helper function of finish_omp_clauses, called via cp_walk_tree.
6561 : : Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
6562 : :
6563 : : static tree
6564 : 14739 : find_omp_placeholder_r (tree *tp, int *, void *data)
6565 : : {
6566 : 14739 : if (*tp == (tree) data)
6567 : 265 : return *tp;
6568 : : return NULL_TREE;
6569 : : }
6570 : :
6571 : : /* Helper function of finish_omp_clauses. Handle OMP_CLAUSE_REDUCTION C.
6572 : : Return true if there is some error and the clause should be removed. */
6573 : :
6574 : : static bool
6575 : 8214 : finish_omp_reduction_clause (tree c, bool *need_default_ctor, bool *need_dtor)
6576 : : {
6577 : 8214 : tree t = OMP_CLAUSE_DECL (c);
6578 : 8214 : bool predefined = false;
6579 : 8214 : if (TREE_CODE (t) == TREE_LIST)
6580 : : {
6581 : 0 : gcc_assert (processing_template_decl);
6582 : : return false;
6583 : : }
6584 : 8214 : tree type = TREE_TYPE (t);
6585 : 8214 : if (TREE_CODE (t) == MEM_REF)
6586 : 1656 : type = TREE_TYPE (type);
6587 : 8214 : if (TYPE_REF_P (type))
6588 : 557 : type = TREE_TYPE (type);
6589 : 8214 : if (TREE_CODE (type) == ARRAY_TYPE)
6590 : : {
6591 : 377 : tree oatype = type;
6592 : 377 : gcc_assert (TREE_CODE (t) != MEM_REF);
6593 : 757 : while (TREE_CODE (type) == ARRAY_TYPE)
6594 : 380 : type = TREE_TYPE (type);
6595 : 377 : if (!processing_template_decl)
6596 : : {
6597 : 270 : t = require_complete_type (t);
6598 : 270 : if (t == error_mark_node
6599 : 270 : || !complete_type_or_else (oatype, NULL_TREE))
6600 : 9 : return true;
6601 : 261 : tree size = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (oatype),
6602 : : TYPE_SIZE_UNIT (type));
6603 : 261 : if (integer_zerop (size))
6604 : : {
6605 : 6 : error_at (OMP_CLAUSE_LOCATION (c),
6606 : : "%qE in %<reduction%> clause is a zero size array",
6607 : : omp_clause_printable_decl (t));
6608 : 3 : return true;
6609 : : }
6610 : 258 : size = size_binop (MINUS_EXPR, size, size_one_node);
6611 : 258 : size = save_expr (size);
6612 : 258 : tree index_type = build_index_type (size);
6613 : 258 : tree atype = build_array_type (type, index_type);
6614 : 258 : tree ptype = build_pointer_type (type);
6615 : 258 : if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6616 : 152 : t = build_fold_addr_expr (t);
6617 : 258 : t = build2 (MEM_REF, atype, t, build_int_cst (ptype, 0));
6618 : 258 : OMP_CLAUSE_DECL (c) = t;
6619 : : }
6620 : : }
6621 : 8202 : if (type == error_mark_node)
6622 : : return true;
6623 : 8199 : else if (ARITHMETIC_TYPE_P (type))
6624 : 6951 : switch (OMP_CLAUSE_REDUCTION_CODE (c))
6625 : : {
6626 : : case PLUS_EXPR:
6627 : : case MULT_EXPR:
6628 : : case MINUS_EXPR:
6629 : : case TRUTH_ANDIF_EXPR:
6630 : : case TRUTH_ORIF_EXPR:
6631 : : predefined = true;
6632 : : break;
6633 : 222 : case MIN_EXPR:
6634 : 222 : case MAX_EXPR:
6635 : 222 : if (TREE_CODE (type) == COMPLEX_TYPE)
6636 : : break;
6637 : : predefined = true;
6638 : : break;
6639 : 93 : case BIT_AND_EXPR:
6640 : 93 : case BIT_IOR_EXPR:
6641 : 93 : case BIT_XOR_EXPR:
6642 : 93 : if (FLOAT_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
6643 : : break;
6644 : : predefined = true;
6645 : : break;
6646 : : default:
6647 : : break;
6648 : : }
6649 : 1248 : else if (TYPE_READONLY (type))
6650 : : {
6651 : 18 : error_at (OMP_CLAUSE_LOCATION (c),
6652 : : "%qE has const type for %<reduction%>",
6653 : : omp_clause_printable_decl (t));
6654 : 9 : return true;
6655 : : }
6656 : 1239 : else if (!processing_template_decl)
6657 : : {
6658 : 1033 : t = require_complete_type (t);
6659 : 1033 : if (t == error_mark_node)
6660 : : return true;
6661 : 1033 : OMP_CLAUSE_DECL (c) = t;
6662 : : }
6663 : :
6664 : 1033 : if (predefined)
6665 : : {
6666 : 6729 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = NULL_TREE;
6667 : 6729 : return false;
6668 : : }
6669 : 1461 : else if (processing_template_decl)
6670 : : {
6671 : 215 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == error_mark_node)
6672 : : return true;
6673 : : return false;
6674 : : }
6675 : :
6676 : 1246 : tree id = OMP_CLAUSE_REDUCTION_PLACEHOLDER (c);
6677 : :
6678 : 1246 : type = TYPE_MAIN_VARIANT (type);
6679 : 1246 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = NULL_TREE;
6680 : 1246 : if (id == NULL_TREE)
6681 : 924 : id = omp_reduction_id (OMP_CLAUSE_REDUCTION_CODE (c),
6682 : : NULL_TREE, NULL_TREE);
6683 : 1246 : id = omp_reduction_lookup (OMP_CLAUSE_LOCATION (c), id, type, NULL, NULL);
6684 : 1246 : if (id)
6685 : : {
6686 : 1201 : if (id == error_mark_node)
6687 : : return true;
6688 : 1195 : mark_used (id);
6689 : 1195 : tree body = DECL_SAVED_TREE (id);
6690 : 1195 : if (!body)
6691 : : return true;
6692 : 1192 : if (TREE_CODE (body) == STATEMENT_LIST)
6693 : : {
6694 : 1192 : tree_stmt_iterator tsi;
6695 : 1192 : tree placeholder = NULL_TREE, decl_placeholder = NULL_TREE;
6696 : 1192 : int i;
6697 : 1192 : tree stmts[7];
6698 : 1192 : tree atype = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (id)));
6699 : 1192 : atype = TREE_TYPE (atype);
6700 : 1192 : bool need_static_cast = !same_type_p (type, atype);
6701 : 1192 : memset (stmts, 0, sizeof stmts);
6702 : 1192 : for (i = 0, tsi = tsi_start (body);
6703 : 8490 : i < 7 && !tsi_end_p (tsi);
6704 : 7298 : i++, tsi_next (&tsi))
6705 : 7298 : stmts[i] = tsi_stmt (tsi);
6706 : 1192 : gcc_assert (tsi_end_p (tsi));
6707 : :
6708 : 1192 : if (i >= 3)
6709 : : {
6710 : 1192 : gcc_assert (TREE_CODE (stmts[0]) == DECL_EXPR
6711 : : && TREE_CODE (stmts[1]) == DECL_EXPR);
6712 : 1192 : placeholder = build_lang_decl (VAR_DECL, NULL_TREE, type);
6713 : 1192 : DECL_ARTIFICIAL (placeholder) = 1;
6714 : 1192 : DECL_IGNORED_P (placeholder) = 1;
6715 : 1192 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = placeholder;
6716 : 1192 : if (TREE_CODE (t) == MEM_REF)
6717 : : {
6718 : 600 : decl_placeholder = build_lang_decl (VAR_DECL, NULL_TREE,
6719 : : type);
6720 : 600 : DECL_ARTIFICIAL (decl_placeholder) = 1;
6721 : 600 : DECL_IGNORED_P (decl_placeholder) = 1;
6722 : 600 : OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c) = decl_placeholder;
6723 : : }
6724 : 1192 : if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[0])))
6725 : 282 : cxx_mark_addressable (placeholder);
6726 : 1192 : if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[1]))
6727 : 1192 : && (decl_placeholder
6728 : 146 : || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
6729 : 366 : cxx_mark_addressable (decl_placeholder ? decl_placeholder
6730 : 115 : : OMP_CLAUSE_DECL (c));
6731 : 1192 : tree omp_out = placeholder;
6732 : 1192 : tree omp_in = decl_placeholder ? decl_placeholder
6733 : 592 : : convert_from_reference (OMP_CLAUSE_DECL (c));
6734 : 1192 : if (need_static_cast)
6735 : : {
6736 : 7 : tree rtype = build_reference_type (atype);
6737 : 7 : omp_out = build_static_cast (input_location,
6738 : : rtype, omp_out,
6739 : : tf_warning_or_error);
6740 : 7 : omp_in = build_static_cast (input_location,
6741 : : rtype, omp_in,
6742 : : tf_warning_or_error);
6743 : 7 : if (omp_out == error_mark_node || omp_in == error_mark_node)
6744 : 3 : return true;
6745 : 7 : omp_out = convert_from_reference (omp_out);
6746 : 7 : omp_in = convert_from_reference (omp_in);
6747 : : }
6748 : 1192 : OMP_CLAUSE_REDUCTION_MERGE (c)
6749 : 2384 : = clone_omp_udr (stmts[2], DECL_EXPR_DECL (stmts[0]),
6750 : 1192 : DECL_EXPR_DECL (stmts[1]), omp_in, omp_out);
6751 : : }
6752 : 1192 : if (i >= 6)
6753 : : {
6754 : 1002 : gcc_assert (TREE_CODE (stmts[3]) == DECL_EXPR
6755 : : && TREE_CODE (stmts[4]) == DECL_EXPR);
6756 : 1002 : if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[3]))
6757 : 1002 : && (decl_placeholder
6758 : 232 : || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
6759 : 844 : cxx_mark_addressable (decl_placeholder ? decl_placeholder
6760 : 170 : : OMP_CLAUSE_DECL (c));
6761 : 1002 : if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[4])))
6762 : 216 : cxx_mark_addressable (placeholder);
6763 : 1002 : tree omp_priv = decl_placeholder ? decl_placeholder
6764 : 426 : : convert_from_reference (OMP_CLAUSE_DECL (c));
6765 : 1002 : tree omp_orig = placeholder;
6766 : 1002 : if (need_static_cast)
6767 : : {
6768 : 5 : if (i == 7)
6769 : : {
6770 : 3 : error_at (OMP_CLAUSE_LOCATION (c),
6771 : : "user defined reduction with constructor "
6772 : : "initializer for base class %qT", atype);
6773 : 3 : return true;
6774 : : }
6775 : 2 : tree rtype = build_reference_type (atype);
6776 : 2 : omp_priv = build_static_cast (input_location,
6777 : : rtype, omp_priv,
6778 : : tf_warning_or_error);
6779 : 2 : omp_orig = build_static_cast (input_location,
6780 : : rtype, omp_orig,
6781 : : tf_warning_or_error);
6782 : 2 : if (omp_priv == error_mark_node
6783 : 2 : || omp_orig == error_mark_node)
6784 : : return true;
6785 : 2 : omp_priv = convert_from_reference (omp_priv);
6786 : 2 : omp_orig = convert_from_reference (omp_orig);
6787 : : }
6788 : 999 : if (i == 6)
6789 : 286 : *need_default_ctor = true;
6790 : 999 : OMP_CLAUSE_REDUCTION_INIT (c)
6791 : 999 : = clone_omp_udr (stmts[5], DECL_EXPR_DECL (stmts[4]),
6792 : 999 : DECL_EXPR_DECL (stmts[3]),
6793 : : omp_priv, omp_orig);
6794 : 999 : if (cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
6795 : : find_omp_placeholder_r, placeholder, NULL))
6796 : 238 : OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c) = 1;
6797 : : }
6798 : 190 : else if (i >= 3)
6799 : : {
6800 : 190 : if (CLASS_TYPE_P (type) && !pod_type_p (type))
6801 : 175 : *need_default_ctor = true;
6802 : : else
6803 : : {
6804 : 15 : tree init;
6805 : 15 : tree v = decl_placeholder ? decl_placeholder
6806 : 15 : : convert_from_reference (t);
6807 : 15 : if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
6808 : 6 : init = build_constructor (TREE_TYPE (v), NULL);
6809 : : else
6810 : 9 : init = fold_convert (TREE_TYPE (v), integer_zero_node);
6811 : 30 : OMP_CLAUSE_REDUCTION_INIT (c)
6812 : 30 : = cp_build_init_expr (v, init);
6813 : : }
6814 : : }
6815 : : }
6816 : : }
6817 : 1234 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
6818 : 1189 : *need_dtor = true;
6819 : : else
6820 : : {
6821 : 90 : error_at (OMP_CLAUSE_LOCATION (c),
6822 : : "user defined reduction not found for %qE",
6823 : : omp_clause_printable_decl (t));
6824 : 45 : return true;
6825 : : }
6826 : 1189 : if (TREE_CODE (OMP_CLAUSE_DECL (c)) == MEM_REF)
6827 : 600 : gcc_assert (TYPE_SIZE_UNIT (type)
6828 : : && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
6829 : : return false;
6830 : : }
6831 : :
6832 : : /* Called from finish_struct_1. linear(this) or linear(this:step)
6833 : : clauses might not be finalized yet because the class has been incomplete
6834 : : when parsing #pragma omp declare simd methods. Fix those up now. */
6835 : :
6836 : : void
6837 : 37372 : finish_omp_declare_simd_methods (tree t)
6838 : : {
6839 : 37372 : if (processing_template_decl)
6840 : : return;
6841 : :
6842 : 244632 : for (tree x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
6843 : : {
6844 : 349599 : if (TREE_CODE (x) == USING_DECL
6845 : 207260 : || !DECL_IOBJ_MEMBER_FUNCTION_P (x))
6846 : 142339 : continue;
6847 : 64921 : tree ods = lookup_attribute ("omp declare simd", DECL_ATTRIBUTES (x));
6848 : 65029 : if (!ods || !TREE_VALUE (ods))
6849 : 64813 : continue;
6850 : 366 : for (tree c = TREE_VALUE (TREE_VALUE (ods)); c; c = OMP_CLAUSE_CHAIN (c))
6851 : 258 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
6852 : 66 : && integer_zerop (OMP_CLAUSE_DECL (c))
6853 : 18 : && OMP_CLAUSE_LINEAR_STEP (c)
6854 : 276 : && TYPE_PTR_P (TREE_TYPE (OMP_CLAUSE_LINEAR_STEP (c))))
6855 : : {
6856 : 18 : tree s = OMP_CLAUSE_LINEAR_STEP (c);
6857 : 18 : s = fold_convert_loc (OMP_CLAUSE_LOCATION (c), sizetype, s);
6858 : 18 : s = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MULT_EXPR,
6859 : 18 : sizetype, s, TYPE_SIZE_UNIT (t));
6860 : 18 : OMP_CLAUSE_LINEAR_STEP (c) = s;
6861 : : }
6862 : : }
6863 : : }
6864 : :
6865 : : /* Adjust sink depend/doacross clause to take into account pointer offsets.
6866 : :
6867 : : Return TRUE if there was a problem processing the offset, and the
6868 : : whole clause should be removed. */
6869 : :
6870 : : static bool
6871 : 295 : cp_finish_omp_clause_doacross_sink (tree sink_clause)
6872 : : {
6873 : 295 : tree t = OMP_CLAUSE_DECL (sink_clause);
6874 : 295 : gcc_assert (TREE_CODE (t) == TREE_LIST);
6875 : :
6876 : : /* Make sure we don't adjust things twice for templates. */
6877 : 295 : if (processing_template_decl)
6878 : : return false;
6879 : :
6880 : 665 : for (; t; t = TREE_CHAIN (t))
6881 : : {
6882 : 388 : tree decl = TREE_VALUE (t);
6883 : 388 : if (TYPE_PTR_P (TREE_TYPE (decl)))
6884 : : {
6885 : 6 : tree offset = TREE_PURPOSE (t);
6886 : 6 : bool neg = wi::neg_p (wi::to_wide (offset));
6887 : 6 : offset = fold_unary (ABS_EXPR, TREE_TYPE (offset), offset);
6888 : 6 : decl = mark_rvalue_use (decl);
6889 : 6 : decl = convert_from_reference (decl);
6890 : 12 : tree t2 = pointer_int_sum (OMP_CLAUSE_LOCATION (sink_clause),
6891 : : neg ? MINUS_EXPR : PLUS_EXPR,
6892 : : decl, offset);
6893 : 6 : t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (sink_clause),
6894 : : MINUS_EXPR, sizetype,
6895 : : fold_convert (sizetype, t2),
6896 : : fold_convert (sizetype, decl));
6897 : 6 : if (t2 == error_mark_node)
6898 : : return true;
6899 : 6 : TREE_PURPOSE (t) = t2;
6900 : : }
6901 : : }
6902 : : return false;
6903 : : }
6904 : :
6905 : : /* Finish OpenMP iterators ITER. Return true if they are errorneous
6906 : : and clauses containing them should be removed. */
6907 : :
6908 : : static bool
6909 : 523 : cp_omp_finish_iterators (tree iter)
6910 : : {
6911 : 523 : bool ret = false;
6912 : 1157 : for (tree it = iter; it; it = TREE_CHAIN (it))
6913 : : {
6914 : 634 : tree var = TREE_VEC_ELT (it, 0);
6915 : 634 : tree begin = TREE_VEC_ELT (it, 1);
6916 : 634 : tree end = TREE_VEC_ELT (it, 2);
6917 : 634 : tree step = TREE_VEC_ELT (it, 3);
6918 : 634 : tree orig_step;
6919 : 634 : tree type = TREE_TYPE (var);
6920 : 634 : location_t loc = DECL_SOURCE_LOCATION (var);
6921 : 634 : if (type == error_mark_node)
6922 : : {
6923 : 0 : ret = true;
6924 : 218 : continue;
6925 : : }
6926 : 634 : if (type_dependent_expression_p (var))
6927 : 59 : continue;
6928 : 575 : if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6929 : : {
6930 : 27 : error_at (loc, "iterator %qD has neither integral nor pointer type",
6931 : : var);
6932 : 27 : ret = true;
6933 : 27 : continue;
6934 : : }
6935 : 548 : else if (TYPE_READONLY (type))
6936 : : {
6937 : 24 : error_at (loc, "iterator %qD has const qualified type", var);
6938 : 24 : ret = true;
6939 : 24 : continue;
6940 : : }
6941 : 524 : if (type_dependent_expression_p (begin)
6942 : 515 : || type_dependent_expression_p (end)
6943 : 1039 : || type_dependent_expression_p (step))
6944 : 15 : continue;
6945 : 509 : else if (error_operand_p (step))
6946 : : {
6947 : 0 : ret = true;
6948 : 0 : continue;
6949 : : }
6950 : 509 : else if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
6951 : : {
6952 : 33 : error_at (EXPR_LOC_OR_LOC (step, loc),
6953 : : "iterator step with non-integral type");
6954 : 21 : ret = true;
6955 : 21 : continue;
6956 : : }
6957 : :
6958 : 488 : begin = mark_rvalue_use (begin);
6959 : 488 : end = mark_rvalue_use (end);
6960 : 488 : step = mark_rvalue_use (step);
6961 : 488 : begin = cp_build_c_cast (input_location, type, begin,
6962 : : tf_warning_or_error);
6963 : 488 : end = cp_build_c_cast (input_location, type, end,
6964 : : tf_warning_or_error);
6965 : 488 : orig_step = step;
6966 : 488 : if (!processing_template_decl)
6967 : 411 : step = orig_step = save_expr (step);
6968 : 488 : tree stype = POINTER_TYPE_P (type) ? sizetype : type;
6969 : 488 : step = cp_build_c_cast (input_location, stype, step,
6970 : : tf_warning_or_error);
6971 : 488 : if (POINTER_TYPE_P (type) && !processing_template_decl)
6972 : : {
6973 : 66 : begin = save_expr (begin);
6974 : 66 : step = pointer_int_sum (loc, PLUS_EXPR, begin, step);
6975 : 66 : step = fold_build2_loc (loc, MINUS_EXPR, sizetype,
6976 : : fold_convert (sizetype, step),
6977 : : fold_convert (sizetype, begin));
6978 : 66 : step = fold_convert (ssizetype, step);
6979 : : }
6980 : 488 : if (!processing_template_decl)
6981 : : {
6982 : 411 : begin = maybe_constant_value (begin);
6983 : 411 : end = maybe_constant_value (end);
6984 : 411 : step = maybe_constant_value (step);
6985 : 411 : orig_step = maybe_constant_value (orig_step);
6986 : : }
6987 : 488 : if (integer_zerop (step))
6988 : : {
6989 : 27 : error_at (loc, "iterator %qD has zero step", var);
6990 : 27 : ret = true;
6991 : 27 : continue;
6992 : : }
6993 : :
6994 : 461 : if (begin == error_mark_node
6995 : 452 : || end == error_mark_node
6996 : 443 : || step == error_mark_node
6997 : 443 : || orig_step == error_mark_node)
6998 : : {
6999 : 18 : ret = true;
7000 : 18 : continue;
7001 : : }
7002 : :
7003 : 443 : if (!processing_template_decl)
7004 : : {
7005 : 366 : begin = fold_build_cleanup_point_expr (TREE_TYPE (begin), begin);
7006 : 366 : end = fold_build_cleanup_point_expr (TREE_TYPE (end), end);
7007 : 366 : step = fold_build_cleanup_point_expr (TREE_TYPE (step), step);
7008 : 366 : orig_step = fold_build_cleanup_point_expr (TREE_TYPE (orig_step),
7009 : : orig_step);
7010 : : }
7011 : 443 : hash_set<tree> pset;
7012 : 443 : tree it2;
7013 : 527 : for (it2 = TREE_CHAIN (it); it2; it2 = TREE_CHAIN (it2))
7014 : : {
7015 : 111 : tree var2 = TREE_VEC_ELT (it2, 0);
7016 : 111 : tree begin2 = TREE_VEC_ELT (it2, 1);
7017 : 111 : tree end2 = TREE_VEC_ELT (it2, 2);
7018 : 111 : tree step2 = TREE_VEC_ELT (it2, 3);
7019 : 111 : location_t loc2 = DECL_SOURCE_LOCATION (var2);
7020 : 111 : if (cp_walk_tree (&begin2, find_omp_placeholder_r, var, &pset))
7021 : : {
7022 : 9 : error_at (EXPR_LOC_OR_LOC (begin2, loc2),
7023 : : "begin expression refers to outer iterator %qD", var);
7024 : 36 : break;
7025 : : }
7026 : 102 : else if (cp_walk_tree (&end2, find_omp_placeholder_r, var, &pset))
7027 : : {
7028 : 9 : error_at (EXPR_LOC_OR_LOC (end2, loc2),
7029 : : "end expression refers to outer iterator %qD", var);
7030 : 9 : break;
7031 : : }
7032 : 93 : else if (cp_walk_tree (&step2, find_omp_placeholder_r, var, &pset))
7033 : : {
7034 : 9 : error_at (EXPR_LOC_OR_LOC (step2, loc2),
7035 : : "step expression refers to outer iterator %qD", var);
7036 : 9 : break;
7037 : : }
7038 : : }
7039 : 443 : if (it2)
7040 : : {
7041 : 27 : ret = true;
7042 : 27 : continue;
7043 : : }
7044 : 416 : TREE_VEC_ELT (it, 1) = begin;
7045 : 416 : TREE_VEC_ELT (it, 2) = end;
7046 : 416 : if (processing_template_decl)
7047 : 71 : TREE_VEC_ELT (it, 3) = orig_step;
7048 : : else
7049 : : {
7050 : 345 : TREE_VEC_ELT (it, 3) = step;
7051 : 345 : TREE_VEC_ELT (it, 4) = orig_step;
7052 : : }
7053 : 443 : }
7054 : 523 : return ret;
7055 : : }
7056 : :
7057 : : /* Ensure that pointers are used in OpenACC attach and detach clauses.
7058 : : Return true if an error has been detected. */
7059 : :
7060 : : static bool
7061 : 17241 : cp_oacc_check_attachments (tree c)
7062 : : {
7063 : 17241 : if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
7064 : : return false;
7065 : :
7066 : : /* OpenACC attach / detach clauses must be pointers. */
7067 : 13344 : if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ATTACH
7068 : 13344 : || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH)
7069 : : {
7070 : 185 : tree t = OMP_CLAUSE_DECL (c);
7071 : 185 : tree type;
7072 : :
7073 : 221 : while (TREE_CODE (t) == OMP_ARRAY_SECTION)
7074 : 36 : t = TREE_OPERAND (t, 0);
7075 : :
7076 : 185 : type = TREE_TYPE (t);
7077 : :
7078 : 185 : if (TREE_CODE (type) == REFERENCE_TYPE)
7079 : 36 : type = TREE_TYPE (type);
7080 : :
7081 : 185 : if (TREE_CODE (type) != POINTER_TYPE)
7082 : : {
7083 : 36 : error_at (OMP_CLAUSE_LOCATION (c), "expected pointer in %qs clause",
7084 : : user_omp_clause_code_name (c, true));
7085 : 36 : return true;
7086 : : }
7087 : : }
7088 : :
7089 : : return false;
7090 : : }
7091 : :
7092 : : /* For all elements of CLAUSES, validate them vs OpenMP constraints.
7093 : : Remove any elements from the list that are invalid. */
7094 : :
7095 : : tree
7096 : 58876 : finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
7097 : : {
7098 : 58876 : bitmap_head generic_head, firstprivate_head, lastprivate_head;
7099 : 58876 : bitmap_head aligned_head, map_head, map_field_head, map_firstprivate_head;
7100 : 58876 : bitmap_head oacc_reduction_head, is_on_device_head;
7101 : 58876 : tree c, t, *pc;
7102 : 58876 : tree safelen = NULL_TREE;
7103 : 58876 : bool openacc = (ort & C_ORT_ACC) != 0;
7104 : 58876 : bool branch_seen = false;
7105 : 58876 : bool copyprivate_seen = false;
7106 : 58876 : bool ordered_seen = false;
7107 : 58876 : bool order_seen = false;
7108 : 58876 : bool schedule_seen = false;
7109 : 58876 : bool oacc_async = false;
7110 : 58876 : bool indir_component_ref_p = false;
7111 : 58876 : tree last_iterators = NULL_TREE;
7112 : 58876 : bool last_iterators_remove = false;
7113 : : /* 1 if normal/task reduction has been seen, -1 if inscan reduction
7114 : : has been seen, -2 if mixed inscan/normal reduction diagnosed. */
7115 : 58876 : int reduction_seen = 0;
7116 : 58876 : bool allocate_seen = false;
7117 : 58876 : tree detach_seen = NULL_TREE;
7118 : 58876 : bool mergeable_seen = false;
7119 : 58876 : bool implicit_moved = false;
7120 : 58876 : bool target_in_reduction_seen = false;
7121 : 58876 : bool num_tasks_seen = false;
7122 : 58876 : bool partial_seen = false;
7123 : :
7124 : 58876 : bitmap_obstack_initialize (NULL);
7125 : 58876 : bitmap_initialize (&generic_head, &bitmap_default_obstack);
7126 : 58876 : bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
7127 : 58876 : bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
7128 : 58876 : bitmap_initialize (&aligned_head, &bitmap_default_obstack);
7129 : : /* If ort == C_ORT_OMP_DECLARE_SIMD used as uniform_head instead. */
7130 : 58876 : bitmap_initialize (&map_head, &bitmap_default_obstack);
7131 : 58876 : bitmap_initialize (&map_field_head, &bitmap_default_obstack);
7132 : 58876 : bitmap_initialize (&map_firstprivate_head, &bitmap_default_obstack);
7133 : : /* If ort == C_ORT_OMP used as nontemporal_head or use_device_xxx_head
7134 : : instead and for ort == C_ORT_OMP_TARGET used as in_reduction_head. */
7135 : 58876 : bitmap_initialize (&oacc_reduction_head, &bitmap_default_obstack);
7136 : 58876 : bitmap_initialize (&is_on_device_head, &bitmap_default_obstack);
7137 : :
7138 : 58876 : if (openacc)
7139 : 25534 : for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
7140 : 14546 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ASYNC)
7141 : : {
7142 : : oacc_async = true;
7143 : : break;
7144 : : }
7145 : :
7146 : 58876 : tree *grp_start_p = NULL, grp_sentinel = NULL_TREE;
7147 : :
7148 : 151894 : for (pc = &clauses, c = clauses; c ; c = *pc)
7149 : : {
7150 : 93018 : bool remove = false;
7151 : 93018 : bool field_ok = false;
7152 : :
7153 : : /* We've reached the end of a list of expanded nodes. Reset the group
7154 : : start pointer. */
7155 : 93018 : if (c == grp_sentinel)
7156 : 5006 : grp_start_p = NULL;
7157 : :
7158 : 93018 : switch (OMP_CLAUSE_CODE (c))
7159 : : {
7160 : 2082 : case OMP_CLAUSE_SHARED:
7161 : 2082 : field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
7162 : 2082 : goto check_dup_generic;
7163 : 2516 : case OMP_CLAUSE_PRIVATE:
7164 : 2516 : field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
7165 : 2516 : goto check_dup_generic;
7166 : 6747 : case OMP_CLAUSE_REDUCTION:
7167 : 6747 : if (reduction_seen == 0)
7168 : 5730 : reduction_seen = OMP_CLAUSE_REDUCTION_INSCAN (c) ? -1 : 1;
7169 : 1017 : else if (reduction_seen != -2
7170 : 2034 : && reduction_seen != (OMP_CLAUSE_REDUCTION_INSCAN (c)
7171 : 1017 : ? -1 : 1))
7172 : : {
7173 : 6 : error_at (OMP_CLAUSE_LOCATION (c),
7174 : : "%<inscan%> and non-%<inscan%> %<reduction%> clauses "
7175 : : "on the same construct");
7176 : 6 : reduction_seen = -2;
7177 : : }
7178 : : /* FALLTHRU */
7179 : 8889 : case OMP_CLAUSE_IN_REDUCTION:
7180 : 8889 : case OMP_CLAUSE_TASK_REDUCTION:
7181 : 8889 : field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
7182 : 8889 : t = OMP_CLAUSE_DECL (c);
7183 : 8889 : if (TREE_CODE (t) == OMP_ARRAY_SECTION)
7184 : : {
7185 : 2315 : if (handle_omp_array_sections (c, ort))
7186 : : {
7187 : : remove = true;
7188 : : break;
7189 : : }
7190 : 2273 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
7191 : 2273 : && OMP_CLAUSE_REDUCTION_INSCAN (c))
7192 : : {
7193 : 3 : error_at (OMP_CLAUSE_LOCATION (c),
7194 : : "%<inscan%> %<reduction%> clause with array "
7195 : : "section");
7196 : 3 : remove = true;
7197 : 3 : break;
7198 : : }
7199 : 2270 : if (TREE_CODE (t) == OMP_ARRAY_SECTION)
7200 : : {
7201 : 4888 : while (TREE_CODE (t) == OMP_ARRAY_SECTION)
7202 : 2618 : t = TREE_OPERAND (t, 0);
7203 : : }
7204 : : else
7205 : : {
7206 : 0 : gcc_assert (TREE_CODE (t) == MEM_REF);
7207 : 0 : t = TREE_OPERAND (t, 0);
7208 : 0 : if (TREE_CODE (t) == POINTER_PLUS_EXPR)
7209 : 0 : t = TREE_OPERAND (t, 0);
7210 : 0 : if (TREE_CODE (t) == ADDR_EXPR
7211 : 0 : || INDIRECT_REF_P (t))
7212 : 0 : t = TREE_OPERAND (t, 0);
7213 : : }
7214 : 2270 : tree n = omp_clause_decl_field (t);
7215 : 2270 : if (n)
7216 : 59 : t = n;
7217 : 2270 : goto check_dup_generic_t;
7218 : : }
7219 : 6574 : if (oacc_async)
7220 : 7 : cxx_mark_addressable (t);
7221 : 6574 : goto check_dup_generic;
7222 : 98 : case OMP_CLAUSE_COPYPRIVATE:
7223 : 98 : copyprivate_seen = true;
7224 : 98 : field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
7225 : 98 : goto check_dup_generic;
7226 : 277 : case OMP_CLAUSE_COPYIN:
7227 : 277 : goto check_dup_generic;
7228 : 1613 : case OMP_CLAUSE_LINEAR:
7229 : 1613 : field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
7230 : 1613 : t = OMP_CLAUSE_DECL (c);
7231 : 1613 : if (ort != C_ORT_OMP_DECLARE_SIMD
7232 : 1613 : && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
7233 : : {
7234 : 84 : if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c))
7235 : : {
7236 : 42 : error_at (OMP_CLAUSE_LOCATION (c),
7237 : : "modifier should not be specified in %<linear%> "
7238 : : "clause on %<simd%> or %<for%> constructs when "
7239 : : "not using OpenMP 5.2 modifiers");
7240 : 42 : OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
7241 : : }
7242 : 42 : else if (OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_VAL)
7243 : : {
7244 : 18 : error_at (OMP_CLAUSE_LOCATION (c),
7245 : : "modifier other than %<val%> specified in "
7246 : : "%<linear%> clause on %<simd%> or %<for%> "
7247 : : "constructs when using OpenMP 5.2 modifiers");
7248 : 18 : OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
7249 : : }
7250 : : }
7251 : 993 : if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
7252 : 2535 : && !type_dependent_expression_p (t))
7253 : : {
7254 : 1511 : tree type = TREE_TYPE (t);
7255 : 1511 : if ((OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
7256 : 1436 : || OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_UVAL)
7257 : 1574 : && !TYPE_REF_P (type))
7258 : : {
7259 : 12 : error_at (OMP_CLAUSE_LOCATION (c),
7260 : : "linear clause with %qs modifier applied to "
7261 : : "non-reference variable with %qT type",
7262 : 12 : OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
7263 : 12 : ? "ref" : "uval", TREE_TYPE (t));
7264 : 12 : remove = true;
7265 : 12 : break;
7266 : : }
7267 : 1499 : if (TYPE_REF_P (type))
7268 : 269 : type = TREE_TYPE (type);
7269 : 1499 : if (OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_REF)
7270 : : {
7271 : 1430 : if (!INTEGRAL_TYPE_P (type)
7272 : 85 : && !TYPE_PTR_P (type))
7273 : : {
7274 : 18 : error_at (OMP_CLAUSE_LOCATION (c),
7275 : : "linear clause applied to non-integral "
7276 : : "non-pointer variable with %qT type",
7277 : 18 : TREE_TYPE (t));
7278 : 18 : remove = true;
7279 : 18 : break;
7280 : : }
7281 : : }
7282 : : }
7283 : 1583 : t = OMP_CLAUSE_LINEAR_STEP (c);
7284 : 1583 : if (t == NULL_TREE)
7285 : 6 : t = integer_one_node;
7286 : 1583 : if (t == error_mark_node)
7287 : : {
7288 : : remove = true;
7289 : : break;
7290 : : }
7291 : 1583 : else if (!type_dependent_expression_p (t)
7292 : 1581 : && !INTEGRAL_TYPE_P (TREE_TYPE (t))
7293 : 1595 : && (ort != C_ORT_OMP_DECLARE_SIMD
7294 : 9 : || TREE_CODE (t) != PARM_DECL
7295 : 6 : || !TYPE_REF_P (TREE_TYPE (t))
7296 : 6 : || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (t)))))
7297 : : {
7298 : 6 : error_at (OMP_CLAUSE_LOCATION (c),
7299 : : "linear step expression must be integral");
7300 : 6 : remove = true;
7301 : 6 : break;
7302 : : }
7303 : : else
7304 : : {
7305 : 1577 : t = mark_rvalue_use (t);
7306 : 1577 : if (ort == C_ORT_OMP_DECLARE_SIMD && TREE_CODE (t) == PARM_DECL)
7307 : : {
7308 : 42 : OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c) = 1;
7309 : 42 : goto check_dup_generic;
7310 : : }
7311 : 1535 : if (!processing_template_decl
7312 : 1535 : && (VAR_P (OMP_CLAUSE_DECL (c))
7313 : 817 : || TREE_CODE (OMP_CLAUSE_DECL (c)) == PARM_DECL))
7314 : : {
7315 : 1354 : if (ort == C_ORT_OMP_DECLARE_SIMD)
7316 : : {
7317 : 571 : t = maybe_constant_value (t);
7318 : 571 : if (TREE_CODE (t) != INTEGER_CST)
7319 : : {
7320 : 6 : error_at (OMP_CLAUSE_LOCATION (c),
7321 : : "%<linear%> clause step %qE is neither "
7322 : : "constant nor a parameter", t);
7323 : 6 : remove = true;
7324 : 6 : break;
7325 : : }
7326 : : }
7327 : 1348 : t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
7328 : 1348 : tree type = TREE_TYPE (OMP_CLAUSE_DECL (c));
7329 : 1348 : if (TYPE_REF_P (type))
7330 : 245 : type = TREE_TYPE (type);
7331 : 1348 : if (OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF)
7332 : : {
7333 : 60 : type = build_pointer_type (type);
7334 : 60 : tree d = fold_convert (type, OMP_CLAUSE_DECL (c));
7335 : 60 : t = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
7336 : : d, t);
7337 : 60 : t = fold_build2_loc (OMP_CLAUSE_LOCATION (c),
7338 : : MINUS_EXPR, sizetype,
7339 : : fold_convert (sizetype, t),
7340 : : fold_convert (sizetype, d));
7341 : 60 : if (t == error_mark_node)
7342 : : {
7343 : : remove = true;
7344 : : break;
7345 : : }
7346 : : }
7347 : 1288 : else if (TYPE_PTR_P (type)
7348 : : /* Can't multiply the step yet if *this
7349 : : is still incomplete type. */
7350 : 1288 : && (ort != C_ORT_OMP_DECLARE_SIMD
7351 : 45 : || TREE_CODE (OMP_CLAUSE_DECL (c)) != PARM_DECL
7352 : 45 : || !DECL_ARTIFICIAL (OMP_CLAUSE_DECL (c))
7353 : 30 : || DECL_NAME (OMP_CLAUSE_DECL (c))
7354 : 30 : != this_identifier
7355 : 30 : || !TYPE_BEING_DEFINED (TREE_TYPE (type |
