| blob | 2f45575bd92ce13a435b5c00c264dc45e362752f |
1 /* coroutine-specific state, expansions and tests.
3 Copyright (C) 2018-2021 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 {
520 }
522 /* Try to find the handle type for the promise. */
523 tree handle_type =
528 /* Complete this, we're going to use it. */
531 /* Diagnostic would be emitted by complete_type_or_else. */
535 /* Build a proxy for a handle to "self" as the param to
536 await_suspend() calls. */
537 coro_info->self_h_proxy
541 /* Build a proxy for the promise so that we can perform lookups. */
542 coro_info->promise_proxy
546 /* Note where we first saw a coroutine keyword. */
548 }
551 }
553 /* Map from actor or destroyer to ramp. */
556 /* Given a tree that is an actor or destroy, find the ramp function. */
558 tree
560 {
567 }
569 /* Given the DECL for a ramp function (the user's original declaration) return
570 the actor function if it has been defined. */
572 tree
574 {
579 }
581 /* Given the DECL for a ramp function (the user's original declaration) return
582 the destroy function if it has been defined. */
584 tree
586 {
591 }
593 /* These functions assumes that the caller has verified that the state for
594 the decl has been initialized, we try to minimize work here. */
596 static tree
598 {
603 }
605 static tree
607 {
612 }
614 static tree
616 {
621 }
623 static tree
625 {
630 }
632 static tree
635 {
637 tree pm_memb
641 {
644 }
646 }
648 /* Build an expression of the form p.method (args) where the p is a promise
649 object for the current coroutine.
650 OBJECT is the promise object instance to use, it may be NULL, in which case
651 we will use the promise_proxy instance for this coroutine.
652 ARGS may be NULL, for empty parm lists. */
654 static tree
658 {
663 /* If we don't find it, and it isn't needed, an empty return is OK. */
667 tree promise
670 tree expr;
674 else
675 {
681 else
684 }
686 }
688 /* Caching get for the expression p.return_void (). */
690 static tree
692 {
694 {
695 /* If we don't have it try to build it. */
697 info->return_void
699 coro_return_void_identifier,
701 /* Don't return an error if it's an optional call. */
705 }
707 }
709 /* Lookup an Awaitable member, which should be await_ready, await_suspend
710 or await_resume. */
712 static tree
714 {
715 tree aw_memb
719 {
722 }
724 }
726 /* Here we check the constraints that are common to all keywords (since the
727 presence of a coroutine keyword makes the function into a coroutine). */
729 static bool
732 {
734 {
737 }
739 /* This is arranged in order of prohibitions in the std. */
741 {
742 /* [basic.start.main] 3. The function main shall not be a coroutine. */
744 kw_name);
746 }
749 {
752 {
753 /* [dcl.constexpr] 3.3 it shall not be a coroutine. */
755 kw_name);
757 }
758 }
761 {
762 /* [dcl.spec.auto] 15. A function declared with a return type that uses
763 a placeholder type shall not be a coroutine. */
766 kw_name);
768 }
771 {
772 /* [dcl.fct.def.coroutine] The parameter-declaration-clause of the
773 coroutine shall not terminate with an ellipsis that is not part
774 of a parameter-declaration. */
778 }
781 {
782 /* [class.ctor] 7. a constructor shall not be a coroutine. */
785 }
788 {
789 /* [class.dtor] 21. a destructor shall not be a coroutine. */
792 }
795 }
797 /* Here we check the constraints that are not per keyword. */
799 static bool
801 {
804 /* For cases where fundamental information cannot be found, e.g. the
805 coroutine traits are missing, we need to punt early. */
809 /* Since we think the function is a coroutine, that implies we parsed
810 a keyword that triggered this. Keywords check promise validity for
811 their context and thus the promise type should be known at this point. */
817 {
818 /* TODO: record or extract positions of returns (and the first coro
819 keyword) so that we can add notes to the diagnostic about where
820 the bad keyword is and what made the function into a coro. */
824 }
827 }
831 CO_YIELD_SUSPEND_POINT,
832 INITIAL_SUSPEND_POINT,
833 FINAL_SUSPEND_POINT
834 };
836 /* Helper function to build a named variable for the temps we use for each
837 await point. The root of the name is determined by SUSPEND_KIND, and
838 the variable is of type V_TYPE. The awaitable number is reset each time
839 we encounter a final suspend. */
841 static tree
843 {
847 {
852 }
858 }
860 /* Helpers to diagnose missing noexcept on final await expressions. */
862 static bool
864 {
866 {
870 fndecl);
873 }
875 }
877 static bool
879 {
888 else
889 {
892 }
895 }
897 /* This performs [expr.await] bullet 3.3 and validates the interface obtained.
898 It is also used to build the initial and final suspend points.
900 'a', 'o' and 'e' are used as per the description in the section noted.
902 A, the original yield/await expr, is found at source location LOC.
904 We will be constructing a CO_AWAIT_EXPR for a suspend point of one of
905 the four suspend_point_kind kinds. This is indicated by SUSPEND_KIND. */
907 static tree
909 {
910 /* Try and overload of operator co_await, .... */
911 tree o;
913 {
916 /* If no viable functions are found, o is a. */
920 {
921 /* We found an overload for co_await(), diagnose throwing cases. */
926 /* We now know that the final suspend object is distinct from the
927 final awaiter, so check for a non-throwing DTOR where needed. */
933 tf_none))
934 {
940 }
941 }
942 }
943 else
954 {
956 o_type);
958 }
960 /* Check for required awaitable members and their types. */
961 tree awrd_meth
965 tree awsp_meth
970 /* The type of the co_await is the return type of the awaitable's
971 await_resume, so we need to look that up. */
972 tree awrs_meth
977 /* To complete the lookups, we need an instance of 'e' which is built from
978 'o' according to [expr.await] 3.4.
980 If we need to materialize this as a temporary, then that will have to be
981 'promoted' to a coroutine frame var. However, if the awaitable is a
982 user variable, parameter or comes from a scope outside this function,
983 then we must use it directly - or we will see unnecessary copies.
985 If o is a variable, find the underlying var. */
990 {
995 {
996 /* We could have operator-> here too. */
1000 {
1005 }
1006 }
1008 }
1010 /* Only build a temporary if we need it. */
1013 {
1016 }
1017 else
1018 {
1021 tf_warning_or_error);
1022 }
1024 /* I suppose we could check that this is contextually convertible to bool. */
1026 tree awrd_call
1033 /* The suspend method may return one of three types:
1034 1. void (no special action needed).
1035 2. bool (if true, we don't need to suspend).
1036 3. a coroutine handle, we execute the handle.resume() call. */
1040 tree awsp_call
1056 {
1060 }
1063 {
1067 }
1069 /* Finally, the type of e.await_resume() is the co_await's type. */
1071 tree awrs_call
1079 {
1090 tf_none))
1091 {
1097 }
1098 }
1100 /* We now have three call expressions, in terms of the promise, handle and
1101 'e' proxies. Save them in the await expression for later expansion. */
1108 {
1111 }
1120 {
1123 }
1126 }
1128 tree
1130 {
1138 /* The current function has now become a coroutine, if it wasn't already. */
1141 /* This function will appear to have no return statement, even if it
1142 is declared to return non-void (most likely). This is correct - we
1143 synthesize the return for the ramp in the compiler. So suppress any
1144 extraneous warnings during substitution. */
1147 /* If we don't know the promise type, we can't proceed, build the
1148 co_await with the expression unchanged. */
1154 /* We must be able to look up the "await_transform" method in the scope of
1155 the promise type, and obtain its return type. */
1159 /* [expr.await] 3.2
1160 The incoming cast expression might be transformed by a promise
1161 'await_transform()'. */
1162 tree at_meth
1171 {
1172 /* try to build a = p.await_transform (e). */
1175 current_function_decl),
1179 /* As I read the section.
1180 We saw an await_transform method, so it's mandatory that we replace
1181 expr with p.await_transform (expr), therefore if the method call fails
1182 (presumably, we don't have suitable arguments) then this part of the
1183 process fails. */
1186 }
1188 /* Now we want to build co_await a. */
1191 {
1194 }
1197 }
1199 /* Take the EXPR given and attempt to build:
1200 co_await p.yield_value (expr);
1201 per [expr.yield] para 1. */
1203 tree
1205 {
1209 /* Check the general requirements and simple syntax errors. */
1214 /* The current function has now become a coroutine, if it wasn't already. */
1217 /* This function will appear to have no return statement, even if it
1218 is declared to return non-void (most likely). This is correct - we
1219 synthesize the return for the ramp in the compiler. So suppress any
1220 extraneous warnings during substitution. */
1223 /* If we don't know the promise type, we can't proceed, build the
1224 co_await with the expression unchanged. */
1230 /* We must be able to look up the "yield_value" method in the scope of
1231 the promise type, and obtain its return type. */
1234 /* [expr.yield] / 1
1235 Let e be the operand of the yield-expression and p be an lvalue naming
1236 the promise object of the enclosing coroutine, then the yield-expression
1237 is equivalent to the expression co_await p.yield_value(e).
1238 build p.yield_value(e): */
1240 tree yield_call
1246 /* Now build co_await p.yield_value (e).
1247 Noting that for co_yield, there is no evaluation of any potential
1248 promise transform_await(), so we call build_co_await directly. */
1252 {
1255 /* If the await expression is wrapped in a TARGET_EXPR, then transfer
1256 that wrapper to the CO_YIELD_EXPR, since this is just a proxy for
1257 its contained await. Otherwise, just build the CO_YIELD_EXPR. */
1259 {
1263 }
1264 else
1268 }
1271 }
1273 /* Check and build a co_return statement.
1274 First that it's valid to have a co_return keyword here.
1275 If it is, then check and build the p.return_{void(),value(expr)}.
1276 These are built against a proxy for the promise, which will be filled
1277 in with the actual frame version when the function is transformed. */
1279 tree
1281 {
1288 /* If it fails the following test, the function is not permitted to be a
1289 coroutine, so the co_return statement is erroneous. */
1294 /* The current function has now become a coroutine, if it wasn't
1295 already. */
1298 /* This function will appear to have no return statement, even if it
1299 is declared to return non-void (most likely). This is correct - we
1300 synthesize the return for the ramp in the compiler. So suppress any
1301 extraneous warnings during substitution. */
1308 /* If we don't know the promise type, we can't proceed, build the
1309 co_return with the expression unchanged. */
1312 {
1313 /* co_return expressions are always void type, regardless of the
1314 expression type. */
1319 }
1324 /* Suppress -Wreturn-type for co_return, we need to check indirectly
1325 whether the promise type has a suitable return_void/return_value. */
1332 {
1333 /* If we had an id-expression obfuscated by force_paren_expr, we need
1334 to undo it so we can try to treat it as an rvalue below. */
1342 }
1344 /* If the promise object doesn't have the correct return call then
1345 there's a mis-match between the co_return <expr> and this. */
1348 co_ret_call
1350 else
1351 {
1352 /* [class.copy.elision] / 3.
1353 An implicitly movable entity is a variable of automatic storage
1354 duration that is either a non-volatile object or an rvalue reference
1355 to a non-volatile object type. For such objects in the context of
1356 the co_return, the overload resolution should be carried out first
1357 treating the object as an rvalue, if that fails, then we fall back
1358 to regular overload resolution. */
1365 co_ret_call
1369 }
1371 /* Makes no sense for a co-routine really. */
1374 "function declared %<noreturn%> has a"
1380 }
1382 /* We need to validate the arguments to __builtin_coro_promise, since the
1383 second two must be constant, and the builtins machinery doesn't seem to
1384 deal with that properly. */
1386 tree
1388 {
1393 {
1398 {
1399 /* Argument 0 is already checked by the normal built-in machinery
1400 Argument 1 must be a constant of size type. It probably makes
1401 little sense if it's not a power of 2, but that isn't specified
1402 formally. */
1406 /* We expect alignof expressions in templates. */
1409 ;
1411 {
1415 }
1416 /* Argument 2 is the direction - to / from handle address to promise
1417 address. */
1421 {
1425 }
1428 }
1429 }
1430 }
1432 /* ================= Morph and Expand. =================
1434 The entry point here is morph_fn_to_coro () which is called from
1435 finish_function () when we have completed any template expansion.
1437 This is preceded by helper functions that implement the phases below.
1439 The process proceeds in four phases.
1441 A Initial framing.
1442 The user's function body is wrapped in the initial and final suspend
1443 points and we begin building the coroutine frame.
1444 We build empty decls for the actor and destroyer functions at this
1445 time too.
1446 When exceptions are enabled, the user's function body will also be
1447 wrapped in a try-catch block with the catch invoking the promise
1448 class 'unhandled_exception' method.
1450 B Analysis.
1451 The user's function body is analyzed to determine the suspend points,
1452 if any, and to capture local variables that might persist across such
1453 suspensions. In most cases, it is not necessary to capture compiler
1454 temporaries, since the tree-lowering nests the suspensions correctly.
1455 However, in the case of a captured reference, there is a lifetime
1456 extension to the end of the full expression - which can mean across a
1457 suspend point in which case it must be promoted to a frame variable.
1459 At the conclusion of analysis, we have a conservative frame layout and
1460 maps of the local variables to their frame entry points.
1462 C Build the ramp function.
1463 Carry out the allocation for the coroutine frame (NOTE; the actual size
1464 computation is deferred until late in the middle end to allow for future
1465 optimizations that will be allowed to elide unused frame entries).
1466 We build the return object.
1468 D Build and expand the actor and destroyer function bodies.
1469 The destroyer is a trivial shim that sets a bit to indicate that the
1470 destroy dispatcher should be used and then calls into the actor.
1472 The actor function is the implementation of the user's state machine.
1473 The current suspend point is noted in an index.
1474 Each suspend point is encoded as a pair of internal functions, one in
1475 the relevant dispatcher, and one representing the suspend point.
1477 During this process, the user's local variables and the proxies for the
1478 self-handle and the promise class instance are re-written to their
1479 coroutine frame equivalents.
1481 The complete bodies for the ramp, actor and destroy function are passed
1482 back to finish_function for folding and gimplification. */
1484 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1486 static tree
1488 {
1490 }
1492 static tree
1494 {
1497 }
1499 /* Helpers to build an artificial var, with location LOC, NAME and TYPE, in
1500 CTX, and with initializer INIT. */
1502 static tree
1504 tree init)
1505 {
1512 }
1514 static tree
1517 {
1520 }
1522 /* Helpers for label creation:
1523 1. Create a named label in the specified context. */
1525 static tree
1527 {
1535 }
1537 /* 2. Create a named label in the specified context. */
1539 static tree
1541 {
1548 }
1550 struct proxy_replace
1551 {
1553 };
1555 static tree
1557 {
1561 {
1564 }
1565 else
1568 }
1570 /* Support for expansion of co_await statements. */
1572 struct coro_aw_data
1573 {
1584 };
1586 /* Lightweight search for the first await expression in tree-walk order.
1587 returns:
1588 The first await expression found in STMT.
1589 NULL_TREE if there are none.
1590 So can be used to determine if the statement needs to be processed for
1591 awaits. */
1593 static tree
1595 {
1598 {
1601 }
1603 }
1605 /* Starting with a statement:
1607 stmt => some tree containing one or more await expressions.
1609 We replace the statement with:
1610 <STATEMENT_LIST> {
1611 initialize awaitable
1612 if (!ready)
1613 {
1614 suspension context.
1615 }
1616 resume:
1617 revised statement with one await expression rewritten to its
1618 await_resume() return value.
1619 }
1621 We then recurse into the initializer and the revised statement
1622 repeating this replacement until there are no more await expressions
1623 in either. */
1627 {
1654 tree r;
1659 else
1660 {
1663 /* We have an initializer, which might itself contain await exprs. */
1665 }
1667 /* Use the await_ready() call to test if we need to suspend. */
1669 /* Convert to bool, if necessary. */
1672 tf_warning_or_error);
1673 /* Be aggressive in folding here, since there are a significant number of
1674 cases where the ready condition is constant. */
1676 ready_cond
1682 susp_idx);
1686 /* Find out what we have to do with the awaiter's suspend method.
1687 [expr.await]
1688 (5.1) If the result of await-ready is false, the coroutine is considered
1689 suspended. Then:
1690 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1691 await-suspend.resume() is evaluated.
1692 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1693 and the coroutine is resumed if the result is false.
1694 (5.1.3) Otherwise, await-suspend is evaluated. */
1700 /* NOTE: final suspend can't resume; the "resume" label in that case
1701 corresponds to implicit destruction. */
1703 {
1704 /* We just call await_suspend() and hit the yield. */
1707 }
1709 {
1710 /* Boolean return, continue if the call returns false. */
1712 suspend
1716 empty_list);
1718 }
1719 else
1720 {
1726 }
1750 /* Implement the suspend, a scope exit without clean ups. */
1766 /* part of finish switch. */
1777 {
1780 tf_warning_or_error);
1782 }
1787 empty_list);
1791 /* Resume point. */
1795 /* This will produce the value (if one is provided) from the co_await
1796 expression. */
1799 /* Sink to await_resume call_expr. */
1804 /* Get a pointer to the revised statement. */
1807 {
1810 tf_warning_or_error);
1812 }
1815 /* Replace the original statement with the expansion. */
1818 /* Now, if the awaitable had an initializer, expand any awaits that might
1819 be embedded in it. */
1825 /* Expand any more await expressions in the the original statement. */
1830 }
1832 /* Check to see if a statement contains at least one await expression, if
1833 so, then process that. */
1835 static tree
1837 {
1842 }
1844 static tree
1846 {
1849 /* Process a statement at a time. */
1853 {
1855 {
1860 }
1862 }
1864 {
1867 }
1869 /* Continue statement walk, where required. */
1871 }
1873 /* Suspend point hash_map. */
1875 struct suspend_point_info
1876 {
1877 /* coro frame field type. */
1878 tree awaitable_type;
1879 /* coro frame field name. */
1880 tree await_field_id;
1881 };
1885 struct await_xform_data
1886 {
1888 tree actor_frame;
1889 };
1891 /* When we built the await expressions, we didn't know the coro frame
1892 layout, therefore no idea where to find the promise or where to put
1893 the awaitables. Now we know these things, fill them in. */
1895 static tree
1897 {
1901 {
1904 }
1906 /* So, on entry, we have:
1907 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1908 We no longer need a [it had diagnostic value, maybe?]
1909 We need to replace the e_proxy in the awr_call. */
1913 /* If we have a frame var for the awaitable, get a reference to it. */
1914 proxy_replace data;
1916 {
1917 tree as_m
1922 tf_warning_or_error);
1924 /* Replace references to the instance proxy with the frame entry now
1925 computed. */
1930 /* .. and replace. */
1932 }
1935 }
1937 /* A wrapper for the transform_await_expr function so that it can be a
1938 callback from cp_walk_tree. */
1940 static tree
1942 {
1943 /* Set actor function as new DECL_CONTEXT of label_decl. */
1949 /* We should have already lowered co_yields to their co_await. */
1959 }
1961 /* This caches information that we determine about function params,
1962 their uses and copies in the coroutine frame. */
1964 struct param_info
1965 {
1979 };
1981 struct local_var_info
1982 {
1983 tree field_id;
1984 tree field_idx;
1985 tree frame_type;
1989 location_t def_loc;
1990 };
1992 /* For figuring out what local variable usage we have. */
1993 struct local_vars_transform
1994 {
1995 tree context;
1996 tree actor_frame;
1997 tree coro_frame_type;
1998 location_t loc;
2000 };
2002 static tree
2004 {
2007 /* For each var in this bind expr (that has a frame id, which means it was
2008 accessed), build a frame reference and add it as the DECL_VALUE_EXPR. */
2011 {
2012 tree lvar;
2015 {
2017 local_var_info &local_var
2021 /* Re-write the variable's context to be in the actor func. */
2024 /* For capture proxies, this could include the decl value expr. */
2028 /* TODO: implement selective generation of fields when vars are
2029 known not-used. */
2033 tree fld_ref
2036 tf_warning_or_error);
2042 }
2046 }
2048 }
2050 /* A helper to build the frame DTOR.
2051 [dcl.fct.def.coroutine] / 12
2052 The deallocation function’s name is looked up in the scope of the promise
2053 type. If this lookup fails, the deallocation function’s name is looked up
2054 in the global scope. If deallocation function lookup finds both a usual
2055 deallocation function with only a pointer parameter and a usual
2056 deallocation function with both a pointer parameter and a size parameter,
2057 then the selected deallocation function shall be the one with two
2058 parameters. Otherwise, the selected deallocation function shall be the
2059 function with one parameter. If no usual deallocation function is found
2060 the program is ill-formed. The selected deallocation function shall be
2061 called with the address of the block of storage to be reclaimed as its
2062 first argument. If a deallocation function with a parameter of type
2063 std::size_t is used, the size of the block is passed as the corresponding
2064 argument. */
2066 static tree
2069 {
2076 {
2077 /* Look for sized version first, since this takes precedence. */
2083 /* It's OK to fail for this one... */
2086 tf_none);
2089 {
2094 tf_none);
2095 }
2097 /* But one of them must succeed, or the program is ill-formed. */
2099 {
2103 }
2104 }
2105 else
2106 {
2110 tf_warning_or_error);
2113 }
2115 }
2117 /* The actor transform. */
2119 static void
2124 {
2126 /* Some things we inherit from the original function. */
2131 /* One param, the coro frame pointer. */
2134 /* We have a definition here. */
2147 NULL_TREE);
2152 /* Link in the block associated with the outer scope of the re-written
2153 function body. */
2165 /* The entry point for the actor code from the ramp. */
2166 tree actor_begin_label
2170 /* Declare the continuation handle. */
2173 /* Re-write local vars, similarly. */
2174 local_vars_transform xform_vars_data
2183 tree ret_label
2186 tree continue_label
2205 /* The destroy point numbered #1 is special, in that it is reached from a
2206 coroutine that is suspended after re-throwing from unhandled_exception().
2207 This label just invokes the cleanup of promise, param copies and the
2208 frame itself. */
2209 tree del_promise_label
2218 {
2224 l_num);
2230 }
2232 /* Insert the prototype dispatcher. */
2254 /* The final resume should be made to hit the default (trap, UB) entry
2255 although it will be unreachable via the normal entry point, since that
2256 is set to NULL on reaching final suspend. */
2258 {
2264 l_num);
2270 }
2272 /* Insert the prototype dispatcher. */
2281 /* actor's coroutine 'self handle'. */
2286 /* So construct the self-handle from the frame address. */
2299 /* Now we know the real promise, and enough about the frame layout to
2300 decide where to put things. */
2304 /* Transform the await expressions in the function body. Only do each
2305 await tree once! */
2309 /* Add in our function body with the co_returns rewritten to final form. */
2312 /* now do the tail of the function. */
2316 /* Destructors for the things we built explicitly. */
2319 tf_warning_or_error);
2322 tree del_frame_label
2327 /* Here deallocate the frame (if we allocated it), which we will have at
2328 present. */
2329 tree fnf_m
2340 {
2342 tree pid;
2344 {
2345 tree m
2350 tree dtor;
2351 dtor
2355 }
2356 }
2358 /* Build the frame DTOR. */
2368 /* done. */
2374 /* This is the suspend return point. */
2383 /* This is the 'continuation' return point. For such a case we have a coro
2384 handle (from the await_suspend() call) and we want handle.resume() to
2385 execute as a tailcall allowing arbitrary chaining of coroutines. */
2389 /* We want to force a tail-call even for O0/1, so this expands the resume
2390 call into its underlying implementation. */
2395 tree resume = build_call_expr_loc
2398 /* In order to support an arbitrary number of coroutine continuations,
2399 we must tail call them. However, some targets do not support indirect
2400 tail calls to arbitrary callees. See PR94359. */
2409 /* We've now rewritten the tree and added the initial and final
2410 co_awaits. Now pass over the tree and expand the co_awaits. */
2423 }
2425 /* The prototype 'destroy' function :
2426 frame->__Coro_resume_index |= 1;
2427 actor (frame); */
2429 static void
2431 tree actor)
2432 {
2433 /* One param, the coro frame pointer. */
2436 /* We have a definition here. */
2450 /* _resume_at |= 1 */
2457 /* So .. call the actor .. */
2462 /* done. */
2469 }
2471 /* Helper that returns an identifier for an appended extension to the
2472 current un-mangled function name. */
2474 static tree
2476 {
2477 /* Figure out the bits we need to generate names for the outlined things
2478 For consistency, this needs to behave the same way as
2479 ASM_FORMAT_PRIVATE_NAME does. */
2482 #ifndef NO_DOT_IN_LABEL
2484 #else
2485 #ifndef NO_DOLLAR_IN_LABEL
2487 #else
2490 #endif
2491 #endif
2499 {
2503 {
2506 }
2508 }
2509 else
2513 }
2515 /* Build an initial or final await initialized from the promise
2516 initial_suspend or final_suspend expression. */
2518 static tree
2520 {
2524 tree setup_call
2528 /* Check for noexcept on the final_suspend call. */
2533 /* So build the co_await for this */
2534 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2537 }
2539 /* Callback to record the essential data for each await point found in the
2540 function. */
2542 static bool
2544 {
2546 suspend_point_info &s
2549 {
2551 await_expr);
2553 }
2557 }
2559 /* This data set is used when analyzing statements for await expressions. */
2561 struct susp_frame_data
2562 {
2563 /* Function-wide. */
2571 /* Temporary values for one statement or expression being analyzed. */
2579 };
2581 /* If this is an await expression, then count it (both uniquely within the
2582 function and locally within a single statement). */
2584 static tree
2586 {
2589 /* We should have already lowered co_yields to their co_await. */
2595 /* Count how many awaits the current expression contains. */
2598 /* Each await suspend context is unique, this is a function-wide value. */
2601 /* Awaitables should either be user-locals or promoted to coroutine frame
2602 entries at this point, and their initializers should have been broken
2603 out. */
2611 /* Rewrite target expressions on the await_suspend () to remove extraneous
2612 cleanups for the awaitables, which are now promoted to frame vars and
2613 managed via that. */
2619 }
2621 /* There are cases where any await expression is relevant. */
2622 static tree
2624 {
2626 {
2631 }
2633 }
2635 static bool
2637 {
2646 }
2648 /* Structure to record sub-expressions that need to be handled by the
2649 statement flattener. */
2651 struct coro_interesting_subtree
2652 {
2655 };
2657 /* tree-walk callback that returns the first encountered sub-expression of
2658 a kind that needs to be handled specifically by the statement flattener. */
2660 static tree
2662 {
2666 {
2669 {
2672 }
2673 }
2676 {
2679 }
2682 }
2684 /* Node for a doubly-linked list of promoted variables and their
2685 initializers. When the initializer is a conditional expression
2686 the 'then' and 'else' clauses are represented by a linked list
2687 attached to then_cl and else_cl respectively. */
2689 struct var_nest_node
2690 {
2694 {
2699 }
2700 tree var;
2701 tree init;
2706 };
2708 /* This is called for single statements from the co-await statement walker.
2709 It checks to see if the statement contains any initializers for awaitables
2710 and if any of these capture items by reference. */
2712 static void
2715 {
2718 {
2720 /* Compound expressions must be flattened specifically. */
2722 {
2725 var_nest_node *ins
2727 /* The compiler (but not the user) can generate temporaries with
2728 uses in the second arm of a compound expr. */
2731 /* The two arms have been processed separately. */
2733 }
2735 /* Handle conditional expressions. */
2738 /* FALLTHROUGH */
2740 {
2743 {
2746 var_nest_node *ins
2752 }
2755 /* Reconstruct x = t ? y : z;
2756 as (void) t ? x = y : x = z; */
2760 /* We are allowed a void type throw in one or both of the cond
2761 expr arms. */
2764 {
2766 then_cl
2769 }
2772 {
2774 else_cl
2777 }
2779 }
2780 /* FALLTHROUGH */
2782 {
2785 /* If the condition contains an await expression, then we need to
2786 set that first and use a separate var. */
2788 {
2795 var_nest_node *ins
2799 }
2801 n->then_cl
2803 n->else_cl
2806 /* Point to the start of the flattened code. */
2813 }
2815 }
2821 {
2824 {
2825 /* Await expressions with initializers have a compiler-temporary
2826 as the awaitable. 'promote' this. */
2832 {
2836 {
2838 /* We can have non-lvalue-expressions here, but when we see
2839 a target expression, mark it as already used. */
2841 {
2843 gcc_checking_assert
2845 }
2846 }
2849 /* If this is a call and not a CTOR, then we didn't expect it. */
2850 gcc_checking_assert
2853 }
2859 }
2862 {
2863 /* We have a temporary; promote it, but allow for the idiom in code
2864 generated by the compiler like
2865 a = (target_expr produces temp, op uses temp). */
2878 tf_warning_or_error);
2879 /* Simplify for the case that we have an init containing the temp
2880 alone. */
2882 {
2890 }
2891 else
2892 {
2893 var_nest_node *ins
2895 /* We have to replace the target expr... */
2897 /* ... and any uses of its var. */
2900 /* Compiler-generated temporaries can also have uses in
2901 following arms of compound expressions, which will be listed
2902 in 'replace_in' if present. */
2907 }
2909 }
2911 }
2912 }
2914 /* Helper for 'process_conditional' that handles recursion into nested
2915 conditionals. */
2917 static void
2920 {
2921 do
2922 {
2924 {
2927 {
2931 {
2932 /* We didn't see this var before and it needs a DTOR, so
2933 build a guard variable for it. */
2938 boolean_type_node);
2941 }
2943 /* The initializer for this variable is replaced by a compound
2944 expression that performs the init and then records that the
2945 variable is live (and the DTOR should be run at the scope
2946 exit. */
2949 n->init
2951 }
2952 }
2954 {
2961 tree new_if
2965 }
2966 else
2970 }
2972 /* helper for 'maybe_promote_temps'.
2974 When we have a conditional expression which might embed await expressions
2975 and/or promoted variables, we need to handle it appropriately.
2977 The linked lists for the 'then' and 'else' clauses in a conditional node
2978 identify the promoted variables (but these cannot be wrapped in a regular
2979 cleanup).
2981 So recurse through the lists and build up a composite list of captured vars.
2982 Declare these and any guard variables needed to decide if a DTOR should be
2983 run. Then embed the conditional into a try-finally expression that handles
2984 running each DTOR conditionally on its guard variable. */
2986 static void
2988 {
2998 /* Declare the vars. There are two loops so that the boolean flags are
2999 grouped in the frame. */
3001 {
3006 }
3007 /* Define the guard flags for variables that need a DTOR. */
3009 {
3012 {
3017 }
3018 }
3019 tree new_if
3022 /* Build a set of conditional DTORs. */
3025 {
3031 tree cleanup
3034 tf_warning_or_error);
3040 }
3042 tree try_finally
3045 }
3047 /* Given *STMT, that contains at least one await expression.
3049 The full expression represented in the original source code will contain
3050 suspension points, but it is still required that the lifetime of temporary
3051 values extends to the end of the expression.
3053 We already have a mechanism to 'promote' user-authored local variables
3054 to a coroutine frame counterpart (which allows explicit management of the
3055 lifetime across suspensions). The transform here re-writes STMT into
3056 a bind expression, promotes temporary values into local variables in that
3057 and flattens the statement into a series of cleanups.
3059 Conditional expressions are re-written to regular 'if' statements.
3060 The cleanups for variables initialized inside a conditional (including
3061 nested cases) are wrapped in a try-finally clause, with guard variables
3062 to determine which DTORs need to be run. */
3064 static tree
3066 {
3071 /* Strip off uninteresting wrappers. */
3081 /* We walk the statement trees, flattening it into an ordered list of
3082 variables with initializers and fragments corresponding to compound
3083 expressions, truth or/and if and ternary conditionals. Conditional
3084 expressions carry a nested list of fragments for the then and else
3085 clauses. We anchor to the 'bottom' of the fragment list; we will write
3086 a cleanup nest with one shell for each variable initialized. */
3088 /* Check to see we didn't promote one twice. */
3096 /* We build the bind scope expression from the bottom-up.
3097 EXPR_LIST holds the inner expression nest at the current cleanup
3098 level (becoming the final expression list when we've exhausted the
3099 number of sub-expression fragments). */
3101 do
3102 {
3104 /* When we have a promoted variable, then add that to the bind scope
3105 and initialize it. When there's no promoted variable, we just need
3106 to run the initializer.
3107 If the initializer is a conditional expression, we need to collect
3108 and declare any promoted variables nested within it. DTORs for such
3109 variables must be run conditionally too. */
3111 {
3118 else
3122 {
3123 tree cleanup
3126 tf_warning_or_error);
3129 }
3131 {
3136 }
3137 }
3138 else
3139 {
3142 else
3145 {
3150 }
3151 }
3158 /* Now produce the bind expression containing the 'promoted' temporaries
3159 as its variable list, and the cleanup nest as the statement. */
3166 {
3169 {
3173 }
3174 }
3181 }
3183 /* Lightweight callback to determine two key factors:
3184 1) If the statement/expression contains any await expressions.
3185 2) If the statement/expression potentially requires a re-write to handle
3186 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3187 so that the await expressions are not processed in the case of the
3188 short-circuit arm.
3190 CO_YIELD expressions are re-written to their underlying co_await. */
3192 static tree
3194 {
3198 {
3201 /* co_yield is syntactic sugar, re-write it to co_await. */
3203 /* FALLTHROUGH */
3206 /* A non-null initializer for the awaiter means we need to expand. */
3212 {
3213 /* We don't need special action for awaits in the always-executed
3214 arm of a TRUTH_IF. */
3218 /* However, if there are await expressions on the conditionally
3219 executed branch, we must expand the TRUTH_IF to ensure that the
3220 expanded await expression control-flow is fully contained in the
3221 conditionally executed code. */
3227 {
3230 }
3231 /* We've done the sub-trees here. */
3233 }
3235 }
3238 }
3240 /* Given *EXPR
3241 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3242 the conditionally executed branch, change this in a ternary operator.
3244 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3245 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3247 Apply this recursively to the condition and the conditionally-exec
3248 branch. */
3252 tree scratch_var;
3254 };
3256 static tree
3258 {
3263 {
3267 /* FALLTHROUGH */
3269 {
3274 /* Transform truth expression into a cond expression with
3275 * the always-executed arm as the condition.
3276 * the conditionally-executed arm as the then clause.
3277 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3283 tree cond_expr
3293 /* We've manually processed necessary sub-trees here. */
3295 }
3297 }
3299 }
3301 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3302 name is made up from NAM_ROOT, NAM_VERS. */
3304 static tree
3307 {
3309 /* Build a variable to hold the condition, this will be included in the
3310 frame as a local var. */
3317 }
3319 /* Helper to build and add if (!cond) break; */
3321 static void
3323 {
3330 }
3332 /* Tree walk callback to replace continue statements with goto label. */
3333 static tree
3335 {
3346 {
3347 /* Unless it's a special case, just walk the subtrees as usual. */
3351 {
3354 /* re-write a continue to goto label. */
3358 }
3360 /* Statements that do not require recursion. */
3367 /* These must break recursion. */
3373 }
3374 }
3376 /* Tree walk callback to analyze, register and pre-process statements that
3377 contain await expressions. */
3379 static tree
3381 {
3385 /* Process a statement at a time. */
3387 {
3388 /* For conditional expressions, we might wish to add an artificial var
3389 to their containing bind expr. */
3391 /* We might need to insert a new bind expression, and want to link it
3392 into the correct scope, so keep a note of the current block scope. */
3401 }
3403 {
3405 {
3410 }
3413 }
3415 /* We have something to be handled as a single statement. We have to handle
3416 a few statements specially where await statements have to be moved out of
3417 constructs. */
3425 {
3426 /* Unless it's a special case, just walk the subtrees as usual. */
3429 /* When we have a conditional expression, which contains one or more
3430 await expressions, we have to break the condition out into a
3431 regular statement so that the control flow introduced by the await
3432 transforms can be implemented. */
3434 {
3437 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3438 bool cond = cond with awaits.
3439 if (cond) then stmt1 else stmt2. */
3441 /* We treat the condition as if it was a stand-alone statement,
3442 to see if there are any await expressions which will be analyzed
3443 and registered. */
3458 /* We want to initialize the new variable with the expression
3459 that contains the await(s) and potentially also needs to
3460 have truth_if expressions expanded. */
3467 /* So now walk the new statement list. */
3471 }
3474 {
3477 /* for loops only need special treatment if the condition or the
3478 iteration expression contain a co_await. */
3480 /* At present, the FE always generates a separate initializer for
3481 the FOR_INIT_STMT, when the expression has an await. Check that
3482 this assumption holds in the future. */
3483 gcc_checking_assert
3488 bool for_cond_await
3493 bool for_expr_await
3497 /* If the condition has an await, then we will need to rewrite the
3498 loop as
3499 for (init expression;true;iteration expression) {
3500 condition = await expression;
3501 if (condition)
3502 break;
3503 ...
3504 }
3505 */
3507 {
3509 /* This will be expanded when the revised body is handled. */
3511 /* .. add the original for body. */
3513 /* To make the new for body. */
3516 }
3517 /* If the iteration expression has an await, it's a bit more
3518 tricky.
3519 for (init expression;condition;) {
3520 ...
3521 iteration_expr_label:
3522 iteration expression with await;
3523 }
3524 but, then we will need to re-write any continue statements into
3525 'goto iteration_expr_label:'.
3526 */
3528 {
3531 /* The original for body. */
3534 tree it_expr_label
3539 /* Present the iteration expression as a statement. */
3546 /* rewrite continue statements to goto label. */
3551 }
3553 /* So now walk the body statement (list), if there were no await
3554 expressions, then this handles the original body - and either
3555 way we will have finished with this statement. */
3560 }
3563 {
3564 /* We turn 'while (cond with awaits) stmt' into
3565 while (true) {
3566 if (!(cond with awaits))
3567 break;
3568 stmt..
3569 } */
3579 /* The original while body. */
3581 /* The new while body. */
3584 /* So now walk the new statement list. */
3589 }
3592 {
3593 /* We turn do stmt while (cond with awaits) into:
3594 do {
3595 stmt..
3596 if (!(cond with awaits))
3597 break;
3598 } while (true); */
3607 /* The original do stmt body. */
3610 /* The new while body. */
3613 /* So now walk the new statement list. */
3618 }
3621 {
3622 /* We turn 'switch (cond with awaits) stmt' into
3623 switch_type cond = cond with awaits
3624 switch (cond) stmt. */
3633 /* Build a variable to hold the condition, this will be
3634 included in the frame as a local var. */
3647 cond_inner);
3650 /* Now add the switch statement with the condition re-
3651 written to use the local var. */
3654 /* Process the expanded list. */
3659 }
3662 {
3663 /* Expand the co_return as per [stmt.return.coroutine]
3664 - for co_return;
3665 { p.return_void (); goto final_suspend; }
3666 - for co_return [void expr];
3667 { expr; p.return_void(); goto final_suspend;}
3668 - for co_return [non void expr];
3669 { p.return_value(expr); goto final_suspend; } */
3674 /* [stmt.return.coroutine], 2.2
3675 If expr is present and void, it is placed immediately before
3676 the call for return_void; */
3679 /* Insert p.return_{void,value(expr)}. */
3685 /* Once this is complete, we will have processed subtrees. */
3688 }
3690 }
3692 {
3711 {
3712 /* If a truth-and/or-if expression has an await expression in the
3713 conditionally-taken branch, then it must be rewritten into a
3714 regular conditional. */
3718 }
3719 /* Process this statement, which contains at least one await expression
3720 to 'promote' temporary values to a coroutine frame slot. */
3722 }
3723 /* Continue recursion, if needed. */
3725 }
3727 /* For figuring out what param usage we have. */
3729 struct param_frame_data
3730 {
3734 location_t loc;
3736 };
3738 /* A tree walk callback that rewrites each parm use to the local variable
3739 that represents its copy in the frame. */
3741 static tree
3743 {
3746 /* For lambda closure content, we have to look specifically. */
3748 {
3751 }
3756 /* If we already saw the containing expression, then we're done. */
3766 }
3768 /* Build up a set of info that determines how each param copy will be
3769 handled. */
3773 {
3779 /* Build a hash map with an entry for each param.
3780 The key is the param tree.
3781 Then we have an entry for the frame field name.
3782 Then a cache for the field ref when we come to use it.
3783 Then a tree list of the uses.
3784 The second two entries start out empty - and only get populated
3785 when we see uses. */
3790 {
3802 {
3803 /* If the user passes by reference, then we will save the
3804 pointer to the original. As noted in
3805 [dcl.fct.def.coroutine] / 13, if the lifetime of the
3806 referenced item ends and then the coroutine is resumed,
3807 we have UB; well, the user asked for it. */
3810 else
3812 }
3823 {
3827 }
3831 {
3834 parm.guard_var
3837 boolean_false_node);
3840 }
3841 else
3843 }
3846 }
3848 /* Small helper for the repetitive task of adding a new field to the coro
3849 frame type. */
3851 static tree
3853 location_t loc)
3854 {
3860 }
3862 /* For recording local variable usage. */
3864 struct local_vars_frame_data
3865 {
3869 location_t loc;
3872 };
3874 /* A tree-walk callback that processes one bind expression noting local
3875 variables, and making a coroutine frame slot available for those that
3876 need it, so that they can be 'promoted' across suspension points. */
3878 static tree
3880 {
3883 /* As we enter a bind expression - record the vars there and then recurse.
3884 As we exit drop the nest depth.
3885 The bind index is a growing count of how many bind indices we've seen.
3886 We build a space in the frame for each local var. */
3889 {
3890 tree lvar;
3893 {
3895 local_var_info &local_var
3903 /* Make sure that we only present vars to the tests below. */
3908 /* We don't move static vars into the frame. */
3914 /* If this var is a lambda capture proxy, we want to leave it alone,
3915 and later rewrite the DECL_VALUE_EXPR to indirect through the
3916 frame copy of the pointer to the lambda closure object. */
3921 /* If a variable has a value expression, then that's what needs
3922 to be processed. */
3927 /* Make names depth+index unique, so that we can support nested
3928 scopes with identically named locals and still be able to
3929 identify them in the coroutine frame. */
3933 /* The outermost bind scope contains the artificial variables that
3934 we inject to implement the coro state machine. We want to be able
3935 to inspect these in debugging. */
3941 else
3944 /* TODO: Figure out if we should build a local type that has any
3945 excess alignment or size from the original decl. */
3946 local_var.field_id
3949 /* We don't walk any of the local var sub-trees, they won't contain
3950 any bind exprs. */
3951 }
3957 }
3959 }
3961 /* Build, return FUNCTION_DECL node based on ORIG with a type FN_TYPE which has
3962 a single argument of type CORO_FRAME_PTR. Build the actor function if
3963 ACTOR_P is true, otherwise the destroy. */
3965 static tree
3968 {
3970 tree fn
3973 /* Allow for locating the ramp (original) function from this one. */
3989 /* Copy selected attributes from the original function. */
3993 /* Copy any alignment that the FE added. */
3996 /* Copy any alignment the user added. */
3998 /* Apply attributes from the original fn. */
4001 /* A void return. */
4008 /* This is a coroutine component. */
4011 /* Set up a means to find out if a decl is one of the helpers and, if so,
4012 which one. */
4014 {
4019 else
4021 }
4023 }
4025 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
4027 static tree
4030 tree resume_fn_ptr_type,
4032 {
4033 /* This will be our new outer scope. */
4039 /* If the function has a top level bind expression, then connect that
4040 after first making sure we give it a new block. */
4043 {
4048 /* Replace the top block to avoid issues with locations for args
4049 appearing to be in a non-existent place. */
4056 /* The top block has one child, so far, and we have now got a
4057 superblock. */
4060 }
4062 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
4063 are enabled. */
4067 /* [stmt.return.coroutine] / 3
4068 If p.return_void() is a valid expression, flowing off the end of a
4069 coroutine is equivalent to a co_return with no operand; otherwise
4070 flowing off the end of a coroutine results in undefined behavior. */
4071 tree return_void
4074 /* The pointer to the resume function. */
4075 tree resume_fn_ptr
4082 /* We will need to be able to set the resume function pointer to nullptr
4083 to signal that the coroutine is 'done'. */
4084 tree zero_resume
4087 /* The pointer to the destroy function. */
4094 /* The promise was created on demand when parsing we now link it into
4095 our scope. */
4103 /* We need a handle to this coroutine, which is passed to every
4104 await_suspend(). This was created on demand when parsing we now link it
4105 into our scope. */
4113 /* If we have function parms, then these will be copied to the coroutine
4114 frame. Create a local (proxy) variable for each parm, since the original
4115 parms will be out of scope once the ramp has finished. The proxy vars will
4116 get DECL_VALUE_EXPRs pointing to the frame copies, so that we can interact
4117 with them in the debugger. */
4119 {
4121 /* Add a local var for each parm. */
4124 {
4127 parm_i->copy_var
4135 }
4137 /* Now replace all uses of the parms in the function body with the proxy
4138 vars. We want to this to apply to every instance of param's use, so
4139 don't include a 'visited' hash_set on the tree walk, however we will
4140 arrange to visit each containing expression only once. */
4145 }
4147 /* We create a resume index, this is initialized in the ramp. */
4148 resume_idx_var
4155 /* If the coroutine has a frame that needs to be freed, this will be set by
4156 the ramp. */
4164 {
4165 /* Build promise.unhandled_exception(); */
4166 tree ueh
4168 coro_unhandled_exception_identifier,
4170 /* Create and initialize the initial-await-resume-called variable per
4171 [dcl.fct.def.coroutine] / 5.3. */
4172 tree i_a_r_c
4175 boolean_false_node);
4179 /* Start the try-catch. */
4184 {
4185 /* Build a compound expression that sets the
4186 initial-await-resume-called variable true and then calls the
4187 initial suspend expression await resume. */
4191 boolean_true_node);
4194 }
4195 /* Add the initial await to the start of the user-authored function. */
4197 /* Append the original function body. */
4203 /* Mimic what the parser does for the catch. */
4207 /* Get the initial await resume called value. */
4212 /* If the initial await resume called value is false, rethrow... */
4221 /* ... else call the promise unhandled exception method
4222 but first we set done = true and the resume index to 0.
4223 If the unhandled exception method returns, then we continue
4224 to the final await expression (which duplicates the clearing of
4225 the field). */
4227 zero_resume);
4231 short_zero);
4236 }
4237 else
4238 {
4240 {
4241 /* We still try to look for the promise method and warn if it's not
4242 present. */
4243 tree ueh_meth
4248 coro_unhandled_exception_identifier,
4250 }
4251 /* Else we don't check and don't care if the method is missing..
4252 just add the initial suspend, function and return. */
4254 /* Append the original function body. */
4258 }
4260 /* co_return branches to the final_suspend label, so declare that now. */
4261 fs_label
4265 /* Before entering the final suspend point, we signal that this point has
4266 been reached by setting the resume function pointer to zero (this is
4267 what the 'done()' builtin tests) as per the current ABI. */
4269 zero_resume);
4277 }
4279 /* Here we:
4280 a) Check that the function and promise type are valid for a
4281 coroutine.
4282 b) Carry out the initial morph to create the skeleton of the
4283 coroutine ramp function and the rewritten body.
4285 Assumptions.
4287 1. We only hit this code once all dependencies are resolved.
4288 2. The function body will be either a bind expr or a statement list
4289 3. That cfun and current_function_decl are valid for the case we're
4290 expanding.
4291 4. 'input_location' will be of the final brace for the function.
4293 We do something like this:
4294 declare a dummy coro frame.
4295 struct _R_frame {
4296 using handle_type = coro::coroutine_handle<coro1::promise_type>;
4297 void (*_Coro_resume_fn)(_R_frame *);
4298 void (*_Coro_destroy_fn)(_R_frame *);
4299 coro1::promise_type _Coro_promise;
4300 bool _Coro_frame_needs_free; free the coro frame mem if set.
4301 bool _Coro_i_a_r_c; [dcl.fct.def.coroutine] / 5.3
4302 short _Coro_resume_index;
4303 handle_type _Coro_self_handle;
4304 parameter copies (were required).
4305 local variables saved (including awaitables)
4306 (maybe) trailing space.
4307 }; */
4309 bool
4311 {
4317 {
4318 /* For early errors, we do not want a diagnostic about the missing
4319 ramp return value, since the user cannot fix this - a 'return' is
4320 not allowed in a coroutine. */
4322 /* Discard the body, we can't process it further. */
4326 }
4328 /* We can't validly get here with an empty statement list, since there's no
4329 way for the FE to decide it's a coroutine in the absence of any code. */
4333 /* We don't have the locus of the opening brace - it's filled in later (and
4334 there doesn't really seem to be any easy way to get at it).
4335 The closing brace is assumed to be input_location. */
4339 /* Initial processing of the function-body.
4340 If we have no expressions or just an error then punt. */
4343 {
4346 /* Suppress warnings about the missing return value. */
4349 }
4351 /* So, we've tied off the original user-authored body in fn_body.
4353 Start the replacement synthesized ramp body as newbody.
4354 If we encounter a fatal error we might return a now-empty body.
4356 Note, the returned ramp body is not 'popped', to be compatible with
4357 the way that decl.c handles regular functions, the scope pop is done
4358 in the caller. */
4363 /* If our original body is noexcept, then that's what we apply to our
4364 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4367 {
4368 /* The function body we will continue with is the single operand to
4369 the must-not-throw. */
4371 /* Transfer the must-not-throw to the ramp body. */
4373 /* Re-start the ramp as must-not-throw. */
4375 }
4377 /* If the original function has a return value with a non-trivial DTOR
4378 and the body contains a var with a DTOR that might throw, the decl is
4379 marked "throwing_cleanup".
4380 We do not [in the ramp, which is synthesised here], use any body var
4381 types with DTORs that might throw.
4382 The original body is transformed into the actor function which only
4383 contains void returns, and is also wrapped in a try-catch block.
4384 So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
4385 not need to transfer it to the actor which only contains void returns. */
4388 /* Create the coro frame type, as far as it can be known at this stage.
4389 1. Types we already know. */
4395 /* 2. Types we need to define or look up. */
4401 tree act_des_fn_type
4405 /* Declare the actor and destroyer function. */
4411 /* Construct the wrapped function body; we will analyze this to determine
4412 the requirements for the coroutine frame. */
4419 act_des_fn_ptr,
4421 /* Build our dummy coro frame layout. */
4424 /* The fields for the coro frame. */
4427 /* We need to know, and inspect, each suspend point in the function
4428 in several places. It's convenient to place this map out of line
4429 since it's used from tree walk callbacks. */
4432 /* Now insert the data for any body await points, at this time we also need
4433 to promote any temporaries that are captured by reference (to regular
4434 vars) they will get added to the coro frame along with other locals. */
4435 susp_frame_data body_aw_points
4443 /* 4. Now make space for local vars, this is conservative again, and we
4444 would expect to delete unused entries later. */
4446 local_vars_frame_data local_vars_data
4450 /* Tie off the struct for now, so that we can build offsets to the
4451 known entries. */
4459 /* Ramp: */
4460 /* Now build the ramp function pieces. */
4471 /* To signal that we need to cleanup copied function args. */
4475 {
4482 }
4484 /* Signal that we need to clean up the promise object on exception. */
4485 tree coro_promise_live
4491 /* When the get-return-object is in the RETURN slot, we need to arrange for
4492 cleanup on exception. */
4493 tree coro_gro_live
4500 /* Collected the scope vars we need ... only one for now. */
4503 /* We're now going to create a new top level scope block for the ramp
4504 function. */
4511 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4512 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4513 directly apparently). This avoids a "used uninitialized" warning. */
4519 {
4524 }
4528 /* The CO_FRAME internal function is a mechanism to allow the middle end
4529 to adjust the allocation in response to optimizations. We provide the
4530 current conservative estimate of the frame size (as per the current)
4531 computed layout. */
4533 tree resizeable
4537 /* [dcl.fct.def.coroutine] / 10 (part1)
4538 The unqualified-id get_return_object_on_allocation_failure is looked up
4539 in the scope of the promise type by class member access lookup. */
4541 /* We don't require this, so coro_build_promise_expression can return NULL,
4542 but, if the lookup succeeds, then the function must be usable. */
4544 tree grooaf
4546 coro_gro_on_allocation_fail_identifier,
4549 /* however, should that fail, returning an error, the later stages can't
4550 handle the erroneous expression, so we reset the call as if it was
4551 absent. */
4555 /* Allocate the frame, this has several possibilities:
4556 [dcl.fct.def.coroutine] / 9 (part 1)
4557 The allocation function’s name is looked up in the scope of the promise
4558 type. It's not a failure for it to be absent see part 4, below. */
4564 {
4567 /* [dcl.fct.def.coroutine] / 9 (part 2)
4568 If the lookup finds an allocation function in the scope of the promise
4569 type, overload resolution is performed on a function call created by
4570 assembling an argument list. The first argument is the amount of space
4571 requested, and has type std::size_t. The succeeding arguments are
4572 those of the original function. */
4578 {
4582 {
4583 /* We pass a reference to *this to the allocator lookup. */
4589 tf_warning_or_error);
4591 }
4592 else
4594 }
4596 /* Note the function selected; we test to see if it's NOTHROW. */
4597 tree func;
4598 /* Failure is not an error for this attempt. */
4604 {
4605 /* [dcl.fct.def.coroutine] / 9 (part 3)
4606 If no viable function is found, overload resolution is performed
4607 again on a function call created by passing just the amount of
4608 space required as an argument of type std::size_t. */
4612 tf_none);
4614 }
4616 /* However, if the promise provides an operator new, then one of these
4617 two options must be available. */
4619 {
4623 }
4629 " no usable %<get_return_object_on_allocation_failure%>"
4631 }
4633 {
4634 /* [dcl.fct.def.coroutine] / 9 (part 4)
4635 If this lookup fails, the allocation function’s name is looked up in
4636 the global scope. */
4639 /* build_operator_new_call () will insert size needed as element 0 of
4640 this, and we might need to append the std::nothrow constant. */
4643 {
4644 /* [dcl.fct.def.coroutine] / 10 (part 2)
4645 If any declarations (of the get return on allocation fail) are
4646 found, then the result of a call to an allocation function used
4647 to obtain storage for the coroutine state is assumed to return
4648 nullptr if it fails to obtain storage and, if a global allocation
4649 function is selected, the ::operator new(size_t, nothrow_t) form
4650 is used. The allocation function used in this case shall have a
4651 non-throwing noexcept-specification. So we need std::nothrow. */
4660 }
4662 /* If we get to this point, we must succeed in looking up the global
4663 operator new for the params provided. Extract a simplified version
4664 of the machinery from build_operator_new_call. This can update the
4665 frame size. */
4670 tf_warning_or_error);
4671 resizeable = build_call_expr_internal_loc
4673 /* If the operator call fails for some reason, then don't try to
4674 amend it. */
4679 }
4686 /* If the user provided a method to return an object on alloc fail, then
4687 check the returned pointer and call the func if it's null.
4688 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4691 {
4692 /* [dcl.fct.def.coroutine] / 10 (part 3)
4693 If the allocation function returns nullptr,the coroutine returns
4694 control to the caller of the coroutine and the return value is
4695 obtained by a call to T::get_return_object_on_allocation_failure(),
4696 where T is the promise type. */
4704 {
4705 /* Execute the get-return-object-on-alloc-fail call... */
4707 /* ... but discard the result, since we return void. */
4709 }
4710 else
4711 {
4712 /* Get the fallback return object. */
4715 }
4718 }
4720 /* Up to now any exception thrown will propagate directly to the caller.
4721 This is OK since the only source of such exceptions would be in allocation
4722 of the coroutine frame, and therefore the ramp will not have initialized
4723 any further state. From here, we will track state that needs explicit
4724 destruction in the case that promise or g.r.o setup fails or an exception
4725 is thrown from the initial suspend expression. */
4728 {
4732 }
4734 /* deref the frame pointer, to use in member access code. */
4737 /* For now, once allocation has succeeded we always assume that this needs
4738 destruction, there's no impl. for frame allocation elision. */
4747 /* Put the resumer and destroyer functions in. */
4750 tree resume_m
4759 tree destroy_m
4762 tree destroy_x
4764 tf_warning_or_error);
4768 /* [dcl.fct.def.coroutine] /13
4769 When a coroutine is invoked, a copy is created for each coroutine
4770 parameter. Each such copy is an object with automatic storage duration
4771 that is direct-initialized from an lvalue referring to the corresponding
4772 parameter if the parameter is an lvalue reference, and from an xvalue
4773 referring to it otherwise. A reference to a parameter in the function-
4774 body of the coroutine and in the call to the coroutine promise
4775 constructor is replaced by a reference to its copy. */
4779 /* The initialization and destruction of each parameter copy occurs in the
4780 context of the called coroutine. Initializations of parameter copies are
4781 sequenced before the call to the coroutine promise constructor and
4782 indeterminately sequenced with respect to each other. The lifetime of
4783 parameter copies ends immediately after the lifetime of the coroutine
4784 promise object ends. */
4789 {
4793 {
4799 tf_warning_or_error);
4800 tree fld_idx
4804 /* Add this to the promise CTOR arguments list, accounting for
4805 refs and special handling for method this ptr. */
4807 {
4808 /* We pass a reference to *this to the param preview. */
4816 tf_warning_or_error);
4818 }
4821 else
4825 /* Initialise the frame reference field directly. */
4828 else
4829 {
4832 tf_warning_or_error);
4833 }
4836 {
4840 /* Cleanup this frame copy on exception. */
4841 parm.fr_copy_dtor
4844 LOOKUP_NORMAL,
4845 tf_warning_or_error);
4847 {
4848 /* This var is now live. */
4853 }
4854 }
4855 }
4856 }
4858 /* Set up the promise. */
4859 tree promise_m
4868 {
4869 /* Do a placement new constructor for the promise type (we never call
4870 the new operator, just the constructor on the object in place in the
4871 frame).
4873 First try to find a constructor with the same parameter list as the
4874 original function (if it has params), failing that find a constructor
4875 with no parameter list. */
4878 {
4883 }
4884 else
4890 tf_warning_or_error);
4897 boolean_type_node);
4900 promise_dtor
4903 tf_warning_or_error);
4904 }
4906 /* Set up a new bind context for the GRO. */
4908 /* Make and connect the scope blocks. */
4915 tree get_ro
4917 coro_get_return_object_identifier,
4919 /* Without a return object we haven't got much clue what's going on. */
4921 {
4924 /* Suppress warnings about the missing return value. */
4927 }
4935 /* Used for return objects in the RESULT slot. */
4938 /* We have to sequence the call to get_return_object before initial
4939 suspend. */
4943 {
4944 /* [dcl.fct.def.coroutine] / 7
4945 The expression promise.get_return_object() is used to initialize the
4946 glvalue result or... (see below)
4947 Construct the return result directly. */
4949 {
4952 complete_ctor_identifier,
4954 tf_warning_or_error);
4956 }
4957 else
4962 /* If some part of the initalization code (prior to the await_resume
4963 of the initial suspend expression), then we need to clean up the
4964 return value. */
4965 gro_ret_dtor
4969 tf_warning_or_error);
4970 }
4971 else
4972 {
4973 /* ... or ... Construct an object that will be used as the single
4974 param to the CTOR for the return object. */
4976 NULL_TREE);
4980 tf_warning_or_error);
4981 /* The constructed object might require a cleanup. */
4983 {
4984 gro_cleanup_stmt
4987 tf_warning_or_error);
4990 }
4991 }
4997 /* If we have a live g.r.o in the return slot, then signal this for exception
4998 cleanup. */
5000 {
5003 boolean_type_node);
5005 }
5006 /* Initialize the resume_idx_var to 0, meaning "not started". */
5007 tree resume_idx_m
5010 tree resume_idx
5012 tf_warning_or_error);
5018 /* So .. call the actor .. */
5023 /* Switch to using 'input_location' as the loc, since we're now more
5024 logically doing things related to the end of the function. */
5026 /* The ramp is done, we just need the return value.
5027 [dcl.fct.def.coroutine] / 7
5028 The expression promise.get_return_object() is used to initialize the
5029 glvalue result or prvalue result object of a call to a coroutine.
5031 If the 'get return object' is non-void, then we built it before the
5032 promise was constructed. We now supply a reference to that var,
5033 either as the return value (if it's the same type) or to the CTOR
5034 for an object of the return type. */
5039 /* check_return_expr will automatically return gro as an rvalue via
5040 treat_lvalue_as_rvalue_p. */
5043 {
5044 /* For class type return objects, we can attempt to construct,
5045 even if the gro is void. ??? Citation ??? c++/100476 */
5049 tf_warning_or_error);
5051 }
5052 else
5053 {
5054 /* We can't initialize a non-class return value from void. */
5058 }
5063 {
5067 }
5069 /* Finish up the ramp function. */
5075 {
5080 /* If we have a live G.R.O in the return slot, then run its DTOR.
5081 When the return object is constructed from a separate g.r.o, this is
5082 already handled by its regular cleanup. */
5084 {
5093 }
5095 /* If the promise is live, then run its dtor if that's available. */
5097 {
5106 }
5108 /* Clean up any frame copies of parms with non-trivial dtors. */
5112 {
5117 {
5126 }
5127 }
5129 /* We always expect to delete the frame. */
5138 }
5143 /* Start to build the final functions.
5145 We push_deferring_access_checks to avoid these routines being seen as
5146 nested by the middle end; we are doing the outlining here. */
5150 /* Build the actor... */
5155 /* Destroyer ... */
5161 /* Link our new functions into the list. */
5172 }