Как я могу создать параллельный стек и выполнить сопрограмму на нем?

Вы правы в том, что PUSHA не будет работать на x64, он вызовет исключение #UD , так как PUSHA только проталкивает 16-битные или 32-битные регистры общего назначения. См. руководства Intel для получения всей информации, которую вы когда-либо хотели знать.

Установить RIP просто: jmp rax установит RIP на 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);

где coro_func - указатель на тело функции сопрограммы.

Эта функция выполняет следующее:

1. выделяет coroutine_state структуру cs
2. присваивает initarg для cs.initarg , они будут быть начальным аргументом сопрограммы
3. назначить coro_func для cs.registers.rip
4. скопировать текущие флаги в cs.registers (не регистры, только флаги, поскольку нам нужны разумные флаги для предотвращения апокалипсиса)
5. выделите некоторую область приличного размера для стека сопрограмм и назначьте ее для cs.registers.rsp
6. возвращает указатель на выделенную структуру coroutine_state

Теперь у нас есть другая функция:

void * coroutine_next (coroutine_state cs, void * arg)

где cs - это структура, возвращенная из coroutine_init , которая представляет экземпляр сопрограммы, а arg будет загружен в сопрограмму, когда она возобновит выполнение.

Эта функция вызывается инициатором сопрограммы для передачи некоторого нового аргумента сопрограмме и возобновления ее работы, возвращаемое значение этой функции - это произвольная структура данных, возвращаемая (полученная) сопрограммой.

1. сохранить все текущие флаги / регистры в cs.caller_registers за исключением RSP , см. Шаг 3.
2. сохранить arg в cs .arg
3. исправляет указатель стека вызывающего объекта ( cs.caller_registers.rsp ), добавление 2 * sizeof (void *) исправит это, если вам повезет, вы бы необходимо найти это, чтобы подтвердить это, вы, вероятно, хотите, чтобы эта функция была stdcall, чтобы никакие регистры не были подделаны перед ее вызовом
4. mov rax, [rsp] , назначьте RAX на ] cs.caller_registers.rip ; объяснение: если ваш компилятор не работает в режиме взлома, [RSP] будет содержать указатель инструкции на инструкцию, которая следует за инструкцией вызова, которая вызвала эту функцию (то есть: адрес возврата)
5. загрузить флаги и регистры из cs.registers
6. jmp cs.registers.rip , эффективно возобновляя выполнение сопрограммы

Обратите внимание, что мы никогда не возвращаемся из этой функции, сопрограмма, к которой мы переходим, "возвращается" для нас (см. coroutine_yield ). Также обратите внимание, что внутри этой функции вы можете столкнуться со многими осложнениями, такими как пролог и эпилог функции, сгенерированные компилятором C, и, возможно, регистрировать аргументы, вы должны обо всем этом позаботиться. Как я уже сказал, stdcall избавит вас от множества неприятностей, я думаю, что gcc -fomit-frame_pointer удалит эпилог.

Последняя функция объявлена ​​как:

void coroutine_yield (void * ret);

Эта функция вызывается внутри сопрограммы, чтобы «приостановить» выполнение сопрограммы и вернуться к вызывающему coroutine_next .

1. сохранить флаги / регистры в 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 равно NULL , то сопрограмма завершена, в противном случае это произвольная структура данных.

Итак, напомним, вы инициализируете сопрограмму с помощью coroutine_init , затем вы можете повторно вызывать созданную сопрограмму с помощью coroutine_next .

Объявляется сама функция сопрограммы: void my_coro (coroutine_state cs)

cs.initarg содержит начальный аргумент функции (конструктор think). Каждый раз, когда вызывается my_coro , cs.arg имеет другой аргумент, указанный в coroutine_next . Вот как вызывающая сопрограмма взаимодействует с сопрограммой.Наконец, каждый раз, когда сопрограмма хочет приостановить себя, она вызывает coroutine_yield и передает ему один аргумент, который является возвращаемым значением вызывающей сопрограммы.

Хорошо, теперь вы можете подумать: «Все просто!», Но я упустил все сложности, связанные с загрузкой регистров и флагов в правильном порядке, при этом сохранив неповрежденный стековый фрейм и каким-то образом сохранив адрес структуры данных вашей сопрограммы. (вы просто перезаписали все свои регистры) потокобезопасным способом. Для этой части вам нужно будет узнать, как ваш компилятор работает внутри ... удачи :)