如何创建并行堆栈并在其上运行协程？

我决定我应该尝试实现协程（我认为我应该这样称呼它们）以获得乐趣和利润。我希望必须使用汇编程序，如果我想让它对任何事情都有用的话，可能还需要一些 C 语言。

请记住，这是出于教育目的。使用已经构建的协程库太容易了（而且真的没什么乐趣）。

你们知道setjmp and longjmp？它们允许您将堆栈展开到预定义的位置，并从那里恢复执行。但是，它无法回退到堆栈上的“稍后”。只能早点回来。

jmpbuf_t checkpoint;
int retval = setjmp(&checkpoint); // returns 0 the first time
/* lots of stuff, lots of calls, ... We're not even in the same frame anymore! */
longjmp(checkpoint, 0xcafebabe); // execution resumes where setjmp is, and now it returns 0xcafebabe instead of 0

我想要的是一种无需线程即可在不同堆栈上运行两个函数的方法。 （显然，一次只能运行一个。我说过，没有线程。）这两个函数必须能够恢复另一个函数的执行（并停止自己的执行）。有点像如果他们是longjmp向对方。一旦它返回到另一个函数，它必须从离开的地方恢复（即，在将控制权交给另一个函数的调用期间或之后），有点像longjmp返回到setjmp.

我是这样想的：

1. 功能A创建并行堆栈并将其清零（分配内存等）。
2. 功能A将其所有寄存器推送到当前堆栈。
3. 功能A将堆栈指针和基指针设置到该新位置，并压入神秘的数据结构指示跳回何处以及将指令指针设置回何处。
4. 功能A将大部分寄存器清零并将指令指针设置为函数的开头B.

那是为了初始化。现在，以下情况将无限循环：

1. 功能B在该堆栈上工作，做它需要做的任何工作。
2. 功能B到了需要打断并给予的地步A再次控制。
3. 功能B将其所有寄存器压入堆栈，获取神秘的数据结构 A一开始就给了它，并将堆栈指针和指令指针设置到哪里A告诉它。在此过程中，它会回手A一个新的、修改过的数据结构告诉我们从哪里恢复B.
4. 功能A唤醒，弹出它推入堆栈的所有寄存器，并继续工作，直到需要中断并给出B再次控制。

这一切对我来说听起来不错。然而，有很多事情我不太放心。

• 显然，在好的 x86 上，有这个pusha将所有寄存器发送到堆栈的指令。然而，处理器架构不断发展，现在使用 x86_64，我们有了更多通用寄存器，可能还有几个 SSE 寄存器。我找不到任何证据表明pusha确实推动了他们。现代 x86 CPU 中有大约 40 个公共寄存器。我必须做所有的事情吗push是我自己吗？而且，没有push对于 SSE 寄存器（尽管肯定有一个等效的 - 我对整个“x86 汇编器”事物很陌生）。
• 改变指令指针有那么简单吗？我可以这样做吗，比如，mov rip, rax（英特尔语法）？此外，从中获取价值必须有些特殊，因为它不断变化。如果我喜欢的话mov rax, rip（再次英特尔语法），将rip位于mov指令，到它后面的指令，还是介于两者之间？ 这只是jmp foo. Dummy.
• 我已经提到过一个神秘的数据结构几次。到目前为止，我假设它至少需要包含三件事：基指针、堆栈指针和指令指针。还有别的事吗？
• 我是不是忘记了什么？
• 虽然我真的很想理解事情是如何运作的，我很确定有一些库可以做到这一点。你知道任何？是否有任何 POSIX 或 BSD 定义的标准方法可以做到这一点，例如pthread对于线程？

感谢您阅读我的问题文本墙。

你是对的PUSHA不能在 x64 上工作，它会引发异常#UD, as PUSHA only压入 16 位或 32 位通用寄存器。请参阅英特尔手册 http://www.intel.com/products/processor/manuals/获取您想了解的所有信息。

Setting RIP很简单，jmp rax将设置RIP to RAX。要检索 RIP，如果您已经知道所有协程退出来源，则可以在编译时获取它，或者可以在运行时获取它，您可以在该调用之后调用下一个地址。像这样：

a:
call b
b:
pop rax

RAX现在将是b。这有效是因为CALL压入下一条指令的地址。这项技术也适用于 IA32（尽管我认为在 x64 上有更好的方法，因为它支持 RIP 相对寻址，但我不知道有哪一种）。当然如果你做了一个函数coroutine_yield，它只能拦截调用者地址:)

