| blob | a5464becf7f67347ff79f2d5c316586f69567e50 |
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. */
1356 }
1358 /* If the promise object doesn't have the correct return call then
1359 there's a mis-match between the co_return <expr> and this. */
1362 co_ret_call
1364 else
1365 {
1366 /* [class.copy.elision] / 3.
1367 An implicitly movable entity is a variable of automatic storage
1368 duration that is either a non-volatile object or an rvalue reference
1369 to a non-volatile object type. For such objects in the context of
1370 the co_return, the overload resolution should be carried out first
1371 treating the object as an rvalue, if that fails, then we fall back
1372 to regular overload resolution. */
1379 co_ret_call
1383 }
1385 /* Makes no sense for a co-routine really. */
1388 "function declared %<noreturn%> has a"
1394 }
1396 /* We need to validate the arguments to __builtin_coro_promise, since the
1397 second two must be constant, and the builtins machinery doesn't seem to
1398 deal with that properly. */
1400 tree
1402 {
1407 {
1412 {
1413 /* Argument 0 is already checked by the normal built-in machinery
1414 Argument 1 must be a constant of size type. It probably makes
1415 little sense if it's not a power of 2, but that isn't specified
1416 formally. */
1420 /* We expect alignof expressions in templates. */
1422 ;
1424 {
1428 }
1429 /* Argument 2 is the direction - to / from handle address to promise
1430 address. */
1434 {
1438 }
1441 }
1442 }
1443 }
1445 /* ================= Morph and Expand. =================
1447 The entry point here is morph_fn_to_coro () which is called from
1448 finish_function () when we have completed any template expansion.
1450 This is preceded by helper functions that implement the phases below.
1452 The process proceeds in four phases.
1454 A Initial framing.
1455 The user's function body is wrapped in the initial and final suspend
1456 points and we begin building the coroutine frame.
1457 We build empty decls for the actor and destroyer functions at this
1458 time too.
1459 When exceptions are enabled, the user's function body will also be
1460 wrapped in a try-catch block with the catch invoking the promise
1461 class 'unhandled_exception' method.
1463 B Analysis.
1464 The user's function body is analyzed to determine the suspend points,
1465 if any, and to capture local variables that might persist across such
1466 suspensions. In most cases, it is not necessary to capture compiler
1467 temporaries, since the tree-lowering nests the suspensions correctly.
1468 However, in the case of a captured reference, there is a lifetime
1469 extension to the end of the full expression - which can mean across a
1470 suspend point in which case it must be promoted to a frame variable.
1472 At the conclusion of analysis, we have a conservative frame layout and
1473 maps of the local variables to their frame entry points.
1475 C Build the ramp function.
1476 Carry out the allocation for the coroutine frame (NOTE; the actual size
1477 computation is deferred until late in the middle end to allow for future
1478 optimizations that will be allowed to elide unused frame entries).
1479 We build the return object.
1481 D Build and expand the actor and destroyer function bodies.
1482 The destroyer is a trivial shim that sets a bit to indicate that the
1483 destroy dispatcher should be used and then calls into the actor.
1485 The actor function is the implementation of the user's state machine.
1486 The current suspend point is noted in an index.
1487 Each suspend point is encoded as a pair of internal functions, one in
1488 the relevant dispatcher, and one representing the suspend point.
1490 During this process, the user's local variables and the proxies for the
1491 self-handle and the promise class instance are re-written to their
1492 coroutine frame equivalents.
1494 The complete bodies for the ramp, actor and destroy function are passed
1495 back to finish_function for folding and gimplification. */
1497 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1499 static tree
1501 {
1503 }
1505 static tree
1507 {
1510 }
1512 /* Helpers to build an artificial var, with location LOC, NAME and TYPE, in
1513 CTX, and with initializer INIT. */
1515 static tree
1517 tree init)
1518 {
1525 }
1527 static tree
1530 {
1533 }
1535 /* Helpers for label creation:
1536 1. Create a named label in the specified context. */
1538 static tree
1540 {
1548 }
1550 /* 2. Create a named label in the specified context. */
1552 static tree
1554 {
1561 }
1563 struct proxy_replace
1564 {
1566 };
1568 static tree
1570 {
1574 {
1577 }
1578 else
1581 }
1583 /* Support for expansion of co_await statements. */
1585 struct coro_aw_data
1586 {
1597 };
1599 /* Lightweight search for the first await expression in tree-walk order.
1600 returns:
1601 The first await expression found in STMT.
1602 NULL_TREE if there are none.
1603 So can be used to determine if the statement needs to be processed for
1604 awaits. */
1606 static tree
1608 {
1611 {
1614 }
1616 }
1618 /* Starting with a statement:
1620 stmt => some tree containing one or more await expressions.
1622 We replace the statement with:
1623 <STATEMENT_LIST> {
1624 initialize awaitable
1625 if (!ready)
1626 {
1627 suspension context.
1628 }
1629 resume:
1630 revised statement with one await expression rewritten to its
1631 await_resume() return value.
1632 }
1634 We then recurse into the initializer and the revised statement
1635 repeating this replacement until there are no more await expressions
1636 in either. */
1640 {
1667 tree r;
1672 else
1673 {
1676 /* We have an initializer, which might itself contain await exprs. */
1678 }
1680 /* Use the await_ready() call to test if we need to suspend. */
1682 /* Convert to bool, if necessary. */
1685 tf_warning_or_error);
1686 /* Be aggressive in folding here, since there are a significant number of
1687 cases where the ready condition is constant. */
1689 ready_cond
1695 susp_idx);
1699 /* Find out what we have to do with the awaiter's suspend method.
1700 [expr.await]
1701 (5.1) If the result of await-ready is false, the coroutine is considered
1702 suspended. Then:
1703 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1704 await-suspend.resume() is evaluated.
1705 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1706 and the coroutine is resumed if the result is false.
1707 (5.1.3) Otherwise, await-suspend is evaluated. */
1713 /* NOTE: final suspend can't resume; the "resume" label in that case
1714 corresponds to implicit destruction. */
1716 {
1717 /* We just call await_suspend() and hit the yield. */
1720 }
1722 {
1723 /* Boolean return, continue if the call returns false. */
1725 suspend
1729 empty_list);
1731 }
1732 else
1733 {
1736 void_coro_handle_type))
1742 }
1766 /* Implement the suspend, a scope exit without clean ups. */
1782 /* part of finish switch. */
1793 {
1796 tf_warning_or_error);
1798 }
1803 empty_list);
1807 /* Resume point. */
1811 /* This will produce the value (if one is provided) from the co_await
1812 expression. */
1815 /* Sink to await_resume call_expr. */
1820 /* Get a pointer to the revised statement. */
1823 {
1826 tf_warning_or_error);
1828 }
1831 /* Replace the original statement with the expansion. */
1834 /* Now, if the awaitable had an initializer, expand any awaits that might
1835 be embedded in it. */
1841 /* Expand any more await expressions in the original statement. */
1846 }
1848 /* Check to see if a statement contains at least one await expression, if
1849 so, then process that. */
1851 static tree
1853 {
1858 }
1860 static tree
1862 {
1865 /* Process a statement at a time. */
1869 {
1871 {
1876 }
1878 }
1880 {
1883 }
1885 /* Continue statement walk, where required. */
1887 }
1889 /* Suspend point hash_map. */
1891 struct suspend_point_info
1892 {
1893 /* coro frame field type. */
1894 tree awaitable_type;
1895 /* coro frame field name. */
1896 tree await_field_id;
1897 };
1901 struct await_xform_data
1902 {
1904 tree actor_frame;
1905 };
1907 /* When we built the await expressions, we didn't know the coro frame
1908 layout, therefore no idea where to find the promise or where to put
1909 the awaitables. Now we know these things, fill them in. */
1911 static tree
1913 {
1917 {
1920 }
1922 /* So, on entry, we have:
1923 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1924 We no longer need a [it had diagnostic value, maybe?]
1925 We need to replace the e_proxy in the awr_call. */
1929 /* If we have a frame var for the awaitable, get a reference to it. */
1930 proxy_replace data;
1932 {
1933 tree as_m
1938 tf_warning_or_error);
1940 /* Replace references to the instance proxy with the frame entry now
1941 computed. */
1946 /* .. and replace. */
1948 }
1951 }
1953 /* A wrapper for the transform_await_expr function so that it can be a
1954 callback from cp_walk_tree. */
1956 static tree
1958 {
1959 /* Set actor function as new DECL_CONTEXT of label_decl. */
1965 /* We should have already lowered co_yields to their co_await. */
1975 }
1977 /* This caches information that we determine about function params,
1978 their uses and copies in the coroutine frame. */
1980 struct param_info
1981 {
1995 };
1997 struct local_var_info
1998 {
1999 tree field_id;
2000 tree field_idx;
2001 tree frame_type;
2005 location_t def_loc;
2006 };
2008 /* For figuring out what local variable usage we have. */
2009 struct local_vars_transform
2010 {
2011 tree context;
2012 tree actor_frame;
2013 tree coro_frame_type;
2014 location_t loc;
2016 };
2018 static tree
2020 {
2023 /* For each var in this bind expr (that has a frame id, which means it was
2024 accessed), build a frame reference and add it as the DECL_VALUE_EXPR. */
2027 {
2028 tree lvar;
2031 {
2033 local_var_info &local_var
2037 /* Re-write the variable's context to be in the actor func. */
2040 /* For capture proxies, this could include the decl value expr. */
2044 /* TODO: implement selective generation of fields when vars are
2045 known not-used. */
2049 tree fld_ref
2052 tf_warning_or_error);
2058 }
2062 }
2064 }
2066 /* A helper to build the frame DTOR.
2067 [dcl.fct.def.coroutine] / 12
2068 The deallocation function’s name is looked up in the scope of the promise
2069 type. If this lookup fails, the deallocation function’s name is looked up
2070 in the global scope. If deallocation function lookup finds both a usual
2071 deallocation function with only a pointer parameter and a usual
2072 deallocation function with both a pointer parameter and a size parameter,
2073 then the selected deallocation function shall be the one with two
2074 parameters. Otherwise, the selected deallocation function shall be the
2075 function with one parameter. If no usual deallocation function is found
2076 the program is ill-formed. The selected deallocation function shall be
2077 called with the address of the block of storage to be reclaimed as its
2078 first argument. If a deallocation function with a parameter of type
2079 std::size_t is used, the size of the block is passed as the corresponding
2080 argument. */
2082 static tree
2085 {
2092 {
2093 /* Look for sized version first, since this takes precedence. */
2099 /* It's OK to fail for this one... */
2102 tf_none);
2105 {
2110 tf_none);
2111 }
2113 /* But one of them must succeed, or the program is ill-formed. */
2115 {
2119 }
2120 }
2121 else
2122 {
2126 tf_warning_or_error);
2129 }
2131 }
2133 /* The actor transform. */
2135 static void
2140 {
2142 /* Some things we inherit from the original function. */
2147 /* One param, the coro frame pointer. */
2150 /* We have a definition here. */
2163 NULL_TREE);
2168 /* Link in the block associated with the outer scope of the re-written
2169 function body. */
2181 /* The entry point for the actor code from the ramp. */
2182 tree actor_begin_label
2186 /* Declare the continuation handle. */
2189 /* Re-write local vars, similarly. */
2190 local_vars_transform xform_vars_data
2199 tree ret_label
2202 tree continue_label
2221 /* The destroy point numbered #1 is special, in that it is reached from a
2222 coroutine that is suspended after re-throwing from unhandled_exception().
2223 This label just invokes the cleanup of promise, param copies and the
2224 frame itself. */
2225 tree del_promise_label
2234 {
2240 l_num);
2246 }
2248 /* Insert the prototype dispatcher. */
2270 /* The final resume should be made to hit the default (trap, UB) entry
2271 although it will be unreachable via the normal entry point, since that
2272 is set to NULL on reaching final suspend. */
2274 {
2280 l_num);
2286 }
2288 /* Insert the prototype dispatcher. */
2297 /* actor's coroutine 'self handle'. */
2302 /* So construct the self-handle from the frame address. */
2315 /* Now we know the real promise, and enough about the frame layout to
2316 decide where to put things. */
2320 /* Transform the await expressions in the function body. Only do each
2321 await tree once! */
2325 /* Add in our function body with the co_returns rewritten to final form. */
2328 /* now do the tail of the function. */
2332 /* Destructors for the things we built explicitly. */
2335 tf_warning_or_error);
2338 tree del_frame_label
2343 /* Here deallocate the frame (if we allocated it), which we will have at
2344 present. */
2345 tree fnf_m
2356 {
2358 tree pid;
2360 {
2361 tree m
2366 tree dtor;
2367 dtor
2371 }
2372 }
2374 /* Build the frame DTOR. */
2384 /* done. */
2390 /* This is the suspend return point. */
2399 /* This is the 'continuation' return point. For such a case we have a coro
2400 handle (from the await_suspend() call) and we want handle.resume() to
2401 execute as a tailcall allowing arbitrary chaining of coroutines. */
2405 /* We want to force a tail-call even for O0/1, so this expands the resume
2406 call into its underlying implementation. */
2411 tree resume = build_call_expr_loc
2414 /* In order to support an arbitrary number of coroutine continuations,
2415 we must tail call them. However, some targets do not support indirect
2416 tail calls to arbitrary callees. See PR94359. */
2425 /* We've now rewritten the tree and added the initial and final
2426 co_awaits. Now pass over the tree and expand the co_awaits. */
2439 }
2441 /* The prototype 'destroy' function :
2442 frame->__Coro_resume_index |= 1;
2443 actor (frame); */
2445 static void
2447 tree actor)
2448 {
2449 /* One param, the coro frame pointer. */
2452 /* We have a definition here. */
2466 /* _resume_at |= 1 */
2473 /* So .. call the actor .. */
2478 /* done. */
2485 }
2487 /* Helper that returns an identifier for an appended extension to the
2488 current un-mangled function name. */
2490 static tree
2492 {
2493 /* Figure out the bits we need to generate names for the outlined things
2494 For consistency, this needs to behave the same way as
2495 ASM_FORMAT_PRIVATE_NAME does. */
2498 #ifndef NO_DOT_IN_LABEL
2500 #else
2501 #ifndef NO_DOLLAR_IN_LABEL
2503 #else
2506 #endif
2507 #endif
2515 {
2519 {
2522 }
2524 }
2525 else
2529 }
2531 /* Build an initial or final await initialized from the promise
2532 initial_suspend or final_suspend expression. */
2534 static tree
2536 {
2540 tree setup_call
2544 /* Check for noexcept on the final_suspend call. */
2549 /* So build the co_await for this */
2550 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2553 }
2555 /* Callback to record the essential data for each await point found in the
2556 function. */
2558 static bool
2560 {
2562 suspend_point_info &s
2565 {
2567 await_expr);
2569 }
2573 }
2575 /* This data set is used when analyzing statements for await expressions. */
2577 struct susp_frame_data
2578 {
2579 /* Function-wide. */
2587 /* Temporary values for one statement or expression being analyzed. */
2595 };
2597 /* If this is an await expression, then count it (both uniquely within the
2598 function and locally within a single statement). */
2600 static tree
2602 {
2605 /* We should have already lowered co_yields to their co_await. */
2611 /* Count how many awaits the current expression contains. */
2614 /* Each await suspend context is unique, this is a function-wide value. */
2617 /* Awaitables should either be user-locals or promoted to coroutine frame
2618 entries at this point, and their initializers should have been broken
2619 out. */
2627 /* Rewrite target expressions on the await_suspend () to remove extraneous
2628 cleanups for the awaitables, which are now promoted to frame vars and
2629 managed via that. */
2635 }
2637 /* There are cases where any await expression is relevant. */
2638 static tree
2640 {
2642 {
2647 }
2649 }
2651 static bool
2653 {
2662 }
2664 /* Structure to record sub-expressions that need to be handled by the
2665 statement flattener. */
2667 struct coro_interesting_subtree
2668 {
2671 };
2673 /* tree-walk callback that returns the first encountered sub-expression of
2674 a kind that needs to be handled specifically by the statement flattener. */
2676 static tree
2678 {
2682 {
2685 {
2688 }
2689 }
2693 {
2696 }
2699 }
2701 /* Node for a doubly-linked list of promoted variables and their
2702 initializers. When the initializer is a conditional expression
2703 the 'then' and 'else' clauses are represented by a linked list
2704 attached to then_cl and else_cl respectively. */
2706 struct var_nest_node
2707 {
2711 {
2716 }
2717 tree var;
2718 tree init;
2723 };
2725 /* This is called for single statements from the co-await statement walker.
2726 It checks to see if the statement contains any initializers for awaitables
2727 and if any of these capture items by reference. */
2729 static void
2732 {
2735 {
2737 /* Compound expressions must be flattened specifically. */
2739 {
2742 var_nest_node *ins
2744 /* The compiler (but not the user) can generate temporaries with
2745 uses in the second arm of a compound expr. */
2748 /* The two arms have been processed separately. */
2750 }
2752 /* Handle conditional expressions. */
2755 /* FALLTHROUGH */
2757 {
2760 {
2763 var_nest_node *ins
2769 }
2772 /* Reconstruct x = t ? y : z;
2773 as (void) t ? x = y : x = z; */
2777 /* We are allowed a void type throw in one or both of the cond
2778 expr arms. */
2781 {
2785 else
2787 }
2790 {
2794 else
2796 }
2798 }
2799 /* FALLTHROUGH */
2801 {
2804 /* If the condition contains an await expression, then we need to
2805 set that first and use a separate var. */
2807 {
2814 var_nest_node *ins
2818 }
2820 n->then_cl
2822 n->else_cl
2825 /* Point to the start of the flattened code. */
2832 }
2834 }
2840 {
2843 {
2844 /* Await expressions with initializers have a compiler-temporary
2845 as the awaitable. 'promote' this. */
2851 {
2855 {
2857 /* We can have non-lvalue-expressions here, but when we see
2858 a target expression, mark it as already used. */
2860 {
2862 gcc_checking_assert
2864 }
2865 }
2868 /* If this is a call and not a CTOR, then we didn't expect it. */
2869 gcc_checking_assert
2872 }
2878 }
2881 {
2882 /* We have a temporary; promote it, but allow for the idiom in code
2883 generated by the compiler like
2884 a = (target_expr produces temp, op uses temp). */
2897 tf_warning_or_error);
2898 /* Simplify for the case that we have an init containing the temp
2899 alone. */
2901 {
2909 }
2910 else
2911 {
2912 var_nest_node *ins
2914 /* We have to replace the target expr... */
2916 /* ... and any uses of its var. */
2919 /* Compiler-generated temporaries can also have uses in
2920 following arms of compound expressions, which will be listed
2921 in 'replace_in' if present. */
2926 }
2928 }
2930 }
2931 }
2933 /* Helper for 'process_conditional' that handles recursion into nested
2934 conditionals. */
2936 static void
2939 {
2940 do
2941 {
2943 {
2946 {
2950 {
2951 /* We didn't see this var before and it needs a DTOR, so
2952 build a guard variable for it. */
2957 boolean_type_node);
2960 }
2962 /* The initializer for this variable is replaced by a compound
2963 expression that performs the init and then records that the
2964 variable is live (and the DTOR should be run at the scope
2965 exit. */
2967 n->init
2969 }
2970 }
2972 {
2979 tree new_if
2983 }
2984 else
2988 }
2990 /* helper for 'maybe_promote_temps'.
2992 When we have a conditional expression which might embed await expressions
2993 and/or promoted variables, we need to handle it appropriately.
2995 The linked lists for the 'then' and 'else' clauses in a conditional node
2996 identify the promoted variables (but these cannot be wrapped in a regular
2997 cleanup).
2999 So recurse through the lists and build up a composite list of captured vars.
3000 Declare these and any guard variables needed to decide if a DTOR should be
3001 run. Then embed the conditional into a try-finally expression that handles
3002 running each DTOR conditionally on its guard variable. */
3004 static void
3006 {
3016 /* Declare the vars. There are two loops so that the boolean flags are
3017 grouped in the frame. */
3019 {
3024 }
3025 /* Define the guard flags for variables that need a DTOR. */
3027 {
3030 {
3035 }
3036 }
3037 tree new_if
3040 /* Build a set of conditional DTORs. */
3043 {
3049 tree cleanup
3052 tf_warning_or_error);
3058 }
3060 tree try_finally
3063 }
3065 /* Given *STMT, that contains at least one await expression.
3067 The full expression represented in the original source code will contain
3068 suspension points, but it is still required that the lifetime of temporary
3069 values extends to the end of the expression.
3071 We already have a mechanism to 'promote' user-authored local variables
3072 to a coroutine frame counterpart (which allows explicit management of the
3073 lifetime across suspensions). The transform here re-writes STMT into
3074 a bind expression, promotes temporary values into local variables in that
3075 and flattens the statement into a series of cleanups.
3077 Conditional expressions are re-written to regular 'if' statements.
3078 The cleanups for variables initialized inside a conditional (including
3079 nested cases) are wrapped in a try-finally clause, with guard variables
3080 to determine which DTORs need to be run. */
3082 static tree
3084 {
3089 /* Strip off uninteresting wrappers. */
3099 /* We walk the statement trees, flattening it into an ordered list of
3100 variables with initializers and fragments corresponding to compound
3101 expressions, truth or/and if and ternary conditionals. Conditional
3102 expressions carry a nested list of fragments for the then and else
3103 clauses. We anchor to the 'bottom' of the fragment list; we will write
3104 a cleanup nest with one shell for each variable initialized. */
3106 /* Check to see we didn't promote one twice. */
3114 /* We build the bind scope expression from the bottom-up.
3115 EXPR_LIST holds the inner expression nest at the current cleanup
3116 level (becoming the final expression list when we've exhausted the
3117 number of sub-expression fragments). */
3119 do
3120 {
3122 /* When we have a promoted variable, then add that to the bind scope
3123 and initialize it. When there's no promoted variable, we just need
3124 to run the initializer.
3125 If the initializer is a conditional expression, we need to collect
3126 and declare any promoted variables nested within it. DTORs for such
3127 variables must be run conditionally too. */
3129 {
3136 else
3140 {
3141 tree cleanup
3144 tf_warning_or_error);
3147 }
3149 {
3154 }
3155 }
3156 else
3157 {
3160 else
3163 {
3168 }
3169 }
3176 /* Now produce the bind expression containing the 'promoted' temporaries
3177 as its variable list, and the cleanup nest as the statement. */
3184 {
3187 {
3191 }
3192 }
3199 }
3201 /* Lightweight callback to determine two key factors:
3202 1) If the statement/expression contains any await expressions.
3203 2) If the statement/expression potentially requires a re-write to handle
3204 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3205 so that the await expressions are not processed in the case of the
3206 short-circuit arm.
3208 CO_YIELD expressions are re-written to their underlying co_await. */
3210 static tree
3212 {
3216 {
3219 /* co_yield is syntactic sugar, re-write it to co_await. */
3221 /* FALLTHROUGH */
3224 /* A non-null initializer for the awaiter means we need to expand. */
3230 {
3231 /* We don't need special action for awaits in the always-executed
3232 arm of a TRUTH_IF. */
3236 /* However, if there are await expressions on the conditionally
3237 executed branch, we must expand the TRUTH_IF to ensure that the
3238 expanded await expression control-flow is fully contained in the
3239 conditionally executed code. */
3245 {
3248 }
3249 /* We've done the sub-trees here. */
3251 }
3253 }
3256 }
3258 /* Given *EXPR
3259 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3260 the conditionally executed branch, change this in a ternary operator.
3262 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3263 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3265 Apply this recursively to the condition and the conditionally-exec
3266 branch. */
3270 tree scratch_var;
3272 };
3274 static tree
3276 {
3281 {
3285 /* FALLTHROUGH */
3287 {
3292 /* Transform truth expression into a cond expression with
3293 * the always-executed arm as the condition.
3294 * the conditionally-executed arm as the then clause.
3295 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3301 tree cond_expr
3311 /* We've manually processed necessary sub-trees here. */
3313 }
3315 }
3317 }
3319 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3320 name is made up from NAM_ROOT, NAM_VERS. */
3322 static tree
3325 {
3327 /* Build a variable to hold the condition, this will be included in the
3328 frame as a local var. */
3335 }
3337 /* Helper to build and add if (!cond) break; */
3339 static void
3341 {
3348 }
3350 /* Tree walk callback to replace continue statements with goto label. */
3351 static tree
3353 {
3364 {
3365 /* Unless it's a special case, just walk the subtrees as usual. */
3369 {
3372 /* re-write a continue to goto label. */
3376 }
3378 /* Statements that do not require recursion. */
3385 /* These must break recursion. */
3391 }
3392 }
3394 /* Tree walk callback to analyze, register and pre-process statements that
3395 contain await expressions. */
3397 static tree
3399 {
3403 /* Process a statement at a time. */
3405 {
3406 /* For conditional expressions, we might wish to add an artificial var
3407 to their containing bind expr. */
3409 /* We might need to insert a new bind expression, and want to link it
3410 into the correct scope, so keep a note of the current block scope. */
3419 }
3421 {
3423 {
3428 }
3431 }
3433 /* We have something to be handled as a single statement. We have to handle
3434 a few statements specially where await statements have to be moved out of
3435 constructs. */
3443 {
3444 /* Unless it's a special case, just walk the subtrees as usual. */
3447 /* When we have a conditional expression, which contains one or more
3448 await expressions, we have to break the condition out into a
3449 regular statement so that the control flow introduced by the await
3450 transforms can be implemented. */
3452 {
3455 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3456 bool cond = cond with awaits.
3457 if (cond) then stmt1 else stmt2. */
3459 /* We treat the condition as if it was a stand-alone statement,
3460 to see if there are any await expressions which will be analyzed
3461 and registered. */
3476 /* We want to initialize the new variable with the expression
3477 that contains the await(s) and potentially also needs to
3478 have truth_if expressions expanded. */
3484 /* So now walk the new statement list. */
3488 }
3491 {
3494 /* for loops only need special treatment if the condition or the
3495 iteration expression contain a co_await. */
3497 /* At present, the FE always generates a separate initializer for
3498 the FOR_INIT_STMT, when the expression has an await. Check that
3499 this assumption holds in the future. */
3500 gcc_checking_assert
3505 bool for_cond_await
3510 bool for_expr_await
3514 /* If the condition has an await, then we will need to rewrite the
3515 loop as
3516 for (init expression;true;iteration expression) {
3517 condition = await expression;
3518 if (condition)
3519 break;
3520 ...
3521 }
3522 */
3524 {
3526 /* This will be expanded when the revised body is handled. */
3528 /* .. add the original for body. */
3530 /* To make the new for body. */
3533 }
3534 /* If the iteration expression has an await, it's a bit more
3535 tricky.
3536 for (init expression;condition;) {
3537 ...
3538 iteration_expr_label:
3539 iteration expression with await;
3540 }
3541 but, then we will need to re-write any continue statements into
3542 'goto iteration_expr_label:'.
3543 */
3545 {
3548 /* The original for body. */
3551 tree it_expr_label
3556 /* Present the iteration expression as a statement. */
3563 /* rewrite continue statements to goto label. */
3568 }
3570 /* So now walk the body statement (list), if there were no await
3571 expressions, then this handles the original body - and either
3572 way we will have finished with this statement. */
3577 }
3580 {
3581 /* We turn 'while (cond with awaits) stmt' into
3582 while (true) {
3583 if (!(cond with awaits))
3584 break;
3585 stmt..
3586 } */
3596 /* The original while body. */
3598 /* The new while body. */
3601 /* So now walk the new statement list. */
3606 }
3609 {
3610 /* We turn do stmt while (cond with awaits) into:
3611 do {
3612 stmt..
3613 if (!(cond with awaits))
3614 break;
3615 } while (true); */
3624 /* The original do stmt body. */
3627 /* The new while body. */
3630 /* So now walk the new statement list. */
3635 }
3638 {
3639 /* We turn 'switch (cond with awaits) stmt' into
3640 switch_type cond = cond with awaits
3641 switch (cond) stmt. */
3650 /* Build a variable to hold the condition, this will be
3651 included in the frame as a local var. */
3664 cond_inner);
3667 /* Now add the switch statement with the condition re-
3668 written to use the local var. */
3671 /* Process the expanded list. */
3676 }
3679 {
3680 /* Expand the co_return as per [stmt.return.coroutine]
3681 - for co_return;
3682 { p.return_void (); goto final_suspend; }
3683 - for co_return [void expr];
3684 { expr; p.return_void(); goto final_suspend;}
3685 - for co_return [non void expr];
3686 { p.return_value(expr); goto final_suspend; } */
3691 /* [stmt.return.coroutine], 2.2
3692 If expr is present and void, it is placed immediately before
3693 the call for return_void; */
3696 /* Insert p.return_{void,value(expr)}. */
3702 /* Once this is complete, we will have processed subtrees. */
3705 }
3708 {
3709 /* [expr.await] An await-expression shall appear only in a
3710 potentially-evaluated expression within the compound-statement
3711 of a function-body outside of a handler. */
3720 }
3722 }
3724 {
3743 {
3744 /* If a truth-and/or-if expression has an await expression in the
3745 conditionally-taken branch, then it must be rewritten into a
3746 regular conditional. */
3750 }
3751 /* Process this statement, which contains at least one await expression
3752 to 'promote' temporary values to a coroutine frame slot. */
3754 }
3755 /* Continue recursion, if needed. */
3757 }
3759 /* For figuring out what param usage we have. */
3761 struct param_frame_data
3762 {
3766 location_t loc;
3768 };
3770 /* A tree walk callback that rewrites each parm use to the local variable
3771 that represents its copy in the frame. */
3773 static tree
3775 {
3778 /* For lambda closure content, we have to look specifically. */
3780 {
3783 }
3788 /* If we already saw the containing expression, then we're done. */
3798 }
3800 /* Build up a set of info that determines how each param copy will be
3801 handled. */
3805 {
3811 /* Build a hash map with an entry for each param.
3812 The key is the param tree.
3813 Then we have an entry for the frame field name.
3814 Then a cache for the field ref when we come to use it.
3815 Then a tree list of the uses.
3816 The second two entries start out empty - and only get populated
3817 when we see uses. */
3822 {
3834 {
3835 /* If the user passes by reference, then we will save the
3836 pointer to the original. As noted in
3837 [dcl.fct.def.coroutine] / 13, if the lifetime of the
3838 referenced item ends and then the coroutine is resumed,
3839 we have UB; well, the user asked for it. */
3842 else
3844 }
3855 {
3859 }
3863 {
3866 parm.guard_var
3869 boolean_false_node);
3872 }
3873 else
3875 }
3878 }
3880 /* Small helper for the repetitive task of adding a new field to the coro
3881 frame type. */
3883 static tree
3885 location_t loc)
3886 {
3892 }
3894 /* For recording local variable usage. */
3896 struct local_vars_frame_data
3897 {
3901 location_t loc;
3904 };
3906 /* A tree-walk callback that processes one bind expression noting local
3907 variables, and making a coroutine frame slot available for those that
3908 need it, so that they can be 'promoted' across suspension points. */
3910 static tree
3912 {
3915 /* As we enter a bind expression - record the vars there and then recurse.
3916 As we exit drop the nest depth.
3917 The bind index is a growing count of how many bind indices we've seen.
3918 We build a space in the frame for each local var. */
3921 {
3922 tree lvar;
3926 {
3928 local_var_info &local_var
3936 /* Make sure that we only present vars to the tests below. */
3941 /* We don't move static vars into the frame. */
3946 poly_uint64 size;
3949 {
3952 /* Ignore it, this is broken anyway. */
3954 }
3957 /* If this var is a lambda capture proxy, we want to leave it alone,
3958 and later rewrite the DECL_VALUE_EXPR to indirect through the
3959 frame copy of the pointer to the lambda closure object. */
3964 /* If a variable has a value expression, then that's what needs
3965 to be processed. */
3970 /* Make names depth+index unique, so that we can support nested
3971 scopes with identically named locals and still be able to
3972 identify them in the coroutine frame. */
3976 /* The outermost bind scope contains the artificial variables that
3977 we inject to implement the coro state machine. We want to be able
3978 to inspect these in debugging. */
3984 else
3986 serial++);
3988 /* TODO: Figure out if we should build a local type that has any
3989 excess alignment or size from the original decl. */
3993 /* We don't walk any of the local var sub-trees, they won't contain
3994 any bind exprs. */
3995 }
4001 }
4003 }
4005 /* Build, return FUNCTION_DECL node based on ORIG with a type FN_TYPE which has
4006 a single argument of type CORO_FRAME_PTR. Build the actor function if
4007 ACTOR_P is true, otherwise the destroy. */
4009 static tree
4012 {
4014 tree fn
4017 /* Allow for locating the ramp (original) function from this one. */
4033 /* Copy selected attributes from the original function. */
4037 /* Copy any alignment that the FE added. */
4040 /* Copy any alignment the user added. */
4042 /* Apply attributes from the original fn. */
4045 /* A void return. */
4052 /* This is a coroutine component. */
4055 /* Set up a means to find out if a decl is one of the helpers and, if so,
4056 which one. */
4058 {
4063 else
4065 }
4067 }
4069 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
4071 static tree
4074 tree resume_fn_ptr_type,
4076 {
4077 /* This will be our new outer scope. */
4083 /* If the function has a top level bind expression, then connect that
4084 after first making sure we give it a new block. */
4087 {
4092 /* Replace the top block to avoid issues with locations for args
4093 appearing to be in a non-existent place. */
4100 /* The top block has one child, so far, and we have now got a
4101 superblock. */
4104 }
4105 else
4106 {
4107 /* We are missing a top level BIND_EXPR. We need one to ensure that we
4108 don't shuffle around the coroutine frame and corrupt it. */
4112 /* Ensure we have a block to connect up the scopes. */
4117 }
4119 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
4120 are enabled. */
4124 /* [stmt.return.coroutine] / 3
4125 If p.return_void() is a valid expression, flowing off the end of a
4126 coroutine is equivalent to a co_return with no operand; otherwise
4127 flowing off the end of a coroutine results in undefined behavior. */
4128 tree return_void
4131 /* The pointer to the resume function. */
4132 tree resume_fn_ptr
4139 /* We will need to be able to set the resume function pointer to nullptr
4140 to signal that the coroutine is 'done'. */
4141 tree zero_resume
4144 /* The pointer to the destroy function. */
4151 /* The promise was created on demand when parsing we now link it into
4152 our scope. */
4160 /* We need a handle to this coroutine, which is passed to every
4161 await_suspend(). This was created on demand when parsing we now link it
4162 into our scope. */
4170 /* If we have function parms, then these will be copied to the coroutine
4171 frame. Create a local (proxy) variable for each parm, since the original
4172 parms will be out of scope once the ramp has finished. The proxy vars will
4173 get DECL_VALUE_EXPRs pointing to the frame copies, so that we can interact
4174 with them in the debugger. */
4176 {
4178 /* Add a local var for each parm. */
4181 {
4184 parm_i->copy_var
4192 }
4194 /* Now replace all uses of the parms in the function body with the proxy
4195 vars. We want to this to apply to every instance of param's use, so
4196 don't include a 'visited' hash_set on the tree walk, however we will
4197 arrange to visit each containing expression only once. */
4202 }
4204 /* We create a resume index, this is initialized in the ramp. */
4205 resume_idx_var
4212 /* If the coroutine has a frame that needs to be freed, this will be set by
4213 the ramp. */
4221 {
4222 /* Build promise.unhandled_exception(); */
4223 tree ueh
4225 coro_unhandled_exception_identifier,
4227 /* Create and initialize the initial-await-resume-called variable per
4228 [dcl.fct.def.coroutine] / 5.3. */
4229 tree i_a_r_c
4232 boolean_false_node);
4236 /* Start the try-catch. */
4241 {
4242 /* Build a compound expression that sets the
4243 initial-await-resume-called variable true and then calls the
4244 initial suspend expression await resume.
4245 In the case that the user decides to make the initial await
4246 await_resume() return a value, we need to discard it and, it is
4247 a reference type, look past the indirection. */
4254 boolean_true_node);
4257 }
4258 /* Add the initial await to the start of the user-authored function. */
4260 /* Append the original function body. */
4266 /* Mimic what the parser does for the catch. */
4270 /* Get the initial await resume called value. */
4275 /* If the initial await resume called value is false, rethrow... */
4284 /* ... else call the promise unhandled exception method
4285 but first we set done = true and the resume index to 0.
4286 If the unhandled exception method returns, then we continue
4287 to the final await expression (which duplicates the clearing of
4288 the field). */
4290 zero_resume);
4294 short_zero);
4299 }
4300 else
4301 {
4303 {
4304 /* We still try to look for the promise method and warn if it's not
4305 present. */
4306 tree ueh_meth
4311 coro_unhandled_exception_identifier,
4313 }
4314 /* Else we don't check and don't care if the method is missing..
4315 just add the initial suspend, function and return. */
4317 /* Append the original function body. */
4321 }
4323 /* co_return branches to the final_suspend label, so declare that now. */
4324 fs_label
4328 /* Before entering the final suspend point, we signal that this point has
4329 been reached by setting the resume function pointer to zero (this is
4330 what the 'done()' builtin tests) as per the current ABI. */
4332 zero_resume);
4340 }
4342 /* Here we:
4343 a) Check that the function and promise type are valid for a
4344 coroutine.
4345 b) Carry out the initial morph to create the skeleton of the
4346 coroutine ramp function and the rewritten body.
4348 Assumptions.
4350 1. We only hit this code once all dependencies are resolved.
4351 2. The function body will be either a bind expr or a statement list
4352 3. That cfun and current_function_decl are valid for the case we're
4353 expanding.
4354 4. 'input_location' will be of the final brace for the function.
4356 We do something like this:
4357 declare a dummy coro frame.
4358 struct _R_frame {
4359 using handle_type = coro::coroutine_handle<coro1::promise_type>;
4360 void (*_Coro_resume_fn)(_R_frame *);
4361 void (*_Coro_destroy_fn)(_R_frame *);
4362 coro1::promise_type _Coro_promise;
4363 bool _Coro_frame_needs_free; free the coro frame mem if set.
4364 bool _Coro_i_a_r_c; [dcl.fct.def.coroutine] / 5.3
4365 short _Coro_resume_index;
4366 handle_type _Coro_self_handle;
4367 parameter copies (were required).
4368 local variables saved (including awaitables)
4369 (maybe) trailing space.
4370 }; */
4372 bool
4374 {
4380 {
4381 /* For early errors, we do not want a diagnostic about the missing
4382 ramp return value, since the user cannot fix this - a 'return' is
4383 not allowed in a coroutine. */
4385 /* Discard the body, we can't process it further. */
4389 }
4391 /* We can't validly get here with an empty statement list, since there's no
4392 way for the FE to decide it's a coroutine in the absence of any code. */
4396 /* We don't have the locus of the opening brace - it's filled in later (and
4397 there doesn't really seem to be any easy way to get at it).
4398 The closing brace is assumed to be input_location. */
4402 /* Initial processing of the function-body.
4403 If we have no expressions or just an error then punt. */
4406 {
4409 /* Suppress warnings about the missing return value. */
4412 }
4414 /* So, we've tied off the original user-authored body in fn_body.
4416 Start the replacement synthesized ramp body as newbody.
4417 If we encounter a fatal error we might return a now-empty body.
4419 Note, the returned ramp body is not 'popped', to be compatible with
4420 the way that decl.cc handles regular functions, the scope pop is done
4421 in the caller. */
4426 /* If our original body is noexcept, then that's what we apply to our
4427 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4430 {
4431 /* The function body we will continue with is the single operand to
4432 the must-not-throw. */
4434 /* Transfer the must-not-throw to the ramp body. */
4436 /* Re-start the ramp as must-not-throw. */
4438 }
4440 /* If the original function has a return value with a non-trivial DTOR
4441 and the body contains a var with a DTOR that might throw, the decl is
4442 marked "throwing_cleanup".
4443 We do not [in the ramp, which is synthesised here], use any body var
4444 types with DTORs that might throw.
4445 The original body is transformed into the actor function which only
4446 contains void returns, and is also wrapped in a try-catch block.
4447 So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
4448 not need to transfer it to the actor which only contains void returns. */
4451 /* Create the coro frame type, as far as it can be known at this stage.
4452 1. Types we already know. */
4458 /* 2. Types we need to define or look up. */
4464 tree act_des_fn_type
4468 /* Declare the actor and destroyer function. */
4474 /* Construct the wrapped function body; we will analyze this to determine
4475 the requirements for the coroutine frame. */
4482 act_des_fn_ptr,
4484 /* Build our dummy coro frame layout. */
4487 /* The fields for the coro frame. */
4490 /* We need to know, and inspect, each suspend point in the function
4491 in several places. It's convenient to place this map out of line
4492 since it's used from tree walk callbacks. */
4495 /* Now insert the data for any body await points, at this time we also need
4496 to promote any temporaries that are captured by reference (to regular
4497 vars) they will get added to the coro frame along with other locals. */
4498 susp_frame_data body_aw_points
4506 /* 4. Now make space for local vars, this is conservative again, and we
4507 would expect to delete unused entries later. */
4509 local_vars_frame_data local_vars_data
4513 /* Tie off the struct for now, so that we can build offsets to the
4514 known entries. */
4522 /* Ramp: */
4523 /* Now build the ramp function pieces. */
4534 /* To signal that we need to cleanup copied function args. */
4538 {
4545 }
4547 /* Signal that we need to clean up the promise object on exception. */
4548 tree coro_promise_live
4554 /* When the get-return-object is in the RETURN slot, we need to arrange for
4555 cleanup on exception. */
4556 tree coro_gro_live
4563 /* Collected the scope vars we need ... only one for now. */
4566 /* We're now going to create a new top level scope block for the ramp
4567 function. */
4575 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4576 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4577 directly apparently). This avoids a "used uninitialized" warning. */
4583 {
4588 }
4592 /* The CO_FRAME internal function is a mechanism to allow the middle end
4593 to adjust the allocation in response to optimizations. We provide the
4594 current conservative estimate of the frame size (as per the current)
4595 computed layout. */
4597 tree resizeable
4601 /* [dcl.fct.def.coroutine] / 10 (part1)
4602 The unqualified-id get_return_object_on_allocation_failure is looked up
4603 in the scope of the promise type by class member access lookup. */
4605 /* We don't require this, so coro_build_promise_expression can return NULL,
4606 but, if the lookup succeeds, then the function must be usable. */
4608 tree grooaf
4610 coro_gro_on_allocation_fail_identifier,
4613 /* however, should that fail, returning an error, the later stages can't
4614 handle the erroneous expression, so we reset the call as if it was
4615 absent. */
4619 /* Allocate the frame, this has several possibilities:
4620 [dcl.fct.def.coroutine] / 9 (part 1)
4621 The allocation function’s name is looked up in the scope of the promise
4622 type. It's not a failure for it to be absent see part 4, below. */
4628 {
4631 /* [dcl.fct.def.coroutine] / 9 (part 2)
4632 If the lookup finds an allocation function in the scope of the promise
4633 type, overload resolution is performed on a function call created by
4634 assembling an argument list. The first argument is the amount of space
4635 requested, and has type std::size_t. The lvalues p1...pn are the
4636 succeeding arguments.. */
4642 {
4646 {
4647 /* We pass a reference to *this to the allocator lookup. */
4653 tf_warning_or_error);
4655 }
4656 else
4658 }
4660 /* Note the function selected; we test to see if it's NOTHROW. */
4661 tree func;
4662 /* Failure is not an error for this attempt. */
4668 {
4669 /* [dcl.fct.def.coroutine] / 9 (part 3)
4670 If no viable function is found, overload resolution is performed
4671 again on a function call created by passing just the amount of
4672 space required as an argument of type std::size_t. */
4676 tf_none);
4678 }
4680 /* However, if the promise provides an operator new, then one of these
4681 two options must be available. */
4683 {
4687 }
4693 " no usable %<get_return_object_on_allocation_failure%>"
4695 }
4697 {
4698 /* [dcl.fct.def.coroutine] / 9 (part 4)
4699 If this lookup fails, the allocation function’s name is looked up in
4700 the global scope. */
4703 /* build_operator_new_call () will insert size needed as element 0 of
4704 this, and we might need to append the std::nothrow constant. */
4707 {
4708 /* [dcl.fct.def.coroutine] / 10 (part 2)
4709 If any declarations (of the get return on allocation fail) are
4710 found, then the result of a call to an allocation function used
4711 to obtain storage for the coroutine state is assumed to return
4712 nullptr if it fails to obtain storage and, if a global allocation
4713 function is selected, the ::operator new(size_t, nothrow_t) form
4714 is used. The allocation function used in this case shall have a
4715 non-throwing noexcept-specification. So we need std::nothrow. */
4724 }
4726 /* If we get to this point, we must succeed in looking up the global
4727 operator new for the params provided. Extract a simplified version
4728 of the machinery from build_operator_new_call. This can update the
4729 frame size. */
4734 tf_warning_or_error);
4735 resizeable = build_call_expr_internal_loc
4737 /* If the operator call fails for some reason, then don't try to
4738 amend it. */
4743 }
4750 /* If the user provided a method to return an object on alloc fail, then
4751 check the returned pointer and call the func if it's null.
4752 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4755 {
4756 /* [dcl.fct.def.coroutine] / 10 (part 3)
4757 If the allocation function returns nullptr,the coroutine returns
4758 control to the caller of the coroutine and the return value is
4759 obtained by a call to T::get_return_object_on_allocation_failure(),
4760 where T is the promise type. */
4768 {
4769 /* Execute the get-return-object-on-alloc-fail call... */
4771 /* ... but discard the result, since we return void. */
4773 }
4774 else
4775 {
4776 /* Get the fallback return object. */
4779 }
4782 }
4784 /* Up to now any exception thrown will propagate directly to the caller.
4785 This is OK since the only source of such exceptions would be in allocation
4786 of the coroutine frame, and therefore the ramp will not have initialized
4787 any further state. From here, we will track state that needs explicit
4788 destruction in the case that promise or g.r.o setup fails or an exception
4789 is thrown from the initial suspend expression. */
4792 {
4796 }
4798 /* deref the frame pointer, to use in member access code. */
4801 /* For now, once allocation has succeeded we always assume that this needs
4802 destruction, there's no impl. for frame allocation elision. */
4811 /* Put the resumer and destroyer functions in. */
4814 tree resume_m
4823 tree destroy_m
4826 tree destroy_x
4828 tf_warning_or_error);
4832 /* [dcl.fct.def.coroutine] /13
4833 When a coroutine is invoked, a copy is created for each coroutine
4834 parameter. Each such copy is an object with automatic storage duration
4835 that is direct-initialized from an lvalue referring to the corresponding
4836 parameter if the parameter is an lvalue reference, and from an xvalue
4837 referring to it otherwise. A reference to a parameter in the function-
4838 body of the coroutine and in the call to the coroutine promise
4839 constructor is replaced by a reference to its copy. */
4843 /* The initialization and destruction of each parameter copy occurs in the
4844 context of the called coroutine. Initializations of parameter copies are
4845 sequenced before the call to the coroutine promise constructor and
4846 indeterminately sequenced with respect to each other. The lifetime of
4847 parameter copies ends immediately after the lifetime of the coroutine
4848 promise object ends. */
4853 {
4857 {
4863 tf_warning_or_error);
4864 tree fld_idx
4868 /* Add this to the promise CTOR arguments list, accounting for
4869 refs and special handling for method this ptr. */
4871 {
4872 /* We pass a reference to *this to the param preview. */
4880 tf_warning_or_error);
4882 }
4885 else
4889 /* Initialise the frame reference field directly. */
4892 else
4893 {
4896 tf_warning_or_error);
4897 }
4900 {
4904 /* Cleanup this frame copy on exception. */
4905 parm.fr_copy_dtor
4908 LOOKUP_NORMAL,
4909 tf_warning_or_error);
4911 {
4912 /* This var is now live. */
4917 }
4918 }
4919 }
4920 }
4922 /* Set up the promise. */
4923 tree promise_m
4932 {
4933 /* Do a placement new constructor for the promise type (we never call
4934 the new operator, just the constructor on the object in place in the
4935 frame).
4937 First try to find a constructor with the same parameter list as the
4938 original function (if it has params), failing that find a constructor
4939 with no parameter list. */
4942 {
4947 }
4948 else
4954 tf_warning_or_error);
4961 boolean_type_node);
4964 promise_dtor
4967 tf_warning_or_error);
4968 }
4970 /* Set up a new bind context for the GRO. */
4972 /* Make and connect the scope blocks. */
4979 tree get_ro
4981 coro_get_return_object_identifier,
4983 /* Without a return object we haven't got much clue what's going on. */
4985 {
4988 /* Suppress warnings about the missing return value. */
4991 }
4999 /* Used for return objects in the RESULT slot. */
5002 /* We have to sequence the call to get_return_object before initial
5003 suspend. */
5007 {
5008 /* [dcl.fct.def.coroutine] / 7
5009 The expression promise.get_return_object() is used to initialize the
5010 glvalue result or... (see below)
5011 Construct the return result directly. */
5013 {
5016 complete_ctor_identifier,
5018 tf_warning_or_error);
5020 }
5021 else
5025 /* If some part of the initalization code (prior to the await_resume
5026 of the initial suspend expression), then we need to clean up the
5027 return value. */
5028 gro_ret_dtor
5032 tf_warning_or_error);
5033 }
5034 else
5035 {
5036 /* ... or ... Construct an object that will be used as the single
5037 param to the CTOR for the return object. */
5039 NULL_TREE);
5043 tf_warning_or_error);
5044 /* The constructed object might require a cleanup. */
5046 {
5047 gro_cleanup_stmt
5050 tf_warning_or_error);
5053 }
5054 }
5060 /* If we have a live g.r.o in the return slot, then signal this for exception
5061 cleanup. */
5063 {
5066 boolean_type_node);
5068 }
5069 /* Initialize the resume_idx_var to 0, meaning "not started". */
5070 tree resume_idx_m
5073 tree resume_idx
5075 tf_warning_or_error);
5081 /* So .. call the actor .. */
5086 /* Switch to using 'input_location' as the loc, since we're now more
5087 logically doing things related to the end of the function. */
5089 /* The ramp is done, we just need the return value.
5090 [dcl.fct.def.coroutine] / 7
5091 The expression promise.get_return_object() is used to initialize the
5092 glvalue result or prvalue result object of a call to a coroutine.
5094 If the 'get return object' is non-void, then we built it before the
5095 promise was constructed. We now supply a reference to that var,
5096 either as the return value (if it's the same type) or to the CTOR
5097 for an object of the return type. */
5102 /* check_return_expr will automatically return gro as an rvalue via
5103 treat_lvalue_as_rvalue_p. */
5106 {
5107 /* For class type return objects, we can attempt to construct,
5108 even if the gro is void. ??? Citation ??? c++/100476 */
5112 tf_warning_or_error);
5114 }
5115 else
5116 {
5117 /* We can't initialize a non-class return value from void. */
5121 }
5126 {
5130 }
5132 /* Finish up the ramp function. */
5138 {
5143 /* If we have a live G.R.O in the return slot, then run its DTOR.
5144 When the return object is constructed from a separate g.r.o, this is
5145 already handled by its regular cleanup. */
5147 {
5156 }
5158 /* If the promise is live, then run its dtor if that's available. */
5160 {
5169 }
5171 /* Clean up any frame copies of parms with non-trivial dtors. */
5175 {
5180 {
5189 }
5190 }
5192 /* We always expect to delete the frame. */
5201 }
5206 /* Start to build the final functions.
5208 We push_deferring_access_checks to avoid these routines being seen as
5209 nested by the middle end; we are doing the outlining here. */
5213 /* Build the actor... */
5218 /* Destroyer ... */
5224 /* Link our new functions into the list. */
5235 }