1
2

push %rip  # 将下一条指令的位置压栈, 即记录函数的返回地址
mov XXX, %rip # 修改指令寄存器, 跳转到指定位置

1
2
3

%rbx
%rbp
%r12 - %15

1

pop %rip #从现在的栈顶取出一个地址, 并跳转过去. 这里实际上就是上面call指令保存的那个返回地址

1
2

// switch 是C的关键字, 没办法直接用 :(
void swtch(struct context_t** ret_from, struct context_t* to);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include<stdint.h>

struct saved_regs_t{
	uint64_t rbx;
	uint64_t rbp;
	uint64_t r12;
	uint64_t r13;
	uint64_t r14;
	uint64_t r15;
};

struct context_t{
	struct saved_regs_t saved_regs;
}

// "naked" 会告诉编译器, 这个函数不需要自己保存寄存器, 也不需要自己恢复寄存器, 一切都由自己来做
__attribute__((naked))
void swtch(context_t** ret_from, context_t* to){
    // 这里说明一下, 用push, pop 指令也是可以的, 但我觉得这样"似乎"会让数据间没有依赖
    // 理论上性能可能会更好一些
    
	// 首先, 先直接把saved_regs_t里面的寄存器值直接放在栈上就好, 当然也可以直接定义在context_t里面, 这个开心就好, 无所谓的, 我只是觉得这样方便点.
	// 注意栈的增长方向哦, 从高到底
    __asm__(
        "sub $48, %rsp \n\t"
        "mov %rbx, 0(%rsp)\n\t"
        "mov %rbp, 8(%rsp)\n\t"
        "mov %r12, 16(%rsp)\n\t"
        "mov %r13, 24(%rsp)\n\t"
        "mov %r14, 32(%rsp)\n\t"
        "mov %r15, 40(%rsp)\n\t"

        // from->saved_regs = rsp
        "mov %rsp, 0(%rdi)\n\t"
    );
    __asm__(
        "mov %rsi, %rsp\n\t"
        "mov 8(%rsp), %rbx\n\t"
        "mov 16(%rsp), %rbp\n\t"
        "mov 24(%rsp), %r12\n\t"
        "mov 32(%rsp), %r13\n\t"
        "mov 40(%rsp), %r14\n\t"
        "mov 48(%rsp), %r15\n\t"
        "add $48, %rsp\n\t"
    );
    
    __asm__("ret");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

enum {
	STK_SIZE = 4*1024*1024,
}

struct coroutine_t{
	uintptr_t stack;
	void (*entry)(void*);
	void *arg;
	struct context_t *context;
	char* name;
};

static coroutine_t main_co = {
    .stack = 0,
    .entry = nullptr,
    .arg = nullptr,
    .context = nullptr
};

static coroutine_t *current_co = &main_co;

void coroutine_yield(){
    swtch(&current_co->context, main_co.context);
}

void coroutine_resume(coroutine_t *co){
    current_co = co;
    swtch(&main_co.context, co->context);
}

extern "C"
void coroutine_exit(){
    coroutine_t *current = current_co;
    exited_co.push_back(current);
    cout << format("coroutine_exit: {}\n", current->name);
    coroutine_yield();
}

__attribute__((naked))
void coroutine_bootstrap(){
    __asm__(
        "pop %rax\n\t" // 参见下面的make_coroutine, 我们直接将入口地址放在了栈顶
        // 取出entry
        "mov 8(%rax), %rbx \n\t"
        // arg
        "mov 16(%rax), %rdi \n\t"
        // call
        "call *%rbx\n\t"

        "call coroutine_exit\n\t"
    );
}

coroutine_t* make_coroutine(void (*entry)(void*), void *arg, const char* name = "NULL"){
    uintptr_t stack_end = (uintptr_t)malloc(STACK_SIZE);
    memset((void*)stack_end, 0, STACK_SIZE);

    uintptr_t stack_start = stack_end + STACK_SIZE;

    uintptr_t rsp = stack_start;
    rsp -= sizeof(saved_regs_t);

    coroutine_t *co = (coroutine_t*)rsp;

    *co = (coroutine_t){
        .stack = stack_end,
        .entry = entry,
        .arg = arg,
        .context = nullptr,
        .name = (char*)name
    };

    rsp -= 8;
    *(uintptr_t*)rsp = (uintptr_t)co;

    rsp -= 8;
    *(uintptr_t*)rsp = (uintptr_t)coroutine_bootstrap;

    rsp -= sizeof(saved_regs_t);
    co->context = (context_t*)rsp;

    co->context->saved_regs.rbp = rsp + sizeof(saved_regs_t) + 8*2;

    return co;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

void test_coroutine_func(void* arg){
    int* n = (int*)arg;
    cout << format("test_coroutine_func: {}\n", *n);
    coroutine_yield();
    cout << "test_coroutine_func: after yield\n";
}

int main(int argc, char* argv[]) {
    int n = 1;
    int m = 2;
    coroutine_t *co = make_coroutine(test_coroutine_func, &n, "co1");
    coroutine_t *co2 = make_coroutine(test_coroutine_func, &m, "co2");
    coroutine_resume(co);
    coroutine_resume(co2);
    cout << "main: after resume\n";
    coroutine_resume(co);
    coroutine_resume(co2);
    
    coroutine_gc();
    return 0;
}

1
2
3
4
5
6
7

test_coroutine_func: 1
test_coroutine_func: 2
main: after resume
test_coroutine_func: after yield
coroutine_exit: co1
test_coroutine_func: after yield
coroutine_exit: co2