| blob | 60b846600b923b30b2d692412d2ca28b66052542 |
1 /* coroutine-specific state, expansions and tests.
3 Copyright (C) 2018-2022 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 {
1029 tf_warning_or_error);
1030 }
1032 /* I suppose we could check that this is contextually convertible to bool. */
1034 tree awrd_call
1041 /* The suspend method may return one of three types:
1042 1. void (no special action needed).
1043 2. bool (if true, we don't need to suspend).
1044 3. a coroutine handle, we execute the handle.resume() call. */
1048 tree awsp_call
1065 {
1069 }
1072 {
1076 }
1078 /* Finally, the type of e.await_resume() is the co_await's type. */
1080 tree awrs_call
1088 {
1099 tf_none))
1100 {
1106 }
1107 }
1109 /* We now have three call expressions, in terms of the promise, handle and
1110 'e' proxies. Save them in the await expression for later expansion. */
1117 {
1120 }
1130 {
1134 }
1137 }
1139 tree
1141 {
1149 /* The current function has now become a coroutine, if it wasn't already. */
1152 /* This function will appear to have no return statement, even if it
1153 is declared to return non-void (most likely). This is correct - we
1154 synthesize the return for the ramp in the compiler. So suppress any
1155 extraneous warnings during substitution. */
1158 /* Defer expansion when we are processing a template.
1159 FIXME: If the coroutine function's type is not dependent, and the operand
1160 is not dependent, we should determine the type of the co_await expression
1161 using the DEPENDENT_EXPR wrapper machinery. That allows us to determine
1162 the subexpression type, but leave its operand unchanged and then
1163 instantiate it later. */
1165 {
1168 integer_zero_node);
1171 }
1173 /* We must be able to look up the "await_transform" method in the scope of
1174 the promise type, and obtain its return type. */
1178 /* [expr.await] 3.2
1179 The incoming cast expression might be transformed by a promise
1180 'await_transform()'. */
1181 tree at_meth
1190 {
1191 /* try to build a = p.await_transform (e). */
1194 current_function_decl),
1198 /* As I read the section.
1199 We saw an await_transform method, so it's mandatory that we replace
1200 expr with p.await_transform (expr), therefore if the method call fails
1201 (presumably, we don't have suitable arguments) then this part of the
1202 process fails. */
1205 }
1207 /* Now we want to build co_await a. */
1209 }
1211 /* Take the EXPR given and attempt to build:
1212 co_await p.yield_value (expr);
1213 per [expr.yield] para 1. */
1215 tree
1217 {
1221 /* Check the general requirements and simple syntax errors. */
1226 /* The current function has now become a coroutine, if it wasn't already. */
1229 /* This function will appear to have no return statement, even if it
1230 is declared to return non-void (most likely). This is correct - we
1231 synthesize the return for the ramp in the compiler. So suppress any
1232 extraneous warnings during substitution. */
1235 /* Defer expansion when we are processing a template; see FIXME in the
1236 co_await code. */
1241 /* We must be able to look up the "yield_value" method in the scope of
1242 the promise type, and obtain its return type. */
1245 /* [expr.yield] / 1
1246 Let e be the operand of the yield-expression and p be an lvalue naming
1247 the promise object of the enclosing coroutine, then the yield-expression
1248 is equivalent to the expression co_await p.yield_value(e).
1249 build p.yield_value(e): */
1251 tree yield_call
1257 /* Now build co_await p.yield_value (e).
1258 Noting that for co_yield, there is no evaluation of any potential
1259 promise transform_await(), so we call build_co_await directly. */
1263 {
1266 /* If the await expression is wrapped in a TARGET_EXPR, then transfer
1267 that wrapper to the CO_YIELD_EXPR, since this is just a proxy for
1268 its contained await. Otherwise, just build the CO_YIELD_EXPR. */
1270 {
1274 }
1275 else
1279 }
1282 }
1284 /* Check and build a co_return statement.
1285 First that it's valid to have a co_return keyword here.
1286 If it is, then check and build the p.return_{void(),value(expr)}.
1287 These are built against a proxy for the promise, which will be filled
1288 in with the actual frame version when the function is transformed. */
1290 tree
1292 {
1299 /* If it fails the following test, the function is not permitted to be a
1300 coroutine, so the co_return statement is erroneous. */
1305 /* The current function has now become a coroutine, if it wasn't
1306 already. */
1309 /* This function will appear to have no return statement, even if it
1310 is declared to return non-void (most likely). This is correct - we
1311 synthesize the return for the ramp in the compiler. So suppress any
1312 extraneous warnings during substitution. */
1319 /* Defer expansion when we are processing a template; see FIXME in the
1320 co_await code. */
1322 {
1323 /* co_return expressions are always void type, regardless of the
1324 expression type. */
1329 }
1334 /* Suppress -Wreturn-type for co_return, we need to check indirectly
1335 whether the promise type has a suitable return_void/return_value. */
1342 {
1343 /* If we had an id-expression obfuscated by force_paren_expr, we need
1344 to undo it so we can try to treat it as an rvalue below. */
1352 }
1354 /* If the promise object doesn't have the correct return call then
1355 there's a mis-match between the co_return <expr> and this. */
1358 co_ret_call
1360 else
1361 {
1362 /* [class.copy.elision] / 3.
1363 An implicitly movable entity is a variable of automatic storage
1364 duration that is either a non-volatile object or an rvalue reference
1365 to a non-volatile object type. For such objects in the context of
1366 the co_return, the overload resolution should be carried out first
1367 treating the object as an rvalue, if that fails, then we fall back
1368 to regular overload resolution. */
1375 co_ret_call
1379 }
1381 /* Makes no sense for a co-routine really. */
1384 "function declared %<noreturn%> has a"
1390 }
1392 /* We need to validate the arguments to __builtin_coro_promise, since the
1393 second two must be constant, and the builtins machinery doesn't seem to
1394 deal with that properly. */
1396 tree
1398 {
1403 {
1408 {
1409 /* Argument 0 is already checked by the normal built-in machinery
1410 Argument 1 must be a constant of size type. It probably makes
1411 little sense if it's not a power of 2, but that isn't specified
1412 formally. */
1416 /* We expect alignof expressions in templates. */
1419 ;
1421 {
1425 }
1426 /* Argument 2 is the direction - to / from handle address to promise
1427 address. */
1431 {
1435 }
1438 }
1439 }
1440 }
1442 /* ================= Morph and Expand. =================
1444 The entry point here is morph_fn_to_coro () which is called from
1445 finish_function () when we have completed any template expansion.
1447 This is preceded by helper functions that implement the phases below.
1449 The process proceeds in four phases.
1451 A Initial framing.
1452 The user's function body is wrapped in the initial and final suspend
1453 points and we begin building the coroutine frame.
1454 We build empty decls for the actor and destroyer functions at this
1455 time too.
1456 When exceptions are enabled, the user's function body will also be
1457 wrapped in a try-catch block with the catch invoking the promise
1458 class 'unhandled_exception' method.
1460 B Analysis.
1461 The user's function body is analyzed to determine the suspend points,
1462 if any, and to capture local variables that might persist across such
1463 suspensions. In most cases, it is not necessary to capture compiler
1464 temporaries, since the tree-lowering nests the suspensions correctly.
1465 However, in the case of a captured reference, there is a lifetime
1466 extension to the end of the full expression - which can mean across a
1467 suspend point in which case it must be promoted to a frame variable.
1469 At the conclusion of analysis, we have a conservative frame layout and
1470 maps of the local variables to their frame entry points.
1472 C Build the ramp function.
1473 Carry out the allocation for the coroutine frame (NOTE; the actual size
1474 computation is deferred until late in the middle end to allow for future
1475 optimizations that will be allowed to elide unused frame entries).
1476 We build the return object.
1478 D Build and expand the actor and destroyer function bodies.
1479 The destroyer is a trivial shim that sets a bit to indicate that the
1480 destroy dispatcher should be used and then calls into the actor.
1482 The actor function is the implementation of the user's state machine.
1483 The current suspend point is noted in an index.
1484 Each suspend point is encoded as a pair of internal functions, one in
1485 the relevant dispatcher, and one representing the suspend point.
1487 During this process, the user's local variables and the proxies for the
1488 self-handle and the promise class instance are re-written to their
1489 coroutine frame equivalents.
1491 The complete bodies for the ramp, actor and destroy function are passed
1492 back to finish_function for folding and gimplification. */
1494 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1496 static tree
1498 {
1500 }
1502 static tree
1504 {
1507 }
1509 /* Helpers to build an artificial var, with location LOC, NAME and TYPE, in
1510 CTX, and with initializer INIT. */
1512 static tree
1514 tree init)
1515 {
1522 }
1524 static tree
1527 {
1530 }
1532 /* Helpers for label creation:
1533 1. Create a named label in the specified context. */
1535 static tree
1537 {
1545 }
1547 /* 2. Create a named label in the specified context. */
1549 static tree
1551 {
1558 }
1560 struct proxy_replace
1561 {
1563 };
1565 static tree
1567 {
1571 {
1574 }
1575 else
1578 }
1580 /* Support for expansion of co_await statements. */
1582 struct coro_aw_data
1583 {
1594 };
1596 /* Lightweight search for the first await expression in tree-walk order.
1597 returns:
1598 The first await expression found in STMT.
1599 NULL_TREE if there are none.
1600 So can be used to determine if the statement needs to be processed for
1601 awaits. */
1603 static tree
1605 {
1608 {
1611 }
1613 }
1615 /* Starting with a statement:
1617 stmt => some tree containing one or more await expressions.
1619 We replace the statement with:
1620 <STATEMENT_LIST> {
1621 initialize awaitable
1622 if (!ready)
1623 {
1624 suspension context.
1625 }
1626 resume:
1627 revised statement with one await expression rewritten to its
1628 await_resume() return value.
1629 }
1631 We then recurse into the initializer and the revised statement
1632 repeating this replacement until there are no more await expressions
1633 in either. */
1637 {
1664 tree r;
1669 else
1670 {
1673 /* We have an initializer, which might itself contain await exprs. */
1675 }
1677 /* Use the await_ready() call to test if we need to suspend. */
1679 /* Convert to bool, if necessary. */
1682 tf_warning_or_error);
1683 /* Be aggressive in folding here, since there are a significant number of
1684 cases where the ready condition is constant. */
1686 ready_cond
1692 susp_idx);
1696 /* Find out what we have to do with the awaiter's suspend method.
1697 [expr.await]
1698 (5.1) If the result of await-ready is false, the coroutine is considered
1699 suspended. Then:
1700 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1701 await-suspend.resume() is evaluated.
1702 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1703 and the coroutine is resumed if the result is false.
1704 (5.1.3) Otherwise, await-suspend is evaluated. */
1710 /* NOTE: final suspend can't resume; the "resume" label in that case
1711 corresponds to implicit destruction. */
1713 {
1714 /* We just call await_suspend() and hit the yield. */
1717 }
1719 {
1720 /* Boolean return, continue if the call returns false. */
1722 suspend
1726 empty_list);
1728 }
1729 else
1730 {
1733 void_coro_handle_type))
1739 }
1763 /* Implement the suspend, a scope exit without clean ups. */
1779 /* part of finish switch. */
1790 {
1793 tf_warning_or_error);
1795 }
1800 empty_list);
1804 /* Resume point. */
1808 /* This will produce the value (if one is provided) from the co_await
1809 expression. */
1812 /* Sink to await_resume call_expr. */
1817 /* Get a pointer to the revised statement. */
1820 {
1823 tf_warning_or_error);
1825 }
1828 /* Replace the original statement with the expansion. */
1831 /* Now, if the awaitable had an initializer, expand any awaits that might
1832 be embedded in it. */
1838 /* Expand any more await expressions in the original statement. */
1843 }
1845 /* Check to see if a statement contains at least one await expression, if
1846 so, then process that. */
1848 static tree
1850 {
1855 }
1857 static tree
1859 {
1862 /* Process a statement at a time. */
1866 {
1868 {
1873 }
1875 }
1877 {
1880 }
1882 /* Continue statement walk, where required. */
1884 }
1886 /* Suspend point hash_map. */
1888 struct suspend_point_info
1889 {
1890 /* coro frame field type. */
1891 tree awaitable_type;
1892 /* coro frame field name. */
1893 tree await_field_id;
1894 };
1898 struct await_xform_data
1899 {
1901 tree actor_frame;
1902 };
1904 /* When we built the await expressions, we didn't know the coro frame
1905 layout, therefore no idea where to find the promise or where to put
1906 the awaitables. Now we know these things, fill them in. */
1908 static tree
1910 {
1914 {
1917 }
1919 /* So, on entry, we have:
1920 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1921 We no longer need a [it had diagnostic value, maybe?]
1922 We need to replace the e_proxy in the awr_call. */
1926 /* If we have a frame var for the awaitable, get a reference to it. */
1927 proxy_replace data;
1929 {
1930 tree as_m
1935 tf_warning_or_error);
1937 /* Replace references to the instance proxy with the frame entry now
1938 computed. */
1943 /* .. and replace. */
1945 }
1948 }
1950 /* A wrapper for the transform_await_expr function so that it can be a
1951 callback from cp_walk_tree. */
1953 static tree
1955 {
1956 /* Set actor function as new DECL_CONTEXT of label_decl. */
1962 /* We should have already lowered co_yields to their co_await. */
1972 }
1974 /* This caches information that we determine about function params,
1975 their uses and copies in the coroutine frame. */
1977 struct param_info
1978 {
1992 };
1994 struct local_var_info
1995 {
1996 tree field_id;
1997 tree field_idx;
1998 tree frame_type;
2002 location_t def_loc;
2003 };
2005 /* For figuring out what local variable usage we have. */
2006 struct local_vars_transform
2007 {
2008 tree context;
2009 tree actor_frame;
2010 tree coro_frame_type;
2011 location_t loc;
2013 };
2015 static tree
2017 {
2020 /* For each var in this bind expr (that has a frame id, which means it was
2021 accessed), build a frame reference and add it as the DECL_VALUE_EXPR. */
2024 {
2025 tree lvar;
2028 {
2030 local_var_info &local_var
2034 /* Re-write the variable's context to be in the actor func. */
2037 /* For capture proxies, this could include the decl value expr. */
2041 /* TODO: implement selective generation of fields when vars are
2042 known not-used. */
2046 tree fld_ref
2049 tf_warning_or_error);
2055 }
2059 }
2061 }
2063 /* A helper to build the frame DTOR.
2064 [dcl.fct.def.coroutine] / 12
2065 The deallocation function’s name is looked up in the scope of the promise
2066 type. If this lookup fails, the deallocation function’s name is looked up
2067 in the global scope. If deallocation function lookup finds both a usual
2068 deallocation function with only a pointer parameter and a usual
2069 deallocation function with both a pointer parameter and a size parameter,
2070 then the selected deallocation function shall be the one with two
2071 parameters. Otherwise, the selected deallocation function shall be the
2072 function with one parameter. If no usual deallocation function is found
2073 the program is ill-formed. The selected deallocation function shall be
2074 called with the address of the block of storage to be reclaimed as its
2075 first argument. If a deallocation function with a parameter of type
2076 std::size_t is used, the size of the block is passed as the corresponding
2077 argument. */
2079 static tree
2082 {
2089 {
2090 /* Look for sized version first, since this takes precedence. */
2096 /* It's OK to fail for this one... */
2099 tf_none);
2102 {
2107 tf_none);
2108 }
2110 /* But one of them must succeed, or the program is ill-formed. */
2112 {
2116 }
2117 }
2118 else
2119 {
2123 tf_warning_or_error);
2126 }
2128 }
2130 /* The actor transform. */
2132 static void
2137 {
2139 /* Some things we inherit from the original function. */
2144 /* One param, the coro frame pointer. */
2147 /* We have a definition here. */
2160 NULL_TREE);
2165 /* Link in the block associated with the outer scope of the re-written
2166 function body. */
2178 /* The entry point for the actor code from the ramp. */
2179 tree actor_begin_label
2183 /* Declare the continuation handle. */
2186 /* Re-write local vars, similarly. */
2187 local_vars_transform xform_vars_data
2196 tree ret_label
2199 tree continue_label
2218 /* The destroy point numbered #1 is special, in that it is reached from a
2219 coroutine that is suspended after re-throwing from unhandled_exception().
2220 This label just invokes the cleanup of promise, param copies and the
2221 frame itself. */
2222 tree del_promise_label
2231 {
2237 l_num);
2243 }
2245 /* Insert the prototype dispatcher. */
2267 /* The final resume should be made to hit the default (trap, UB) entry
2268 although it will be unreachable via the normal entry point, since that
2269 is set to NULL on reaching final suspend. */
2271 {
2277 l_num);
2283 }
2285 /* Insert the prototype dispatcher. */
2294 /* actor's coroutine 'self handle'. */
2299 /* So construct the self-handle from the frame address. */
2312 /* Now we know the real promise, and enough about the frame layout to
2313 decide where to put things. */
2317 /* Transform the await expressions in the function body. Only do each
2318 await tree once! */
2322 /* Add in our function body with the co_returns rewritten to final form. */
2325 /* now do the tail of the function. */
2329 /* Destructors for the things we built explicitly. */
2332 tf_warning_or_error);
2335 tree del_frame_label
2340 /* Here deallocate the frame (if we allocated it), which we will have at
2341 present. */
2342 tree fnf_m
2353 {
2355 tree pid;
2357 {
2358 tree m
2363 tree dtor;
2364 dtor
2368 }
2369 }
2371 /* Build the frame DTOR. */
2381 /* done. */
2387 /* This is the suspend return point. */
2396 /* This is the 'continuation' return point. For such a case we have a coro
2397 handle (from the await_suspend() call) and we want handle.resume() to
2398 execute as a tailcall allowing arbitrary chaining of coroutines. */
2402 /* We want to force a tail-call even for O0/1, so this expands the resume
2403 call into its underlying implementation. */
2408 tree resume = build_call_expr_loc
2411 /* In order to support an arbitrary number of coroutine continuations,
2412 we must tail call them. However, some targets do not support indirect
2413 tail calls to arbitrary callees. See PR94359. */
2422 /* We've now rewritten the tree and added the initial and final
2423 co_awaits. Now pass over the tree and expand the co_awaits. */
2436 }
2438 /* The prototype 'destroy' function :
2439 frame->__Coro_resume_index |= 1;
2440 actor (frame); */
2442 static void
2444 tree actor)
2445 {
2446 /* One param, the coro frame pointer. */
2449 /* We have a definition here. */
2463 /* _resume_at |= 1 */
2470 /* So .. call the actor .. */
2475 /* done. */
2482 }
2484 /* Helper that returns an identifier for an appended extension to the
2485 current un-mangled function name. */
2487 static tree
2489 {
2490 /* Figure out the bits we need to generate names for the outlined things
2491 For consistency, this needs to behave the same way as
2492 ASM_FORMAT_PRIVATE_NAME does. */
2495 #ifndef NO_DOT_IN_LABEL
2497 #else
2498 #ifndef NO_DOLLAR_IN_LABEL
2500 #else
2503 #endif
2504 #endif
2512 {
2516 {
2519 }
2521 }
2522 else
2526 }
2528 /* Build an initial or final await initialized from the promise
2529 initial_suspend or final_suspend expression. */
2531 static tree
2533 {
2537 tree setup_call
2541 /* Check for noexcept on the final_suspend call. */
2546 /* So build the co_await for this */
2547 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2550 }
2552 /* Callback to record the essential data for each await point found in the
2553 function. */
2555 static bool
2557 {
2559 suspend_point_info &s
2562 {
2564 await_expr);
2566 }
2570 }
2572 /* This data set is used when analyzing statements for await expressions. */
2574 struct susp_frame_data
2575 {
2576 /* Function-wide. */
2584 /* Temporary values for one statement or expression being analyzed. */
2592 };
2594 /* If this is an await expression, then count it (both uniquely within the
2595 function and locally within a single statement). */
2597 static tree
2599 {
2602 /* We should have already lowered co_yields to their co_await. */
2608 /* Count how many awaits the current expression contains. */
2611 /* Each await suspend context is unique, this is a function-wide value. */
2614 /* Awaitables should either be user-locals or promoted to coroutine frame
2615 entries at this point, and their initializers should have been broken
2616 out. */
2624 /* Rewrite target expressions on the await_suspend () to remove extraneous
2625 cleanups for the awaitables, which are now promoted to frame vars and
2626 managed via that. */
2632 }
2634 /* There are cases where any await expression is relevant. */
2635 static tree
2637 {
2639 {
2644 }
2646 }
2648 static bool
2650 {
2659 }
2661 /* Structure to record sub-expressions that need to be handled by the
2662 statement flattener. */
2664 struct coro_interesting_subtree
2665 {
2668 };
2670 /* tree-walk callback that returns the first encountered sub-expression of
2671 a kind that needs to be handled specifically by the statement flattener. */
2673 static tree
2675 {
2679 {
2682 {
2685 }
2686 }
2689 {
2692 }
2695 }
2697 /* Node for a doubly-linked list of promoted variables and their
2698 initializers. When the initializer is a conditional expression
2699 the 'then' and 'else' clauses are represented by a linked list
2700 attached to then_cl and else_cl respectively. */
2702 struct var_nest_node
2703 {
2707 {
2712 }
2713 tree var;
2714 tree init;
2719 };
2721 /* This is called for single statements from the co-await statement walker.
2722 It checks to see if the statement contains any initializers for awaitables
2723 and if any of these capture items by reference. */
2725 static void
2728 {
2731 {
2733 /* Compound expressions must be flattened specifically. */
2735 {
2738 var_nest_node *ins
2740 /* The compiler (but not the user) can generate temporaries with
2741 uses in the second arm of a compound expr. */
2744 /* The two arms have been processed separately. */
2746 }
2748 /* Handle conditional expressions. */
2751 /* FALLTHROUGH */
2753 {
2756 {
2759 var_nest_node *ins
2765 }
2768 /* Reconstruct x = t ? y : z;
2769 as (void) t ? x = y : x = z; */
2773 /* We are allowed a void type throw in one or both of the cond
2774 expr arms. */
2777 {
2779 then_cl
2782 }
2785 {
2787 else_cl
2790 }
2792 }
2793 /* FALLTHROUGH */
2795 {
2798 /* If the condition contains an await expression, then we need to
2799 set that first and use a separate var. */
2801 {
2808 var_nest_node *ins
2812 }
2814 n->then_cl
2816 n->else_cl
2819 /* Point to the start of the flattened code. */
2826 }
2828 }
2834 {
2837 {
2838 /* Await expressions with initializers have a compiler-temporary
2839 as the awaitable. 'promote' this. */
2845 {
2849 {
2851 /* We can have non-lvalue-expressions here, but when we see
2852 a target expression, mark it as already used. */
2854 {
2856 gcc_checking_assert
2858 }
2859 }
2862 /* If this is a call and not a CTOR, then we didn't expect it. */
2863 gcc_checking_assert
2866 }
2872 }
2875 {
2876 /* We have a temporary; promote it, but allow for the idiom in code
2877 generated by the compiler like
2878 a = (target_expr produces temp, op uses temp). */
2891 tf_warning_or_error);
2892 /* Simplify for the case that we have an init containing the temp
2893 alone. */
2895 {
2903 }
2904 else
2905 {
2906 var_nest_node *ins
2908 /* We have to replace the target expr... */
2910 /* ... and any uses of its var. */
2913 /* Compiler-generated temporaries can also have uses in
2914 following arms of compound expressions, which will be listed
2915 in 'replace_in' if present. */
2920 }
2922 }
2924 }
2925 }
2927 /* Helper for 'process_conditional' that handles recursion into nested
2928 conditionals. */
2930 static void
2933 {
2934 do
2935 {
2937 {
2940 {
2944 {
2945 /* We didn't see this var before and it needs a DTOR, so
2946 build a guard variable for it. */
2951 boolean_type_node);
2954 }
2956 /* The initializer for this variable is replaced by a compound
2957 expression that performs the init and then records that the
2958 variable is live (and the DTOR should be run at the scope
2959 exit. */
2962 n->init
2964 }
2965 }
2967 {
2974 tree new_if
2978 }
2979 else
2983 }
2985 /* helper for 'maybe_promote_temps'.
2987 When we have a conditional expression which might embed await expressions
2988 and/or promoted variables, we need to handle it appropriately.
2990 The linked lists for the 'then' and 'else' clauses in a conditional node
2991 identify the promoted variables (but these cannot be wrapped in a regular
2992 cleanup).
2994 So recurse through the lists and build up a composite list of captured vars.
2995 Declare these and any guard variables needed to decide if a DTOR should be
2996 run. Then embed the conditional into a try-finally expression that handles
2997 running each DTOR conditionally on its guard variable. */
2999 static void
3001 {
3011 /* Declare the vars. There are two loops so that the boolean flags are
3012 grouped in the frame. */
3014 {
3019 }
3020 /* Define the guard flags for variables that need a DTOR. */
3022 {
3025 {
3030 }
3031 }
3032 tree new_if
3035 /* Build a set of conditional DTORs. */
3038 {
3044 tree cleanup
3047 tf_warning_or_error);
3053 }
3055 tree try_finally
3058 }
3060 /* Given *STMT, that contains at least one await expression.
3062 The full expression represented in the original source code will contain
3063 suspension points, but it is still required that the lifetime of temporary
3064 values extends to the end of the expression.
3066 We already have a mechanism to 'promote' user-authored local variables
3067 to a coroutine frame counterpart (which allows explicit management of the
3068 lifetime across suspensions). The transform here re-writes STMT into
3069 a bind expression, promotes temporary values into local variables in that
3070 and flattens the statement into a series of cleanups.
3072 Conditional expressions are re-written to regular 'if' statements.
3073 The cleanups for variables initialized inside a conditional (including
3074 nested cases) are wrapped in a try-finally clause, with guard variables
3075 to determine which DTORs need to be run. */
3077 static tree
3079 {
3084 /* Strip off uninteresting wrappers. */
3094 /* We walk the statement trees, flattening it into an ordered list of
3095 variables with initializers and fragments corresponding to compound
3096 expressions, truth or/and if and ternary conditionals. Conditional
3097 expressions carry a nested list of fragments for the then and else
3098 clauses. We anchor to the 'bottom' of the fragment list; we will write
3099 a cleanup nest with one shell for each variable initialized. */
3101 /* Check to see we didn't promote one twice. */
3109 /* We build the bind scope expression from the bottom-up.
3110 EXPR_LIST holds the inner expression nest at the current cleanup
3111 level (becoming the final expression list when we've exhausted the
3112 number of sub-expression fragments). */
3114 do
3115 {
3117 /* When we have a promoted variable, then add that to the bind scope
3118 and initialize it. When there's no promoted variable, we just need
3119 to run the initializer.
3120 If the initializer is a conditional expression, we need to collect
3121 and declare any promoted variables nested within it. DTORs for such
3122 variables must be run conditionally too. */
3124 {
3131 else
3135 {
3136 tree cleanup
3139 tf_warning_or_error);
3142 }
3144 {
3149 }
3150 }
3151 else
3152 {
3155 else
3158 {
3163 }
3164 }
3171 /* Now produce the bind expression containing the 'promoted' temporaries
3172 as its variable list, and the cleanup nest as the statement. */
3179 {
3182 {
3186 }
3187 }
3194 }
3196 /* Lightweight callback to determine two key factors:
3197 1) If the statement/expression contains any await expressions.
3198 2) If the statement/expression potentially requires a re-write to handle
3199 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3200 so that the await expressions are not processed in the case of the
3201 short-circuit arm.
3203 CO_YIELD expressions are re-written to their underlying co_await. */
3205 static tree
3207 {
3211 {
3214 /* co_yield is syntactic sugar, re-write it to co_await. */
3216 /* FALLTHROUGH */
3219 /* A non-null initializer for the awaiter means we need to expand. */
3225 {
3226 /* We don't need special action for awaits in the always-executed
3227 arm of a TRUTH_IF. */
3231 /* However, if there are await expressions on the conditionally
3232 executed branch, we must expand the TRUTH_IF to ensure that the
3233 expanded await expression control-flow is fully contained in the
3234 conditionally executed code. */
3240 {
3243 }
3244 /* We've done the sub-trees here. */
3246 }
3248 }
3251 }
3253 /* Given *EXPR
3254 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3255 the conditionally executed branch, change this in a ternary operator.
3257 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3258 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3260 Apply this recursively to the condition and the conditionally-exec
3261 branch. */
3265 tree scratch_var;
3267 };
3269 static tree
3271 {
3276 {
3280 /* FALLTHROUGH */
3282 {
3287 /* Transform truth expression into a cond expression with
3288 * the always-executed arm as the condition.
3289 * the conditionally-executed arm as the then clause.
3290 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3296 tree cond_expr
3306 /* We've manually processed necessary sub-trees here. */
3308 }
3310 }
3312 }
3314 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3315 name is made up from NAM_ROOT, NAM_VERS. */
3317 static tree
3320 {
3322 /* Build a variable to hold the condition, this will be included in the
3323 frame as a local var. */
3330 }
3332 /* Helper to build and add if (!cond) break; */
3334 static void
3336 {
3343 }
3345 /* Tree walk callback to replace continue statements with goto label. */
3346 static tree
3348 {
3359 {
3360 /* Unless it's a special case, just walk the subtrees as usual. */
3364 {
3367 /* re-write a continue to goto label. */
3371 }
3373 /* Statements that do not require recursion. */
3380 /* These must break recursion. */
3386 }
3387 }
3389 /* Tree walk callback to analyze, register and pre-process statements that
3390 contain await expressions. */
3392 static tree
3394 {
3398 /* Process a statement at a time. */
3400 {
3401 /* For conditional expressions, we might wish to add an artificial var
3402 to their containing bind expr. */
3404 /* We might need to insert a new bind expression, and want to link it
3405 into the correct scope, so keep a note of the current block scope. */
3414 }
3416 {
3418 {
3423 }
3426 }
3428 /* We have something to be handled as a single statement. We have to handle
3429 a few statements specially where await statements have to be moved out of
3430 constructs. */
3438 {
3439 /* Unless it's a special case, just walk the subtrees as usual. */
3442 /* When we have a conditional expression, which contains one or more
3443 await expressions, we have to break the condition out into a
3444 regular statement so that the control flow introduced by the await
3445 transforms can be implemented. */
3447 {
3450 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3451 bool cond = cond with awaits.
3452 if (cond) then stmt1 else stmt2. */
3454 /* We treat the condition as if it was a stand-alone statement,
3455 to see if there are any await expressions which will be analyzed
3456 and registered. */
3471 /* We want to initialize the new variable with the expression
3472 that contains the await(s) and potentially also needs to
3473 have truth_if expressions expanded. */
3480 /* So now walk the new statement list. */
3484 }
3487 {
3490 /* for loops only need special treatment if the condition or the
3491 iteration expression contain a co_await. */
3493 /* At present, the FE always generates a separate initializer for
3494 the FOR_INIT_STMT, when the expression has an await. Check that
3495 this assumption holds in the future. */
3496 gcc_checking_assert
3501 bool for_cond_await
3506 bool for_expr_await
3510 /* If the condition has an await, then we will need to rewrite the
3511 loop as
3512 for (init expression;true;iteration expression) {
3513 condition = await expression;
3514 if (condition)
3515 break;
3516 ...
3517 }
3518 */
3520 {
3522 /* This will be expanded when the revised body is handled. */
3524 /* .. add the original for body. */
3526 /* To make the new for body. */
3529 }
3530 /* If the iteration expression has an await, it's a bit more
3531 tricky.
3532 for (init expression;condition;) {
3533 ...
3534 iteration_expr_label:
3535 iteration expression with await;
3536 }
3537 but, then we will need to re-write any continue statements into
3538 'goto iteration_expr_label:'.
3539 */
3541 {
3544 /* The original for body. */
3547 tree it_expr_label
3552 /* Present the iteration expression as a statement. */
3559 /* rewrite continue statements to goto label. */
3564 }
3566 /* So now walk the body statement (list), if there were no await
3567 expressions, then this handles the original body - and either
3568 way we will have finished with this statement. */
3573 }
3576 {
3577 /* We turn 'while (cond with awaits) stmt' into
3578 while (true) {
3579 if (!(cond with awaits))
3580 break;
3581 stmt..
3582 } */
3592 /* The original while body. */
3594 /* The new while body. */
3597 /* So now walk the new statement list. */
3602 }
3605 {
3606 /* We turn do stmt while (cond with awaits) into:
3607 do {
3608 stmt..
3609 if (!(cond with awaits))
3610 break;
3611 } while (true); */
3620 /* The original do stmt body. */
3623 /* The new while body. */
3626 /* So now walk the new statement list. */
3631 }
3634 {
3635 /* We turn 'switch (cond with awaits) stmt' into
3636 switch_type cond = cond with awaits
3637 switch (cond) stmt. */
3646 /* Build a variable to hold the condition, this will be
3647 included in the frame as a local var. */
3660 cond_inner);
3663 /* Now add the switch statement with the condition re-
3664 written to use the local var. */
3667 /* Process the expanded list. */
3672 }
3675 {
3676 /* Expand the co_return as per [stmt.return.coroutine]
3677 - for co_return;
3678 { p.return_void (); goto final_suspend; }
3679 - for co_return [void expr];
3680 { expr; p.return_void(); goto final_suspend;}
3681 - for co_return [non void expr];
3682 { p.return_value(expr); goto final_suspend; } */
3687 /* [stmt.return.coroutine], 2.2
3688 If expr is present and void, it is placed immediately before
3689 the call for return_void; */
3692 /* Insert p.return_{void,value(expr)}. */
3698 /* Once this is complete, we will have processed subtrees. */
3701 }
3704 {
3705 /* [expr.await] An await-expression shall appear only in a
3706 potentially-evaluated expression within the compound-statement
3707 of a function-body outside of a handler. */
3716 }
3718 }
3720 {
3739 {
3740 /* If a truth-and/or-if expression has an await expression in the
3741 conditionally-taken branch, then it must be rewritten into a
3742 regular conditional. */
3746 }
3747 /* Process this statement, which contains at least one await expression
3748 to 'promote' temporary values to a coroutine frame slot. */
3750 }
3751 /* Continue recursion, if needed. */
3753 }
3755 /* For figuring out what param usage we have. */
3757 struct param_frame_data
3758 {
3762 location_t loc;
3764 };
3766 /* A tree walk callback that rewrites each parm use to the local variable
3767 that represents its copy in the frame. */
3769 static tree
3771 {
3774 /* For lambda closure content, we have to look specifically. */
3776 {
3779 }
3784 /* If we already saw the containing expression, then we're done. */
3794 }
3796 /* Build up a set of info that determines how each param copy will be
3797 handled. */
3801 {
3807 /* Build a hash map with an entry for each param.
3808 The key is the param tree.
3809 Then we have an entry for the frame field name.
3810 Then a cache for the field ref when we come to use it.
3811 Then a tree list of the uses.
3812 The second two entries start out empty - and only get populated
3813 when we see uses. */
3818 {
3830 {
3831 /* If the user passes by reference, then we will save the
3832 pointer to the original. As noted in
3833 [dcl.fct.def.coroutine] / 13, if the lifetime of the
3834 referenced item ends and then the coroutine is resumed,
3835 we have UB; well, the user asked for it. */
3838 else
3840 }
3851 {
3855 }
3859 {
3862 parm.guard_var
3865 boolean_false_node);
3868 }
3869 else
3871 }
3874 }
3876 /* Small helper for the repetitive task of adding a new field to the coro
3877 frame type. */
3879 static tree
3881 location_t loc)
3882 {
3888 }
3890 /* For recording local variable usage. */
3892 struct local_vars_frame_data
3893 {
3897 location_t loc;
3900 };
3902 /* A tree-walk callback that processes one bind expression noting local
3903 variables, and making a coroutine frame slot available for those that
3904 need it, so that they can be 'promoted' across suspension points. */
3906 static tree
3908 {
3911 /* As we enter a bind expression - record the vars there and then recurse.
3912 As we exit drop the nest depth.
3913 The bind index is a growing count of how many bind indices we've seen.
3914 We build a space in the frame for each local var. */
3917 {
3918 tree lvar;
3922 {
3924 local_var_info &local_var
3932 /* Make sure that we only present vars to the tests below. */
3937 /* We don't move static vars into the frame. */
3942 poly_uint64 size;
3945 {
3948 /* Ignore it, this is broken anyway. */
3950 }
3953 /* If this var is a lambda capture proxy, we want to leave it alone,
3954 and later rewrite the DECL_VALUE_EXPR to indirect through the
3955 frame copy of the pointer to the lambda closure object. */
3960 /* If a variable has a value expression, then that's what needs
3961 to be processed. */
3966 /* Make names depth+index unique, so that we can support nested
3967 scopes with identically named locals and still be able to
3968 identify them in the coroutine frame. */
3972 /* The outermost bind scope contains the artificial variables that
3973 we inject to implement the coro state machine. We want to be able
3974 to inspect these in debugging. */
3980 else
3982 serial++);
3984 /* TODO: Figure out if we should build a local type that has any
3985 excess alignment or size from the original decl. */
3989 /* We don't walk any of the local var sub-trees, they won't contain
3990 any bind exprs. */
3991 }
3997 }
3999 }
4001 /* Build, return FUNCTION_DECL node based on ORIG with a type FN_TYPE which has
4002 a single argument of type CORO_FRAME_PTR. Build the actor function if
4003 ACTOR_P is true, otherwise the destroy. */
4005 static tree
4008 {
4010 tree fn
4013 /* Allow for locating the ramp (original) function from this one. */
4029 /* Copy selected attributes from the original function. */
4033 /* Copy any alignment that the FE added. */
4036 /* Copy any alignment the user added. */
4038 /* Apply attributes from the original fn. */
4041 /* A void return. */
4048 /* This is a coroutine component. */
4051 /* Set up a means to find out if a decl is one of the helpers and, if so,
4052 which one. */
4054 {
4059 else
4061 }
4063 }
4065 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
4067 static tree
4070 tree resume_fn_ptr_type,
4072 {
4073 /* This will be our new outer scope. */
4079 /* If the function has a top level bind expression, then connect that
4080 after first making sure we give it a new block. */
4083 {
4088 /* Replace the top block to avoid issues with locations for args
4089 appearing to be in a non-existent place. */
4096 /* The top block has one child, so far, and we have now got a
4097 superblock. */
4100 }
4101 else
4102 {
4103 /* We are missing a top level BIND_EXPR. We need one to ensure that we
4104 don't shuffle around the coroutine frame and corrupt it. */
4109 }
4111 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
4112 are enabled. */
4116 /* [stmt.return.coroutine] / 3
4117 If p.return_void() is a valid expression, flowing off the end of a
4118 coroutine is equivalent to a co_return with no operand; otherwise
4119 flowing off the end of a coroutine results in undefined behavior. */
4120 tree return_void
4123 /* The pointer to the resume function. */
4124 tree resume_fn_ptr
4131 /* We will need to be able to set the resume function pointer to nullptr
4132 to signal that the coroutine is 'done'. */
4133 tree zero_resume
4136 /* The pointer to the destroy function. */
4143 /* The promise was created on demand when parsing we now link it into
4144 our scope. */
4152 /* We need a handle to this coroutine, which is passed to every
4153 await_suspend(). This was created on demand when parsing we now link it
4154 into our scope. */
4162 /* If we have function parms, then these will be copied to the coroutine
4163 frame. Create a local (proxy) variable for each parm, since the original
4164 parms will be out of scope once the ramp has finished. The proxy vars will
4165 get DECL_VALUE_EXPRs pointing to the frame copies, so that we can interact
4166 with them in the debugger. */
4168 {
4170 /* Add a local var for each parm. */
4173 {
4176 parm_i->copy_var
4184 }
4186 /* Now replace all uses of the parms in the function body with the proxy
4187 vars. We want to this to apply to every instance of param's use, so
4188 don't include a 'visited' hash_set on the tree walk, however we will
4189 arrange to visit each containing expression only once. */
4194 }
4196 /* We create a resume index, this is initialized in the ramp. */
4197 resume_idx_var
4204 /* If the coroutine has a frame that needs to be freed, this will be set by
4205 the ramp. */
4213 {
4214 /* Build promise.unhandled_exception(); */
4215 tree ueh
4217 coro_unhandled_exception_identifier,
4219 /* Create and initialize the initial-await-resume-called variable per
4220 [dcl.fct.def.coroutine] / 5.3. */
4221 tree i_a_r_c
4224 boolean_false_node);
4228 /* Start the try-catch. */
4233 {
4234 /* Build a compound expression that sets the
4235 initial-await-resume-called variable true and then calls the
4236 initial suspend expression await resume.
4237 In the case that the user decides to make the initial await
4238 await_resume() return a value, we need to discard it and, it is
4239 a reference type, look past the indirection. */
4246 boolean_true_node);
4249 }
4250 /* Add the initial await to the start of the user-authored function. */
4252 /* Append the original function body. */
4258 /* Mimic what the parser does for the catch. */
4262 /* Get the initial await resume called value. */
4267 /* If the initial await resume called value is false, rethrow... */
4276 /* ... else call the promise unhandled exception method
4277 but first we set done = true and the resume index to 0.
4278 If the unhandled exception method returns, then we continue
4279 to the final await expression (which duplicates the clearing of
4280 the field). */
4282 zero_resume);
4286 short_zero);
4291 }
4292 else
4293 {
4295 {
4296 /* We still try to look for the promise method and warn if it's not
4297 present. */
4298 tree ueh_meth
4303 coro_unhandled_exception_identifier,
4305 }
4306 /* Else we don't check and don't care if the method is missing..
4307 just add the initial suspend, function and return. */
4309 /* Append the original function body. */
4313 }
4315 /* co_return branches to the final_suspend label, so declare that now. */
4316 fs_label
4320 /* Before entering the final suspend point, we signal that this point has
4321 been reached by setting the resume function pointer to zero (this is
4322 what the 'done()' builtin tests) as per the current ABI. */
4324 zero_resume);
4332 }
4334 /* Here we:
4335 a) Check that the function and promise type are valid for a
4336 coroutine.
4337 b) Carry out the initial morph to create the skeleton of the
4338 coroutine ramp function and the rewritten body.
4340 Assumptions.
4342 1. We only hit this code once all dependencies are resolved.
4343 2. The function body will be either a bind expr or a statement list
4344 3. That cfun and current_function_decl are valid for the case we're
4345 expanding.
4346 4. 'input_location' will be of the final brace for the function.
4348 We do something like this:
4349 declare a dummy coro frame.
4350 struct _R_frame {
4351 using handle_type = coro::coroutine_handle<coro1::promise_type>;
4352 void (*_Coro_resume_fn)(_R_frame *);
4353 void (*_Coro_destroy_fn)(_R_frame *);
4354 coro1::promise_type _Coro_promise;
4355 bool _Coro_frame_needs_free; free the coro frame mem if set.
4356 bool _Coro_i_a_r_c; [dcl.fct.def.coroutine] / 5.3
4357 short _Coro_resume_index;
4358 handle_type _Coro_self_handle;
4359 parameter copies (were required).
4360 local variables saved (including awaitables)
4361 (maybe) trailing space.
4362 }; */
4364 bool
4366 {
4372 {
4373 /* For early errors, we do not want a diagnostic about the missing
4374 ramp return value, since the user cannot fix this - a 'return' is
4375 not allowed in a coroutine. */
4377 /* Discard the body, we can't process it further. */
4381 }
4383 /* We can't validly get here with an empty statement list, since there's no
4384 way for the FE to decide it's a coroutine in the absence of any code. */
4388 /* We don't have the locus of the opening brace - it's filled in later (and
4389 there doesn't really seem to be any easy way to get at it).
4390 The closing brace is assumed to be input_location. */
4394 /* Initial processing of the function-body.
4395 If we have no expressions or just an error then punt. */
4398 {
4401 /* Suppress warnings about the missing return value. */
4404 }
4406 /* So, we've tied off the original user-authored body in fn_body.
4408 Start the replacement synthesized ramp body as newbody.
4409 If we encounter a fatal error we might return a now-empty body.
4411 Note, the returned ramp body is not 'popped', to be compatible with
4412 the way that decl.cc handles regular functions, the scope pop is done
4413 in the caller. */
4418 /* If our original body is noexcept, then that's what we apply to our
4419 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4422 {
4423 /* The function body we will continue with is the single operand to
4424 the must-not-throw. */
4426 /* Transfer the must-not-throw to the ramp body. */
4428 /* Re-start the ramp as must-not-throw. */
4430 }
4432 /* If the original function has a return value with a non-trivial DTOR
4433 and the body contains a var with a DTOR that might throw, the decl is
4434 marked "throwing_cleanup".
4435 We do not [in the ramp, which is synthesised here], use any body var
4436 types with DTORs that might throw.
4437 The original body is transformed into the actor function which only
4438 contains void returns, and is also wrapped in a try-catch block.
4439 So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
4440 not need to transfer it to the actor which only contains void returns. */
4443 /* Create the coro frame type, as far as it can be known at this stage.
4444 1. Types we already know. */
4450 /* 2. Types we need to define or look up. */
4456 tree act_des_fn_type
4460 /* Declare the actor and destroyer function. */
4466 /* Construct the wrapped function body; we will analyze this to determine
4467 the requirements for the coroutine frame. */
4474 act_des_fn_ptr,
4476 /* Build our dummy coro frame layout. */
4479 /* The fields for the coro frame. */
4482 /* We need to know, and inspect, each suspend point in the function
4483 in several places. It's convenient to place this map out of line
4484 since it's used from tree walk callbacks. */
4487 /* Now insert the data for any body await points, at this time we also need
4488 to promote any temporaries that are captured by reference (to regular
4489 vars) they will get added to the coro frame along with other locals. */
4490 susp_frame_data body_aw_points
4498 /* 4. Now make space for local vars, this is conservative again, and we
4499 would expect to delete unused entries later. */
4501 local_vars_frame_data local_vars_data
4505 /* Tie off the struct for now, so that we can build offsets to the
4506 known entries. */
4514 /* Ramp: */
4515 /* Now build the ramp function pieces. */
4526 /* To signal that we need to cleanup copied function args. */
4530 {
4537 }
4539 /* Signal that we need to clean up the promise object on exception. */
4540 tree coro_promise_live
4546 /* When the get-return-object is in the RETURN slot, we need to arrange for
4547 cleanup on exception. */
4548 tree coro_gro_live
4555 /* Collected the scope vars we need ... only one for now. */
4558 /* We're now going to create a new top level scope block for the ramp
4559 function. */
4567 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4568 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4569 directly apparently). This avoids a "used uninitialized" warning. */
4575 {
4580 }
4584 /* The CO_FRAME internal function is a mechanism to allow the middle end
4585 to adjust the allocation in response to optimizations. We provide the
4586 current conservative estimate of the frame size (as per the current)
4587 computed layout. */
4589 tree resizeable
4593 /* [dcl.fct.def.coroutine] / 10 (part1)
4594 The unqualified-id get_return_object_on_allocation_failure is looked up
4595 in the scope of the promise type by class member access lookup. */
4597 /* We don't require this, so coro_build_promise_expression can return NULL,
4598 but, if the lookup succeeds, then the function must be usable. */
4600 tree grooaf
4602 coro_gro_on_allocation_fail_identifier,
4605 /* however, should that fail, returning an error, the later stages can't
4606 handle the erroneous expression, so we reset the call as if it was
4607 absent. */
4611 /* Allocate the frame, this has several possibilities:
4612 [dcl.fct.def.coroutine] / 9 (part 1)
4613 The allocation function’s name is looked up in the scope of the promise
4614 type. It's not a failure for it to be absent see part 4, below. */
4620 {
4623 /* [dcl.fct.def.coroutine] / 9 (part 2)
4624 If the lookup finds an allocation function in the scope of the promise
4625 type, overload resolution is performed on a function call created by
4626 assembling an argument list. The first argument is the amount of space
4627 requested, and has type std::size_t. The lvalues p1...pn are the
4628 succeeding arguments.. */
4634 {
4638 {
4639 /* We pass a reference to *this to the allocator lookup. */
4645 tf_warning_or_error);
4647 }
4648 else
4650 }
4652 /* Note the function selected; we test to see if it's NOTHROW. */
4653 tree func;
4654 /* Failure is not an error for this attempt. */
4660 {
4661 /* [dcl.fct.def.coroutine] / 9 (part 3)
4662 If no viable function is found, overload resolution is performed
4663 again on a function call created by passing just the amount of
4664 space required as an argument of type std::size_t. */
4668 tf_none);
4670 }
4672 /* However, if the promise provides an operator new, then one of these
4673 two options must be available. */
4675 {
4679 }
4685 " no usable %<get_return_object_on_allocation_failure%>"
4687 }
4689 {
4690 /* [dcl.fct.def.coroutine] / 9 (part 4)
4691 If this lookup fails, the allocation function’s name is looked up in
4692 the global scope. */
4695 /* build_operator_new_call () will insert size needed as element 0 of
4696 this, and we might need to append the std::nothrow constant. */
4699 {
4700 /* [dcl.fct.def.coroutine] / 10 (part 2)
4701 If any declarations (of the get return on allocation fail) are
4702 found, then the result of a call to an allocation function used
4703 to obtain storage for the coroutine state is assumed to return
4704 nullptr if it fails to obtain storage and, if a global allocation
4705 function is selected, the ::operator new(size_t, nothrow_t) form
4706 is used. The allocation function used in this case shall have a
4707 non-throwing noexcept-specification. So we need std::nothrow. */
4716 }
4718 /* If we get to this point, we must succeed in looking up the global
4719 operator new for the params provided. Extract a simplified version
4720 of the machinery from build_operator_new_call. This can update the
4721 frame size. */
4726 tf_warning_or_error);
4727 resizeable = build_call_expr_internal_loc
4729 /* If the operator call fails for some reason, then don't try to
4730 amend it. */
4735 }
4742 /* If the user provided a method to return an object on alloc fail, then
4743 check the returned pointer and call the func if it's null.
4744 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4747 {
4748 /* [dcl.fct.def.coroutine] / 10 (part 3)
4749 If the allocation function returns nullptr,the coroutine returns
4750 control to the caller of the coroutine and the return value is
4751 obtained by a call to T::get_return_object_on_allocation_failure(),
4752 where T is the promise type. */
4760 {
4761 /* Execute the get-return-object-on-alloc-fail call... */
4763 /* ... but discard the result, since we return void. */
4765 }
4766 else
4767 {
4768 /* Get the fallback return object. */
4771 }
4774 }
4776 /* Up to now any exception thrown will propagate directly to the caller.
4777 This is OK since the only source of such exceptions would be in allocation
4778 of the coroutine frame, and therefore the ramp will not have initialized
4779 any further state. From here, we will track state that needs explicit
4780 destruction in the case that promise or g.r.o setup fails or an exception
4781 is thrown from the initial suspend expression. */
4784 {
4788 }
4790 /* deref the frame pointer, to use in member access code. */
4793 /* For now, once allocation has succeeded we always assume that this needs
4794 destruction, there's no impl. for frame allocation elision. */
4803 /* Put the resumer and destroyer functions in. */
4806 tree resume_m
4815 tree destroy_m
4818 tree destroy_x
4820 tf_warning_or_error);
4824 /* [dcl.fct.def.coroutine] /13
4825 When a coroutine is invoked, a copy is created for each coroutine
4826 parameter. Each such copy is an object with automatic storage duration
4827 that is direct-initialized from an lvalue referring to the corresponding
4828 parameter if the parameter is an lvalue reference, and from an xvalue
4829 referring to it otherwise. A reference to a parameter in the function-
4830 body of the coroutine and in the call to the coroutine promise
4831 constructor is replaced by a reference to its copy. */
4835 /* The initialization and destruction of each parameter copy occurs in the
4836 context of the called coroutine. Initializations of parameter copies are
4837 sequenced before the call to the coroutine promise constructor and
4838 indeterminately sequenced with respect to each other. The lifetime of
4839 parameter copies ends immediately after the lifetime of the coroutine
4840 promise object ends. */
4845 {
4849 {
4855 tf_warning_or_error);
4856 tree fld_idx
4860 /* Add this to the promise CTOR arguments list, accounting for
4861 refs and special handling for method this ptr. */
4863 {
4864 /* We pass a reference to *this to the param preview. */
4872 tf_warning_or_error);
4874 }
4877 else
4881 /* Initialise the frame reference field directly. */
4884 else
4885 {
4888 tf_warning_or_error);
4889 }
4892 {
4896 /* Cleanup this frame copy on exception. */
4897 parm.fr_copy_dtor
4900 LOOKUP_NORMAL,
4901 tf_warning_or_error);
4903 {
4904 /* This var is now live. */
4909 }
4910 }
4911 }
4912 }
4914 /* Set up the promise. */
4915 tree promise_m
4924 {
4925 /* Do a placement new constructor for the promise type (we never call
4926 the new operator, just the constructor on the object in place in the
4927 frame).
4929 First try to find a constructor with the same parameter list as the
4930 original function (if it has params), failing that find a constructor
4931 with no parameter list. */
4934 {
4939 }
4940 else
4946 tf_warning_or_error);
4953 boolean_type_node);
4956 promise_dtor
4959 tf_warning_or_error);
4960 }
4962 /* Set up a new bind context for the GRO. */
4964 /* Make and connect the scope blocks. */
4971 tree get_ro
4973 coro_get_return_object_identifier,
4975 /* Without a return object we haven't got much clue what's going on. */
4977 {
4980 /* Suppress warnings about the missing return value. */
4983 }
4991 /* Used for return objects in the RESULT slot. */
4994 /* We have to sequence the call to get_return_object before initial
4995 suspend. */
4999 {
5000 /* [dcl.fct.def.coroutine] / 7
5001 The expression promise.get_return_object() is used to initialize the
5002 glvalue result or... (see below)
5003 Construct the return result directly. */
5005 {
5008 complete_ctor_identifier,
5010 tf_warning_or_error);
5012 }
5013 else
5018 /* If some part of the initalization code (prior to the await_resume
5019 of the initial suspend expression), then we need to clean up the
5020 return value. */
5021 gro_ret_dtor
5025 tf_warning_or_error);
5026 }
5027 else
5028 {
5029 /* ... or ... Construct an object that will be used as the single
5030 param to the CTOR for the return object. */
5032 NULL_TREE);
5036 tf_warning_or_error);
5037 /* The constructed object might require a cleanup. */
5039 {
5040 gro_cleanup_stmt
5043 tf_warning_or_error);
5046 }
5047 }
5053 /* If we have a live g.r.o in the return slot, then signal this for exception
5054 cleanup. */
5056 {
5059 boolean_type_node);
5061 }
5062 /* Initialize the resume_idx_var to 0, meaning "not started". */
5063 tree resume_idx_m
5066 tree resume_idx
5068 tf_warning_or_error);
5074 /* So .. call the actor .. */
5079 /* Switch to using 'input_location' as the loc, since we're now more
5080 logically doing things related to the end of the function. */
5082 /* The ramp is done, we just need the return value.
5083 [dcl.fct.def.coroutine] / 7
5084 The expression promise.get_return_object() is used to initialize the
5085 glvalue result or prvalue result object of a call to a coroutine.
5087 If the 'get return object' is non-void, then we built it before the
5088 promise was constructed. We now supply a reference to that var,
5089 either as the return value (if it's the same type) or to the CTOR
5090 for an object of the return type. */
5095 /* check_return_expr will automatically return gro as an rvalue via
5096 treat_lvalue_as_rvalue_p. */
5099 {
5100 /* For class type return objects, we can attempt to construct,
5101 even if the gro is void. ??? Citation ??? c++/100476 */
5105 tf_warning_or_error);
5107 }
5108 else
5109 {
5110 /* We can't initialize a non-class return value from void. */
5114 }
5119 {
5123 }
5125 /* Finish up the ramp function. */
5131 {
5136 /* If we have a live G.R.O in the return slot, then run its DTOR.
5137 When the return object is constructed from a separate g.r.o, this is
5138 already handled by its regular cleanup. */
5140 {
5149 }
5151 /* If the promise is live, then run its dtor if that's available. */
5153 {
5162 }
5164 /* Clean up any frame copies of parms with non-trivial dtors. */
5168 {
5173 {
5182 }
5183 }
5185 /* We always expect to delete the frame. */
5194 }
5199 /* Start to build the final functions.
5201 We push_deferring_access_checks to avoid these routines being seen as
5202 nested by the middle end; we are doing the outlining here. */
5206 /* Build the actor... */
5211 /* Destroyer ... */
5217 /* Link our new functions into the list. */
5228 }