由于您无法在一条指令中将所有寄存器推送到堆栈，因此我不建议将协程状态存储在堆栈上，因为无论如何这都会使事情变得复杂。我认为最好的做法是为每个协程实例分配一个数据结构。

为什么你要把函数归零A？那可能没有必要。

以下是我处理整个事情的方法，试图使其尽可能简单：

创建一个结构coroutine_state包含以下内容：

• initarg
• arg
• registers（还包含标志）
• caller_registers

创建一个函数：

coroutine_state* coroutine_init(void (*coro_func)(coroutine_state*), void* initarg);

where coro_func是指向协程函数体的指针。

该函数执行以下操作：

1. 分配一个coroutine_state结构cs
2. assign initarg to cs.initarg，这些将是协程的初始参数
3. assign coro_func to cs.registers.rip
4. 将当前标志复制到cs.registers（不是寄存器，只有标志，因为我们需要一些理智的标志来防止世界末日）
5. 为协程的堆栈分配一些合适大小的区域并将其分配给cs.registers.rsp
6. 返回指向分配的指针coroutine_state结构

现在我们有另一个函数：

void* coroutine_next(coroutine_state cs, void* arg)

where cs是从返回的结构coroutine_init它代表一个协程实例，并且arg当协程恢复执行时将被输入到协程中。

该函数由协程调用者调用，将一些新参数传递给协程并恢复它，该函数的返回值是协程返回（产生）的任意数据结构。

1. 将所有当前标志/寄存器存储在cs.caller_registers除了RSP，参见步骤 3。
2. 存储arg in cs.arg
3. 修复调用者堆栈指针（cs.caller_registers.rsp），添加2*sizeof(void*)如果你幸运的话会修复它，你必须查找这个来确认它，你可能希望这个函数是stdcall，这样在调用它之前不会篡改寄存器
4. mov rax, [rsp]， 分配RAX to cs.caller_registers.rip;解释：除非你的编译器是破解的，[RSP]将保存指向调用该函数的调用指令后面的指令的指令指针（即：返回地址）
5. 加载标志和寄存器cs.registers
6. jmp cs.registers.rip，有效地恢复协程的执行

请注意，我们永远不会从此函数返回，我们跳转到的协程会为我们“返回”（请参阅coroutine_yield）。另请注意，在该函数内部，您可能会遇到许多复杂情况，例如 C 编译器生成的函数序言和结尾，也许还包括寄存器参数，您必须处理所有这些问题。就像我说的，stdcall 会拯救你lots麻烦的是，我认为 gcc -fomit-frame 指针会删除尾声的内容。

最后一个函数声明为：

void coroutine_yield(void* ret);

该函数在协程内部调用，以“暂停”协程的执行并返回到调用者coroutine_next.

1. 存储标志/寄存器in cs.registers
2. 修复协程堆栈指针（cs.registers.rsp），再次添加2*sizeof(void*)到它，并且你希望这个函数也成为 stdcall
3. mov rax, arg（让我们假装编译器中的所有函数都将其参数返回到RAX)
4. 加载标志/寄存器cs.caller_registers
5. jmp cs.caller_registers.rip这本质上是从coroutine_next调用协程调用者的堆栈帧，并且由于返回值被传入RAX， 我们回来了arg。我们就说如果arg is NULL，则协程已终止，否则它是任意数据结构。

回顾一下，您可以使用以下命令初始化协程coroutine_init，然后您可以重复调用实例化的协程coroutine_next.

协程的函数本身声明为：void my_coro(coroutine_state cs)

cs.initarg保存初始函数参数（想想构造函数）。每一次my_coro叫做，cs.arg有一个不同的参数，由coroutine_next。这就是协程调用者与协程通信的方式。最后，每次协程想要暂停自己时，它都会调用coroutine_yield，并向其传递一个参数，该参数是协程调用程序的返回值。

好吧，你现在可能会想“这很简单！”，但我忽略了以正确的顺序加载寄存器和标志的所有复杂性，同时仍然保持未损坏的堆栈帧并以某种方式保留协程数据结构的地址（你只需以线程安全的方式覆盖所有寄存器）。对于这一部分，您需要了解编译器内部是如何工作的...祝您好运:)