| blob | 3493d3c6ed33101eaf6d2e0cac4a653896d23941 |
1 /* coroutine-specific state, expansions and tests.
3 Copyright (C) 2018-2023 Free Software Foundation, Inc.
5 Contributed by Iain Sandoe <iain@sandoe.co.uk> under contract to Facebook.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
38 /* GCC C++ coroutines implementation.
40 The user authors a function that becomes a coroutine (lazily) by
41 making use of any of the co_await, co_yield or co_return keywords.
43 Unlike a regular function, where the activation record is placed on the
44 stack, and is destroyed on function exit, a coroutine has some state that
45 persists between calls - the coroutine frame (analogous to a stack frame).
47 We transform the user's function into three pieces:
48 1. A so-called ramp function, that establishes the coroutine frame and
49 begins execution of the coroutine.
50 2. An actor function that contains the state machine corresponding to the
51 user's suspend/resume structure.
52 3. A stub function that calls the actor function in 'destroy' mode.
54 The actor function is executed:
55 * from "resume point 0" by the ramp.
56 * from resume point N ( > 0 ) for handle.resume() calls.
57 * from the destroy stub for destroy point N for handle.destroy() calls.
59 The functions in this file carry out the necessary analysis of, and
60 transforms to, the AST to perform this.
62 The C++ coroutine design makes use of some helper functions that are
63 authored in a so-called "promise" class provided by the user.
65 At parse time (or post substitution) the type of the coroutine promise
66 will be determined. At that point, we can look up the required promise
67 class methods and issue diagnostics if they are missing or incorrect. To
68 avoid repeating these actions at code-gen time, we make use of temporary
69 'proxy' variables for the coroutine handle and the promise - which will
70 eventually be instantiated in the coroutine frame.
72 Each of the keywords will expand to a code sequence (although co_yield is
73 just syntactic sugar for a co_await).
75 We defer the analysis and transformation until template expansion is
76 complete so that we have complete types at that time. */
79 /* The state that we collect during parsing (and template expansion) for
80 a coroutine. */
83 {
90 one that will eventually be allocated in the coroutine
91 frame. */
95 function into a coroutine. */
96 /* Flags to avoid repeated errors for per-function issues. */
100 };
103 {
109 };
111 /* This table holds all the collected coroutine state for coroutines in
112 the current translation unit. */
116 /* We will initialize state lazily. */
119 /* Return a hash value for the entry pointed to by INFO.
120 The compare type is a tree, but the only trees we are going use are
121 function decls. We use the DECL_UID as the hash value since that is
122 stable across PCH. */
124 hashval_t
126 {
128 }
130 /* Return a hash value for the compare value COMP. */
132 hashval_t
134 {
136 }
138 /* Return true if the entries pointed to by LHS and RHS are for the
139 same coroutine. */
141 bool
143 {
145 }
147 bool
149 {
151 }
153 /* Get the existing coroutine_info for FN_DECL, or insert a new one if the
154 entry does not yet exist. */
156 coroutine_info *
158 {
165 {
168 }
171 }
173 /* Get the existing coroutine_info for FN_DECL, fail if it doesn't exist. */
175 coroutine_info *
177 {
186 }
188 /* We will lazily create all the identifiers that are used by coroutines
189 on the first attempt to lookup the traits. */
191 /* Identifiers that are used by all coroutines. */
197 /* Required promise method name identifiers. */
212 /* Awaitable methods. */
218 /* Accessors for the coroutine frame state used by the implementation. */
229 /* Create the identifiers used by the coroutines library interfaces and
230 the implementation frame state. */
232 static void
234 {
249 coro_gro_on_allocation_fail_identifier =
257 /* Coroutine state frame field accessors. */
266 }
268 /* Trees we only need to set up once. */
274 /* ================= Parse, Semantics and Type checking ================= */
276 /* This initial set of routines are helper for the parsing and template
277 expansion phases.
279 At the completion of this, we will have completed trees for each of the
280 keywords, but making use of proxy variables for the self-handle and the
281 promise class instance. */
283 /* [coroutine.traits]
284 Lookup the coroutine_traits template decl. */
286 static tree
288 {
289 /* If we are missing fundamental information, such as the traits, (or the
290 declaration found is not a type template), then don't emit an error for
291 every keyword in a TU, just do it once. */
299 {
301 {
307 }
309 }
310 else
312 }
314 /* Instantiate Coroutine traits for the function signature. */
316 static tree
318 {
319 /* [coroutine.traits.primary]
320 So now build up a type list for the template <typename _R, typename...>.
321 The types are the function's arg types and _R is the function return
322 type. */
331 {
334 {
335 /* We pass a reference to *this to the param preview. */
338 }
339 else
344 }
353 tree traits_class
359 {
362 }
365 }
367 /* [coroutine.handle] */
369 static tree
371 {
372 /* As for the coroutine traits, this error is per TU, so only emit
373 it once. */
380 {
386 }
387 else
389 }
391 /* Instantiate the handle template for a given promise type. */
393 static tree
395 {
396 /* So now build up a type list for the template, one entry, the promise. */
399 tree handle_type
406 {
410 }
413 }
415 /* Look for the promise_type in the instantiated traits. */
417 static tree
419 {
420 tree promise_type
425 promise_type
428 /* NULL_TREE on fail. */
430 }
432 static bool
434 {
438 {
439 /* Trees we only need to create once.
440 Set up the identifiers we will use. */
443 /* Coroutine traits template. */
448 /* coroutine_handle<> template. */
453 /* We can also instantiate the void coroutine_handle<> */
454 void_coro_handle_type =
459 /* A table to hold the state, per coroutine decl. */
461 coroutine_info_table =
468 }
470 /* Save the coroutine data on the side to avoid the overhead on every
471 function decl tree. */
474 /* Without this, we cannot really proceed. */
477 /* If we don't already have a current promise type, try to look it up. */
479 {
480 /* Get the coroutine traits template class instance for the function
481 signature we have - coroutine_traits <R, ...> */
485 /* Find the promise type for that. */
488 /* If we don't find it, punt on the rest. */
490 {
496 }
498 /* Test for errors in the promise type that can be determined now. */
500 coro_return_void_identifier,
502 tf_none);
504 coro_return_value_identifier,
506 tf_none);
508 {
519 {
522 }
526 }
528 /* Try to find the handle type for the promise. */
529 tree handle_type =
534 /* Complete this, we're going to use it. */
537 /* Diagnostic would be emitted by complete_type_or_else. */
541 /* Build a proxy for a handle to "self" as the param to
542 await_suspend() calls. */
543 coro_info->self_h_proxy
547 /* Build a proxy for the promise so that we can perform lookups. */
548 coro_info->promise_proxy
552 /* Note where we first saw a coroutine keyword. */
554 }
557 }
559 /* Map from actor or destroyer to ramp. */
562 /* Given a tree that is an actor or destroy, find the ramp function. */
564 tree
566 {
573 }
575 /* Given the DECL for a ramp function (the user's original declaration) return
576 the actor function if it has been defined. */
578 tree
580 {
585 }
587 /* Given the DECL for a ramp function (the user's original declaration) return
588 the destroy function if it has been defined. */
590 tree
592 {
597 }
599 /* These functions assumes that the caller has verified that the state for
600 the decl has been initialized, we try to minimize work here. */
602 static tree
604 {
609 }
611 static tree
613 {
618 }
620 static tree
622 {
627 }
629 static tree
631 {
636 }
638 static tree
641 {
643 tree pm_memb
647 {
650 }
652 }
654 /* Build an expression of the form p.method (args) where the p is a promise
655 object for the current coroutine.
656 OBJECT is the promise object instance to use, it may be NULL, in which case
657 we will use the promise_proxy instance for this coroutine.
658 ARGS may be NULL, for empty parm lists. */
660 static tree
664 {
669 /* If we don't find it, and it isn't needed, an empty return is OK. */
673 tree promise
676 tree expr;
680 else
681 {
687 else
690 }
692 }
694 /* Caching get for the expression p.return_void (). */
696 static tree
698 {
700 {
701 /* If we don't have it try to build it. */
703 info->return_void
705 coro_return_void_identifier,
707 /* Don't return an error if it's an optional call. */
711 }
713 }
715 /* Lookup an Awaitable member, which should be await_ready, await_suspend
716 or await_resume. */
718 static tree
720 {
721 tree aw_memb
725 {
728 }
730 }
732 /* Here we check the constraints that are common to all keywords (since the
733 presence of a coroutine keyword makes the function into a coroutine). */
735 static bool
738 {
740 {
743 }
745 /* This is arranged in order of prohibitions in the std. */
747 {
748 /* [basic.start.main] 3. The function main shall not be a coroutine. */
750 kw_name);
752 }
755 {
758 {
759 /* [dcl.constexpr] 3.3 it shall not be a coroutine. */
761 kw_name);
763 }
764 }
767 {
768 /* [dcl.spec.auto] 15. A function declared with a return type that uses
769 a placeholder type shall not be a coroutine. */
772 kw_name);
774 }
777 {
778 /* [dcl.fct.def.coroutine] The parameter-declaration-clause of the
779 coroutine shall not terminate with an ellipsis that is not part
780 of a parameter-declaration. */
784 }
787 {
788 /* [class.ctor] 7. a constructor shall not be a coroutine. */
791 }
794 {
795 /* [class.dtor] 21. a destructor shall not be a coroutine. */
798 }
801 }
803 /* Here we check the constraints that are not per keyword. */
805 static bool
807 {
810 /* For cases where fundamental information cannot be found, e.g. the
811 coroutine traits are missing, we need to punt early. */
815 /* Since we think the function is a coroutine, that implies we parsed
816 a keyword that triggered this. Keywords check promise validity for
817 their context and thus the promise type should be known at this point. */
823 {
824 /* TODO: record or extract positions of returns (and the first coro
825 keyword) so that we can add notes to the diagnostic about where
826 the bad keyword is and what made the function into a coro. */
830 }
833 }
837 CO_YIELD_SUSPEND_POINT,
838 INITIAL_SUSPEND_POINT,
839 FINAL_SUSPEND_POINT
840 };
842 /* Helper function to build a named variable for the temps we use for each
843 await point. The root of the name is determined by SUSPEND_KIND, and
844 the variable is of type V_TYPE. The awaitable number is reset each time
845 we encounter a final suspend. */
847 static tree
849 {
853 {
858 }
864 }
866 /* Helpers to diagnose missing noexcept on final await expressions. */
868 static bool
870 {
872 {
876 fndecl);
879 }
881 }
883 static bool
885 {
895 else
896 {
899 }
902 }
904 /* This performs [expr.await] bullet 3.3 and validates the interface obtained.
905 It is also used to build the initial and final suspend points.
907 'a', 'o' and 'e' are used as per the description in the section noted.
909 A, the original yield/await expr, is found at source location LOC.
911 We will be constructing a CO_AWAIT_EXPR for a suspend point of one of
912 the four suspend_point_kind kinds. This is indicated by SUSPEND_KIND. */
914 static tree
916 {
917 /* Try and overload of operator co_await, .... */
918 tree o;
920 {
923 /* If no viable functions are found, o is a. */
927 {
928 /* We found an overload for co_await(), diagnose throwing cases. */
933 /* We now know that the final suspend object is distinct from the
934 final awaiter, so check for a non-throwing DTOR where needed. */
940 tf_none))
941 {
947 }
948 }
949 }
950 else
961 {
963 o_type);
965 }
967 /* Check for required awaitable members and their types. */
968 tree awrd_meth
972 tree awsp_meth
977 /* The type of the co_await is the return type of the awaitable's
978 await_resume, so we need to look that up. */
979 tree awrs_meth
984 /* To complete the lookups, we need an instance of 'e' which is built from
985 'o' according to [expr.await] 3.4.
987 If we need to materialize this as a temporary, then that will have to be
988 'promoted' to a coroutine frame var. However, if the awaitable is a
989 user variable, parameter or comes from a scope outside this function,
990 then we must use it directly - or we will see unnecessary copies.
992 If o is a variable, find the underlying var. */
997 {
1002 {
1003 /* We could have operator-> here too. */
1007 {
1012 }
1013 }
1015 }
1017 /* Only build a temporary if we need it. */
1021 {
1024 }
1025 else
1026 {
1032 tf_warning_or_error);
1034 }
1036 /* I suppose we could check that this is contextually convertible to bool. */
1038 tree awrd_call
1045 /* The suspend method may return one of three types:
1046 1. void (no special action needed).
1047 2. bool (if true, we don't need to suspend).
1048 3. a coroutine handle, we execute the handle.resume() call. */
1052 tree awsp_call
1069 {
1073 }
1076 {
1080 }
1082 /* Finally, the type of e.await_resume() is the co_await's type. */
1084 tree awrs_call
1092 {
1103 tf_none))
1104 {
1110 }
1111 }
1113 /* We now have three call expressions, in terms of the promise, handle and
1114 'e' proxies. Save them in the await expression for later expansion. */
1121 {
1124 }
1137 {
1141 }
1144 }
1146 tree
1148 {
1156 /* The current function has now become a coroutine, if it wasn't already. */
1159 /* This function will appear to have no return statement, even if it
1160 is declared to return non-void (most likely). This is correct - we
1161 synthesize the return for the ramp in the compiler. So suppress any
1162 extraneous warnings during substitution. */
1165 /* Defer expansion when we are processing a template.
1166 FIXME: If the coroutine function's type is not dependent, and the operand
1167 is not dependent, we should determine the type of the co_await expression
1168 using the DEPENDENT_EXPR wrapper machinery. That allows us to determine
1169 the subexpression type, but leave its operand unchanged and then
1170 instantiate it later. */
1172 {
1175 integer_zero_node);
1178 }
1180 /* We must be able to look up the "await_transform" method in the scope of
1181 the promise type, and obtain its return type. */
1185 /* [expr.await] 3.2
1186 The incoming cast expression might be transformed by a promise
1187 'await_transform()'. */
1188 tree at_meth
1197 {
1198 /* try to build a = p.await_transform (e). */
1201 current_function_decl),
1205 /* As I read the section.
1206 We saw an await_transform method, so it's mandatory that we replace
1207 expr with p.await_transform (expr), therefore if the method call fails
1208 (presumably, we don't have suitable arguments) then this part of the
1209 process fails. */
1212 }
1214 /* Now we want to build co_await a. */
1216 }
1218 /* Take the EXPR given and attempt to build:
1219 co_await p.yield_value (expr);
1220 per [expr.yield] para 1. */
1222 tree
1224 {
1228 /* Check the general requirements and simple syntax errors. */
1233 /* The current function has now become a coroutine, if it wasn't already. */
1236 /* This function will appear to have no return statement, even if it
1237 is declared to return non-void (most likely). This is correct - we
1238 synthesize the return for the ramp in the compiler. So suppress any
1239 extraneous warnings during substitution. */
1242 /* Defer expansion when we are processing a template; see FIXME in the
1243 co_await code. */
1248 /* We must be able to look up the "yield_value" method in the scope of
1249 the promise type, and obtain its return type. */
1252 /* [expr.yield] / 1
1253 Let e be the operand of the yield-expression and p be an lvalue naming
1254 the promise object of the enclosing coroutine, then the yield-expression
1255 is equivalent to the expression co_await p.yield_value(e).
1256 build p.yield_value(e): */
1258 tree yield_call
1264 /* Now build co_await p.yield_value (e).
1265 Noting that for co_yield, there is no evaluation of any potential
1266 promise transform_await(), so we call build_co_await directly. */
1270 {
1273 /* If the await expression is wrapped in a TARGET_EXPR, then transfer
1274 that wrapper to the CO_YIELD_EXPR, since this is just a proxy for
1275 its contained await. Otherwise, just build the CO_YIELD_EXPR. */
1277 {
1281 }
1282 else
1286 }
1289 }
1291 /* Check and build a co_return statement.
1292 First that it's valid to have a co_return keyword here.
1293 If it is, then check and build the p.return_{void(),value(expr)}.
1294 These are built against a proxy for the promise, which will be filled
1295 in with the actual frame version when the function is transformed. */
1297 tree
1299 {
1306 /* If it fails the following test, the function is not permitted to be a
1307 coroutine, so the co_return statement is erroneous. */
1312 /* The current function has now become a coroutine, if it wasn't
1313 already. */
1316 /* This function will appear to have no return statement, even if it
1317 is declared to return non-void (most likely). This is correct - we
1318 synthesize the return for the ramp in the compiler. So suppress any
1319 extraneous warnings during substitution. */
1326 /* Defer expansion when we are processing a template; see FIXME in the
1327 co_await code. */
1329 {
1330 /* co_return expressions are always void type, regardless of the
1331 expression type. */
1336 }
1341 /* Suppress -Wreturn-type for co_return, we need to check indirectly
1342 whether the promise type has a suitable return_void/return_value. */
1349 {
1350 /* If we had an id-expression obfuscated by force_paren_expr, we need
1351 to undo it so we can try to treat it as an rvalue below. */
1359 }
1361 /* If the promise object doesn't have the correct return call then
1362 there's a mis-match between the co_return <expr> and this. */
1365 co_ret_call
1367 else
1368 {
1369 /* [class.copy.elision] / 3.
1370 An implicitly movable entity is a variable of automatic storage
1371 duration that is either a non-volatile object or an rvalue reference
1372 to a non-volatile object type. For such objects in the context of
1373 the co_return, the overload resolution should be carried out first
1374 treating the object as an rvalue, if that fails, then we fall back
1375 to regular overload resolution. */
1382 co_ret_call
1386 }
1388 /* Makes no sense for a co-routine really. */
1391 "function declared %<noreturn%> has a"
1397 }
1399 /* We need to validate the arguments to __builtin_coro_promise, since the
1400 second two must be constant, and the builtins machinery doesn't seem to
1401 deal with that properly. */
1403 tree
1405 {
1410 {
1415 {
1416 /* Argument 0 is already checked by the normal built-in machinery
1417 Argument 1 must be a constant of size type. It probably makes
1418 little sense if it's not a power of 2, but that isn't specified
1419 formally. */
1423 /* We expect alignof expressions in templates. */
1426 ;
1428 {
1432 }
1433 /* Argument 2 is the direction - to / from handle address to promise
1434 address. */
1438 {
1442 }
1445 }
1446 }
1447 }
1449 /* ================= Morph and Expand. =================
1451 The entry point here is morph_fn_to_coro () which is called from
1452 finish_function () when we have completed any template expansion.
1454 This is preceded by helper functions that implement the phases below.
1456 The process proceeds in four phases.
1458 A Initial framing.
1459 The user's function body is wrapped in the initial and final suspend
1460 points and we begin building the coroutine frame.
1461 We build empty decls for the actor and destroyer functions at this
1462 time too.
1463 When exceptions are enabled, the user's function body will also be
1464 wrapped in a try-catch block with the catch invoking the promise
1465 class 'unhandled_exception' method.
1467 B Analysis.
1468 The user's function body is analyzed to determine the suspend points,
1469 if any, and to capture local variables that might persist across such
1470 suspensions. In most cases, it is not necessary to capture compiler
1471 temporaries, since the tree-lowering nests the suspensions correctly.
1472 However, in the case of a captured reference, there is a lifetime
1473 extension to the end of the full expression - which can mean across a
1474 suspend point in which case it must be promoted to a frame variable.
1476 At the conclusion of analysis, we have a conservative frame layout and
1477 maps of the local variables to their frame entry points.
1479 C Build the ramp function.
1480 Carry out the allocation for the coroutine frame (NOTE; the actual size
1481 computation is deferred until late in the middle end to allow for future
1482 optimizations that will be allowed to elide unused frame entries).
1483 We build the return object.
1485 D Build and expand the actor and destroyer function bodies.
1486 The destroyer is a trivial shim that sets a bit to indicate that the
1487 destroy dispatcher should be used and then calls into the actor.
1489 The actor function is the implementation of the user's state machine.
1490 The current suspend point is noted in an index.
1491 Each suspend point is encoded as a pair of internal functions, one in
1492 the relevant dispatcher, and one representing the suspend point.
1494 During this process, the user's local variables and the proxies for the
1495 self-handle and the promise class instance are re-written to their
1496 coroutine frame equivalents.
1498 The complete bodies for the ramp, actor and destroy function are passed
1499 back to finish_function for folding and gimplification. */
1501 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1503 static tree
1505 {
1507 }
1509 static tree
1511 {
1514 }
1516 /* Helpers to build an artificial var, with location LOC, NAME and TYPE, in
1517 CTX, and with initializer INIT. */
1519 static tree
1521 tree init)
1522 {
1529 }
1531 static tree
1534 {
1537 }
1539 /* Helpers for label creation:
1540 1. Create a named label in the specified context. */
1542 static tree
1544 {
1552 }
1554 /* 2. Create a named label in the specified context. */
1556 static tree
1558 {
1565 }
1567 struct proxy_replace
1568 {
1570 };
1572 static tree
1574 {
1578 {
1581 }
1582 else
1585 }
1587 /* Support for expansion of co_await statements. */
1589 struct coro_aw_data
1590 {
1601 };
1603 /* Lightweight search for the first await expression in tree-walk order.
1604 returns:
1605 The first await expression found in STMT.
1606 NULL_TREE if there are none.
1607 So can be used to determine if the statement needs to be processed for
1608 awaits. */
1610 static tree
1612 {
1615 {
1618 }
1620 }
1622 /* Starting with a statement:
1624 stmt => some tree containing one or more await expressions.
1626 We replace the statement with:
1627 <STATEMENT_LIST> {
1628 initialize awaitable
1629 if (!ready)
1630 {
1631 suspension context.
1632 }
1633 resume:
1634 revised statement with one await expression rewritten to its
1635 await_resume() return value.
1636 }
1638 We then recurse into the initializer and the revised statement
1639 repeating this replacement until there are no more await expressions
1640 in either. */
1644 {
1671 tree r;
1676 else
1677 {
1680 /* We have an initializer, which might itself contain await exprs. */
1682 }
1684 /* Use the await_ready() call to test if we need to suspend. */
1686 /* Convert to bool, if necessary. */
1689 tf_warning_or_error);
1690 /* Be aggressive in folding here, since there are a significant number of
1691 cases where the ready condition is constant. */
1693 ready_cond
1699 susp_idx);
1703 /* Find out what we have to do with the awaiter's suspend method.
1704 [expr.await]
1705 (5.1) If the result of await-ready is false, the coroutine is considered
1706 suspended. Then:
1707 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1708 await-suspend.resume() is evaluated.
1709 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1710 and the coroutine is resumed if the result is false.
1711 (5.1.3) Otherwise, await-suspend is evaluated. */
1717 /* NOTE: final suspend can't resume; the "resume" label in that case
1718 corresponds to implicit destruction. */
1720 {
1721 /* We just call await_suspend() and hit the yield. */
1724 }
1726 {
1727 /* Boolean return, continue if the call returns false. */
1729 suspend
1733 empty_list);
1735 }
1736 else
1737 {
1740 void_coro_handle_type))
1746 }
1770 /* Implement the suspend, a scope exit without clean ups. */
1786 /* part of finish switch. */
1797 {
1800 tf_warning_or_error);
1802 }
1807 empty_list);
1811 /* Resume point. */
1815 /* This will produce the value (if one is provided) from the co_await
1816 expression. */
1819 /* Sink to await_resume call_expr. */
1824 /* Get a pointer to the revised statement. */
1827 {
1830 tf_warning_or_error);
1832 }
1835 /* Replace the original statement with the expansion. */
1838 /* Now, if the awaitable had an initializer, expand any awaits that might
1839 be embedded in it. */
1845 /* Expand any more await expressions in the original statement. */
1850 }
1852 /* Check to see if a statement contains at least one await expression, if
1853 so, then process that. */
1855 static tree
1857 {
1862 }
1864 static tree
1866 {
1869 /* Process a statement at a time. */
1873 {
1875 {
1880 }
1882 }
1884 {
1887 }
1889 /* Continue statement walk, where required. */
1891 }
1893 /* Suspend point hash_map. */
1895 struct suspend_point_info
1896 {
1897 /* coro frame field type. */
1898 tree awaitable_type;
1899 /* coro frame field name. */
1900 tree await_field_id;
1901 };
1905 struct await_xform_data
1906 {
1908 tree actor_frame;
1909 };
1911 /* When we built the await expressions, we didn't know the coro frame
1912 layout, therefore no idea where to find the promise or where to put
1913 the awaitables. Now we know these things, fill them in. */
1915 static tree
1917 {
1921 {
1924 }
1926 /* So, on entry, we have:
1927 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1928 We no longer need a [it had diagnostic value, maybe?]
1929 We need to replace the e_proxy in the awr_call. */
1933 /* If we have a frame var for the awaitable, get a reference to it. */
1934 proxy_replace data;
1936 {
1937 tree as_m
1942 tf_warning_or_error);
1944 /* Replace references to the instance proxy with the frame entry now
1945 computed. */
1950 /* .. and replace. */
1952 }
1955 }
1957 /* A wrapper for the transform_await_expr function so that it can be a
1958 callback from cp_walk_tree. */
1960 static tree
1962 {
1963 /* Set actor function as new DECL_CONTEXT of label_decl. */
1969 /* We should have already lowered co_yields to their co_await. */
1979 }
1981 /* This caches information that we determine about function params,
1982 their uses and copies in the coroutine frame. */
1984 struct param_info
1985 {
1999 };
2001 struct local_var_info
2002 {
2003 tree field_id;
2004 tree field_idx;
2005 tree frame_type;
2009 location_t def_loc;
2010 };
2012 /* For figuring out what local variable usage we have. */
2013 struct local_vars_transform
2014 {
2015 tree context;
2016 tree actor_frame;
2017 tree coro_frame_type;
2018 location_t loc;
2020 };
2022 static tree
2024 {
2027 /* For each var in this bind expr (that has a frame id, which means it was
2028 accessed), build a frame reference and add it as the DECL_VALUE_EXPR. */
2031 {
2032 tree lvar;
2035 {
2037 local_var_info &local_var
2041 /* Re-write the variable's context to be in the actor func. */
2044 /* For capture proxies, this could include the decl value expr. */
2048 /* TODO: implement selective generation of fields when vars are
2049 known not-used. */
2053 tree fld_ref
2056 tf_warning_or_error);
2062 }
2066 }
2068 }
2070 /* A helper to build the frame DTOR.
2071 [dcl.fct.def.coroutine] / 12
2072 The deallocation function’s name is looked up in the scope of the promise
2073 type. If this lookup fails, the deallocation function’s name is looked up
2074 in the global scope. If deallocation function lookup finds both a usual
2075 deallocation function with only a pointer parameter and a usual
2076 deallocation function with both a pointer parameter and a size parameter,
2077 then the selected deallocation function shall be the one with two
2078 parameters. Otherwise, the selected deallocation function shall be the
2079 function with one parameter. If no usual deallocation function is found
2080 the program is ill-formed. The selected deallocation function shall be
2081 called with the address of the block of storage to be reclaimed as its
2082 first argument. If a deallocation function with a parameter of type
2083 std::size_t is used, the size of the block is passed as the corresponding
2084 argument. */
2086 static tree
2089 {
2096 {
2097 /* Look for sized version first, since this takes precedence. */
2103 /* It's OK to fail for this one... */
2106 tf_none);
2109 {
2114 tf_none);
2115 }
2117 /* But one of them must succeed, or the program is ill-formed. */
2119 {
2123 }
2124 }
2125 else
2126 {
2130 tf_warning_or_error);
2133 }
2135 }
2137 /* The actor transform. */
2139 static void
2144 {
2146 /* Some things we inherit from the original function. */
2151 /* One param, the coro frame pointer. */
2154 /* We have a definition here. */
2167 NULL_TREE);
2172 /* Link in the block associated with the outer scope of the re-written
2173 function body. */
2185 /* The entry point for the actor code from the ramp. */
2186 tree actor_begin_label
2190 /* Declare the continuation handle. */
2193 /* Re-write local vars, similarly. */
2194 local_vars_transform xform_vars_data
2203 tree ret_label
2206 tree continue_label
2225 /* The destroy point numbered #1 is special, in that it is reached from a
2226 coroutine that is suspended after re-throwing from unhandled_exception().
2227 This label just invokes the cleanup of promise, param copies and the
2228 frame itself. */
2229 tree del_promise_label
2238 {
2244 l_num);
2250 }
2252 /* Insert the prototype dispatcher. */
2274 /* The final resume should be made to hit the default (trap, UB) entry
2275 although it will be unreachable via the normal entry point, since that
2276 is set to NULL on reaching final suspend. */
2278 {
2284 l_num);
2290 }
2292 /* Insert the prototype dispatcher. */
2301 /* actor's coroutine 'self handle'. */
2306 /* So construct the self-handle from the frame address. */
2319 /* Now we know the real promise, and enough about the frame layout to
2320 decide where to put things. */
2324 /* Transform the await expressions in the function body. Only do each
2325 await tree once! */
2329 /* Add in our function body with the co_returns rewritten to final form. */
2332 /* now do the tail of the function. */
2336 /* Destructors for the things we built explicitly. */
2339 tf_warning_or_error);
2342 tree del_frame_label
2347 /* Here deallocate the frame (if we allocated it), which we will have at
2348 present. */
2349 tree fnf_m
2360 {
2362 tree pid;
2364 {
2365 tree m
2370 tree dtor;
2371 dtor
2375 }
2376 }
2378 /* Build the frame DTOR. */
2388 /* done. */
2394 /* This is the suspend return point. */
2403 /* This is the 'continuation' return point. For such a case we have a coro
2404 handle (from the await_suspend() call) and we want handle.resume() to
2405 execute as a tailcall allowing arbitrary chaining of coroutines. */
2409 /* We want to force a tail-call even for O0/1, so this expands the resume
2410 call into its underlying implementation. */
2415 tree resume = build_call_expr_loc
2418 /* In order to support an arbitrary number of coroutine continuations,
2419 we must tail call them. However, some targets do not support indirect
2420 tail calls to arbitrary callees. See PR94359. */
2429 /* We've now rewritten the tree and added the initial and final
2430 co_awaits. Now pass over the tree and expand the co_awaits. */
2443 }
2445 /* The prototype 'destroy' function :
2446 frame->__Coro_resume_index |= 1;
2447 actor (frame); */
2449 static void
2451 tree actor)
2452 {
2453 /* One param, the coro frame pointer. */
2456 /* We have a definition here. */
2470 /* _resume_at |= 1 */
2477 /* So .. call the actor .. */
2482 /* done. */
2489 }
2491 /* Helper that returns an identifier for an appended extension to the
2492 current un-mangled function name. */
2494 static tree
2496 {
2497 /* Figure out the bits we need to generate names for the outlined things
2498 For consistency, this needs to behave the same way as
2499 ASM_FORMAT_PRIVATE_NAME does. */
2502 #ifndef NO_DOT_IN_LABEL
2504 #else
2505 #ifndef NO_DOLLAR_IN_LABEL
2507 #else
2510 #endif
2511 #endif
2519 {
2523 {
2526 }
2528 }
2529 else
2533 }
2535 /* Build an initial or final await initialized from the promise
2536 initial_suspend or final_suspend expression. */
2538 static tree
2540 {
2544 tree setup_call
2548 /* Check for noexcept on the final_suspend call. */
2553 /* So build the co_await for this */
2554 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2557 }
2559 /* Callback to record the essential data for each await point found in the
2560 function. */
2562 static bool
2564 {
2566 suspend_point_info &s
2569 {
2571 await_expr);
2573 }
2577 }
2579 /* This data set is used when analyzing statements for await expressions. */
2581 struct susp_frame_data
2582 {
2583 /* Function-wide. */
2591 /* Temporary values for one statement or expression being analyzed. */
2599 };
2601 /* If this is an await expression, then count it (both uniquely within the
2602 function and locally within a single statement). */
2604 static tree
2606 {
2609 /* We should have already lowered co_yields to their co_await. */
2615 /* Count how many awaits the current expression contains. */
2618 /* Each await suspend context is unique, this is a function-wide value. */
2621 /* Awaitables should either be user-locals or promoted to coroutine frame
2622 entries at this point, and their initializers should have been broken
2623 out. */
2631 /* Rewrite target expressions on the await_suspend () to remove extraneous
2632 cleanups for the awaitables, which are now promoted to frame vars and
2633 managed via that. */
2639 }
2641 /* There are cases where any await expression is relevant. */
2642 static tree
2644 {
2646 {
2651 }
2653 }
2655 static bool
2657 {
2666 }
2668 /* Structure to record sub-expressions that need to be handled by the
2669 statement flattener. */
2671 struct coro_interesting_subtree
2672 {
2675 };
2677 /* tree-walk callback that returns the first encountered sub-expression of
2678 a kind that needs to be handled specifically by the statement flattener. */
2680 static tree
2682 {
2686 {
2689 {
2692 }
2693 }
2697 {
2700 }
2703 }
2705 /* Node for a doubly-linked list of promoted variables and their
2706 initializers. When the initializer is a conditional expression
2707 the 'then' and 'else' clauses are represented by a linked list
2708 attached to then_cl and else_cl respectively. */
2710 struct var_nest_node
2711 {
2715 {
2720 }
2721 tree var;
2722 tree init;
2727 };
2729 /* This is called for single statements from the co-await statement walker.
2730 It checks to see if the statement contains any initializers for awaitables
2731 and if any of these capture items by reference. */
2733 static void
2736 {
2739 {
2741 /* Compound expressions must be flattened specifically. */
2743 {
2746 var_nest_node *ins
2748 /* The compiler (but not the user) can generate temporaries with
2749 uses in the second arm of a compound expr. */
2752 /* The two arms have been processed separately. */
2754 }
2756 /* Handle conditional expressions. */
2759 /* FALLTHROUGH */
2761 {
2764 {
2767 var_nest_node *ins
2773 }
2776 /* Reconstruct x = t ? y : z;
2777 as (void) t ? x = y : x = z; */
2781 /* We are allowed a void type throw in one or both of the cond
2782 expr arms. */
2785 {
2789 else
2791 }
2794 {
2798 else
2800 }
2802 }
2803 /* FALLTHROUGH */
2805 {
2808 /* If the condition contains an await expression, then we need to
2809 set that first and use a separate var. */
2811 {
2818 var_nest_node *ins
2822 }
2824 n->then_cl
2826 n->else_cl
2829 /* Point to the start of the flattened code. */
2836 }
2838 }
2844 {
2847 {
2848 /* Await expressions with initializers have a compiler-temporary
2849 as the awaitable. 'promote' this. */
2855 {
2859 {
2861 /* We can have non-lvalue-expressions here, but when we see
2862 a target expression, mark it as already used. */
2864 {
2866 gcc_checking_assert
2868 }
2869 }
2872 /* If this is a call and not a CTOR, then we didn't expect it. */
2873 gcc_checking_assert
2876 }
2882 }
2885 {
2886 /* We have a temporary; promote it, but allow for the idiom in code
2887 generated by the compiler like
2888 a = (target_expr produces temp, op uses temp). */
2901 tf_warning_or_error);
2902 /* Simplify for the case that we have an init containing the temp
2903 alone. */
2905 {
2913 }
2914 else
2915 {
2916 var_nest_node *ins
2918 /* We have to replace the target expr... */
2920 /* ... and any uses of its var. */
2923 /* Compiler-generated temporaries can also have uses in
2924 following arms of compound expressions, which will be listed
2925 in 'replace_in' if present. */
2930 }
2932 }
2934 }
2935 }
2937 /* Helper for 'process_conditional' that handles recursion into nested
2938 conditionals. */
2940 static void
2943 {
2944 do
2945 {
2947 {
2950 {
2954 {
2955 /* We didn't see this var before and it needs a DTOR, so
2956 build a guard variable for it. */
2961 boolean_type_node);
2964 }
2966 /* The initializer for this variable is replaced by a compound
2967 expression that performs the init and then records that the
2968 variable is live (and the DTOR should be run at the scope
2969 exit. */
2971 n->init
2973 }
2974 }
2976 {
2983 tree new_if
2987 }
2988 else
2992 }
2994 /* helper for 'maybe_promote_temps'.
2996 When we have a conditional expression which might embed await expressions
2997 and/or promoted variables, we need to handle it appropriately.
2999 The linked lists for the 'then' and 'else' clauses in a conditional node
3000 identify the promoted variables (but these cannot be wrapped in a regular
3001 cleanup).
3003 So recurse through the lists and build up a composite list of captured vars.
3004 Declare these and any guard variables needed to decide if a DTOR should be
3005 run. Then embed the conditional into a try-finally expression that handles
3006 running each DTOR conditionally on its guard variable. */
3008 static void
3010 {
3020 /* Declare the vars. There are two loops so that the boolean flags are
3021 grouped in the frame. */
3023 {
3028 }
3029 /* Define the guard flags for variables that need a DTOR. */
3031 {
3034 {
3039 }
3040 }
3041 tree new_if
3044 /* Build a set of conditional DTORs. */
3047 {
3053 tree cleanup
3056 tf_warning_or_error);
3062 }
3064 tree try_finally
3067 }
3069 /* Given *STMT, that contains at least one await expression.
3071 The full expression represented in the original source code will contain
3072 suspension points, but it is still required that the lifetime of temporary
3073 values extends to the end of the expression.
3075 We already have a mechanism to 'promote' user-authored local variables
3076 to a coroutine frame counterpart (which allows explicit management of the
3077 lifetime across suspensions). The transform here re-writes STMT into
3078 a bind expression, promotes temporary values into local variables in that
3079 and flattens the statement into a series of cleanups.
3081 Conditional expressions are re-written to regular 'if' statements.
3082 The cleanups for variables initialized inside a conditional (including
3083 nested cases) are wrapped in a try-finally clause, with guard variables
3084 to determine which DTORs need to be run. */
3086 static tree
3088 {
3093 /* Strip off uninteresting wrappers. */
3103 /* We walk the statement trees, flattening it into an ordered list of
3104 variables with initializers and fragments corresponding to compound
3105 expressions, truth or/and if and ternary conditionals. Conditional
3106 expressions carry a nested list of fragments for the then and else
3107 clauses. We anchor to the 'bottom' of the fragment list; we will write
3108 a cleanup nest with one shell for each variable initialized. */
3110 /* Check to see we didn't promote one twice. */
3118 /* We build the bind scope expression from the bottom-up.
3119 EXPR_LIST holds the inner expression nest at the current cleanup
3120 level (becoming the final expression list when we've exhausted the
3121 number of sub-expression fragments). */
3123 do
3124 {
3126 /* When we have a promoted variable, then add that to the bind scope
3127 and initialize it. When there's no promoted variable, we just need
3128 to run the initializer.
3129 If the initializer is a conditional expression, we need to collect
3130 and declare any promoted variables nested within it. DTORs for such
3131 variables must be run conditionally too. */
3133 {
3140 else
3144 {
3145 tree cleanup
3148 tf_warning_or_error);
3151 }
3153 {
3158 }
3159 }
3160 else
3161 {
3164 else
3167 {
3172 }
3173 }
3180 /* Now produce the bind expression containing the 'promoted' temporaries
3181 as its variable list, and the cleanup nest as the statement. */
3188 {
3191 {
3195 }
3196 }
3203 }
3205 /* Lightweight callback to determine two key factors:
3206 1) If the statement/expression contains any await expressions.
3207 2) If the statement/expression potentially requires a re-write to handle
3208 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3209 so that the await expressions are not processed in the case of the
3210 short-circuit arm.
3212 CO_YIELD expressions are re-written to their underlying co_await. */
3214 static tree
3216 {
3220 {
3223 /* co_yield is syntactic sugar, re-write it to co_await. */
3225 /* FALLTHROUGH */
3228 /* A non-null initializer for the awaiter means we need to expand. */
3234 {
3235 /* We don't need special action for awaits in the always-executed
3236 arm of a TRUTH_IF. */
3240 /* However, if there are await expressions on the conditionally
3241 executed branch, we must expand the TRUTH_IF to ensure that the
3242 expanded await expression control-flow is fully contained in the
3243 conditionally executed code. */
3249 {
3252 }
3253 /* We've done the sub-trees here. */
3255 }
3257 }
3260 }
3262 /* Given *EXPR
3263 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3264 the conditionally executed branch, change this in a ternary operator.
3266 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3267 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3269 Apply this recursively to the condition and the conditionally-exec
3270 branch. */
3274 tree scratch_var;
3276 };
3278 static tree
3280 {
3285 {
3289 /* FALLTHROUGH */
3291 {
3296 /* Transform truth expression into a cond expression with
3297 * the always-executed arm as the condition.
3298 * the conditionally-executed arm as the then clause.
3299 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3305 tree cond_expr
3315 /* We've manually processed necessary sub-trees here. */
3317 }
3319 }
3321 }
3323 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3324 name is made up from NAM_ROOT, NAM_VERS. */
3326 static tree
3329 {
3331 /* Build a variable to hold the condition, this will be included in the
3332 frame as a local var. */
3339 }
3341 /* Helper to build and add if (!cond) break; */
3343 static void
3345 {
3352 }
3354 /* Tree walk callback to replace continue statements with goto label. */
3355 static tree
3357 {
3368 {
3369 /* Unless it's a special case, just walk the subtrees as usual. */
3373 {
3376 /* re-write a continue to goto label. */
3380 }
3382 /* Statements that do not require recursion. */
3389 /* These must break recursion. */
3395 }
3396 }
3398 /* Tree walk callback to analyze, register and pre-process statements that
3399 contain await expressions. */
3401 static tree
3403 {
3407 /* Process a statement at a time. */
3409 {
3410 /* For conditional expressions, we might wish to add an artificial var
3411 to their containing bind expr. */
3413 /* We might need to insert a new bind expression, and want to link it
3414 into the correct scope, so keep a note of the current block scope. */
3423 }
3425 {
3427 {
3432 }
3435 }
3437 /* We have something to be handled as a single statement. We have to handle
3438 a few statements specially where await statements have to be moved out of
3439 constructs. */
3447 {
3448 /* Unless it's a special case, just walk the subtrees as usual. */
3451 /* When we have a conditional expression, which contains one or more
3452 await expressions, we have to break the condition out into a
3453 regular statement so that the control flow introduced by the await
3454 transforms can be implemented. */
3456 {
3459 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3460 bool cond = cond with awaits.
3461 if (cond) then stmt1 else stmt2. */
3463 /* We treat the condition as if it was a stand-alone statement,
3464 to see if there are any await expressions which will be analyzed
3465 and registered. */
3480 /* We want to initialize the new variable with the expression
3481 that contains the await(s) and potentially also needs to
3482 have truth_if expressions expanded. */
3488 /* So now walk the new statement list. */
3492 }
3495 {
3498 /* for loops only need special treatment if the condition or the
3499 iteration expression contain a co_await. */
3501 /* At present, the FE always generates a separate initializer for
3502 the FOR_INIT_STMT, when the expression has an await. Check that
3503 this assumption holds in the future. */
3504 gcc_checking_assert
3509 bool for_cond_await
3514 bool for_expr_await
3518 /* If the condition has an await, then we will need to rewrite the
3519 loop as
3520 for (init expression;true;iteration expression) {
3521 condition = await expression;
3522 if (condition)
3523 break;
3524 ...
3525 }
3526 */
3528 {
3530 /* This will be expanded when the revised body is handled. */
3532 /* .. add the original for body. */
3534 /* To make the new for body. */
3537 }
3538 /* If the iteration expression has an await, it's a bit more
3539 tricky.
3540 for (init expression;condition;) {
3541 ...
3542 iteration_expr_label:
3543 iteration expression with await;
3544 }
3545 but, then we will need to re-write any continue statements into
3546 'goto iteration_expr_label:'.
3547 */
3549 {
3552 /* The original for body. */
3555 tree it_expr_label
3560 /* Present the iteration expression as a statement. */
3567 /* rewrite continue statements to goto label. */
3572 }
3574 /* So now walk the body statement (list), if there were no await
3575 expressions, then this handles the original body - and either
3576 way we will have finished with this statement. */
3581 }
3584 {
3585 /* We turn 'while (cond with awaits) stmt' into
3586 while (true) {
3587 if (!(cond with awaits))
3588 break;
3589 stmt..
3590 } */
3600 /* The original while body. */
3602 /* The new while body. */
3605 /* So now walk the new statement list. */
3610 }
3613 {
3614 /* We turn do stmt while (cond with awaits) into:
3615 do {
3616 stmt..
3617 if (!(cond with awaits))
3618 break;
3619 } while (true); */
3628 /* The original do stmt body. */
3631 /* The new while body. */
3634 /* So now walk the new statement list. */
3639 }
3642 {
3643 /* We turn 'switch (cond with awaits) stmt' into
3644 switch_type cond = cond with awaits
3645 switch (cond) stmt. */
3654 /* Build a variable to hold the condition, this will be
3655 included in the frame as a local var. */
3668 cond_inner);
3671 /* Now add the switch statement with the condition re-
3672 written to use the local var. */
3675 /* Process the expanded list. */
3680 }
3683 {
3684 /* Expand the co_return as per [stmt.return.coroutine]
3685 - for co_return;
3686 { p.return_void (); goto final_suspend; }
3687 - for co_return [void expr];
3688 { expr; p.return_void(); goto final_suspend;}
3689 - for co_return [non void expr];
3690 { p.return_value(expr); goto final_suspend; } */
3695 /* [stmt.return.coroutine], 2.2
3696 If expr is present and void, it is placed immediately before
3697 the call for return_void; */
3700 /* Insert p.return_{void,value(expr)}. */
3706 /* Once this is complete, we will have processed subtrees. */
3709 }
3712 {
3713 /* [expr.await] An await-expression shall appear only in a
3714 potentially-evaluated expression within the compound-statement
3715 of a function-body outside of a handler. */
3724 }
3726 }
3728 {
3747 {
3748 /* If a truth-and/or-if expression has an await expression in the
3749 conditionally-taken branch, then it must be rewritten into a
3750 regular conditional. */
3754 }
3755 /* Process this statement, which contains at least one await expression
3756 to 'promote' temporary values to a coroutine frame slot. */
3758 }
3759 /* Continue recursion, if needed. */
3761 }
3763 /* For figuring out what param usage we have. */
3765 struct param_frame_data
3766 {
3770 location_t loc;
3772 };
3774 /* A tree walk callback that rewrites each parm use to the local variable
3775 that represents its copy in the frame. */
3777 static tree
3779 {
3782 /* For lambda closure content, we have to look specifically. */
3784 {
3787 }
3792 /* If we already saw the containing expression, then we're done. */
3802 }
3804 /* Build up a set of info that determines how each param copy will be
3805 handled. */
3809 {
3815 /* Build a hash map with an entry for each param.
3816 The key is the param tree.
3817 Then we have an entry for the frame field name.
3818 Then a cache for the field ref when we come to use it.
3819 Then a tree list of the uses.
3820 The second two entries start out empty - and only get populated
3821 when we see uses. */
3826 {
3838 {
3839 /* If the user passes by reference, then we will save the
3840 pointer to the original. As noted in
3841 [dcl.fct.def.coroutine] / 13, if the lifetime of the
3842 referenced item ends and then the coroutine is resumed,
3843 we have UB; well, the user asked for it. */
3846 else
3848 }
3859 {
3863 }
3867 {
3870 parm.guard_var
3873 boolean_false_node);
3876 }
3877 else
3879 }
3882 }
3884 /* Small helper for the repetitive task of adding a new field to the coro
3885 frame type. */
3887 static tree
3889 location_t loc)
3890 {
3896 }
3898 /* For recording local variable usage. */
3900 struct local_vars_frame_data
3901 {
3905 location_t loc;
3908 };
3910 /* A tree-walk callback that processes one bind expression noting local
3911 variables, and making a coroutine frame slot available for those that
3912 need it, so that they can be 'promoted' across suspension points. */
3914 static tree
3916 {
3919 /* As we enter a bind expression - record the vars there and then recurse.
3920 As we exit drop the nest depth.
3921 The bind index is a growing count of how many bind indices we've seen.
3922 We build a space in the frame for each local var. */
3925 {
3926 tree lvar;
3930 {
3932 local_var_info &local_var
3940 /* Make sure that we only present vars to the tests below. */
3945 /* We don't move static vars into the frame. */
3950 poly_uint64 size;
3953 {
3956 /* Ignore it, this is broken anyway. */
3958 }
3961 /* If this var is a lambda capture proxy, we want to leave it alone,
3962 and later rewrite the DECL_VALUE_EXPR to indirect through the
3963 frame copy of the pointer to the lambda closure object. */
3968 /* If a variable has a value expression, then that's what needs
3969 to be processed. */
3974 /* Make names depth+index unique, so that we can support nested
3975 scopes with identically named locals and still be able to
3976 identify them in the coroutine frame. */
3980 /* The outermost bind scope contains the artificial variables that
3981 we inject to implement the coro state machine. We want to be able
3982 to inspect these in debugging. */
3988 else
3990 serial++);
3992 /* TODO: Figure out if we should build a local type that has any
3993 excess alignment or size from the original decl. */
3997 /* We don't walk any of the local var sub-trees, they won't contain
3998 any bind exprs. */
3999 }
4005 }
4007 }
4009 /* Build, return FUNCTION_DECL node based on ORIG with a type FN_TYPE which has
4010 a single argument of type CORO_FRAME_PTR. Build the actor function if
4011 ACTOR_P is true, otherwise the destroy. */
4013 static tree
4016 {
4018 tree fn
4021 /* Allow for locating the ramp (original) function from this one. */
4037 /* Copy selected attributes from the original function. */
4041 /* Copy any alignment that the FE added. */
4044 /* Copy any alignment the user added. */
4046 /* Apply attributes from the original fn. */
4049 /* A void return. */
4056 /* This is a coroutine component. */
4059 /* Set up a means to find out if a decl is one of the helpers and, if so,
4060 which one. */
4062 {
4067 else
4069 }
4071 }
4073 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
4075 static tree
4078 tree resume_fn_ptr_type,
4080 {
4081 /* This will be our new outer scope. */
4087 /* If the function has a top level bind expression, then connect that
4088 after first making sure we give it a new block. */
4091 {
4096 /* Replace the top block to avoid issues with locations for args
4097 appearing to be in a non-existent place. */
4104 /* The top block has one child, so far, and we have now got a
4105 superblock. */
4108 }
4109 else
4110 {
4111 /* We are missing a top level BIND_EXPR. We need one to ensure that we
4112 don't shuffle around the coroutine frame and corrupt it. */
4116 /* Ensure we have a block to connect up the scopes. */
4121 }
4123 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
4124 are enabled. */
4128 /* [stmt.return.coroutine] / 3
4129 If p.return_void() is a valid expression, flowing off the end of a
4130 coroutine is equivalent to a co_return with no operand; otherwise
4131 flowing off the end of a coroutine results in undefined behavior. */
4132 tree return_void
4135 /* The pointer to the resume function. */
4136 tree resume_fn_ptr
4143 /* We will need to be able to set the resume function pointer to nullptr
4144 to signal that the coroutine is 'done'. */
4145 tree zero_resume
4148 /* The pointer to the destroy function. */
4155 /* The promise was created on demand when parsing we now link it into
4156 our scope. */
4164 /* We need a handle to this coroutine, which is passed to every
4165 await_suspend(). This was created on demand when parsing we now link it
4166 into our scope. */
4174 /* If we have function parms, then these will be copied to the coroutine
4175 frame. Create a local (proxy) variable for each parm, since the original
4176 parms will be out of scope once the ramp has finished. The proxy vars will
4177 get DECL_VALUE_EXPRs pointing to the frame copies, so that we can interact
4178 with them in the debugger. */
4180 {
4182 /* Add a local var for each parm. */
4185 {
4188 parm_i->copy_var
4196 }
4198 /* Now replace all uses of the parms in the function body with the proxy
4199 vars. We want to this to apply to every instance of param's use, so
4200 don't include a 'visited' hash_set on the tree walk, however we will
4201 arrange to visit each containing expression only once. */
4206 }
4208 /* We create a resume index, this is initialized in the ramp. */
4209 resume_idx_var
4216 /* If the coroutine has a frame that needs to be freed, this will be set by
4217 the ramp. */
4225 {
4226 /* Build promise.unhandled_exception(); */
4227 tree ueh
4229 coro_unhandled_exception_identifier,
4231 /* Create and initialize the initial-await-resume-called variable per
4232 [dcl.fct.def.coroutine] / 5.3. */
4233 tree i_a_r_c
4236 boolean_false_node);
4240 /* Start the try-catch. */
4245 {
4246 /* Build a compound expression that sets the
4247 initial-await-resume-called variable true and then calls the
4248 initial suspend expression await resume.
4249 In the case that the user decides to make the initial await
4250 await_resume() return a value, we need to discard it and, it is
4251 a reference type, look past the indirection. */
4258 boolean_true_node);
4261 }
4262 /* Add the initial await to the start of the user-authored function. */
4264 /* Append the original function body. */
4270 /* Mimic what the parser does for the catch. */
4274 /* Get the initial await resume called value. */
4279 /* If the initial await resume called value is false, rethrow... */
4288 /* ... else call the promise unhandled exception method
4289 but first we set done = true and the resume index to 0.
4290 If the unhandled exception method returns, then we continue
4291 to the final await expression (which duplicates the clearing of
4292 the field). */
4294 zero_resume);
4298 short_zero);
4303 }
4304 else
4305 {
4307 {
4308 /* We still try to look for the promise method and warn if it's not
4309 present. */
4310 tree ueh_meth
4315 coro_unhandled_exception_identifier,
4317 }
4318 /* Else we don't check and don't care if the method is missing..
4319 just add the initial suspend, function and return. */
4321 /* Append the original function body. */
4325 }
4327 /* co_return branches to the final_suspend label, so declare that now. */
4328 fs_label
4332 /* Before entering the final suspend point, we signal that this point has
4333 been reached by setting the resume function pointer to zero (this is
4334 what the 'done()' builtin tests) as per the current ABI. */
4336 zero_resume);
4344 }
4346 /* Here we:
4347 a) Check that the function and promise type are valid for a
4348 coroutine.
4349 b) Carry out the initial morph to create the skeleton of the
4350 coroutine ramp function and the rewritten body.
4352 Assumptions.
4354 1. We only hit this code once all dependencies are resolved.
4355 2. The function body will be either a bind expr or a statement list
4356 3. That cfun and current_function_decl are valid for the case we're
4357 expanding.
4358 4. 'input_location' will be of the final brace for the function.
4360 We do something like this:
4361 declare a dummy coro frame.
4362 struct _R_frame {
4363 using handle_type = coro::coroutine_handle<coro1::promise_type>;
4364 void (*_Coro_resume_fn)(_R_frame *);
4365 void (*_Coro_destroy_fn)(_R_frame *);
4366 coro1::promise_type _Coro_promise;
4367 bool _Coro_frame_needs_free; free the coro frame mem if set.
4368 bool _Coro_i_a_r_c; [dcl.fct.def.coroutine] / 5.3
4369 short _Coro_resume_index;
4370 handle_type _Coro_self_handle;
4371 parameter copies (were required).
4372 local variables saved (including awaitables)
4373 (maybe) trailing space.
4374 }; */
4376 bool
4378 {
4384 {
4385 /* For early errors, we do not want a diagnostic about the missing
4386 ramp return value, since the user cannot fix this - a 'return' is
4387 not allowed in a coroutine. */
4389 /* Discard the body, we can't process it further. */
4393 }
4395 /* We can't validly get here with an empty statement list, since there's no
4396 way for the FE to decide it's a coroutine in the absence of any code. */
4400 /* We don't have the locus of the opening brace - it's filled in later (and
4401 there doesn't really seem to be any easy way to get at it).
4402 The closing brace is assumed to be input_location. */
4406 /* Initial processing of the function-body.
4407 If we have no expressions or just an error then punt. */
4410 {
4413 /* Suppress warnings about the missing return value. */
4416 }
4418 /* So, we've tied off the original user-authored body in fn_body.
4420 Start the replacement synthesized ramp body as newbody.
4421 If we encounter a fatal error we might return a now-empty body.
4423 Note, the returned ramp body is not 'popped', to be compatible with
4424 the way that decl.cc handles regular functions, the scope pop is done
4425 in the caller. */
4430 /* If our original body is noexcept, then that's what we apply to our
4431 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4434 {
4435 /* The function body we will continue with is the single operand to
4436 the must-not-throw. */
4438 /* Transfer the must-not-throw to the ramp body. */
4440 /* Re-start the ramp as must-not-throw. */
4442 }
4444 /* If the original function has a return value with a non-trivial DTOR
4445 and the body contains a var with a DTOR that might throw, the decl is
4446 marked "throwing_cleanup".
4447 We do not [in the ramp, which is synthesised here], use any body var
4448 types with DTORs that might throw.
4449 The original body is transformed into the actor function which only
4450 contains void returns, and is also wrapped in a try-catch block.
4451 So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
4452 not need to transfer it to the actor which only contains void returns. */
4455 /* Create the coro frame type, as far as it can be known at this stage.
4456 1. Types we already know. */
4462 /* 2. Types we need to define or look up. */
4468 tree act_des_fn_type
4472 /* Declare the actor and destroyer function. */
4478 /* Construct the wrapped function body; we will analyze this to determine
4479 the requirements for the coroutine frame. */
4486 act_des_fn_ptr,
4488 /* Build our dummy coro frame layout. */
4491 /* The fields for the coro frame. */
4494 /* We need to know, and inspect, each suspend point in the function
4495 in several places. It's convenient to place this map out of line
4496 since it's used from tree walk callbacks. */
4499 /* Now insert the data for any body await points, at this time we also need
4500 to promote any temporaries that are captured by reference (to regular
4501 vars) they will get added to the coro frame along with other locals. */
4502 susp_frame_data body_aw_points
4510 /* 4. Now make space for local vars, this is conservative again, and we
4511 would expect to delete unused entries later. */
4513 local_vars_frame_data local_vars_data
4517 /* Tie off the struct for now, so that we can build offsets to the
4518 known entries. */
4526 /* Ramp: */
4527 /* Now build the ramp function pieces. */
4538 /* To signal that we need to cleanup copied function args. */
4542 {
4549 }
4551 /* Signal that we need to clean up the promise object on exception. */
4552 tree coro_promise_live
4558 /* When the get-return-object is in the RETURN slot, we need to arrange for
4559 cleanup on exception. */
4560 tree coro_gro_live
4567 /* Collected the scope vars we need ... only one for now. */
4570 /* We're now going to create a new top level scope block for the ramp
4571 function. */
4579 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4580 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4581 directly apparently). This avoids a "used uninitialized" warning. */
4587 {
4592 }
4596 /* The CO_FRAME internal function is a mechanism to allow the middle end
4597 to adjust the allocation in response to optimizations. We provide the
4598 current conservative estimate of the frame size (as per the current)
4599 computed layout. */
4601 tree resizeable
4605 /* [dcl.fct.def.coroutine] / 10 (part1)
4606 The unqualified-id get_return_object_on_allocation_failure is looked up
4607 in the scope of the promise type by class member access lookup. */
4609 /* We don't require this, so coro_build_promise_expression can return NULL,
4610 but, if the lookup succeeds, then the function must be usable. */
4612 tree grooaf
4614 coro_gro_on_allocation_fail_identifier,
4617 /* however, should that fail, returning an error, the later stages can't
4618 handle the erroneous expression, so we reset the call as if it was
4619 absent. */
4623 /* Allocate the frame, this has several possibilities:
4624 [dcl.fct.def.coroutine] / 9 (part 1)
4625 The allocation function’s name is looked up in the scope of the promise
4626 type. It's not a failure for it to be absent see part 4, below. */
4632 {
4635 /* [dcl.fct.def.coroutine] / 9 (part 2)
4636 If the lookup finds an allocation function in the scope of the promise
4637 type, overload resolution is performed on a function call created by
4638 assembling an argument list. The first argument is the amount of space
4639 requested, and has type std::size_t. The lvalues p1...pn are the
4640 succeeding arguments.. */
4646 {
4650 {
4651 /* We pass a reference to *this to the allocator lookup. */
4657 tf_warning_or_error);
4659 }
4660 else
4662 }
4664 /* Note the function selected; we test to see if it's NOTHROW. */
4665 tree func;
4666 /* Failure is not an error for this attempt. */
4672 {
4673 /* [dcl.fct.def.coroutine] / 9 (part 3)
4674 If no viable function is found, overload resolution is performed
4675 again on a function call created by passing just the amount of
4676 space required as an argument of type std::size_t. */
4680 tf_none);
4682 }
4684 /* However, if the promise provides an operator new, then one of these
4685 two options must be available. */
4687 {
4691 }
4697 " no usable %<get_return_object_on_allocation_failure%>"
4699 }
4701 {
4702 /* [dcl.fct.def.coroutine] / 9 (part 4)
4703 If this lookup fails, the allocation function’s name is looked up in
4704 the global scope. */
4707 /* build_operator_new_call () will insert size needed as element 0 of
4708 this, and we might need to append the std::nothrow constant. */
4711 {
4712 /* [dcl.fct.def.coroutine] / 10 (part 2)
4713 If any declarations (of the get return on allocation fail) are
4714 found, then the result of a call to an allocation function used
4715 to obtain storage for the coroutine state is assumed to return
4716 nullptr if it fails to obtain storage and, if a global allocation
4717 function is selected, the ::operator new(size_t, nothrow_t) form
4718 is used. The allocation function used in this case shall have a
4719 non-throwing noexcept-specification. So we need std::nothrow. */
4728 }
4730 /* If we get to this point, we must succeed in looking up the global
4731 operator new for the params provided. Extract a simplified version
4732 of the machinery from build_operator_new_call. This can update the
4733 frame size. */
4738 tf_warning_or_error);
4739 resizeable = build_call_expr_internal_loc
4741 /* If the operator call fails for some reason, then don't try to
4742 amend it. */
4747 }
4754 /* If the user provided a method to return an object on alloc fail, then
4755 check the returned pointer and call the func if it's null.
4756 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4759 {
4760 /* [dcl.fct.def.coroutine] / 10 (part 3)
4761 If the allocation function returns nullptr,the coroutine returns
4762 control to the caller of the coroutine and the return value is
4763 obtained by a call to T::get_return_object_on_allocation_failure(),
4764 where T is the promise type. */
4772 {
4773 /* Execute the get-return-object-on-alloc-fail call... */
4775 /* ... but discard the result, since we return void. */
4777 }
4778 else
4779 {
4780 /* Get the fallback return object. */
4783 }
4786 }
4788 /* Up to now any exception thrown will propagate directly to the caller.
4789 This is OK since the only source of such exceptions would be in allocation
4790 of the coroutine frame, and therefore the ramp will not have initialized
4791 any further state. From here, we will track state that needs explicit
4792 destruction in the case that promise or g.r.o setup fails or an exception
4793 is thrown from the initial suspend expression. */
4796 {
4800 }
4802 /* deref the frame pointer, to use in member access code. */
4805 /* For now, once allocation has succeeded we always assume that this needs
4806 destruction, there's no impl. for frame allocation elision. */
4815 /* Put the resumer and destroyer functions in. */
4818 tree resume_m
4827 tree destroy_m
4830 tree destroy_x
4832 tf_warning_or_error);
4836 /* [dcl.fct.def.coroutine] /13
4837 When a coroutine is invoked, a copy is created for each coroutine
4838 parameter. Each such copy is an object with automatic storage duration
4839 that is direct-initialized from an lvalue referring to the corresponding
4840 parameter if the parameter is an lvalue reference, and from an xvalue
4841 referring to it otherwise. A reference to a parameter in the function-
4842 body of the coroutine and in the call to the coroutine promise
4843 constructor is replaced by a reference to its copy. */
4847 /* The initialization and destruction of each parameter copy occurs in the
4848 context of the called coroutine. Initializations of parameter copies are
4849 sequenced before the call to the coroutine promise constructor and
4850 indeterminately sequenced with respect to each other. The lifetime of
4851 parameter copies ends immediately after the lifetime of the coroutine
4852 promise object ends. */
4857 {
4861 {
4867 tf_warning_or_error);
4868 tree fld_idx
4872 /* Add this to the promise CTOR arguments list, accounting for
4873 refs and special handling for method this ptr. */
4875 {
4876 /* We pass a reference to *this to the param preview. */
4884 tf_warning_or_error);
4886 }
4889 else
4893 /* Initialise the frame reference field directly. */
4896 else
4897 {
4900 tf_warning_or_error);
4901 }
4904 {
4908 /* Cleanup this frame copy on exception. */
4909 parm.fr_copy_dtor
4912 LOOKUP_NORMAL,
4913 tf_warning_or_error);
4915 {
4916 /* This var is now live. */
4921 }
4922 }
4923 }
4924 }
4926 /* Set up the promise. */
4927 tree promise_m
4936 {
4937 /* Do a placement new constructor for the promise type (we never call
4938 the new operator, just the constructor on the object in place in the
4939 frame).
4941 First try to find a constructor with the same parameter list as the
4942 original function (if it has params), failing that find a constructor
4943 with no parameter list. */
4946 {
4951 }
4952 else
4958 tf_warning_or_error);
4965 boolean_type_node);
4968 promise_dtor
4971 tf_warning_or_error);
4972 }
4974 /* Set up a new bind context for the GRO. */
4976 /* Make and connect the scope blocks. */
4983 tree get_ro
4985 coro_get_return_object_identifier,
4987 /* Without a return object we haven't got much clue what's going on. */
4989 {
4992 /* Suppress warnings about the missing return value. */
4995 }
5003 /* Used for return objects in the RESULT slot. */
5006 /* We have to sequence the call to get_return_object before initial
5007 suspend. */
5011 {
5012 /* [dcl.fct.def.coroutine] / 7
5013 The expression promise.get_return_object() is used to initialize the
5014 glvalue result or... (see below)
5015 Construct the return result directly. */
5017 {
5020 complete_ctor_identifier,
5022 tf_warning_or_error);
5024 }
5025 else
5029 /* If some part of the initalization code (prior to the await_resume
5030 of the initial suspend expression), then we need to clean up the
5031 return value. */
5032 gro_ret_dtor
5036 tf_warning_or_error);
5037 }
5038 else
5039 {
5040 /* ... or ... Construct an object that will be used as the single
5041 param to the CTOR for the return object. */
5043 NULL_TREE);
5047 tf_warning_or_error);
5048 /* The constructed object might require a cleanup. */
5050 {
5051 gro_cleanup_stmt
5054 tf_warning_or_error);
5057 }
5058 }
5064 /* If we have a live g.r.o in the return slot, then signal this for exception
5065 cleanup. */
5067 {
5070 boolean_type_node);
5072 }
5073 /* Initialize the resume_idx_var to 0, meaning "not started". */
5074 tree resume_idx_m
5077 tree resume_idx
5079 tf_warning_or_error);
5085 /* So .. call the actor .. */
5090 /* Switch to using 'input_location' as the loc, since we're now more
5091 logically doing things related to the end of the function. */
5093 /* The ramp is done, we just need the return value.
5094 [dcl.fct.def.coroutine] / 7
5095 The expression promise.get_return_object() is used to initialize the
5096 glvalue result or prvalue result object of a call to a coroutine.
5098 If the 'get return object' is non-void, then we built it before the
5099 promise was constructed. We now supply a reference to that var,
5100 either as the return value (if it's the same type) or to the CTOR
5101 for an object of the return type. */
5106 /* check_return_expr will automatically return gro as an rvalue via
5107 treat_lvalue_as_rvalue_p. */
5110 {
5111 /* For class type return objects, we can attempt to construct,
5112 even if the gro is void. ??? Citation ??? c++/100476 */
5116 tf_warning_or_error);
5118 }
5119 else
5120 {
5121 /* We can't initialize a non-class return value from void. */
5125 }
5130 {
5134 }
5136 /* Finish up the ramp function. */
5142 {
5147 /* If we have a live G.R.O in the return slot, then run its DTOR.
5148 When the return object is constructed from a separate g.r.o, this is
5149 already handled by its regular cleanup. */
5151 {
5160 }
5162 /* If the promise is live, then run its dtor if that's available. */
5164 {
5173 }
5175 /* Clean up any frame copies of parms with non-trivial dtors. */
5179 {
5184 {
5193 }
5194 }
5196 /* We always expect to delete the frame. */
5205 }
5210 /* Start to build the final functions.
5212 We push_deferring_access_checks to avoid these routines being seen as
5213 nested by the middle end; we are doing the outlining here. */
5217 /* Build the actor... */
5222 /* Destroyer ... */
5228 /* Link our new functions into the list. */
5239 }