| blob | 47c79e58db5395fe3049392a67b8750955b6f111 |
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 /* Create the identifiers used by the coroutines library interfaces. */
220 static void
222 {
237 coro_gro_on_allocation_fail_identifier =
244 }
246 /* Trees we only need to set up once. */
252 /* ================= Parse, Semantics and Type checking ================= */
254 /* This initial set of routines are helper for the parsing and template
255 expansion phases.
257 At the completion of this, we will have completed trees for each of the
258 keywords, but making use of proxy variables for the self-handle and the
259 promise class instance. */
261 /* [coroutine.traits]
262 Lookup the coroutine_traits template decl. */
264 static tree
266 {
267 /* If we are missing fundamental information, such as the traits, (or the
268 declaration found is not a type template), then don't emit an error for
269 every keyword in a TU, just do it once. */
277 {
279 {
285 }
287 }
288 else
290 }
292 /* Instantiate Coroutine traits for the function signature. */
294 static tree
296 {
297 /* [coroutine.traits.primary]
298 So now build up a type list for the template <typename _R, typename...>.
299 The types are the function's arg types and _R is the function return
300 type. */
309 {
312 {
313 /* We pass a reference to *this to the param preview. */
316 }
317 else
322 }
331 tree traits_class
337 {
340 }
343 }
345 /* [coroutine.handle] */
347 static tree
349 {
350 /* As for the coroutine traits, this error is per TU, so only emit
351 it once. */
358 {
364 }
365 else
367 }
369 /* Instantiate the handle template for a given promise type. */
371 static tree
373 {
374 /* So now build up a type list for the template, one entry, the promise. */
377 tree handle_type
384 {
388 }
391 }
393 /* Look for the promise_type in the instantiated traits. */
395 static tree
397 {
398 tree promise_type
403 promise_type
406 /* NULL_TREE on fail. */
408 }
410 static bool
412 {
416 {
417 /* Trees we only need to create once.
418 Set up the identifiers we will use. */
421 /* Coroutine traits template. */
426 /* coroutine_handle<> template. */
431 /* We can also instantiate the void coroutine_handle<> */
432 void_coro_handle_type =
437 /* A table to hold the state, per coroutine decl. */
439 coroutine_info_table =
446 }
448 /* Save the coroutine data on the side to avoid the overhead on every
449 function decl tree. */
452 /* Without this, we cannot really proceed. */
455 /* If we don't already have a current promise type, try to look it up. */
457 {
458 /* Get the coroutine traits template class instance for the function
459 signature we have - coroutine_traits <R, ...> */
463 /* Find the promise type for that. */
466 /* If we don't find it, punt on the rest. */
468 {
474 }
476 /* Test for errors in the promise type that can be determined now. */
478 coro_return_void_identifier,
480 tf_none);
482 coro_return_value_identifier,
484 tf_none);
486 {
498 }
500 /* Try to find the handle type for the promise. */
501 tree handle_type =
506 /* Complete this, we're going to use it. */
509 /* Diagnostic would be emitted by complete_type_or_else. */
513 /* Build a proxy for a handle to "self" as the param to
514 await_suspend() calls. */
515 coro_info->self_h_proxy
519 /* Build a proxy for the promise so that we can perform lookups. */
520 coro_info->promise_proxy
524 /* Note where we first saw a coroutine keyword. */
526 }
529 }
531 /* Map from actor or destroyer to ramp. */
534 /* Given a tree that is an actor or destroy, find the ramp function. */
536 tree
538 {
545 }
547 /* Given the DECL for a ramp function (the user's original declaration) return
548 the actor function if it has been defined. */
550 tree
552 {
557 }
559 /* Given the DECL for a ramp function (the user's original declaration) return
560 the destroy function if it has been defined. */
562 tree
564 {
569 }
571 /* These functions assumes that the caller has verified that the state for
572 the decl has been initialized, we try to minimize work here. */
574 static tree
576 {
581 }
583 static tree
585 {
590 }
592 static tree
594 {
599 }
601 static tree
603 {
608 }
610 static tree
613 {
615 tree pm_memb
619 {
622 }
624 }
626 /* Build an expression of the form p.method (args) where the p is a promise
627 object for the current coroutine.
628 OBJECT is the promise object instance to use, it may be NULL, in which case
629 we will use the promise_proxy instance for this coroutine.
630 ARGS may be NULL, for empty parm lists. */
632 static tree
636 {
641 /* If we don't find it, and it isn't needed, an empty return is OK. */
645 tree promise
648 tree expr;
652 else
653 {
659 else
662 }
664 }
666 /* Caching get for the expression p.return_void (). */
668 static tree
670 {
672 {
673 /* If we don't have it try to build it. */
675 info->return_void
677 coro_return_void_identifier,
679 /* Don't return an error if it's an optional call. */
683 }
685 }
687 /* Lookup an Awaitable member, which should be await_ready, await_suspend
688 or await_resume. */
690 static tree
692 {
693 tree aw_memb
697 {
700 }
702 }
704 /* Here we check the constraints that are common to all keywords (since the
705 presence of a coroutine keyword makes the function into a coroutine). */
707 static bool
710 {
712 {
715 }
717 /* This is arranged in order of prohibitions in the std. */
719 {
720 /* [basic.start.main] 3. The function main shall not be a coroutine. */
722 kw_name);
724 }
727 {
730 {
731 /* [dcl.constexpr] 3.3 it shall not be a coroutine. */
733 kw_name);
735 }
736 }
739 {
740 /* [dcl.spec.auto] 15. A function declared with a return type that uses
741 a placeholder type shall not be a coroutine. */
744 kw_name);
746 }
749 {
750 /* [dcl.fct.def.coroutine] The parameter-declaration-clause of the
751 coroutine shall not terminate with an ellipsis that is not part
752 of a parameter-declaration. */
756 }
759 {
760 /* [class.ctor] 7. a constructor shall not be a coroutine. */
763 }
766 {
767 /* [class.dtor] 21. a destructor shall not be a coroutine. */
770 }
773 }
775 /* Here we check the constraints that are not per keyword. */
777 static bool
779 {
782 /* For cases where fundamental information cannot be found, e.g. the
783 coroutine traits are missing, we need to punt early. */
787 /* Since we think the function is a coroutine, that implies we parsed
788 a keyword that triggered this. Keywords check promise validity for
789 their context and thus the promise type should be known at this point. */
795 {
796 /* TODO: record or extract positions of returns (and the first coro
797 keyword) so that we can add notes to the diagnostic about where
798 the bad keyword is and what made the function into a coro. */
802 }
805 }
809 CO_YIELD_SUSPEND_POINT,
810 INITIAL_SUSPEND_POINT,
811 FINAL_SUSPEND_POINT
812 };
814 /* Helper function to build a named variable for the temps we use for each
815 await point. The root of the name is determined by SUSPEND_KIND, and
816 the variable is of type V_TYPE. The awaitable number is reset each time
817 we encounter a final suspend. */
819 static tree
821 {
825 {
830 }
836 }
838 /* Helpers to diagnose missing noexcept on final await expressions. */
840 static bool
842 {
844 {
848 fndecl);
851 }
853 }
855 static bool
857 {
866 else
867 {
870 }
873 }
875 /* This performs [expr.await] bullet 3.3 and validates the interface obtained.
876 It is also used to build the initial and final suspend points.
878 'a', 'o' and 'e' are used as per the description in the section noted.
880 A, the original yield/await expr, is found at source location LOC.
882 We will be constructing a CO_AWAIT_EXPR for a suspend point of one of
883 the four suspend_point_kind kinds. This is indicated by SUSPEND_KIND. */
885 static tree
887 {
888 /* Try and overload of operator co_await, .... */
889 tree o;
891 {
894 /* If no viable functions are found, o is a. */
898 {
899 /* We found an overload for co_await(), diagnose throwing cases. */
904 /* We now know that the final suspend object is distinct from the
905 final awaiter, so check for a non-throwing DTOR where needed. */
911 tf_none))
912 {
918 }
919 }
920 }
921 else
932 {
934 o_type);
936 }
938 /* Check for required awaitable members and their types. */
939 tree awrd_meth
943 tree awsp_meth
948 /* The type of the co_await is the return type of the awaitable's
949 await_resume, so we need to look that up. */
950 tree awrs_meth
955 /* To complete the lookups, we need an instance of 'e' which is built from
956 'o' according to [expr.await] 3.4.
958 If we need to materialize this as a temporary, then that will have to be
959 'promoted' to a coroutine frame var. However, if the awaitable is a
960 user variable, parameter or comes from a scope outside this function,
961 then we must use it directly - or we will see unnecessary copies.
963 If o is a variable, find the underlying var. */
968 {
973 {
974 /* We could have operator-> here too. */
978 {
983 }
984 }
986 }
988 /* Only build a temporary if we need it. */
991 {
994 }
995 else
996 {
999 tf_warning_or_error);
1000 }
1002 /* I suppose we could check that this is contextually convertible to bool. */
1004 tree awrd_call
1011 /* The suspend method may return one of three types:
1012 1. void (no special action needed).
1013 2. bool (if true, we don't need to suspend).
1014 3. a coroutine handle, we execute the handle.resume() call. */
1018 tree awsp_call
1034 {
1038 }
1041 {
1045 }
1047 /* Finally, the type of e.await_resume() is the co_await's type. */
1049 tree awrs_call
1057 {
1068 tf_none))
1069 {
1075 }
1076 }
1078 /* We now have three call expressions, in terms of the promise, handle and
1079 'e' proxies. Save them in the await expression for later expansion. */
1086 {
1089 }
1098 {
1101 }
1104 }
1106 tree
1108 {
1116 /* The current function has now become a coroutine, if it wasn't already. */
1119 /* This function will appear to have no return statement, even if it
1120 is declared to return non-void (most likely). This is correct - we
1121 synthesize the return for the ramp in the compiler. So suppress any
1122 extraneous warnings during substitution. */
1125 /* If we don't know the promise type, we can't proceed, build the
1126 co_await with the expression unchanged. */
1132 /* We must be able to look up the "await_transform" method in the scope of
1133 the promise type, and obtain its return type. */
1137 /* [expr.await] 3.2
1138 The incoming cast expression might be transformed by a promise
1139 'await_transform()'. */
1140 tree at_meth
1149 {
1150 /* try to build a = p.await_transform (e). */
1153 current_function_decl),
1157 /* As I read the section.
1158 We saw an await_transform method, so it's mandatory that we replace
1159 expr with p.await_transform (expr), therefore if the method call fails
1160 (presumably, we don't have suitable arguments) then this part of the
1161 process fails. */
1164 }
1166 /* Now we want to build co_await a. */
1169 {
1172 }
1175 }
1177 /* Take the EXPR given and attempt to build:
1178 co_await p.yield_value (expr);
1179 per [expr.yield] para 1. */
1181 tree
1183 {
1187 /* Check the general requirements and simple syntax errors. */
1192 /* The current function has now become a coroutine, if it wasn't already. */
1195 /* This function will appear to have no return statement, even if it
1196 is declared to return non-void (most likely). This is correct - we
1197 synthesize the return for the ramp in the compiler. So suppress any
1198 extraneous warnings during substitution. */
1201 /* If we don't know the promise type, we can't proceed, build the
1202 co_await with the expression unchanged. */
1208 /* We must be able to look up the "yield_value" method in the scope of
1209 the promise type, and obtain its return type. */
1212 /* [expr.yield] / 1
1213 Let e be the operand of the yield-expression and p be an lvalue naming
1214 the promise object of the enclosing coroutine, then the yield-expression
1215 is equivalent to the expression co_await p.yield_value(e).
1216 build p.yield_value(e): */
1218 tree yield_call
1224 /* Now build co_await p.yield_value (e).
1225 Noting that for co_yield, there is no evaluation of any potential
1226 promise transform_await(), so we call build_co_await directly. */
1230 {
1233 /* If the await expression is wrapped in a TARGET_EXPR, then transfer
1234 that wrapper to the CO_YIELD_EXPR, since this is just a proxy for
1235 its contained await. Otherwise, just build the CO_YIELD_EXPR. */
1237 {
1241 }
1242 else
1246 }
1249 }
1251 /* Check and build a co_return statement.
1252 First that it's valid to have a co_return keyword here.
1253 If it is, then check and build the p.return_{void(),value(expr)}.
1254 These are built against a proxy for the promise, which will be filled
1255 in with the actual frame version when the function is transformed. */
1257 tree
1259 {
1266 /* If it fails the following test, the function is not permitted to be a
1267 coroutine, so the co_return statement is erroneous. */
1272 /* The current function has now become a coroutine, if it wasn't
1273 already. */
1276 /* This function will appear to have no return statement, even if it
1277 is declared to return non-void (most likely). This is correct - we
1278 synthesize the return for the ramp in the compiler. So suppress any
1279 extraneous warnings during substitution. */
1286 /* If we don't know the promise type, we can't proceed, build the
1287 co_return with the expression unchanged. */
1290 {
1291 /* co_return expressions are always void type, regardless of the
1292 expression type. */
1297 }
1302 /* Suppress -Wreturn-type for co_return, we need to check indirectly
1303 whether the promise type has a suitable return_void/return_value. */
1310 {
1311 /* If we had an id-expression obfuscated by force_paren_expr, we need
1312 to undo it so we can try to treat it as an rvalue below. */
1320 }
1322 /* If the promise object doesn't have the correct return call then
1323 there's a mis-match between the co_return <expr> and this. */
1326 co_ret_call
1328 else
1329 {
1330 /* [class.copy.elision] / 3.
1331 An implicitly movable entity is a variable of automatic storage
1332 duration that is either a non-volatile object or an rvalue reference
1333 to a non-volatile object type. For such objects in the context of
1334 the co_return, the overload resolution should be carried out first
1335 treating the object as an rvalue, if that fails, then we fall back
1336 to regular overload resolution. */
1343 co_ret_call
1347 }
1349 /* Makes no sense for a co-routine really. */
1352 "function declared %<noreturn%> has a"
1358 }
1360 /* We need to validate the arguments to __builtin_coro_promise, since the
1361 second two must be constant, and the builtins machinery doesn't seem to
1362 deal with that properly. */
1364 tree
1366 {
1371 {
1376 {
1377 /* Argument 0 is already checked by the normal built-in machinery
1378 Argument 1 must be a constant of size type. It probably makes
1379 little sense if it's not a power of 2, but that isn't specified
1380 formally. */
1384 /* We expect alignof expressions in templates. */
1387 ;
1389 {
1393 }
1394 /* Argument 2 is the direction - to / from handle address to promise
1395 address. */
1399 {
1403 }
1406 }
1407 }
1408 }
1410 /* ================= Morph and Expand. =================
1412 The entry point here is morph_fn_to_coro () which is called from
1413 finish_function () when we have completed any template expansion.
1415 This is preceded by helper functions that implement the phases below.
1417 The process proceeds in four phases.
1419 A Initial framing.
1420 The user's function body is wrapped in the initial and final suspend
1421 points and we begin building the coroutine frame.
1422 We build empty decls for the actor and destroyer functions at this
1423 time too.
1424 When exceptions are enabled, the user's function body will also be
1425 wrapped in a try-catch block with the catch invoking the promise
1426 class 'unhandled_exception' method.
1428 B Analysis.
1429 The user's function body is analyzed to determine the suspend points,
1430 if any, and to capture local variables that might persist across such
1431 suspensions. In most cases, it is not necessary to capture compiler
1432 temporaries, since the tree-lowering nests the suspensions correctly.
1433 However, in the case of a captured reference, there is a lifetime
1434 extension to the end of the full expression - which can mean across a
1435 suspend point in which case it must be promoted to a frame variable.
1437 At the conclusion of analysis, we have a conservative frame layout and
1438 maps of the local variables to their frame entry points.
1440 C Build the ramp function.
1441 Carry out the allocation for the coroutine frame (NOTE; the actual size
1442 computation is deferred until late in the middle end to allow for future
1443 optimizations that will be allowed to elide unused frame entries).
1444 We build the return object.
1446 D Build and expand the actor and destroyer function bodies.
1447 The destroyer is a trivial shim that sets a bit to indicate that the
1448 destroy dispatcher should be used and then calls into the actor.
1450 The actor function is the implementation of the user's state machine.
1451 The current suspend point is noted in an index.
1452 Each suspend point is encoded as a pair of internal functions, one in
1453 the relevant dispatcher, and one representing the suspend point.
1455 During this process, the user's local variables and the proxies for the
1456 self-handle and the promise class instance are re-written to their
1457 coroutine frame equivalents.
1459 The complete bodies for the ramp, actor and destroy function are passed
1460 back to finish_function for folding and gimplification. */
1462 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1464 static tree
1466 {
1468 }
1470 static tree
1472 {
1475 }
1477 /* Helpers for label creation:
1478 1. Create a named label in the specified context. */
1480 static tree
1482 {
1490 }
1492 /* 2. Create a named label in the specified context. */
1494 static tree
1496 {
1503 }
1505 struct proxy_replace
1506 {
1508 };
1510 static tree
1512 {
1516 {
1519 }
1520 else
1523 }
1525 /* Support for expansion of co_await statements. */
1527 struct coro_aw_data
1528 {
1539 };
1541 /* Lightweight search for the first await expression in tree-walk order.
1542 returns:
1543 The first await expression found in STMT.
1544 NULL_TREE if there are none.
1545 So can be used to determine if the statement needs to be processed for
1546 awaits. */
1548 static tree
1550 {
1553 {
1556 }
1558 }
1560 /* Starting with a statement:
1562 stmt => some tree containing one or more await expressions.
1564 We replace the statement with:
1565 <STATEMENT_LIST> {
1566 initialize awaitable
1567 if (!ready)
1568 {
1569 suspension context.
1570 }
1571 resume:
1572 revised statement with one await expression rewritten to its
1573 await_resume() return value.
1574 }
1576 We then recurse into the initializer and the revised statement
1577 repeating this replacement until there are no more await expressions
1578 in either. */
1582 {
1609 tree r;
1614 else
1615 {
1618 /* We have an initializer, which might itself contain await exprs. */
1620 }
1622 /* Use the await_ready() call to test if we need to suspend. */
1624 /* Convert to bool, if necessary. */
1627 tf_warning_or_error);
1628 /* Be aggressive in folding here, since there are a significant number of
1629 cases where the ready condition is constant. */
1631 ready_cond
1637 susp_idx);
1641 /* Find out what we have to do with the awaiter's suspend method.
1642 [expr.await]
1643 (5.1) If the result of await-ready is false, the coroutine is considered
1644 suspended. Then:
1645 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1646 await-suspend.resume() is evaluated.
1647 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1648 and the coroutine is resumed if the result is false.
1649 (5.1.3) Otherwise, await-suspend is evaluated. */
1655 /* NOTE: final suspend can't resume; the "resume" label in that case
1656 corresponds to implicit destruction. */
1658 {
1659 /* We just call await_suspend() and hit the yield. */
1662 }
1664 {
1665 /* Boolean return, continue if the call returns false. */
1667 suspend
1671 empty_list);
1673 }
1674 else
1675 {
1681 }
1705 /* Implement the suspend, a scope exit without clean ups. */
1721 /* part of finish switch. */
1732 {
1735 tf_warning_or_error);
1737 }
1742 empty_list);
1746 /* Resume point. */
1750 /* This will produce the value (if one is provided) from the co_await
1751 expression. */
1754 /* Sink to await_resume call_expr. */
1759 /* Get a pointer to the revised statement. */
1762 {
1765 tf_warning_or_error);
1767 }
1770 /* Replace the original statement with the expansion. */
1773 /* Now, if the awaitable had an initializer, expand any awaits that might
1774 be embedded in it. */
1780 /* Expand any more await expressions in the the original statement. */
1785 }
1787 /* Check to see if a statement contains at least one await expression, if
1788 so, then process that. */
1790 static tree
1792 {
1797 }
1799 static tree
1801 {
1804 /* Process a statement at a time. */
1808 {
1810 {
1815 }
1817 }
1819 {
1822 }
1824 /* Continue statement walk, where required. */
1826 }
1828 /* Suspend point hash_map. */
1830 struct suspend_point_info
1831 {
1832 /* coro frame field type. */
1833 tree awaitable_type;
1834 /* coro frame field name. */
1835 tree await_field_id;
1836 };
1840 struct await_xform_data
1841 {
1843 tree actor_frame;
1844 tree promise_proxy;
1845 tree real_promise;
1846 tree self_h_proxy;
1847 tree real_self_h;
1848 };
1850 /* When we built the await expressions, we didn't know the coro frame
1851 layout, therefore no idea where to find the promise or where to put
1852 the awaitables. Now we know these things, fill them in. */
1854 static tree
1856 {
1860 {
1863 }
1865 /* So, on entry, we have:
1866 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1867 We no longer need a [it had diagnostic value, maybe?]
1868 We need to replace the promise proxy in all elements
1869 We need to replace the e_proxy in the awr_call. */
1873 /* If we have a frame var for the awaitable, get a reference to it. */
1874 proxy_replace data;
1876 {
1877 tree as_m
1882 tf_warning_or_error);
1884 /* Replace references to the instance proxy with the frame entry now
1885 computed. */
1890 /* .. and replace. */
1892 }
1894 /* Now do the self_handle. */
1899 /* Now do the promise. */
1905 }
1907 /* A wrapper for the transform_await_expr function so that it can be a
1908 callback from cp_walk_tree. */
1910 static tree
1912 {
1913 /* Set actor function as new DECL_CONTEXT of label_decl. */
1919 /* We should have already lowered co_yields to their co_await. */
1929 }
1931 /* This caches information that we determine about function params,
1932 their uses and copies in the coroutine frame. */
1934 struct param_info
1935 {
1948 };
1950 struct local_var_info
1951 {
1952 tree field_id;
1953 tree field_idx;
1954 tree frame_type;
1958 location_t def_loc;
1959 };
1961 /* For figuring out what local variable usage we have. */
1962 struct local_vars_transform
1963 {
1964 tree context;
1965 tree actor_frame;
1966 tree coro_frame_type;
1967 location_t loc;
1969 };
1971 static tree
1973 {
1976 /* For each var in this bind expr (that has a frame id, which means it was
1977 accessed), build a frame reference for each and then walk the bind expr
1978 statements, substituting the frame ref for the original var. */
1981 {
1982 tree lvar;
1985 {
1987 local_var_info &local_var
1991 /* Re-write the variable's context to be in the actor func. */
1994 /* For capture proxies, this could include the decl value expr. */
1996 {
2000 }
2002 /* TODO: implement selective generation of fields when vars are
2003 known not-used. */
2007 tree fld_ref
2010 tf_warning_or_error);
2014 }
2015 /* FIXME: we should be able to do this in the loop above, but (at least
2016 for range for) there are cases where the DECL_INITIAL contains
2017 forward references.
2018 So, now we've built the revised var in the frame, substitute uses of
2019 it in initializers and the bind expr body. */
2022 {
2023 /* we need to walk some of the decl trees, which might contain
2024 references to vars replaced at a higher level. */
2026 NULL);
2029 NULL);
2030 }
2033 /* Now we have processed and removed references to the original vars,
2034 we can drop those from the bind - leaving capture proxies alone. */
2036 {
2038 local_var_info &local_var
2042 /* Leave lambda closure captures alone, we replace the *this
2043 pointer with the frame version and let the normal process
2044 deal with the rest.
2045 Likewise, variables with their value found elsewhere.
2046 Skip past unused ones too. */
2050 {
2053 }
2055 /* Discard this one, we replaced it. */
2057 }
2061 }
2064 /* Look inside cleanups, we don't want to wrap a statement list in a
2065 cleanup. */
2069 else
2072 /* Look inside the decl_expr for the actual var. */
2079 /* VAR_DECLs that are not recorded can belong to the proxies we've placed
2080 for the promise and coroutine handle(s), to global vars or to compiler
2081 temporaries. Skip past these, we will handle them later. */
2092 /* This is our revised 'local' i.e. a frame slot. */
2097 {
2099 tree r
2105 }
2106 else
2112 }
2114 /* A helper to build the frame DTOR.
2115 [dcl.fct.def.coroutine] / 12
2116 The deallocation function’s name is looked up in the scope of the promise
2117 type. If this lookup fails, the deallocation function’s name is looked up
2118 in the global scope. If deallocation function lookup finds both a usual
2119 deallocation function with only a pointer parameter and a usual
2120 deallocation function with both a pointer parameter and a size parameter,
2121 then the selected deallocation function shall be the one with two
2122 parameters. Otherwise, the selected deallocation function shall be the
2123 function with one parameter. If no usual deallocation function is found
2124 the program is ill-formed. The selected deallocation function shall be
2125 called with the address of the block of storage to be reclaimed as its
2126 first argument. If a deallocation function with a parameter of type
2127 std::size_t is used, the size of the block is passed as the corresponding
2128 argument. */
2130 static tree
2133 {
2140 {
2141 /* Look for sized version first, since this takes precedence. */
2147 /* It's OK to fail for this one... */
2150 tf_none);
2153 {
2158 tf_none);
2159 }
2161 /* But one of them must succeed, or the program is ill-formed. */
2163 {
2167 }
2168 }
2169 else
2170 {
2174 tf_warning_or_error);
2177 }
2179 }
2181 /* The actor transform. */
2183 static void
2189 {
2191 /* Some things we inherit from the original function. */
2197 /* One param, the coro frame pointer. */
2200 /* We have a definition here. */
2213 void_coro_handle_type);
2219 /* Link in the block associated with the outer scope of the re-written
2220 function body. */
2232 /* The entry point for the actor code from the ramp. */
2233 tree actor_begin_label
2237 /* Declare the continuation handle. */
2240 /* Re-write param references in the body, no code should be generated
2241 here. */
2243 {
2244 tree arg;
2246 {
2254 tf_warning_or_error);
2258 /* We keep these in the frame as a regular pointer, so convert that
2259 back to the type expected. */
2267 }
2268 }
2270 /* Re-write local vars, similarly. */
2271 local_vars_transform xform_vars_data
2277 tf_warning_or_error);
2281 tree ret_label
2284 tree continue_label
2303 /* The destroy point numbered #1 is special, in that it is reached from a
2304 coroutine that is suspended after re-throwing from unhandled_exception().
2305 This label just invokes the cleanup of promise, param copies and the
2306 frame itself. */
2307 tree del_promise_label
2316 {
2322 l_num);
2328 }
2330 /* Insert the prototype dispatcher. */
2351 /* The final resume should be made to hit the default (trap, UB) entry
2352 although it will be unreachable via the normal entry point, since that
2353 is set to NULL on reaching final suspend. */
2355 {
2361 l_num);
2367 }
2369 /* Insert the prototype dispatcher. */
2377 /* actor's version of the promise. */
2379 tf_warning_or_error);
2381 tf_warning_or_error);
2383 /* actor's coroutine 'self handle'. */
2388 /* So construct the self-handle from the frame address. */
2401 /* Now we know the real promise, and enough about the frame layout to
2402 decide where to put things. */
2404 await_xform_data xform
2407 /* Transform the await expressions in the function body. Only do each
2408 await tree once! */
2412 /* Now replace the promise proxy with its real value. */
2413 proxy_replace p_data;
2418 /* The rewrite of the function adds code to set the __resume field to
2419 nullptr when the coroutine is done and also the index to zero when
2420 calling an unhandled exception. These are represented by two proxies
2421 in the function, so rewrite them to the proper frame access. */
2422 tree resume_m
2435 /* Add in our function body with the co_returns rewritten to final form. */
2438 /* now do the tail of the function. */
2442 /* Destructors for the things we built explicitly. */
2445 tf_warning_or_error);
2448 tree del_frame_label
2453 /* Here deallocate the frame (if we allocated it), which we will have at
2454 present. */
2455 tree fnf_m
2466 {
2468 tree pid;
2470 {
2471 tree m
2476 tree dtor;
2477 dtor
2481 }
2482 }
2484 /* Build the frame DTOR. */
2494 /* done. */
2500 /* This is the suspend return point. */
2509 /* This is the 'continuation' return point. For such a case we have a coro
2510 handle (from the await_suspend() call) and we want handle.resume() to
2511 execute as a tailcall allowing arbitrary chaining of coroutines. */
2515 /* We want to force a tail-call even for O0/1, so this expands the resume
2516 call into its underlying implementation. */
2521 tree resume = build_call_expr_loc
2524 /* In order to support an arbitrary number of coroutine continuations,
2525 we must tail call them. However, some targets do not support indirect
2526 tail calls to arbitrary callees. See PR94359. */
2535 /* We will need to know which resume point number should be encoded. */
2536 tree res_idx_m
2539 tree resume_pt_number
2541 tf_warning_or_error);
2543 /* We've now rewritten the tree and added the initial and final
2544 co_awaits. Now pass over the tree and expand the co_awaits. */
2557 }
2559 /* The prototype 'destroy' function :
2560 frame->__resume_at |= 1;
2561 actor (frame); */
2563 static void
2565 tree actor)
2566 {
2567 /* One param, the coro frame pointer. */
2570 /* We have a definition here. */
2581 tf_warning_or_error);
2585 /* _resume_at |= 1 */
2592 /* So .. call the actor .. */
2597 /* done. */
2604 }
2606 /* Helper that returns an identifier for an appended extension to the
2607 current un-mangled function name. */
2609 static tree
2611 {
2612 /* Figure out the bits we need to generate names for the outlined things
2613 For consistency, this needs to behave the same way as
2614 ASM_FORMAT_PRIVATE_NAME does. */
2617 #ifndef NO_DOT_IN_LABEL
2619 #else
2620 #ifndef NO_DOLLAR_IN_LABEL
2622 #else
2625 #endif
2626 #endif
2634 {
2638 {
2641 }
2643 }
2644 else
2648 }
2650 /* Build an initial or final await initialized from the promise
2651 initial_suspend or final_suspend expression. */
2653 static tree
2655 {
2659 tree setup_call
2663 /* Check for noexcept on the final_suspend call. */
2668 /* So build the co_await for this */
2669 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2672 }
2674 /* Callback to record the essential data for each await point found in the
2675 function. */
2677 static bool
2679 {
2681 suspend_point_info &s
2684 {
2686 await_expr);
2688 }
2692 }
2694 /* This data set is used when analyzing statements for await expressions. */
2696 struct susp_frame_data
2697 {
2698 /* Function-wide. */
2706 /* Temporary values for one statement or expression being analyzed. */
2714 };
2716 /* If this is an await expression, then count it (both uniquely within the
2717 function and locally within a single statement). */
2719 static tree
2721 {
2724 /* We should have already lowered co_yields to their co_await. */
2730 /* Count how many awaits the current expression contains. */
2733 /* Each await suspend context is unique, this is a function-wide value. */
2736 /* Awaitables should either be user-locals or promoted to coroutine frame
2737 entries at this point, and their initializers should have been broken
2738 out. */
2746 /* Rewrite target expressions on the await_suspend () to remove extraneous
2747 cleanups for the awaitables, which are now promoted to frame vars and
2748 managed via that. */
2754 }
2756 /* There are cases where any await expression is relevant. */
2757 static tree
2759 {
2761 {
2766 }
2768 }
2770 static bool
2772 {
2781 }
2783 /* Structure to record sub-expressions that need to be handled by the
2784 statement flattener. */
2786 struct coro_interesting_subtree
2787 {
2790 };
2792 /* tree-walk callback that returns the first encountered sub-expression of
2793 a kind that needs to be handled specifically by the statement flattener. */
2795 static tree
2797 {
2801 {
2804 {
2807 }
2808 }
2811 {
2814 }
2817 }
2819 /* Node for a doubly-linked list of promoted variables and their
2820 initializers. When the initializer is a conditional expression
2821 the 'then' and 'else' clauses are represented by a linked list
2822 attached to then_cl and else_cl respectively. */
2824 struct var_nest_node
2825 {
2829 {
2834 }
2835 tree var;
2836 tree init;
2841 };
2843 /* This is called for single statements from the co-await statement walker.
2844 It checks to see if the statement contains any initializers for awaitables
2845 and if any of these capture items by reference. */
2847 static void
2850 {
2853 {
2855 /* Compound expressions must be flattened specifically. */
2857 {
2860 var_nest_node *ins
2862 /* The compiler (but not the user) can generate temporaries with
2863 uses in the second arm of a compound expr. */
2866 /* The two arms have been processed separately. */
2868 }
2870 /* Handle conditional expressions. */
2873 /* FALLTHROUGH */
2875 {
2878 {
2881 var_nest_node *ins
2887 }
2890 /* Reconstruct x = t ? y : z;
2891 as (void) t ? x = y : x = z; */
2895 /* We are allowed a void type throw in one or both of the cond
2896 expr arms. */
2899 {
2901 then_cl
2904 }
2907 {
2909 else_cl
2912 }
2914 }
2915 /* FALLTHROUGH */
2917 {
2920 /* If the condition contains an await expression, then we need to
2921 set that first and use a separate var. */
2923 {
2930 var_nest_node *ins
2934 }
2936 n->then_cl
2938 n->else_cl
2941 /* Point to the start of the flattened code. */
2948 }
2950 }
2956 {
2959 {
2960 /* Await expressions with initializers have a compiler-temporary
2961 as the awaitable. 'promote' this. */
2967 {
2971 {
2973 /* We can have non-lvalue-expressions here, but when we see
2974 a target expression, mark it as already used. */
2976 {
2978 gcc_checking_assert
2980 }
2981 }
2984 /* If this is a call and not a CTOR, then we didn't expect it. */
2985 gcc_checking_assert
2988 }
2994 }
2997 {
2998 /* We have a temporary; promote it, but allow for the idiom in code
2999 generated by the compiler like
3000 a = (target_expr produces temp, op uses temp). */
3013 tf_warning_or_error);
3014 /* Simplify for the case that we have an init containing the temp
3015 alone. */
3017 {
3025 }
3026 else
3027 {
3028 var_nest_node *ins
3030 /* We have to replace the target expr... */
3032 /* ... and any uses of its var. */
3035 /* Compiler-generated temporaries can also have uses in
3036 following arms of compound expressions, which will be listed
3037 in 'replace_in' if present. */
3042 }
3044 }
3046 }
3047 }
3049 /* Helper for 'process_conditional' that handles recursion into nested
3050 conditionals. */
3052 static void
3055 {
3056 do
3057 {
3059 {
3062 {
3066 {
3067 /* We didn't see this var before and it needs a DTOR, so
3068 build a guard variable for it. */
3073 boolean_type_node);
3076 }
3078 /* The initializer for this variable is replaced by a compound
3079 expression that performs the init and then records that the
3080 variable is live (and the DTOR should be run at the scope
3081 exit. */
3084 n->init
3086 }
3087 }
3089 {
3096 tree new_if
3100 }
3101 else
3105 }
3107 /* helper for 'maybe_promote_temps'.
3109 When we have a conditional expression which might embed await expressions
3110 and/or promoted variables, we need to handle it appropriately.
3112 The linked lists for the 'then' and 'else' clauses in a conditional node
3113 identify the promoted variables (but these cannot be wrapped in a regular
3114 cleanup).
3116 So recurse through the lists and build up a composite list of captured vars.
3117 Declare these and any guard variables needed to decide if a DTOR should be
3118 run. Then embed the conditional into a try-finally expression that handles
3119 running each DTOR conditionally on its guard variable. */
3121 static void
3123 {
3133 /* Declare the vars. There are two loops so that the boolean flags are
3134 grouped in the frame. */
3136 {
3141 }
3142 /* Define the guard flags for variables that need a DTOR. */
3144 {
3147 {
3152 }
3153 }
3154 tree new_if
3157 /* Build a set of conditional DTORs. */
3160 {
3166 tree cleanup
3169 tf_warning_or_error);
3175 }
3177 tree try_finally
3180 }
3182 /* Given *STMT, that contains at least one await expression.
3184 The full expression represented in the original source code will contain
3185 suspension points, but it is still required that the lifetime of temporary
3186 values extends to the end of the expression.
3188 We already have a mechanism to 'promote' user-authored local variables
3189 to a coroutine frame counterpart (which allows explicit management of the
3190 lifetime across suspensions). The transform here re-writes STMT into
3191 a bind expression, promotes temporary values into local variables in that
3192 and flattens the statement into a series of cleanups.
3194 Conditional expressions are re-written to regular 'if' statements.
3195 The cleanups for variables initialized inside a conditional (including
3196 nested cases) are wrapped in a try-finally clause, with guard variables
3197 to determine which DTORs need to be run. */
3199 static tree
3201 {
3206 /* Strip off uninteresting wrappers. */
3216 /* We walk the statement trees, flattening it into an ordered list of
3217 variables with initializers and fragments corresponding to compound
3218 expressions, truth or/and if and ternary conditionals. Conditional
3219 expressions carry a nested list of fragments for the then and else
3220 clauses. We anchor to the 'bottom' of the fragment list; we will write
3221 a cleanup nest with one shell for each variable initialized. */
3223 /* Check to see we didn't promote one twice. */
3231 /* We build the bind scope expression from the bottom-up.
3232 EXPR_LIST holds the inner expression nest at the current cleanup
3233 level (becoming the final expression list when we've exhausted the
3234 number of sub-expression fragments). */
3236 do
3237 {
3239 /* When we have a promoted variable, then add that to the bind scope
3240 and initialize it. When there's no promoted variable, we just need
3241 to run the initializer.
3242 If the initializer is a conditional expression, we need to collect
3243 and declare any promoted variables nested within it. DTORs for such
3244 variables must be run conditionally too. */
3246 {
3253 else
3257 {
3258 tree cleanup
3261 tf_warning_or_error);
3264 }
3266 {
3271 }
3272 }
3273 else
3274 {
3277 else
3280 {
3285 }
3286 }
3293 /* Now produce the bind expression containing the 'promoted' temporaries
3294 as its variable list, and the cleanup nest as the statement. */
3301 {
3304 {
3308 }
3309 }
3316 }
3318 /* Lightweight callback to determine two key factors:
3319 1) If the statement/expression contains any await expressions.
3320 2) If the statement/expression potentially requires a re-write to handle
3321 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3322 so that the await expressions are not processed in the case of the
3323 short-circuit arm.
3325 CO_YIELD expressions are re-written to their underlying co_await. */
3327 static tree
3329 {
3333 {
3336 /* co_yield is syntactic sugar, re-write it to co_await. */
3338 /* FALLTHROUGH */
3341 /* A non-null initializer for the awaiter means we need to expand. */
3347 {
3348 /* We don't need special action for awaits in the always-executed
3349 arm of a TRUTH_IF. */
3353 /* However, if there are await expressions on the conditionally
3354 executed branch, we must expand the TRUTH_IF to ensure that the
3355 expanded await expression control-flow is fully contained in the
3356 conditionally executed code. */
3362 {
3365 }
3366 /* We've done the sub-trees here. */
3368 }
3370 }
3373 }
3375 /* Given *EXPR
3376 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3377 the conditionally executed branch, change this in a ternary operator.
3379 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3380 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3382 Apply this recursively to the condition and the conditionally-exec
3383 branch. */
3387 tree scratch_var;
3389 };
3391 static tree
3393 {
3398 {
3402 /* FALLTHROUGH */
3404 {
3409 /* Transform truth expression into a cond expression with
3410 * the always-executed arm as the condition.
3411 * the conditionally-executed arm as the then clause.
3412 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3418 tree cond_expr
3428 /* We've manually processed necessary sub-trees here. */
3430 }
3432 }
3434 }
3436 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3437 name is made up from NAM_ROOT, NAM_VERS. */
3439 static tree
3442 {
3444 /* Build a variable to hold the condition, this will be included in the
3445 frame as a local var. */
3452 }
3454 /* Helper to build and add if (!cond) break; */
3456 static void
3458 {
3465 }
3467 /* Tree walk callback to replace continue statements with goto label. */
3468 static tree
3470 {
3481 {
3482 /* Unless it's a special case, just walk the subtrees as usual. */
3486 {
3489 /* re-write a continue to goto label. */
3493 }
3495 /* Statements that do not require recursion. */
3502 /* These must break recursion. */
3508 }
3509 }
3511 /* Tree walk callback to analyze, register and pre-process statements that
3512 contain await expressions. */
3514 static tree
3516 {
3520 /* Process a statement at a time. */
3522 {
3523 /* For conditional expressions, we might wish to add an artificial var
3524 to their containing bind expr. */
3526 /* We might need to insert a new bind expression, and want to link it
3527 into the correct scope, so keep a note of the current block scope. */
3536 }
3538 {
3540 {
3545 }
3548 }
3550 /* We have something to be handled as a single statement. */
3565 {
3566 /* Unless it's a special case, just walk the subtrees as usual. */
3569 /* When we have a conditional expression, which contains one or more
3570 await expressions, we have to break the condition out into a
3571 regular statement so that the control flow introduced by the await
3572 transforms can be implemented. */
3574 {
3575 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3576 bool cond = cond with awaits.
3577 if (cond) then stmt1 else stmt2. */
3579 /* We treat the condition as if it was a stand-alone statement,
3580 to see if there are any await expressions which will be analyzed
3581 and registered. */
3598 /* We want to initialize the new variable with the expression
3599 that contains the await(s) and potentially also needs to
3600 have truth_if expressions expanded. */
3607 /* So now walk the new statement list. */
3611 }
3614 {
3615 /* for loops only need special treatment if the condition or the
3616 iteration expression contain a co_await. */
3618 /* Sanity check. */
3635 /* If the condition has an await, then we will need to rewrite the
3636 loop as
3637 for (init expression;true;iteration expression) {
3638 condition = await expression;
3639 if (condition)
3640 break;
3641 ...
3642 }
3643 */
3645 {
3647 /* This will be expanded when the revised body is handled. */
3649 /* .. add the original for body. */
3651 /* To make the new for body. */
3654 }
3655 /* If the iteration expression has an await, it's a bit more
3656 tricky.
3657 for (init expression;condition;) {
3658 ...
3659 iteration_expr_label:
3660 iteration expression with await;
3661 }
3662 but, then we will need to re-write any continue statements into
3663 'goto iteration_expr_label:'.
3664 */
3666 {
3669 /* The original for body. */
3672 tree it_expr_label
3679 /* rewrite continue statements to goto label. */
3684 }
3686 /* So now walk the body statement (list), if there were no await
3687 expressions, then this handles the original body - and either
3688 way we will have finished with this statement. */
3693 }
3696 {
3697 /* We turn 'while (cond with awaits) stmt' into
3698 while (true) {
3699 if (!(cond with awaits))
3700 break;
3701 stmt..
3702 } */
3712 /* The original while body. */
3714 /* The new while body. */
3717 /* So now walk the new statement list. */
3722 }
3725 {
3726 /* We turn do stmt while (cond with awaits) into:
3727 do {
3728 stmt..
3729 if (!(cond with awaits))
3730 break;
3731 } while (true); */
3740 /* The original do stmt body. */
3743 /* The new while body. */
3746 /* So now walk the new statement list. */
3751 }
3754 {
3755 /* We turn 'switch (cond with awaits) stmt' into
3756 switch_type cond = cond with awaits
3757 switch (cond) stmt. */
3766 /* Build a variable to hold the condition, this will be
3767 included in the frame as a local var. */
3780 cond_inner);
3783 /* Now add the switch statement with the condition re-
3784 written to use the local var. */
3787 /* Process the expanded list. */
3792 }
3795 {
3796 /* Expand the co_return as per [stmt.return.coroutine]
3797 - for co_return;
3798 { p.return_void (); goto final_suspend; }
3799 - for co_return [void expr];
3800 { expr; p.return_void(); goto final_suspend;}
3801 - for co_return [non void expr];
3802 { p.return_value(expr); goto final_suspend; } */
3810 /* [stmt.return.coroutine], 2.2
3811 If expr is present and void, it is placed immediately before
3812 the call for return_void; */
3815 {
3817 /* If the return argument was a void expression, then any
3818 awaits must be contained in that. */
3820 }
3821 /* Insert p.return_{void,value(expr)}. */
3823 /* Absent a return of a void expression, any awaits must be in
3824 the parameter to return_value(). */
3830 /* Once this is complete, we will have processed subtrees. */
3833 {
3839 }
3841 }
3843 }
3845 {
3853 {
3854 /* If a truth-and/or-if expression has an await expression in the
3855 conditionally-taken branch, then it must be rewritten into a
3856 regular conditional. */
3860 }
3861 /* Process this statement, which contains at least one await expression
3862 to 'promote' temporary values to a coroutine frame slot. */
3864 }
3865 /* Continue recursion, if needed. */
3867 }
3869 /* For figuring out what param usage we have. */
3871 struct param_frame_data
3872 {
3876 location_t loc;
3878 };
3880 /* A tree-walk callback that records the use of parameters (to allow for
3881 optimizations where handling unused parameters may be omitted). */
3883 static tree
3885 {
3888 /* For lambda closure content, we have to look specifically. */
3890 {
3893 }
3898 /* If we already saw the containing expression, then we're done. */
3907 {
3911 }
3912 else
3916 }
3918 /* Small helper for the repetitive task of adding a new field to the coro
3919 frame type. */
3921 static tree
3923 location_t loc)
3924 {
3930 }
3932 /* For recording local variable usage. */
3934 struct local_vars_frame_data
3935 {
3939 location_t loc;
3942 };
3944 /* A tree-walk callback that processes one bind expression noting local
3945 variables, and making a coroutine frame slot available for those that
3946 need it, so that they can be 'promoted' across suspension points. */
3948 static tree
3950 {
3953 /* As we enter a bind expression - record the vars there and then recurse.
3954 As we exit drop the nest depth.
3955 The bind index is a growing count of how many bind indices we've seen.
3956 We build a space in the frame for each local var. */
3959 {
3962 tree lvar;
3965 {
3967 local_var_info &local_var
3975 /* Make sure that we only present vars to the tests below. */
3980 /* We don't move static vars into the frame. */
3986 /* If this var is a lambda capture proxy, we want to leave it alone,
3987 and later rewrite the DECL_VALUE_EXPR to indirect through the
3988 frame copy of the pointer to the lambda closure object. */
3993 /* If a variable has a value expression, then that's what needs
3994 to be processed. */
3999 /* Make names depth+index unique, so that we can support nested
4000 scopes with identically named locals. */
4006 else
4009 /* TODO: Figure out if we should build a local type that has any
4010 excess alignment or size from the original decl. */
4011 local_var.field_id
4014 /* We don't walk any of the local var sub-trees, they won't contain
4015 any bind exprs. */
4016 }
4020 }
4022 }
4024 /* Build, return FUNCTION_DECL node based on ORIG with a type FN_TYPE which has
4025 a single argument of type CORO_FRAME_PTR. Build the actor function if
4026 ACTOR_P is true, otherwise the destroy. */
4028 static tree
4031 {
4033 tree fn
4036 /* Allow for locating the ramp (original) function from this one. */
4052 /* Copy selected attributes from the original function. */
4056 /* Copy any alignment that the FE added. */
4059 /* Copy any alignment the user added. */
4061 /* Apply attributes from the original fn. */
4064 /* A void return. */
4071 /* This is a coroutine component. */
4074 /* Set up a means to find out if a decl is one of the helpers and, if so,
4075 which one. */
4077 {
4082 else
4084 }
4086 }
4088 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
4090 static tree
4094 {
4095 /* This will be our new outer scope. */
4101 /* If the function has a top level bind expression, then connect that
4102 after first making sure we give it a new block. */
4105 {
4110 /* Replace the top block to avoid issues with locations for args
4111 appearing to be in a non-existent place. */
4118 /* The top block has one child, so far, and we have now got a
4119 superblock. */
4122 }
4124 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
4125 are enabled. */
4130 /* [stmt.return.coroutine] / 3
4131 If p.return_void() is a valid expression, flowing off the end of a
4132 coroutine is equivalent to a co_return with no operand; otherwise
4133 flowing off the end of a coroutine results in undefined behavior. */
4134 tree return_void
4137 /* We will need to be able to set the resume function pointer to nullptr
4138 to signal that the coroutine is 'done'. */
4139 resume_fn_field
4141 resume_fn_ptr_type);
4143 tree zero_resume
4145 zero_resume
4147 /* Likewise, the resume index needs to be reset. */
4148 resume_idx_field
4150 short_unsigned_type_node);
4157 {
4158 /* Build promise.unhandled_exception(); */
4159 tree ueh
4161 coro_unhandled_exception_identifier,
4163 /* Create and initialize the initial-await-resume-called variable per
4164 [dcl.fct.def.coroutine] / 5.3. */
4166 boolean_type_node);
4172 /* Start the try-catch. */
4177 {
4178 /* Build a compound expression that sets the
4179 initial-await-resume-called variable true and then calls the
4180 initial suspend expression await resume. */
4184 boolean_true_node);
4187 }
4188 /* Add the initial await to the start of the user-authored function. */
4190 /* Append the original function body. */
4196 /* Mimic what the parser does for the catch. */
4200 /* Get the initial await resume called value. */
4205 /* If the initial await resume called value is false, rethrow... */
4214 /* ... else call the promise unhandled exception method
4215 but first we set done = true and the resume index to 0.
4216 If the unhandled exception method returns, then we continue
4217 to the final await expression (which duplicates the clearing of
4218 the field). */
4225 }
4226 else
4227 {
4229 {
4230 /* We still try to look for the promise method and warn if it's not
4231 present. */
4232 tree ueh_meth
4237 coro_unhandled_exception_identifier,
4239 }
4240 /* Else we don't check and don't care if the method is missing..
4241 just add the initial suspend, function and return. */
4243 /* Append the original function body. */
4247 }
4249 /* co_return branches to the final_suspend label, so declare that now. */
4250 fs_label
4254 /* Before entering the final suspend point, we signal that this point has
4255 been reached by setting the resume function pointer to zero (this is
4256 what the 'done()' builtin tests) as per the current ABI. */
4264 }
4266 /* Here we:
4267 a) Check that the function and promise type are valid for a
4268 coroutine.
4269 b) Carry out the initial morph to create the skeleton of the
4270 coroutine ramp function and the rewritten body.
4272 Assumptions.
4274 1. We only hit this code once all dependencies are resolved.
4275 2. The function body will be either a bind expr or a statement list
4276 3. That cfun and current_function_decl are valid for the case we're
4277 expanding.
4278 4. 'input_location' will be of the final brace for the function.
4280 We do something like this:
4281 declare a dummy coro frame.
4282 struct _R_frame {
4283 using handle_type = coro::coroutine_handle<coro1::promise_type>;
4284 void (*__resume)(_R_frame *);
4285 void (*__destroy)(_R_frame *);
4286 coro1::promise_type __p;
4287 bool frame_needs_free; free the coro frame mem if set.
4288 bool i_a_r_c; [dcl.fct.def.coroutine] / 5.3
4289 short __resume_at;
4290 handle_type self_handle;
4291 (maybe) parameter copies.
4292 (maybe) local variables saved (including awaitables)
4293 (maybe) trailing space.
4294 }; */
4296 bool
4298 {
4304 {
4305 /* For early errors, we do not want a diagnostic about the missing
4306 ramp return value, since the user cannot fix this - a 'return' is
4307 not allowed in a coroutine. */
4309 /* Discard the body, we can't process it further. */
4313 }
4315 /* We can't validly get here with an empty statement list, since there's no
4316 way for the FE to decide it's a coroutine in the absence of any code. */
4320 /* We don't have the locus of the opening brace - it's filled in later (and
4321 there doesn't really seem to be any easy way to get at it).
4322 The closing brace is assumed to be input_location. */
4326 /* Initial processing of the function-body.
4327 If we have no expressions or just an error then punt. */
4330 {
4333 /* Suppress warnings about the missing return value. */
4336 }
4338 /* So, we've tied off the original user-authored body in fn_body.
4340 Start the replacement synthesized ramp body as newbody.
4341 If we encounter a fatal error we might return a now-empty body.
4343 Note, the returned ramp body is not 'popped', to be compatible with
4344 the way that decl.c handles regular functions, the scope pop is done
4345 in the caller. */
4350 /* If our original body is noexcept, then that's what we apply to our
4351 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4354 {
4355 /* The function body we will continue with is the single operand to
4356 the must-not-throw. */
4358 /* Transfer the must-not-throw to the ramp body. */
4360 /* Re-start the ramp as must-not-throw. */
4362 }
4364 /* If the original function has a return value with a non-trivial DTOR
4365 and the body contains a var with a DTOR that might throw, the decl is
4366 marked "throwing_cleanup".
4367 We do not [in the ramp, which is synthesised here], use any body var
4368 types with DTORs that might throw.
4369 The original body is transformed into the actor function which only
4370 contains void returns, and is also wrapped in a try-catch block.
4371 So (a) the 'throwing_cleanup' is not correct for the ramp and (b) we do
4372 not need to transfer it to the actor which only contains void returns. */
4375 /* Create the coro frame type, as far as it can be known at this stage.
4376 1. Types we already know. */
4382 /* 2. Types we need to define or look up. */
4388 tree act_des_fn_type
4392 /* Declare the actor and destroyer function. */
4398 /* Construct the wrapped function body; we will analyze this to determine
4399 the requirements for the coroutine frame. */
4407 /* Build our dummy coro frame layout. */
4411 tree resume_name
4414 tree destroy_name
4417 tree promise_name
4421 tree resume_idx_name
4425 /* We need a handle to this coroutine, which is passed to every
4426 await_suspend(). There's no point in creating it over and over. */
4429 /* Now add in fields for function params (if there are any).
4430 We do not attempt elision of copies at this stage, we do analyze the
4431 uses and build worklists to replace those when the state machine is
4432 lowered. */
4436 {
4437 /* Build a hash map with an entry for each param.
4438 The key is the param tree.
4439 Then we have an entry for the frame field name.
4440 Then a cache for the field ref when we come to use it.
4441 Then a tree list of the uses.
4442 The second two entries start out empty - and only get populated
4443 when we see uses. */
4450 {
4462 {
4463 /* If the user passes by reference, then we will save the
4464 pointer to the original. As noted in
4465 [dcl.fct.def.coroutine] / 13, if the lifetime of the
4466 referenced item ends and then the coroutine is resumed,
4467 we have UB; well, the user asked for it. */
4470 else
4472 }
4483 {
4486 }
4487 else
4491 {
4493 parm.guard_var
4495 boolean_type_node);
4500 }
4501 else
4506 }
4508 /* We want to record every instance of param's use, so don't include
4509 a 'visited' hash_set on the tree walk, but only record a containing
4510 expression once. */
4512 param_frame_data param_data
4515 }
4517 /* We need to know, and inspect, each suspend point in the function
4518 in several places. It's convenient to place this map out of line
4519 since it's used from tree walk callbacks. */
4522 /* Now insert the data for any body await points, at this time we also need
4523 to promote any temporaries that are captured by reference (to regular
4524 vars) they will get added to the coro frame along with other locals. */
4525 susp_frame_data body_aw_points
4533 /* 4. Now make space for local vars, this is conservative again, and we
4534 would expect to delete unused entries later. */
4536 local_vars_frame_data local_vars_data
4540 /* Tie off the struct for now, so that we can build offsets to the
4541 known entries. */
4549 /* Ramp: */
4550 /* Now build the ramp function pieces. */
4556 coro_frame_ptr);
4559 /* To signal that we need to cleanup copied function args. */
4563 {
4570 }
4572 /* Signal that we need to clean up the promise object on exception. */
4573 tree coro_promise_live
4575 boolean_type_node);
4580 /* When the get-return-object is in the RETURN slot, we need to arrange for
4581 cleanup on exception. */
4582 tree coro_gro_live
4584 boolean_type_node);
4590 /* Collected the scope vars we need ... only one for now. */
4593 /* We're now going to create a new top level scope block for the ramp
4594 function. */
4601 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4602 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4603 directly apparently). This avoids a "used uninitialized" warning. */
4610 {
4615 }
4619 /* The CO_FRAME internal function is a mechanism to allow the middle end
4620 to adjust the allocation in response to optimizations. We provide the
4621 current conservative estimate of the frame size (as per the current)
4622 computed layout. */
4624 tree resizeable
4628 /* [dcl.fct.def.coroutine] / 10 (part1)
4629 The unqualified-id get_return_object_on_allocation_failure is looked up
4630 in the scope of the promise type by class member access lookup. */
4632 /* We don't require this, so coro_build_promise_expression can return NULL,
4633 but, if the lookup succeeds, then the function must be usable. */
4635 tree grooaf
4637 coro_gro_on_allocation_fail_identifier,
4640 /* however, should that fail, returning an error, the later stages can't
4641 handle the erroneous expression, so we reset the call as if it was
4642 absent. */
4646 /* Allocate the frame, this has several possibilities:
4647 [dcl.fct.def.coroutine] / 9 (part 1)
4648 The allocation function’s name is looked up in the scope of the promise
4649 type. It's not a failure for it to be absent see part 4, below. */
4655 {
4658 /* [dcl.fct.def.coroutine] / 9 (part 2)
4659 If the lookup finds an allocation function in the scope of the promise
4660 type, overload resolution is performed on a function call created by
4661 assembling an argument list. The first argument is the amount of space
4662 requested, and has type std::size_t. The succeeding arguments are
4663 those of the original function. */
4669 {
4673 {
4674 /* We pass a reference to *this to the allocator lookup. */
4680 tf_warning_or_error);
4682 }
4683 else
4685 }
4687 /* Note the function selected; we test to see if it's NOTHROW. */
4688 tree func;
4689 /* Failure is not an error for this attempt. */
4695 {
4696 /* [dcl.fct.def.coroutine] / 9 (part 3)
4697 If no viable function is found, overload resolution is performed
4698 again on a function call created by passing just the amount of
4699 space required as an argument of type std::size_t. */
4703 tf_none);
4705 }
4707 /* However, if the promise provides an operator new, then one of these
4708 two options must be available. */
4710 {
4714 }
4720 " no usable %<get_return_object_on_allocation_failure%>"
4722 }
4724 {
4725 /* [dcl.fct.def.coroutine] / 9 (part 4)
4726 If this lookup fails, the allocation function’s name is looked up in
4727 the global scope. */
4730 /* build_operator_new_call () will insert size needed as element 0 of
4731 this, and we might need to append the std::nothrow constant. */
4734 {
4735 /* [dcl.fct.def.coroutine] / 10 (part 2)
4736 If any declarations (of the get return on allocation fail) are
4737 found, then the result of a call to an allocation function used
4738 to obtain storage for the coroutine state is assumed to return
4739 nullptr if it fails to obtain storage and, if a global allocation
4740 function is selected, the ::operator new(size_t, nothrow_t) form
4741 is used. The allocation function used in this case shall have a
4742 non-throwing noexcept-specification. So we need std::nothrow. */
4751 }
4753 /* If we get to this point, we must succeed in looking up the global
4754 operator new for the params provided. Extract a simplified version
4755 of the machinery from build_operator_new_call. This can update the
4756 frame size. */
4761 tf_warning_or_error);
4762 resizeable = build_call_expr_internal_loc
4764 /* If the operator call fails for some reason, then don't try to
4765 amend it. */
4770 }
4777 /* If the user provided a method to return an object on alloc fail, then
4778 check the returned pointer and call the func if it's null.
4779 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4782 {
4783 /* [dcl.fct.def.coroutine] / 10 (part 3)
4784 If the allocation function returns nullptr,the coroutine returns
4785 control to the caller of the coroutine and the return value is
4786 obtained by a call to T::get_return_object_on_allocation_failure(),
4787 where T is the promise type. */
4795 {
4796 /* Execute the get-return-object-on-alloc-fail call... */
4798 /* ... but discard the result, since we return void. */
4800 }
4801 else
4802 {
4803 /* Get the fallback return object. */
4806 }
4809 }
4811 /* Up to now any exception thrown will propagate directly to the caller.
4812 This is OK since the only source of such exceptions would be in allocation
4813 of the coroutine frame, and therefore the ramp will not have initialized
4814 any further state. From here, we will track state that needs explicit
4815 destruction in the case that promise or g.r.o setup fails or an exception
4816 is thrown from the initial suspend expression. */
4819 {
4823 }
4825 /* deref the frame pointer, to use in member access code. */
4828 /* For now, once allocation has succeeded we always assume that this needs
4829 destruction, there's no impl. for frame allocation elision. */
4830 tree fnf_m
4838 /* Put the resumer and destroyer functions in. */
4841 tree resume_m
4851 tree destroy_m
4854 tree destroy_x
4856 tf_warning_or_error);
4861 /* [dcl.fct.def.coroutine] /13
4862 When a coroutine is invoked, a copy is created for each coroutine
4863 parameter. Each such copy is an object with automatic storage duration
4864 that is direct-initialized from an lvalue referring to the corresponding
4865 parameter if the parameter is an lvalue reference, and from an xvalue
4866 referring to it otherwise. A reference to a parameter in the function-
4867 body of the coroutine and in the call to the coroutine promise
4868 constructor is replaced by a reference to its copy. */
4872 /* The initialization and destruction of each parameter copy occurs in the
4873 context of the called coroutine. Initializations of parameter copies are
4874 sequenced before the call to the coroutine promise constructor and
4875 indeterminately sequenced with respect to each other. The lifetime of
4876 parameter copies ends immediately after the lifetime of the coroutine
4877 promise object ends. */
4882 {
4886 {
4892 tf_warning_or_error);
4893 tree fld_idx
4897 /* Add this to the promise CTOR arguments list, accounting for
4898 refs and special handling for method this ptr. */
4900 {
4901 /* We pass a reference to *this to the param preview. */
4909 tf_warning_or_error);
4911 }
4914 else
4918 /* Initialise the frame reference field directly. */
4921 else
4922 {
4925 tf_warning_or_error);
4926 }
4929 {
4933 /* Cleanup this frame copy on exception. */
4934 parm.fr_copy_dtor
4937 LOOKUP_NORMAL,
4938 tf_warning_or_error);
4939 /* This var is now live. */
4944 }
4945 }
4946 }
4948 /* Set up the promise. */
4949 tree promise_m
4958 {
4959 /* Do a placement new constructor for the promise type (we never call
4960 the new operator, just the constructor on the object in place in the
4961 frame).
4963 First try to find a constructor with the same parameter list as the
4964 original function (if it has params), failing that find a constructor
4965 with no parameter list. */
4968 {
4973 }
4974 else
4980 tf_warning_or_error);
4987 boolean_type_node);
4990 promise_dtor
4993 tf_warning_or_error);
4994 }
4996 /* Set up a new bind context for the GRO. */
4998 /* Make and connect the scope blocks. */
5005 tree get_ro
5007 coro_get_return_object_identifier,
5009 /* Without a return object we haven't got much clue what's going on. */
5011 {
5014 /* Suppress warnings about the missing return value. */
5017 }
5025 /* Used for return objects in the RESULT slot. */
5028 /* We have to sequence the call to get_return_object before initial
5029 suspend. */
5033 {
5034 /* [dcl.fct.def.coroutine] / 7
5035 The expression promise.get_return_object() is used to initialize the
5036 glvalue result or... (see below)
5037 Construct the return result directly. */
5039 {
5042 complete_ctor_identifier,
5044 tf_warning_or_error);
5046 }
5047 else
5052 /* If some part of the initalization code (prior to the await_resume
5053 of the initial suspend expression), then we need to clean up the
5054 return value. */
5055 gro_ret_dtor
5059 tf_warning_or_error);
5060 }
5061 else
5062 {
5063 /* ... or ... Construct an object that will be used as the single
5064 param to the CTOR for the return object. */
5072 tf_warning_or_error);
5073 /* The constructed object might require a cleanup. */
5075 {
5076 gro_cleanup_stmt
5079 tf_warning_or_error);
5082 }
5083 }
5089 /* If we have a live g.r.o in the return slot, then signal this for exception
5090 cleanup. */
5092 {
5095 boolean_type_node);
5097 }
5098 /* Initialize the resume_idx_name to 0, meaning "not started". */
5099 tree resume_idx_m
5102 tree resume_idx
5104 tf_warning_or_error);
5110 /* So .. call the actor .. */
5115 /* Switch to using 'input_location' as the loc, since we're now more
5116 logically doing things related to the end of the function. */
5118 /* The ramp is done, we just need the return value.
5119 [dcl.fct.def.coroutine] / 7
5120 The expression promise.get_return_object() is used to initialize the
5121 glvalue result or prvalue result object of a call to a coroutine.
5123 If the 'get return object' is non-void, then we built it before the
5124 promise was constructed. We now supply a reference to that var,
5125 either as the return value (if it's the same type) or to the CTOR
5126 for an object of the return type. */
5131 /* check_return_expr will automatically return gro as an rvalue via
5132 treat_lvalue_as_rvalue_p. */
5135 {
5136 /* For class type return objects, we can attempt to construct,
5137 even if the gro is void. ??? Citation ??? c++/100476 */
5141 tf_warning_or_error);
5143 }
5144 else
5145 {
5146 /* We can't initialize a non-class return value from void. */
5150 }
5155 {
5159 }
5161 /* Finish up the ramp function. */
5167 {
5172 /* If we have a live G.R.O in the return slot, then run its DTOR.
5173 When the return object is constructed from a separate g.r.o, this is
5174 already handled by its regular cleanup. */
5176 {
5185 }
5187 /* If the promise is live, then run its dtor if that's available. */
5189 {
5198 }
5200 /* Clean up any frame copies of parms with non-trivial dtors. */
5204 {
5209 {
5218 }
5219 }
5221 /* We always expect to delete the frame. */
5230 }
5235 /* Start to build the final functions.
5237 We push_deferring_access_checks to avoid these routines being seen as
5238 nested by the middle end; we are doing the outlining here. */
5242 /* Build the actor... */
5247 /* Destroyer ... */
5253 /* Link our new functions into the list. */
5264 }