| blob | 9b9141e51fd59c33caa6e61d4871edbe9e3d5636 |
1 /* coroutine-specific state, expansions and tests.
3 Copyright (C) 2018-2020 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 {
88 one that will eventually be allocated in the coroutine
89 frame. */
93 function into a coroutine. */
94 /* Flags to avoid repeated errors for per-function issues. */
98 };
101 {
107 };
109 /* This table holds all the collected coroutine state for coroutines in
110 the current translation unit. */
114 /* We will initialize state lazily. */
117 /* Return a hash value for the entry pointed to by INFO.
118 The compare type is a tree, but the only trees we are going use are
119 function decls. We use the DECL_UID as the hash value since that is
120 stable across PCH. */
122 hashval_t
124 {
126 }
128 /* Return a hash value for the compare value COMP. */
130 hashval_t
132 {
134 }
136 /* Return true if the entries pointed to by LHS and RHS are for the
137 same coroutine. */
139 bool
141 {
143 }
145 bool
147 {
149 }
151 /* Get the existing coroutine_info for FN_DECL, or insert a new one if the
152 entry does not yet exist. */
154 coroutine_info *
156 {
163 {
166 }
169 }
171 /* Get the existing coroutine_info for FN_DECL, fail if it doesn't exist. */
173 coroutine_info *
175 {
184 }
186 /* We will lazily create all the identifiers that are used by coroutines
187 on the first attempt to lookup the traits. */
189 /* Identifiers that are used by all coroutines. */
195 /* Required promise method name identifiers. */
210 /* Awaitable methods. */
216 /* Create the identifiers used by the coroutines library interfaces. */
218 static void
220 {
235 coro_gro_on_allocation_fail_identifier =
242 }
244 /* Trees we only need to set up once. */
250 /* ================= Parse, Semantics and Type checking ================= */
252 /* This initial set of routines are helper for the parsing and template
253 expansion phases.
255 At the completion of this, we will have completed trees for each of the
256 keywords, but making use of proxy variables for the self-handle and the
257 promise class instance. */
259 /* [coroutine.traits]
260 Lookup the coroutine_traits template decl. */
262 static tree
264 {
265 /* If we are missing fundamental information, such as the traits, (or the
266 declaration found is not a type template), then don't emit an error for
267 every keyword in a TU, just do it once. */
275 {
277 {
283 }
285 }
286 else
288 }
290 /* Instantiate Coroutine traits for the function signature. */
292 static tree
294 {
295 /* [coroutine.traits.primary]
296 So now build up a type list for the template <typename _R, typename...>.
297 The types are the function's arg types and _R is the function return
298 type. */
307 {
310 {
311 /* We pass a reference to *this to the param preview. */
314 }
315 else
320 }
329 tree traits_class
335 {
338 }
341 }
343 /* [coroutine.handle] */
345 static tree
347 {
348 /* As for the coroutine traits, this error is per TU, so only emit
349 it once. */
356 {
362 }
363 else
365 }
367 /* Instantiate the handle template for a given promise type. */
369 static tree
371 {
372 /* So now build up a type list for the template, one entry, the promise. */
375 tree handle_type
382 {
386 }
389 }
391 /* Look for the promise_type in the instantiated traits. */
393 static tree
395 {
396 tree promise_type
401 promise_type
404 /* NULL_TREE on fail. */
406 }
408 static bool
410 {
414 {
415 /* Trees we only need to create once.
416 Set up the identifiers we will use. */
419 /* Coroutine traits template. */
424 /* coroutine_handle<> template. */
429 /* We can also instantiate the void coroutine_handle<> */
430 void_coro_handle_type =
435 /* A table to hold the state, per coroutine decl. */
437 coroutine_info_table =
444 }
446 /* Save the coroutine data on the side to avoid the overhead on every
447 function decl tree. */
450 /* Without this, we cannot really proceed. */
453 /* If we don't already have a current promise type, try to look it up. */
455 {
456 /* Get the coroutine traits template class instance for the function
457 signature we have - coroutine_traits <R, ...> */
461 /* Find the promise type for that. */
464 /* If we don't find it, punt on the rest. */
466 {
472 }
474 /* Test for errors in the promise type that can be determined now. */
476 coro_return_void_identifier,
478 tf_none);
480 coro_return_value_identifier,
482 tf_none);
484 {
496 }
498 /* Try to find the handle type for the promise. */
499 tree handle_type =
504 /* Complete this, we're going to use it. */
507 /* Diagnostic would be emitted by complete_type_or_else. */
511 /* Build a proxy for a handle to "self" as the param to
512 await_suspend() calls. */
513 coro_info->self_h_proxy
517 /* Build a proxy for the promise so that we can perform lookups. */
518 coro_info->promise_proxy
522 /* Note where we first saw a coroutine keyword. */
524 }
527 }
529 /* These functions assumes that the caller has verified that the state for
530 the decl has been initialized, we try to minimize work here. */
532 static tree
534 {
539 }
541 static tree
543 {
548 }
550 static tree
552 {
557 }
559 static tree
561 {
566 }
568 static tree
571 {
573 tree pm_memb
577 {
580 }
582 }
584 /* Build an expression of the form p.method (args) where the p is a promise
585 object for the current coroutine.
586 OBJECT is the promise object instance to use, it may be NULL, in which case
587 we will use the promise_proxy instance for this coroutine.
588 ARGS may be NULL, for empty parm lists. */
590 static tree
594 {
599 /* If we don't find it, and it isn't needed, an empty return is OK. */
603 tree promise
606 tree expr;
610 else
611 {
617 else
620 }
622 }
624 /* Caching get for the expression p.return_void (). */
626 static tree
628 {
630 {
631 /* If we don't have it try to build it. */
633 info->return_void
635 coro_return_void_identifier,
637 /* Don't return an error if it's an optional call. */
641 }
643 }
645 /* Lookup an Awaitable member, which should be await_ready, await_suspend
646 or await_resume. */
648 static tree
650 {
651 tree aw_memb
655 {
658 }
660 }
662 /* Here we check the constraints that are common to all keywords (since the
663 presence of a coroutine keyword makes the function into a coroutine). */
665 static bool
668 {
670 {
673 }
675 /* This is arranged in order of prohibitions in the std. */
677 {
678 /* [basic.start.main] 3. The function main shall not be a coroutine. */
680 kw_name);
682 }
685 {
686 /* [dcl.constexpr] 3.3 it shall not be a coroutine. */
688 kw_name);
691 }
694 {
695 /* [dcl.spec.auto] 15. A function declared with a return type that uses
696 a placeholder type shall not be a coroutine. */
699 kw_name);
701 }
704 {
705 /* [dcl.fct.def.coroutine] The parameter-declaration-clause of the
706 coroutine shall not terminate with an ellipsis that is not part
707 of a parameter-declaration. */
711 }
714 {
715 /* [class.ctor] 7. a constructor shall not be a coroutine. */
718 }
721 {
722 /* [class.dtor] 21. a destructor shall not be a coroutine. */
725 }
728 }
730 /* Here we check the constraints that are not per keyword. */
732 static bool
734 {
737 /* For cases where fundamental information cannot be found, e.g. the
738 coroutine traits are missing, we need to punt early. */
742 /* Since we think the function is a coroutine, that implies we parsed
743 a keyword that triggered this. Keywords check promise validity for
744 their context and thus the promise type should be known at this point. */
750 {
751 /* TODO: record or extract positions of returns (and the first coro
752 keyword) so that we can add notes to the diagnostic about where
753 the bad keyword is and what made the function into a coro. */
757 }
760 }
764 CO_YIELD_SUSPEND_POINT,
765 INITIAL_SUSPEND_POINT,
766 FINAL_SUSPEND_POINT
767 };
769 /* Helper function to build a named variable for the temps we use for each
770 await point. The root of the name is determined by SUSPEND_KIND, and
771 the variable is of type V_TYPE. The awaitable number is reset each time
772 we encounter a final suspend. */
774 static tree
776 {
780 {
785 }
791 }
793 /* This performs [expr.await] bullet 3.3 and validates the interface obtained.
794 It is also used to build the initial and final suspend points.
796 'a', 'o' and 'e' are used as per the description in the section noted.
798 A, the original yield/await expr, is found at source location LOC.
800 We will be constructing a CO_AWAIT_EXPR for a suspend point of one of
801 the four suspend_point_kind kinds. This is indicated by SUSPEND_KIND. */
803 static tree
805 {
806 /* Try and overload of operator co_await, .... */
807 tree o;
809 {
812 /* If no viable functions are found, o is a. */
815 }
816 else
827 {
829 o_type);
831 }
833 /* Check for required awaitable members and their types. */
834 tree awrd_meth
838 tree awsp_meth
843 /* The type of the co_await is the return type of the awaitable's
844 await_resume, so we need to look that up. */
845 tree awrs_meth
850 /* To complete the lookups, we need an instance of 'e' which is built from
851 'o' according to [expr.await] 3.4.
853 If we need to materialize this as a temporary, then that will have to be
854 'promoted' to a coroutine frame var. However, if the awaitable is a
855 user variable, parameter or comes from a scope outside this function,
856 then we must use it directly - or we will see unnecessary copies.
858 If o is a variable, find the underlying var. */
863 {
868 {
869 /* We could have operator-> here too. */
873 {
878 }
879 }
881 }
883 /* Only build a temporary if we need it. */
886 {
889 }
891 {
896 tf_warning_or_error);
897 }
898 else
899 {
902 }
904 /* I suppose we could check that this is contextually convertible to bool. */
906 tree awrd_call
913 /* The suspend method may return one of three types:
914 1. void (no special action needed).
915 2. bool (if true, we don't need to suspend).
916 3. a coroutine handle, we execute the handle.resume() call. */
920 tree awsp_call
936 {
940 }
943 {
947 }
949 /* Finally, the type of e.await_resume() is the co_await's type. */
951 tree awrs_call
958 /* We now have three call expressions, in terms of the promise, handle and
959 'e' proxies. Save them in the await expression for later expansion. */
966 {
969 }
978 {
981 }
984 }
986 tree
988 {
996 /* The current function has now become a coroutine, if it wasn't already. */
999 /* This function will appear to have no return statement, even if it
1000 is declared to return non-void (most likely). This is correct - we
1001 synthesize the return for the ramp in the compiler. So suppress any
1002 extraneous warnings during substitution. */
1005 /* If we don't know the promise type, we can't proceed, build the
1006 co_await with the expression unchanged. */
1012 /* We must be able to look up the "await_transform" method in the scope of
1013 the promise type, and obtain its return type. */
1017 /* [expr.await] 3.2
1018 The incoming cast expression might be transformed by a promise
1019 'await_transform()'. */
1020 tree at_meth
1029 {
1030 /* try to build a = p.await_transform (e). */
1033 current_function_decl),
1037 /* As I read the section.
1038 We saw an await_transform method, so it's mandatory that we replace
1039 expr with p.await_transform (expr), therefore if the method call fails
1040 (presumably, we don't have suitable arguments) then this part of the
1041 process fails. */
1044 }
1046 /* Now we want to build co_await a. */
1049 {
1052 }
1055 }
1057 /* Take the EXPR given and attempt to build:
1058 co_await p.yield_value (expr);
1059 per [expr.yield] para 1. */
1061 tree
1063 {
1067 /* Check the general requirements and simple syntax errors. */
1072 /* The current function has now become a coroutine, if it wasn't already. */
1075 /* This function will appear to have no return statement, even if it
1076 is declared to return non-void (most likely). This is correct - we
1077 synthesize the return for the ramp in the compiler. So suppress any
1078 extraneous warnings during substitution. */
1081 /* If we don't know the promise type, we can't proceed, build the
1082 co_await with the expression unchanged. */
1088 /* We must be able to look up the "yield_value" method in the scope of
1089 the promise type, and obtain its return type. */
1092 /* [expr.yield] / 1
1093 Let e be the operand of the yield-expression and p be an lvalue naming
1094 the promise object of the enclosing coroutine, then the yield-expression
1095 is equivalent to the expression co_await p.yield_value(e).
1096 build p.yield_value(e): */
1098 tree yield_call
1104 /* Now build co_await p.yield_value (e).
1105 Noting that for co_yield, there is no evaluation of any potential
1106 promise transform_await(), so we call build_co_await directly. */
1110 {
1113 /* If the await expression is wrapped in a TARGET_EXPR, then transfer
1114 that wrapper to the CO_YIELD_EXPR, since this is just a proxy for
1115 its contained await. Otherwise, just build the CO_YIELD_EXPR. */
1117 {
1121 }
1122 else
1126 }
1129 }
1131 /* Check and build a co_return statement.
1132 First that it's valid to have a co_return keyword here.
1133 If it is, then check and build the p.return_{void(),value(expr)}.
1134 These are built against a proxy for the promise, which will be filled
1135 in with the actual frame version when the function is transformed. */
1137 tree
1139 {
1146 /* If it fails the following test, the function is not permitted to be a
1147 coroutine, so the co_return statement is erroneous. */
1152 /* The current function has now become a coroutine, if it wasn't
1153 already. */
1156 /* This function will appear to have no return statement, even if it
1157 is declared to return non-void (most likely). This is correct - we
1158 synthesize the return for the ramp in the compiler. So suppress any
1159 extraneous warnings during substitution. */
1166 /* If we don't know the promise type, we can't proceed, build the
1167 co_return with the expression unchanged. */
1170 {
1171 /* co_return expressions are always void type, regardless of the
1172 expression type. */
1177 }
1182 /* Suppress -Wreturn-type for co_return, we need to check indirectly
1183 whether the promise type has a suitable return_void/return_value. */
1190 {
1191 /* If we had an id-expression obfuscated by force_paren_expr, we need
1192 to undo it so we can try to treat it as an rvalue below. */
1200 }
1202 /* If the promise object doesn't have the correct return call then
1203 there's a mis-match between the co_return <expr> and this. */
1206 co_ret_call
1208 else
1209 {
1210 /* [class.copy.elision] / 3.
1211 An implicitly movable entity is a variable of automatic storage
1212 duration that is either a non-volatile object or an rvalue reference
1213 to a non-volatile object type. For such objects in the context of
1214 the co_return, the overload resolution should be carried out first
1215 treating the object as an rvalue, if that fails, then we fall back
1216 to regular overload resolution. */
1223 co_ret_call
1227 }
1229 /* Makes no sense for a co-routine really. */
1232 "function declared %<noreturn%> has a"
1238 }
1240 /* We need to validate the arguments to __builtin_coro_promise, since the
1241 second two must be constant, and the builtins machinery doesn't seem to
1242 deal with that properly. */
1244 tree
1246 {
1251 {
1256 {
1257 /* Argument 0 is already checked by the normal built-in machinery
1258 Argument 1 must be a constant of size type. It probably makes
1259 little sense if it's not a power of 2, but that isn't specified
1260 formally. */
1264 /* We expect alignof expressions in templates. */
1267 ;
1269 {
1273 }
1274 /* Argument 2 is the direction - to / from handle address to promise
1275 address. */
1279 {
1283 }
1286 }
1287 }
1288 }
1290 /* ================= Morph and Expand. =================
1292 The entry point here is morph_fn_to_coro () which is called from
1293 finish_function () when we have completed any template expansion.
1295 This is preceded by helper functions that implement the phases below.
1297 The process proceeds in four phases.
1299 A Initial framing.
1300 The user's function body is wrapped in the initial and final suspend
1301 points and we begin building the coroutine frame.
1302 We build empty decls for the actor and destroyer functions at this
1303 time too.
1304 When exceptions are enabled, the user's function body will also be
1305 wrapped in a try-catch block with the catch invoking the promise
1306 class 'unhandled_exception' method.
1308 B Analysis.
1309 The user's function body is analyzed to determine the suspend points,
1310 if any, and to capture local variables that might persist across such
1311 suspensions. In most cases, it is not necessary to capture compiler
1312 temporaries, since the tree-lowering nests the suspensions correctly.
1313 However, in the case of a captured reference, there is a lifetime
1314 extension to the end of the full expression - which can mean across a
1315 suspend point in which case it must be promoted to a frame variable.
1317 At the conclusion of analysis, we have a conservative frame layout and
1318 maps of the local variables to their frame entry points.
1320 C Build the ramp function.
1321 Carry out the allocation for the coroutine frame (NOTE; the actual size
1322 computation is deferred until late in the middle end to allow for future
1323 optimizations that will be allowed to elide unused frame entries).
1324 We build the return object.
1326 D Build and expand the actor and destroyer function bodies.
1327 The destroyer is a trivial shim that sets a bit to indicate that the
1328 destroy dispatcher should be used and then calls into the actor.
1330 The actor function is the implementation of the user's state machine.
1331 The current suspend point is noted in an index.
1332 Each suspend point is encoded as a pair of internal functions, one in
1333 the relevant dispatcher, and one representing the suspend point.
1335 During this process, the user's local variables and the proxies for the
1336 self-handle and the promise class instance are re-written to their
1337 coroutine frame equivalents.
1339 The complete bodies for the ramp, actor and destroy function are passed
1340 back to finish_function for folding and gimplification. */
1342 /* Helpers to build EXPR_STMT and void-cast EXPR_STMT, common ops. */
1344 static tree
1346 {
1348 }
1350 static tree
1352 {
1355 }
1357 /* Helpers for label creation:
1358 1. Create a named label in the specified context. */
1360 static tree
1362 {
1370 }
1372 /* 2. Create a named label in the specified context. */
1374 static tree
1376 {
1383 }
1385 struct proxy_replace
1386 {
1388 };
1390 static tree
1392 {
1396 {
1399 }
1400 else
1403 }
1405 /* Support for expansion of co_await statements. */
1407 struct coro_aw_data
1408 {
1419 };
1421 /* Lightweight search for the first await expression in tree-walk order.
1422 returns:
1423 The first await expression found in STMT.
1424 NULL_TREE if there are none.
1425 So can be used to determine if the statement needs to be processed for
1426 awaits. */
1428 static tree
1430 {
1433 {
1436 }
1438 }
1440 /* Starting with a statement:
1442 stmt => some tree containing one or more await expressions.
1444 We replace the statement with:
1445 <STATEMENT_LIST> {
1446 initialize awaitable
1447 if (!ready)
1448 {
1449 suspension context.
1450 }
1451 resume:
1452 revised statement with one await expression rewritten to its
1453 await_resume() return value.
1454 }
1456 We then recurse into the initializer and the revised statement
1457 repeating this replacement until there are no more await expressions
1458 in either. */
1462 {
1489 tree r;
1494 else
1495 {
1498 /* We have an initializer, which might itself contain await exprs. */
1500 }
1502 /* Use the await_ready() call to test if we need to suspend. */
1505 ready_cond
1511 susp_idx);
1515 /* Find out what we have to do with the awaiter's suspend method.
1516 [expr.await]
1517 (5.1) If the result of await-ready is false, the coroutine is considered
1518 suspended. Then:
1519 (5.1.1) If the type of await-suspend is std::coroutine_handle<Z>,
1520 await-suspend.resume() is evaluated.
1521 (5.1.2) if the type of await-suspend is bool, await-suspend is evaluated,
1522 and the coroutine is resumed if the result is false.
1523 (5.1.3) Otherwise, await-suspend is evaluated. */
1529 /* NOTE: final suspend can't resume; the "resume" label in that case
1530 corresponds to implicit destruction. */
1532 {
1533 /* We just call await_suspend() and hit the yield. */
1536 }
1538 {
1539 /* Boolean return, continue if the call returns false. */
1541 suspend
1545 empty_list);
1547 }
1548 else
1549 {
1555 }
1579 /* Implement the suspend, a scope exit without clean ups. */
1595 /* part of finish switch. */
1606 {
1609 tf_warning_or_error);
1611 }
1616 empty_list);
1620 /* Resume point. */
1624 /* This will produce the value (if one is provided) from the co_await
1625 expression. */
1628 /* Sink to await_resume call_expr. */
1633 /* Get a pointer to the revised statement. */
1636 {
1639 tf_warning_or_error);
1641 }
1644 /* Replace the original statement with the expansion. */
1647 /* Now, if the awaitable had an initializer, expand any awaits that might
1648 be embedded in it. */
1654 /* Expand any more await expressions in the the original statement. */
1659 }
1661 /* Check to see if a statement contains at least one await expression, if
1662 so, then process that. */
1664 static tree
1666 {
1671 }
1673 static tree
1675 {
1678 /* Process a statement at a time. */
1682 {
1683 tree_stmt_iterator i;
1685 {
1690 }
1692 }
1694 {
1697 }
1699 /* Continue statement walk, where required. */
1701 }
1703 /* Suspend point hash_map. */
1705 struct suspend_point_info
1706 {
1707 /* coro frame field type. */
1708 tree awaitable_type;
1709 /* coro frame field name. */
1710 tree await_field_id;
1711 };
1715 struct await_xform_data
1716 {
1718 tree actor_frame;
1719 tree promise_proxy;
1720 tree real_promise;
1721 tree self_h_proxy;
1722 tree real_self_h;
1723 };
1725 /* When we built the await expressions, we didn't know the coro frame
1726 layout, therefore no idea where to find the promise or where to put
1727 the awaitables. Now we know these things, fill them in. */
1729 static tree
1731 {
1735 {
1738 }
1740 /* So, on entry, we have:
1741 in : CO_AWAIT_EXPR (a, e_proxy, o, awr_call_vector, mode)
1742 We no longer need a [it had diagnostic value, maybe?]
1743 We need to replace the promise proxy in all elements
1744 We need to replace the e_proxy in the awr_call. */
1748 /* If we have a frame var for the awaitable, get a reference to it. */
1749 proxy_replace data;
1751 {
1752 tree as_m
1757 tf_warning_or_error);
1759 /* Replace references to the instance proxy with the frame entry now
1760 computed. */
1765 /* .. and replace. */
1767 }
1769 /* Now do the self_handle. */
1774 /* Now do the promise. */
1780 }
1782 /* A wrapper for the transform_await_expr function so that it can be a
1783 callback from cp_walk_tree. */
1785 static tree
1787 {
1788 /* Set actor function as new DECL_CONTEXT of label_decl. */
1794 /* We should have already lowered co_yields to their co_await. */
1804 }
1806 /* This caches information that we determine about function params,
1807 their uses and copies in the coroutine frame. */
1809 struct param_info
1810 {
1820 };
1822 struct local_var_info
1823 {
1824 tree field_id;
1825 tree field_idx;
1826 tree frame_type;
1830 location_t def_loc;
1831 };
1833 /* For figuring out what local variable usage we have. */
1834 struct local_vars_transform
1835 {
1836 tree context;
1837 tree actor_frame;
1838 tree coro_frame_type;
1839 location_t loc;
1841 };
1843 static tree
1845 {
1848 /* For each var in this bind expr (that has a frame id, which means it was
1849 accessed), build a frame reference for each and then walk the bind expr
1850 statements, substituting the frame ref for the original var. */
1853 {
1854 tree lvar;
1857 {
1859 local_var_info &local_var
1863 /* Re-write the variable's context to be in the actor func. */
1866 /* For capture proxies, this could include the decl value expr. */
1868 {
1872 }
1874 /* TODO: implement selective generation of fields when vars are
1875 known not-used. */
1879 tree fld_ref
1882 tf_warning_or_error);
1886 }
1887 /* FIXME: we should be able to do this in the loop above, but (at least
1888 for range for) there are cases where the DECL_INITIAL contains
1889 forward references.
1890 So, now we've built the revised var in the frame, substitute uses of
1891 it in initializers and the bind expr body. */
1894 {
1895 /* we need to walk some of the decl trees, which might contain
1896 references to vars replaced at a higher level. */
1898 NULL);
1901 NULL);
1902 }
1905 /* Now we have processed and removed references to the original vars,
1906 we can drop those from the bind - leaving capture proxies alone. */
1908 {
1910 local_var_info &local_var
1914 /* Leave lambda closure captures alone, we replace the *this
1915 pointer with the frame version and let the normal process
1916 deal with the rest.
1917 Likewise, variables with their value found elsewhere.
1918 Skip past unused ones too. */
1922 {
1925 }
1927 /* Discard this one, we replaced it. */
1929 }
1933 }
1936 /* Look inside cleanups, we don't want to wrap a statement list in a
1937 cleanup. */
1941 else
1944 /* Look inside the decl_expr for the actual var. */
1951 /* VAR_DECLs that are not recorded can belong to the proxies we've placed
1952 for the promise and coroutine handle(s), to global vars or to compiler
1953 temporaries. Skip past these, we will handle them later. */
1964 /* This is our revised 'local' i.e. a frame slot. */
1969 {
1971 tree r
1977 }
1978 else
1984 }
1986 /* The actor transform. */
1988 static void
1994 {
1996 /* Some things we inherit from the original function. */
2002 /* One param, the coro frame pointer. */
2005 /* A void return. */
2012 /* We have a definition here. */
2025 void_coro_handle_type);
2031 /* Link in the block associated with the outer scope of the re-written
2032 function body. */
2044 /* The entry point for the actor code from the ramp. */
2045 tree actor_begin_label
2049 /* Declare the continuation handle. */
2052 /* Re-write param references in the body, no code should be generated
2053 here. */
2055 {
2056 tree arg;
2058 {
2066 tf_warning_or_error);
2070 /* We keep these in the frame as a regular pointer, so convert that
2071 back to the type expected. */
2079 }
2080 }
2082 /* Re-write local vars, similarly. */
2083 local_vars_transform xform_vars_data
2089 tf_warning_or_error);
2093 tree ret_label
2096 tree continue_label
2117 {
2123 l_num);
2129 }
2131 /* Insert the prototype dispatcher. */
2152 /* The final resume should be made to hit the default (trap, UB) entry
2153 although it will be unreachable via the normal entry point, since that
2154 is set to NULL on reaching final suspend. */
2156 {
2162 l_num);
2168 }
2170 /* Insert the prototype dispatcher. */
2178 /* actor's version of the promise. */
2180 tf_warning_or_error);
2182 tf_warning_or_error);
2184 /* actor's coroutine 'self handle'. */
2189 /* So construct the self-handle from the frame address. */
2202 /* Now we know the real promise, and enough about the frame layout to
2203 decide where to put things. */
2205 await_xform_data xform
2208 /* Transform the await expressions in the function body. Only do each
2209 await tree once! */
2213 /* Now replace the promise proxy with its real value. */
2214 proxy_replace p_data;
2219 /* Set the actor pointer to null, so that 'done' will work.
2220 Resume from here is UB anyway - although a 'ready' await will
2221 branch to the final resume, and fall through to the destroy. */
2222 tree resume_m
2231 /* Add in our function body with the co_returns rewritten to final form. */
2234 /* now do the tail of the function. */
2235 tree del_promise_label
2240 /* Destructors for the things we built explicitly. */
2243 tf_warning_or_error);
2246 tree del_frame_label
2251 /* Here deallocate the frame (if we allocated it), which we will have at
2252 present. */
2253 tree fnf_m
2264 {
2266 tree pid;
2268 {
2269 tree m
2274 tree dtor;
2275 dtor
2279 }
2280 }
2282 /* [dcl.fct.def.coroutine] / 12
2283 The deallocation function’s name is looked up in the scope of the promise
2284 type. If this lookup fails, the deallocation function’s name is looked up
2285 in the global scope. If deallocation function lookup finds both a usual
2286 deallocation function with only a pointer parameter and a usual
2287 deallocation function with both a pointer parameter and a size parameter,
2288 then the selected deallocation function shall be the one with two
2289 parameters. Otherwise, the selected deallocation function shall be the
2290 function with one parameter. If no usual deallocation function is found
2291 the program is ill-formed. The selected deallocation function shall be
2292 called with the address of the block of storage to be reclaimed as its
2293 first argument. If a deallocation function with a parameter of type
2294 std::size_t is used, the size of the block is passed as the corresponding
2295 argument. */
2303 {
2304 /* Look for sized version first, since this takes precedence. */
2310 /* It's OK to fail for this one... */
2313 tf_none);
2316 {
2321 tf_none);
2322 }
2324 /* But one of them must succeed, or the program is ill-formed. */
2326 {
2330 }
2331 }
2332 else
2333 {
2337 tf_warning_or_error);
2340 }
2350 /* done. */
2356 /* This is the suspend return point. */
2365 /* This is the 'continuation' return point. For such a case we have a coro
2366 handle (from the await_suspend() call) and we want handle.resume() to
2367 execute as a tailcall allowing arbitrary chaining of coroutines. */
2371 /* We want to force a tail-call even for O0/1, so this expands the resume
2372 call into its underlying implementation. */
2377 tree resume = build_call_expr_loc
2380 /* In order to support an arbitrary number of coroutine continuations,
2381 we must tail call them. However, some targets do not support indirect
2382 tail calls to arbitrary callees. See PR94359. */
2391 /* We will need to know which resume point number should be encoded. */
2392 tree res_idx_m
2395 tree resume_pt_number
2397 tf_warning_or_error);
2399 /* We've now rewritten the tree and added the initial and final
2400 co_awaits. Now pass over the tree and expand the co_awaits. */
2413 }
2415 /* The prototype 'destroy' function :
2416 frame->__resume_at |= 1;
2417 actor (frame); */
2419 static void
2421 tree actor)
2422 {
2423 /* One param, the coro frame pointer. */
2426 /* A void return. */
2432 /* We have a definition here. */
2444 tf_warning_or_error);
2448 /* _resume_at |= 1 */
2455 /* So .. call the actor .. */
2460 /* done. */
2467 }
2469 /* Helper that returns an identifier for an appended extension to the
2470 current un-mangled function name. */
2472 static tree
2474 {
2475 /* Figure out the bits we need to generate names for the outlined things
2476 For consistency, this needs to behave the same way as
2477 ASM_FORMAT_PRIVATE_NAME does. */
2480 #ifndef NO_DOT_IN_LABEL
2482 #else
2483 #ifndef NO_DOLLAR_IN_LABEL
2485 #else
2488 #endif
2489 #endif
2497 {
2501 {
2504 }
2506 }
2507 else
2511 }
2513 /* Build an initial or final await initialized from the promise
2514 initial_suspend or final_suspend expression. */
2516 static tree
2518 {
2522 tree setup_call
2526 /* So build the co_await for this */
2527 /* For initial/final suspends the call is "a" per [expr.await] 3.2. */
2530 }
2532 /* Callback to record the essential data for each await point found in the
2533 function. */
2535 static bool
2537 {
2539 suspend_point_info &s
2542 {
2544 await_expr);
2546 }
2550 }
2552 /* This data set is used when analyzing statements for await expressions. */
2554 struct susp_frame_data
2555 {
2556 /* Function-wide. */
2564 /* Temporary values for one statement or expression being analyzed. */
2572 };
2574 /* If this is an await expression, then count it (both uniquely within the
2575 function and locally within a single statement). */
2577 static tree
2579 {
2582 /* We should have already lowered co_yields to their co_await. */
2588 /* Count how many awaits the current expression contains. */
2591 /* Each await suspend context is unique, this is a function-wide value. */
2594 /* Awaitables should either be user-locals or promoted to coroutine frame
2595 entries at this point, and their initializers should have been broken
2596 out. */
2604 /* Rewrite target expressions on the await_suspend () to remove extraneous
2605 cleanups for the awaitables, which are now promoted to frame vars and
2606 managed via that. */
2612 }
2614 /* There are cases where any await expression is relevant. */
2615 static tree
2617 {
2619 {
2624 }
2626 }
2628 static bool
2630 {
2639 }
2641 /* Structure to record sub-expressions that need to be handled by the
2642 statement flattener. */
2644 struct coro_interesting_subtree
2645 {
2648 };
2650 /* tree-walk callback that returns the first encountered sub-expression of
2651 a kind that needs to be handled specifically by the statement flattener. */
2653 static tree
2655 {
2659 {
2662 {
2665 }
2666 }
2669 {
2672 }
2675 }
2677 /* Node for a doubly-linked list of promoted variables and their
2678 initializers. When the initializer is a conditional expression
2679 the 'then' and 'else' clauses are represented by a linked list
2680 attached to then_cl and else_cl respectively. */
2682 struct var_nest_node
2683 {
2687 {
2692 }
2693 tree var;
2694 tree init;
2699 };
2701 /* This is called for single statements from the co-await statement walker.
2702 It checks to see if the statement contains any initializers for awaitables
2703 and if any of these capture items by reference. */
2705 static void
2708 {
2711 {
2713 /* Compound expressions must be flattened specifically. */
2715 {
2718 var_nest_node *ins
2720 /* The compiler (but not the user) can generate temporaries with
2721 uses in the second arm of a compound expr. */
2724 /* The two arms have been processed separately. */
2726 }
2728 /* Handle conditional expressions. */
2731 /* FALLTHROUGH */
2733 {
2736 {
2739 var_nest_node *ins
2745 }
2748 /* Reconstruct x = t ? y : z;
2749 as (void) t ? x = y : x = z; */
2753 /* We are allowed a void type throw in one or both of the cond
2754 expr arms. */
2757 {
2759 then_cl
2762 }
2765 {
2767 else_cl
2770 }
2772 }
2773 /* FALLTHROUGH */
2775 {
2778 /* If the condition contains an await expression, then we need to
2779 set that first and use a separate var. */
2781 {
2788 var_nest_node *ins
2792 }
2794 n->then_cl
2796 n->else_cl
2799 /* Point to the start of the flattened code. */
2806 }
2808 }
2814 {
2817 {
2818 /* Await expressions with initializers have a compiler-temporary
2819 as the awaitable. 'promote' this. */
2825 {
2829 {
2831 /* We can have non-lvalue-expressions here, but when we see
2832 a target expression, mark it as already used. */
2834 {
2836 gcc_checking_assert
2838 }
2839 }
2842 /* If this is a call and not a CTOR, then we didn't expect it. */
2843 gcc_checking_assert
2846 }
2852 }
2855 {
2856 /* We have a temporary; promote it. */
2869 {
2873 tf_warning_or_error);
2874 }
2875 else
2877 var_nest_node *ins
2879 /* We have to replace the target expr... */
2882 /* ... and any uses of its var. */
2884 /* Compiler-generated temporaries can also have uses in following
2885 arms of compound expressions, which will be listed in 'replace_in'
2886 if present. */
2892 }
2894 }
2895 }
2897 /* Helper for 'process_conditional' that handles recursion into nested
2898 conditionals. */
2900 static void
2903 {
2904 do
2905 {
2907 {
2910 {
2914 {
2915 /* We didn't see this var before and it needs a DTOR, so
2916 build a guard variable for it. */
2921 boolean_type_node);
2924 }
2926 /* The initializer for this variable is replaced by a compound
2927 expression that performs the init and then records that the
2928 variable is live (and the DTOR should be run at the scope
2929 exit. */
2932 n->init
2934 }
2935 }
2937 {
2944 tree new_if
2948 }
2949 else
2953 }
2955 /* helper for 'maybe_promote_temps'.
2957 When we have a conditional expression which might embed await expressions
2958 and/or promoted variables, we need to handle it appropriately.
2960 The linked lists for the 'then' and 'else' clauses in a conditional node
2961 identify the promoted variables (but these cannot be wrapped in a regular
2962 cleanup).
2964 So recurse through the lists and build up a composite list of captured vars.
2965 Declare these and any guard variables needed to decide if a DTOR should be
2966 run. Then embed the conditional into a try-finally expression that handles
2967 running each DTOR conditionally on its guard variable. */
2969 static void
2971 {
2981 /* Declare the vars. There are two loops so that the boolean flags are
2982 grouped in the frame. */
2984 {
2989 }
2990 /* Define the guard flags for variables that need a DTOR. */
2992 {
2995 {
3000 }
3001 }
3002 tree new_if
3005 /* Build a set of conditional DTORs. */
3008 {
3014 tree cleanup
3017 tf_warning_or_error);
3023 }
3025 tree try_finally
3028 }
3030 /* Given *STMT, that contains at least one await expression.
3032 The full expression represented in the original source code will contain
3033 suspension points, but it is still required that the lifetime of temporary
3034 values extends to the end of the expression.
3036 We already have a mechanism to 'promote' user-authored local variables
3037 to a coroutine frame counterpart (which allows explicit management of the
3038 lifetime across suspensions). The transform here re-writes STMT into
3039 a bind expression, promotes temporary values into local variables in that
3040 and flattens the statement into a series of cleanups.
3042 Conditional expressions are re-written to regular 'if' statements.
3043 The cleanups for variables initialized inside a conditional (including
3044 nested cases) are wrapped in a try-finally clause, with guard variables
3045 to determine which DTORs need to be run. */
3047 static tree
3049 {
3054 /* Strip off uninteresting wrappers. */
3064 /* We walk the statement trees, flattening it into an ordered list of
3065 variables with initializers and fragments corresponding to compound
3066 expressions, truth or/and if and ternary conditionals. Conditional
3067 expressions carry a nested list of fragments for the then and else
3068 clauses. We anchor to the 'bottom' of the fragment list; we will write
3069 a cleanup nest with one shell for each variable initialized. */
3071 /* Check to see we didn't promote one twice. */
3080 /* We build the bind scope expression from the bottom-up.
3081 EXPR_LIST holds the inner expression nest at the current cleanup
3082 level (becoming the final expression list when we've exhausted the
3083 number of sub-expression fragments). */
3085 do
3086 {
3088 /* When we have a promoted variable, then add that to the bind scope
3089 and initialize it. When there's no promoted variable, we just need
3090 to run the initializer.
3091 If the initializer is a conditional expression, we need to collect
3092 and declare any promoted variables nested within it. DTORs for such
3093 variables must be run conditionally too. */
3095 {
3102 else
3106 {
3107 tree cleanup
3110 tf_warning_or_error);
3113 }
3116 else
3118 }
3119 else
3120 {
3123 else
3127 }
3134 /* Now produce the bind expression containing the 'promoted' temporaries
3135 as its variable list, and the cleanup nest as the statement. */
3142 {
3145 {
3149 }
3150 }
3157 }
3159 /* Lightweight callback to determine two key factors:
3160 1) If the statement/expression contains any await expressions.
3161 2) If the statement/expression potentially requires a re-write to handle
3162 TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion
3163 so that the await expressions are not processed in the case of the
3164 short-circuit arm.
3166 CO_YIELD expressions are re-written to their underlying co_await. */
3168 static tree
3170 {
3174 {
3177 /* co_yield is syntactic sugar, re-write it to co_await. */
3179 /* FALLTHROUGH */
3182 /* A non-null initializer for the awaiter means we need to expand. */
3188 {
3189 /* We don't need special action for awaits in the always-executed
3190 arm of a TRUTH_IF. */
3194 /* However, if there are await expressions on the conditionally
3195 executed branch, we must expand the TRUTH_IF to ensure that the
3196 expanded await expression control-flow is fully contained in the
3197 conditionally executed code. */
3203 {
3206 }
3207 /* We've done the sub-trees here. */
3209 }
3211 }
3214 }
3216 /* Given *EXPR
3217 If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on
3218 the conditionally executed branch, change this in a ternary operator.
3220 bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP;
3221 not_expr (always-exec expr) ? conditionally-exec expr : not_expr;
3223 Apply this recursively to the condition and the conditionally-exec
3224 branch. */
3228 tree scratch_var;
3230 };
3232 static tree
3234 {
3239 {
3243 /* FALLTHROUGH */
3245 {
3250 /* Transform truth expression into a cond expression with
3251 * the always-executed arm as the condition.
3252 * the conditionally-executed arm as the then clause.
3253 * the 'else' clause is fixed: 'true' for ||,'false' for &&. */
3259 tree cond_expr
3269 /* We've manually processed necessary sub-trees here. */
3271 }
3273 }
3275 }
3277 /* Helper that adds a new variable of VAR_TYPE to a bind scope BIND, the
3278 name is made up from NAM_ROOT, NAM_VERS. */
3280 static tree
3283 {
3285 /* Build a variable to hold the condition, this will be included in the
3286 frame as a local var. */
3293 }
3295 /* Helper to build and add if (!cond) break; */
3297 static void
3299 {
3306 }
3308 /* Tree walk callback to analyze, register and pre-process statements that
3309 contain await expressions. */
3311 static tree
3313 {
3317 /* Process a statement at a time. */
3319 {
3320 /* For conditional expressions, we might wish to add an artificial var
3321 to their containing bind expr. */
3323 /* We might need to insert a new bind expression, and want to link it
3324 into the correct scope, so keep a note of the current block scope. */
3333 }
3335 {
3336 tree_stmt_iterator i;
3338 {
3343 }
3346 }
3348 /* We have something to be handled as a single statement. */
3363 {
3364 /* Unless it's a special case, just walk the subtrees as usual. */
3367 /* When we have a conditional expression, which contains one or more
3368 await expressions, we have to break the condition out into a
3369 regular statement so that the control flow introduced by the await
3370 transforms can be implemented. */
3372 {
3373 /* Transform 'if (cond with awaits) then stmt1 else stmt2' into
3374 bool cond = cond with awaits.
3375 if (cond) then stmt1 else stmt2. */
3377 /* We treat the condition as if it was a stand-alone statement,
3378 to see if there are any await expressions which will be analyzed
3379 and registered. */
3396 /* We want to initialize the new variable with the expression
3397 that contains the await(s) and potentially also needs to
3398 have truth_if expressions expanded. */
3405 /* So now walk the new statement list. */
3409 }
3412 {
3413 /* We turn 'while (cond with awaits) stmt' into
3414 while (true) {
3415 if (!(cond with awaits))
3416 break;
3417 stmt..
3418 } */
3428 /* The original while body. */
3430 /* The new while body. */
3433 /* So now walk the new statement list. */
3438 }
3441 {
3442 /* We turn do stmt while (cond with awaits) into:
3443 do {
3444 stmt..
3445 if (!(cond with awaits))
3446 break;
3447 } while (true); */
3456 /* The original do stmt body. */
3459 /* The new while body. */
3462 /* So now walk the new statement list. */
3467 }
3470 {
3471 /* We turn 'switch (cond with awaits) stmt' into
3472 switch_type cond = cond with awaits
3473 switch (cond) stmt. */
3482 /* Build a variable to hold the condition, this will be
3483 included in the frame as a local var. */
3496 cond_inner);
3499 /* Now add the switch statement with the condition re-
3500 written to use the local var. */
3503 /* Process the expanded list. */
3508 }
3511 {
3512 /* Expand the co_return as per [stmt.return.coroutine]
3513 - for co_return;
3514 { p.return_void (); goto final_suspend; }
3515 - for co_return [void expr];
3516 { expr; p.return_void(); goto final_suspend;}
3517 - for co_return [non void expr];
3518 { p.return_value(expr); goto final_suspend; } */
3526 /* [stmt.return.coroutine], 2.2
3527 If expr is present and void, it is placed immediately before
3528 the call for return_void; */
3531 {
3533 /* If the return argument was a void expression, then any
3534 awaits must be contained in that. */
3536 }
3537 /* Insert p.return_{void,value(expr)}. */
3539 /* Absent a return of a void expression, any awaits must be in
3540 the parameter to return_value(). */
3546 /* Once this is complete, we will have processed subtrees. */
3549 {
3555 }
3557 }
3559 }
3561 {
3569 {
3570 /* If a truth-and/or-if expression has an await expression in the
3571 conditionally-taken branch, then it must be rewritten into a
3572 regular conditional. */
3576 }
3577 /* Process this statement, which contains at least one await expression
3578 to 'promote' temporary values to a coroutine frame slot. */
3580 }
3581 /* Continue recursion, if needed. */
3583 }
3585 /* For figuring out what param usage we have. */
3587 struct param_frame_data
3588 {
3592 location_t loc;
3594 };
3596 /* A tree-walk callback that records the use of parameters (to allow for
3597 optimizations where handling unused parameters may be omitted). */
3599 static tree
3601 {
3604 /* For lambda closure content, we have to look specifically. */
3606 {
3609 }
3614 /* If we already saw the containing expression, then we're done. */
3623 {
3627 }
3628 else
3632 }
3634 /* Small helper for the repetitive task of adding a new field to the coro
3635 frame type. */
3637 static tree
3639 location_t loc)
3640 {
3646 }
3648 /* For recording local variable usage. */
3650 struct local_vars_frame_data
3651 {
3655 location_t loc;
3658 };
3660 /* A tree-walk callback that processes one bind expression noting local
3661 variables, and making a coroutine frame slot available for those that
3662 need it, so that they can be 'promoted' across suspension points. */
3664 static tree
3666 {
3669 /* As we enter a bind expression - record the vars there and then recurse.
3670 As we exit drop the nest depth.
3671 The bind index is a growing count of how many bind indices we've seen.
3672 We build a space in the frame for each local var. */
3675 {
3678 tree lvar;
3681 {
3683 local_var_info &local_var
3691 /* Make sure that we only present vars to the tests below. */
3696 /* We don't move static vars into the frame. */
3702 /* If this var is a lambda capture proxy, we want to leave it alone,
3703 and later rewrite the DECL_VALUE_EXPR to indirect through the
3704 frame copy of the pointer to the lambda closure object. */
3709 /* If a variable has a value expression, then that's what needs
3710 to be processed. */
3715 /* Make names depth+index unique, so that we can support nested
3716 scopes with identically named locals. */
3722 else
3725 /* TODO: Figure out if we should build a local type that has any
3726 excess alignment or size from the original decl. */
3727 local_var.field_id
3730 /* We don't walk any of the local var sub-trees, they won't contain
3731 any bind exprs. */
3732 }
3736 }
3738 }
3740 /* Build, return FUNCTION_DECL node with its coroutine frame pointer argument
3741 for either actor or destroy functions. */
3743 static tree
3745 {
3756 /* Copy selected attributes from the original function. */
3760 /* Copy any alignment that the FE added. */
3763 /* Copy any alignment the user added. */
3765 /* Apply attributes from the original fn. */
3768 }
3770 /* Re-write the body as per [dcl.fct.def.coroutine] / 5. */
3772 static tree
3776 {
3777 /* This will be our new outer scope. */
3783 /* If the function has a top level bind expression, then connect that
3784 after first making sure we give it a new block. */
3787 {
3792 /* Replace the top block to avoid issues with locations for args
3793 appearing to be in a non-existent place. */
3800 /* The top block has one child, so far, and we have now got a
3801 superblock. */
3804 }
3806 /* Wrap the function body in a try {} catch (...) {} block, if exceptions
3807 are enabled. */
3812 /* [stmt.return.coroutine] / 3
3813 If p.return_void() is a valid expression, flowing off the end of a
3814 coroutine is equivalent to a co_return with no operand; otherwise
3815 flowing off the end of a coroutine results in undefined behavior. */
3816 tree return_void
3820 {
3821 /* Build promise.unhandled_exception(); */
3822 tree ueh
3824 coro_unhandled_exception_identifier,
3826 /* Create and initialize the initial-await-resume-called variable per
3827 [dcl.fct.def.coroutine] / 5.3. */
3829 boolean_type_node);
3835 /* Start the try-catch. */
3840 {
3841 /* Build a compound expression that sets the
3842 initial-await-resume-called variable true and then calls the
3843 initial suspend expression await resume. */
3847 boolean_true_node);
3850 }
3851 /* Add the initial await to the start of the user-authored function. */
3853 /* Append the original function body. */
3859 /* Mimic what the parser does for the catch. */
3863 /* Get the initial await resume called value. */
3868 /* If the initial await resume called value is false, rethrow... */
3877 /* ... else call the promise unhandled exception method. */
3882 }
3883 else
3884 {
3886 {
3887 /* We still try to look for the promise method and warn if it's not
3888 present. */
3889 tree ueh_meth
3894 coro_unhandled_exception_identifier,
3896 }
3897 /* Else we don't check and don't care if the method is missing..
3898 just add the initial suspend, function and return. */
3900 /* Append the original function body. */
3904 }
3906 /* co_return branches to the final_suspend label, so declare that now. */
3907 fs_label
3911 /* Before entering the final suspend point, we signal that this point has
3912 been reached by setting the resume function pointer to zero (this is
3913 what the 'done()' builtin tests) as per the current ABI. */
3914 resume_fn_field
3916 resume_fn_ptr_type);
3918 tree zero_resume
3920 zero_resume
3929 }
3931 /* Here we:
3932 a) Check that the function and promise type are valid for a
3933 coroutine.
3934 b) Carry out the initial morph to create the skeleton of the
3935 coroutine ramp function and the rewritten body.
3937 Assumptions.
3939 1. We only hit this code once all dependencies are resolved.
3940 2. The function body will be either a bind expr or a statement list
3941 3. That cfun and current_function_decl are valid for the case we're
3942 expanding.
3943 4. 'input_location' will be of the final brace for the function.
3945 We do something like this:
3946 declare a dummy coro frame.
3947 struct _R_frame {
3948 using handle_type = coro::coroutine_handle<coro1::promise_type>;
3949 void (*__resume)(_R_frame *);
3950 void (*__destroy)(_R_frame *);
3951 coro1::promise_type __p;
3952 bool frame_needs_free; free the coro frame mem if set.
3953 bool i_a_r_c; [dcl.fct.def.coroutine] / 5.3
3954 short __resume_at;
3955 handle_type self_handle;
3956 (maybe) parameter copies.
3957 (maybe) local variables saved (including awaitables)
3958 (maybe) trailing space.
3959 }; */
3961 bool
3963 {
3969 {
3970 /* For early errors, we do not want a diagnostic about the missing
3971 ramp return value, since the user cannot fix this - a 'return' is
3972 not allowed in a coroutine. */
3974 /* Discard the body, we can't process it further. */
3978 }
3980 /* We can't validly get here with an empty statement list, since there's no
3981 way for the FE to decide it's a coroutine in the absence of any code. */
3985 /* We don't have the locus of the opening brace - it's filled in later (and
3986 there doesn't really seem to be any easy way to get at it).
3987 The closing brace is assumed to be input_location. */
3991 /* Initial processing of the function-body.
3992 If we have no expressions or just an error then punt. */
3995 {
3998 /* Suppress warnings about the missing return value. */
4001 }
4003 /* So, we've tied off the original user-authored body in fn_body.
4005 Start the replacement synthesized ramp body as newbody.
4006 If we encounter a fatal error we might return a now-empty body.
4008 Note, the returned ramp body is not 'popped', to be compatible with
4009 the way that decl.c handles regular functions, the scope pop is done
4010 in the caller. */
4015 /* If our original body is noexcept, then that's what we apply to our
4016 generated ramp, transfer any MUST_NOT_THOW_EXPR to that. */
4019 {
4020 /* The function body we will continue with is the single operand to
4021 the must-not-throw. */
4023 /* Transfer the must-not-throw to the ramp body. */
4025 /* Re-start the ramp as must-not-throw. */
4027 }
4029 /* Create the coro frame type, as far as it can be known at this stage.
4030 1. Types we already know. */
4036 /* 2. Types we need to define or look up. */
4042 tree act_des_fn_type
4046 /* Declare the actor and destroyer function. */
4050 /* Construct the wrapped function body; we will analyze this to determine
4051 the requirements for the coroutine frame. */
4057 /* Build our dummy coro frame layout. */
4061 tree resume_name
4064 tree destroy_name
4067 tree promise_name
4071 tree resume_idx_name
4075 /* We need a handle to this coroutine, which is passed to every
4076 await_suspend(). There's no point in creating it over and over. */
4079 /* Now add in fields for function params (if there are any).
4080 We do not attempt elision of copies at this stage, we do analyze the
4081 uses and build worklists to replace those when the state machine is
4082 lowered. */
4086 {
4087 /* Build a hash map with an entry for each param.
4088 The key is the param tree.
4089 Then we have an entry for the frame field name.
4090 Then a cache for the field ref when we come to use it.
4091 Then a tree list of the uses.
4092 The second two entries start out empty - and only get populated
4093 when we see uses. */
4100 {
4112 {
4113 /* If the user passes by reference, then we will save the
4114 pointer to the original. As noted in
4115 [dcl.fct.def.coroutine] / 13, if the lifetime of the
4116 referenced item ends and then the coroutine is resumed,
4117 we have UB; well, the user asked for it. */
4120 }
4132 {
4135 }
4136 else
4141 }
4143 /* We want to record every instance of param's use, so don't include
4144 a 'visited' hash_set on the tree walk, but only record a containing
4145 expression once. */
4147 param_frame_data param_data
4150 }
4152 /* We need to know, and inspect, each suspend point in the function
4153 in several places. It's convenient to place this map out of line
4154 since it's used from tree walk callbacks. */
4157 /* Now insert the data for any body await points, at this time we also need
4158 to promote any temporaries that are captured by reference (to regular
4159 vars) they will get added to the coro frame along with other locals. */
4160 susp_frame_data body_aw_points
4168 /* 4. Now make space for local vars, this is conservative again, and we
4169 would expect to delete unused entries later. */
4171 local_vars_frame_data local_vars_data
4175 /* Tie off the struct for now, so that we can build offsets to the
4176 known entries. */
4184 /* Ramp: */
4185 /* Now build the ramp function pieces. */
4191 coro_frame_ptr);
4194 /* Collected the scope vars we need ... only one for now. */
4197 /* We're now going to create a new top level scope block for the ramp
4198 function. */
4205 /* The decl_expr for the coro frame pointer, initialize to zero so that we
4206 can pass it to the IFN_CO_FRAME (since there's no way to pass a type,
4207 directly apparently). This avoids a "used uninitialized" warning. */
4212 /* The CO_FRAME internal function is a mechanism to allow the middle end
4213 to adjust the allocation in response to optimizations. We provide the
4214 current conservative estimate of the frame size (as per the current)
4215 computed layout. */
4217 tree resizeable
4221 /* [dcl.fct.def.coroutine] / 10 (part1)
4222 The unqualified-id get_return_object_on_allocation_failure is looked up
4223 in the scope of the promise type by class member access lookup. */
4225 /* We don't require this, so coro_build_promise_expression can return NULL,
4226 but, if the lookup succeeds, then the function must be usable. */
4228 tree grooaf
4230 coro_gro_on_allocation_fail_identifier,
4233 /* however, should that fail, returning an error, the later stages can't
4234 handle the erroneous expression, so we reset the call as if it was
4235 absent. */
4239 /* Allocate the frame, this has several possibilities:
4240 [dcl.fct.def.coroutine] / 9 (part 1)
4241 The allocation function’s name is looked up in the scope of the promise
4242 type. It's not a failure for it to be absent see part 4, below. */
4248 {
4251 /* [dcl.fct.def.coroutine] / 9 (part 2)
4252 If the lookup finds an allocation function in the scope of the promise
4253 type, overload resolution is performed on a function call created by
4254 assembling an argument list. The first argument is the amount of space
4255 requested, and has type std::size_t. The succeeding arguments are
4256 those of the original function. */
4262 {
4266 {
4267 /* We pass a reference to *this to the allocator lookup. */
4273 tf_warning_or_error);
4275 }
4276 else
4278 }
4280 /* Note the function selected; we test to see if it's NOTHROW. */
4281 tree func;
4282 /* Failure is not an error for this attempt. */
4288 {
4289 /* [dcl.fct.def.coroutine] / 9 (part 3)
4290 If no viable function is found, overload resolution is performed
4291 again on a function call created by passing just the amount of
4292 space required as an argument of type std::size_t. */
4296 tf_none);
4298 }
4300 /* However, if the promise provides an operator new, then one of these
4301 two options must be available. */
4303 {
4307 }
4313 " no usable %<get_return_object_on_allocation_failure%>"
4315 }
4317 {
4318 /* [dcl.fct.def.coroutine] / 9 (part 4)
4319 If this lookup fails, the allocation function’s name is looked up in
4320 the global scope. */
4323 /* build_operator_new_call () will insert size needed as element 0 of
4324 this, and we might need to append the std::nothrow constant. */
4327 {
4328 /* [dcl.fct.def.coroutine] / 10 (part 2)
4329 If any declarations (of the get return on allocation fail) are
4330 found, then the result of a call to an allocation function used
4331 to obtain storage for the coroutine state is assumed to return
4332 nullptr if it fails to obtain storage and, if a global allocation
4333 function is selected, the ::operator new(size_t, nothrow_t) form
4334 is used. The allocation function used in this case shall have a
4335 non-throwing noexcept-specification. So we need std::nothrow. */
4344 }
4346 /* If we get to this point, we must succeed in looking up the global
4347 operator new for the params provided. Extract a simplified version
4348 of the machinery from build_operator_new_call. This can update the
4349 frame size. */
4354 tf_warning_or_error);
4355 resizeable = build_call_expr_internal_loc
4357 /* If the operator call fails for some reason, then don't try to
4358 amend it. */
4363 }
4370 /* If the user provided a method to return an object on alloc fail, then
4371 check the returned pointer and call the func if it's null.
4372 Otherwise, no check, and we fail for noexcept/fno-exceptions cases. */
4375 {
4376 /* [dcl.fct.def.coroutine] / 10 (part 3)
4377 If the allocation function returns nullptr,the coroutine returns
4378 control to the caller of the coroutine and the return value is
4379 obtained by a call to T::get_return_object_on_allocation_failure(),
4380 where T is the promise type. */
4388 {
4389 /* Execute the get-return-object-on-alloc-fail call... */
4391 /* ... but discard the result, since we return void. */
4393 }
4394 else
4395 {
4396 /* Get the fallback return object. */
4399 }
4402 }
4404 /* deref the frame pointer, to use in member access code. */
4407 /* For now, once allocation has succeeded we always assume that this needs
4408 destruction, there's no impl. for frame allocation elision. */
4409 tree fnf_m
4417 /* Put the resumer and destroyer functions in. */
4420 tree resume_m
4430 tree destroy_m
4433 tree destroy_x
4435 tf_warning_or_error);
4440 /* [dcl.fct.def.coroutine] /13
4441 When a coroutine is invoked, a copy is created for each coroutine
4442 parameter. Each such copy is an object with automatic storage duration
4443 that is direct-initialized from an lvalue referring to the corresponding
4444 parameter if the parameter is an lvalue reference, and from an xvalue
4445 referring to it otherwise. A reference to a parameter in the function-
4446 body of the coroutine and in the call to the coroutine promise
4447 constructor is replaced by a reference to its copy. */
4451 /* The initialization and destruction of each parameter copy occurs in the
4452 context of the called coroutine. Initializations of parameter copies are
4453 sequenced before the call to the coroutine promise constructor and
4454 indeterminately sequenced with respect to each other. The lifetime of
4455 parameter copies ends immediately after the lifetime of the coroutine
4456 promise object ends. */
4461 {
4465 {
4471 tf_warning_or_error);
4472 tree fld_idx
4476 /* Add this to the promise CTOR arguments list, accounting for
4477 refs and special handling for method this ptr. */
4479 {
4480 /* We pass a reference to *this to the param preview. */
4488 tf_warning_or_error);
4490 }
4493 else
4497 {
4504 else
4506 /* Construct in place or move as relevant. */
4509 LOOKUP_NORMAL,
4510 tf_warning_or_error);
4512 }
4513 else
4514 {
4518 else
4523 }
4527 {
4531 }
4532 }
4533 }
4535 /* Set up the promise. */
4536 tree promise_m
4544 {
4545 /* Do a placement new constructor for the promise type (we never call
4546 the new operator, just the constructor on the object in place in the
4547 frame).
4549 First try to find a constructor with the same parameter list as the
4550 original function (if it has params), failing that find a constructor
4551 with no parameter list. */
4554 {
4559 }
4560 else
4566 tf_warning_or_error);
4570 }
4572 /* Set up a new bind context for the GRO. */
4574 /* Make and connect the scope blocks. */
4581 tree get_ro
4583 coro_get_return_object_identifier,
4585 /* Without a return object we haven't got much clue what's going on. */
4587 {
4590 /* Suppress warnings about the missing return value. */
4593 }
4602 /* We have to sequence the call to get_return_object before initial
4603 suspend. */
4607 {
4608 /* [dcl.fct.def.coroutine] / 7
4609 The expression promise.get_return_object() is used to initialize the
4610 glvalue result or... (see below)
4611 Construct the return result directly. */
4613 {
4616 complete_ctor_identifier,
4618 tf_warning_or_error);
4620 }
4621 else
4624 }
4625 else
4626 {
4627 /* ... or ... Construct an object that will be used as the single
4628 param to the CTOR for the return object. */
4636 {
4640 tf_warning_or_error);
4642 }
4643 else
4645 /* The constructed object might require a cleanup. */
4647 {
4648 tree cleanup
4651 tf_warning_or_error);
4654 }
4655 }
4661 /* Initialize the resume_idx_name to 0, meaning "not started". */
4662 tree resume_idx_m
4665 tree resume_idx
4667 tf_warning_or_error);
4673 /* So .. call the actor .. */
4678 /* Switch to using 'input_location' as the loc, since we're now more
4679 logically doing things related to the end of the function. */
4681 /* The ramp is done, we just need the return value.
4682 [dcl.fct.def.coroutine] / 7
4683 The expression promise.get_return_object() is used to initialize the
4684 glvalue result or prvalue result object of a call to a coroutine.
4686 If the 'get return object' is non-void, then we built it before the
4687 promise was constructed. We now supply a reference to that var,
4688 either as the return value (if it's the same type) or to the CTOR
4689 for an object of the return type. */
4693 else
4694 {
4696 {
4697 /* For class type return objects, we can attempt to construct,
4698 even if the gro is void. */
4702 {
4705 }
4709 tf_warning_or_error);
4713 }
4715 {
4716 /* We can't initialize a non-class return value from void. */
4720 }
4721 else
4724 }
4729 {
4733 }
4735 /* Finish up the ramp function. */
4742 /* Start to build the final functions.
4744 We push_deferring_access_checks to avoid these routines being seen as
4745 nested by the middle end; we are doing the outlining here. */
4749 /* Build the actor... */
4754 /* Destroyer ... */
4760 /* Link our new functions into the list. */
4771 }