ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libcoro/coro.c
(Generate patch)

Comparing libcoro/coro.c (file contents):
Revision 1.30 by root, Fri Apr 4 20:07:35 2008 UTC vs.
Revision 1.72 by root, Tue Aug 14 14:25:10 2018 UTC

1/* 1/*
2 * Copyright (c) 2001-2008 Marc Alexander Lehmann <schmorp@schmorp.de> 2 * Copyright (c) 2001-2011 Marc Alexander Lehmann <schmorp@schmorp.de>
3 * 3 *
4 * Redistribution and use in source and binary forms, with or without modifica- 4 * Redistribution and use in source and binary forms, with or without modifica-
5 * tion, are permitted provided that the following conditions are met: 5 * tion, are permitted provided that the following conditions are met:
6 * 6 *
7 * 1. Redistributions of source code must retain the above copyright notice, 7 * 1. Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer. 8 * this list of conditions and the following disclaimer.
9 * 9 *
10 * 2. Redistributions in binary form must reproduce the above copyright 10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the 11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution. 12 * documentation and/or other materials provided with the distribution.
13 * 13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
15 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER- 15 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
16 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 16 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
17 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE- 17 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
18 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 18 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
… …
38 * go to Ralf S. Engelschall <rse@engelschall.com>. 38 * go to Ralf S. Engelschall <rse@engelschall.com>.
39 */ 39 */
40 40
41#include "coro.h" 41#include "coro.h"
42 42
43#include <stddef.h>
44#include <string.h>
45
46/*****************************************************************************/
47/* ucontext/setjmp/asm backends */
48/*****************************************************************************/
49#if CORO_UCONTEXT || CORO_SJLJ || CORO_LOSER || CORO_LINUX || CORO_IRIX || CORO_ASM
50
51# if CORO_UCONTEXT
52# include <stddef.h>
53# endif
54
43#if !defined(STACK_ADJUST_PTR) 55# if !defined(STACK_ADJUST_PTR)
56# if __sgi
44/* IRIX is decidedly NON-unix */ 57/* IRIX is decidedly NON-unix */
45# if __sgi
46# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss) - 8) 58# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss) - 8)
47# define STACK_ADJUST_SIZE(sp,ss) ((ss) - 8) 59# define STACK_ADJUST_SIZE(sp,ss) ((ss) - 8)
48# elif __i386__ && CORO_LINUX 60# elif (__i386__ && CORO_LINUX) || (_M_IX86 && CORO_LOSER)
49# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss)) 61# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss))
50# define STACK_ADJUST_SIZE(sp,ss) (ss) 62# define STACK_ADJUST_SIZE(sp,ss) (ss)
51# elif __amd64__ && CORO_LINUX 63# elif (__amd64__ && CORO_LINUX) || ((_M_AMD64 || _M_IA64) && CORO_LOSER)
52# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss) - 8) 64# define STACK_ADJUST_PTR(sp,ss) ((char *)(sp) + (ss) - 8)
53# define STACK_ADJUST_SIZE(sp,ss) (ss) 65# define STACK_ADJUST_SIZE(sp,ss) (ss)
54# else 66# else
55# define STACK_ADJUST_PTR(sp,ss) (sp) 67# define STACK_ADJUST_PTR(sp,ss) (sp)
56# define STACK_ADJUST_SIZE(sp,ss) (ss) 68# define STACK_ADJUST_SIZE(sp,ss) (ss)
69# endif
57# endif 70# endif
58#endif
59 71
60#if CORO_UCONTEXT
61# include <stddef.h>
62#endif
63
64#if CORO_SJLJ || CORO_LOSER || CORO_LINUX || CORO_IRIX || CORO_ASM
65
66#include <stdlib.h> 72# include <stdlib.h>
67 73
68#if CORO_SJLJ 74# if CORO_SJLJ
69# include <stdio.h> 75# include <stdio.h>
70# include <signal.h> 76# include <signal.h>
71# include <unistd.h> 77# include <unistd.h>
72#endif 78# endif
73 79
74static volatile coro_func coro_init_func; 80static coro_func coro_init_func;
75static volatile void *coro_init_arg; 81static void *coro_init_arg;
76static volatile coro_context *new_coro, *create_coro; 82static coro_context *new_coro, *create_coro;
77
78/* what we really want to detect here is wether we use a new-enough version of GAS */
79/* instead, check for gcc 3, ELF and GNU/Linux and hope for the best */
80#if __GNUC__ >= 3 && __ELF__ && __linux__
81# define HAVE_CFI 1
82#endif
83 83
84static void 84static void
85coro_init (void) 85coro_init (void)
86{ 86{
87 volatile coro_func func = coro_init_func; 87 volatile coro_func func = coro_init_func;
88 volatile void *arg = coro_init_arg; 88 volatile void *arg = coro_init_arg;
89 89
90 coro_transfer ((coro_context *)new_coro, (coro_context *)create_coro); 90 coro_transfer (new_coro, create_coro);
91
92#if __GCC_HAVE_DWARF2_CFI_ASM && __amd64
93 /*asm (".cfi_startproc");*/
94 /*asm (".cfi_undefined rip");*/
95#endif
91 96
92 func ((void *)arg); 97 func ((void *)arg);
98
99#if __GCC_HAVE_DWARF2_CFI_ASM && __amd64
100 /*asm (".cfi_endproc");*/
101#endif
93 102
94 /* the new coro returned. bad. just abort() for now */ 103 /* the new coro returned. bad. just abort() for now */
95 abort (); 104 abort ();
96} 105}
97 106
98# if CORO_SJLJ 107# if CORO_SJLJ
99 108
100static volatile int trampoline_count; 109static volatile int trampoline_done;
101 110
102/* trampoline signal handler */ 111/* trampoline signal handler */
103static void 112static void
104trampoline (int sig) 113trampoline (int sig)
105{ 114{
106 if (setjmp (((coro_context *)new_coro)->env)) 115 if (coro_setjmp (new_coro->env))
107 {
108#if HAVE_CFI
109 asm (".cfi_startproc");
110#endif
111 coro_init (); /* start it */ 116 coro_init (); /* start it */
112#if HAVE_CFI
113 asm (".cfi_endproc");
114#endif
115 }
116 else 117 else
117 trampoline_count++; 118 trampoline_done = 1;
118} 119}
119 120
120# endif 121# endif
121 122
122#endif
123
124#if CORO_ASM 123# if CORO_ASM
125void __attribute__((__noinline__, __fastcall__)) 124
126coro_transfer (struct coro_context *prev, struct coro_context *next) 125 #if __arm__ && \
127{ 126 (defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
128 asm volatile ( 127 || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__ \
128 || __ARM_ARCH == 7)
129 #define CORO_ARM 1
130 #endif
131
132 #if _WIN32 || __CYGWIN__
133 #define CORO_WIN_TIB 1
134 #endif
135
136 asm (
137 "\t.text\n"
138 #if _WIN32 || __CYGWIN__
139 "\t.globl _coro_transfer\n"
140 "_coro_transfer:\n"
141 #else
142 "\t.globl coro_transfer\n"
143 "coro_transfer:\n"
144 #endif
145 /* windows, of course, gives a shit on the amd64 ABI and uses different registers */
146 /* http://blogs.msdn.com/freik/archive/2005/03/17/398200.aspx */
129#if __amd64 147 #if __amd64
130# define NUM_CLOBBERED 5 148
131 "push %%rbx\n\t" 149 #if _WIN32 || __CYGWIN__
132 "push %%r12\n\t" 150 #define NUM_SAVED 29
133 "push %%r13\n\t" 151 "\tsubq $168, %rsp\t" /* one dummy qword to improve alignment */
134 "push %%r14\n\t" 152 "\tmovaps %xmm6, (%rsp)\n"
135 "push %%r15\n\t" 153 "\tmovaps %xmm7, 16(%rsp)\n"
136 "mov %%rsp, %0\n\t" 154 "\tmovaps %xmm8, 32(%rsp)\n"
137 "mov %1, %%rsp\n\t" 155 "\tmovaps %xmm9, 48(%rsp)\n"
138 "pop %%r15\n\t" 156 "\tmovaps %xmm10, 64(%rsp)\n"
139 "pop %%r14\n\t" 157 "\tmovaps %xmm11, 80(%rsp)\n"
140 "pop %%r13\n\t" 158 "\tmovaps %xmm12, 96(%rsp)\n"
141 "pop %%r12\n\t" 159 "\tmovaps %xmm13, 112(%rsp)\n"
142 "pop %%rbx\n\t" 160 "\tmovaps %xmm14, 128(%rsp)\n"
143#elif __i386 161 "\tmovaps %xmm15, 144(%rsp)\n"
144# define NUM_CLOBBERED 4 162 "\tpushq %rsi\n"
145 "push %%ebx\n\t" 163 "\tpushq %rdi\n"
146 "push %%esi\n\t" 164 "\tpushq %rbp\n"
147 "push %%edi\n\t" 165 "\tpushq %rbx\n"
148 "push %%ebp\n\t" 166 "\tpushq %r12\n"
149 "mov %%esp, %0\n\t" 167 "\tpushq %r13\n"
150 "mov %1, %%esp\n\t" 168 "\tpushq %r14\n"
151 "pop %%ebp\n\t" 169 "\tpushq %r15\n"
152 "pop %%edi\n\t" 170 #if CORO_WIN_TIB
153 "pop %%esi\n\t" 171 "\tpushq %fs:0x0\n"
154 "pop %%ebx\n\t" 172 "\tpushq %fs:0x8\n"
155#else 173 "\tpushq %fs:0xc\n"
174 #endif
175 "\tmovq %rsp, (%rcx)\n"
176 "\tmovq (%rdx), %rsp\n"
177 #if CORO_WIN_TIB
178 "\tpopq %fs:0xc\n"
179 "\tpopq %fs:0x8\n"
180 "\tpopq %fs:0x0\n"
181 #endif
182 "\tpopq %r15\n"
183 "\tpopq %r14\n"
184 "\tpopq %r13\n"
185 "\tpopq %r12\n"
186 "\tpopq %rbx\n"
187 "\tpopq %rbp\n"
188 "\tpopq %rdi\n"
189 "\tpopq %rsi\n"
190 "\tmovaps (%rsp), %xmm6\n"
191 "\tmovaps 16(%rsp), %xmm7\n"
192 "\tmovaps 32(%rsp), %xmm8\n"
193 "\tmovaps 48(%rsp), %xmm9\n"
194 "\tmovaps 64(%rsp), %xmm10\n"
195 "\tmovaps 80(%rsp), %xmm11\n"
196 "\tmovaps 96(%rsp), %xmm12\n"
197 "\tmovaps 112(%rsp), %xmm13\n"
198 "\tmovaps 128(%rsp), %xmm14\n"
199 "\tmovaps 144(%rsp), %xmm15\n"
200 "\taddq $168, %rsp\n"
201 #else
202 #define NUM_SAVED 6
203 "\tpushq %rbp\n"
204 "\tpushq %rbx\n"
205 "\tpushq %r12\n"
206 "\tpushq %r13\n"
207 "\tpushq %r14\n"
208 "\tpushq %r15\n"
209 "\tmovq %rsp, (%rdi)\n"
210 "\tmovq (%rsi), %rsp\n"
211 "\tpopq %r15\n"
212 "\tpopq %r14\n"
213 "\tpopq %r13\n"
214 "\tpopq %r12\n"
215 "\tpopq %rbx\n"
216 "\tpopq %rbp\n"
217 #endif
218 "\tpopq %rcx\n"
219 "\tjmpq *%rcx\n"
220
221 #elif __i386__
222
223 #define NUM_SAVED 4
224 "\tpushl %ebp\n"
225 "\tpushl %ebx\n"
226 "\tpushl %esi\n"
227 "\tpushl %edi\n"
228 #if CORO_WIN_TIB
229 #undef NUM_SAVED
230 #define NUM_SAVED 7
231 "\tpushl %fs:0\n"
232 "\tpushl %fs:4\n"
233 "\tpushl %fs:8\n"
234 #endif
235 "\tmovl %esp, (%eax)\n"
236 "\tmovl (%edx), %esp\n"
237 #if CORO_WIN_TIB
238 "\tpopl %fs:8\n"
239 "\tpopl %fs:4\n"
240 "\tpopl %fs:0\n"
241 #endif
242 "\tpopl %edi\n"
243 "\tpopl %esi\n"
244 "\tpopl %ebx\n"
245 "\tpopl %ebp\n"
246 "\tpopl %ecx\n"
247 "\tjmpl *%ecx\n"
248
249 #elif CORO_ARM /* untested, what about thumb, neon, iwmmxt? */
250
251 #if __ARM_PCS_VFP
252 "\tvpush {d8-d15}\n"
253 #define NUM_SAVED (9 + 8 * 2)
254 #else
255 #define NUM_SAVED 9
256 #endif
257 "\tpush {r4-r11,lr}\n"
258 "\tstr sp, [r0]\n"
259 "\tldr sp, [r1]\n"
260 "\tpop {r4-r11,lr}\n"
261 #if __ARM_PCS_VFP
262 "\tvpop {d8-d15}\n"
263 #endif
264 "\tmov r15, lr\n"
265
266 #elif __mips__ && 0 /* untested, 32 bit only */
267
268 #define NUM_SAVED (12 + 8 * 2)
269 /* TODO: n64/o64, lw=>ld */
270
271 "\t.set nomips16\n"
272 "\t.frame $sp,112,$31\n"
273 #if __mips_soft_float
274 "\taddiu $sp,$sp,-44\n"
275 #else
276 "\taddiu $sp,$sp,-112\n"
277 "\ts.d $f30,88($sp)\n"
278 "\ts.d $f28,80($sp)\n"
279 "\ts.d $f26,72($sp)\n"
280 "\ts.d $f24,64($sp)\n"
281 "\ts.d $f22,56($sp)\n"
282 "\ts.d $f20,48($sp)\n"
283 #endif
284 "\tsw $28,40($sp)\n"
285 "\tsw $31,36($sp)\n"
286 "\tsw $fp,32($sp)\n"
287 "\tsw $23,28($sp)\n"
288 "\tsw $22,24($sp)\n"
289 "\tsw $21,20($sp)\n"
290 "\tsw $20,16($sp)\n"
291 "\tsw $19,12($sp)\n"
292 "\tsw $18,8($sp)\n"
293 "\tsw $17,4($sp)\n"
294 "\tsw $16,0($sp)\n"
295 "\tsw $sp,0($4)\n"
296 "\tlw $sp,0($5)\n"
297 #if !__mips_soft_float
298 "\tl.d $f30,88($sp)\n"
299 "\tl.d $f28,80($sp)\n"
300 "\tl.d $f26,72($sp)\n"
301 "\tl.d $f24,64($sp)\n"
302 "\tl.d $f22,56($sp)\n"
303 "\tl.d $f20,48($sp)\n"
304 #endif
305 "\tlw $28,40($sp)\n"
306 "\tlw $31,36($sp)\n"
307 "\tlw $fp,32($sp)\n"
308 "\tlw $23,28($sp)\n"
309 "\tlw $22,24($sp)\n"
310 "\tlw $21,20($sp)\n"
311 "\tlw $20,16($sp)\n"
312 "\tlw $19,12($sp)\n"
313 "\tlw $18,8($sp)\n"
314 "\tlw $17,4($sp)\n"
315 "\tlw $16,0($sp)\n"
316 "\tj $31\n"
317 #if __mips_soft_float
318 "\taddiu $sp,$sp,44\n"
319 #else
320 "\taddiu $sp,$sp,112\n"
321 #endif
322
323 #else
156# error unsupported architecture 324 #error unsupported architecture
157#endif 325 #endif
158 : "=m" (prev->sp)
159 : "m" (next->sp)
160 ); 326 );
161} 327
162#endif 328# endif
163 329
164#if CORO_PTHREAD 330void
165 331coro_create (coro_context *ctx, coro_func coro, void *arg, void *sptr, size_t ssize)
166struct coro_init_args {
167 coro_func func;
168 void *arg;
169 coro_context *self, *main;
170};
171
172pthread_mutex_t coro_mutex = PTHREAD_MUTEX_INITIALIZER;
173
174static void *
175trampoline (void *args_)
176{ 332{
177 struct coro_init_args *args = (struct coro_init_args *)args_; 333 coro_context nctx;
178 coro_func func = args->func;
179 void *arg = args->arg;
180
181 pthread_mutex_lock (&coro_mutex);
182 pthread_cond_destroy (&args->self->c);
183 coro_transfer (args->self, args->main);
184 func (arg);
185 pthread_mutex_unlock (&coro_mutex);
186
187 return 0;
188}
189
190void coro_transfer(coro_context *prev, coro_context *next)
191{
192 pthread_cond_init (&prev->c, 0);
193 pthread_cond_signal (&next->c);
194 pthread_cond_wait (&prev->c, &coro_mutex);
195 pthread_cond_destroy (&prev->c);
196}
197
198#endif
199
200/* initialize a machine state */
201void coro_create (coro_context *ctx,
202 coro_func coro, void *arg,
203 void *sptr, long ssize)
204{
205#if CORO_UCONTEXT
206
207 getcontext (&(ctx->uc));
208
209 ctx->uc.uc_link = 0;
210 ctx->uc.uc_stack.ss_sp = STACK_ADJUST_PTR (sptr,ssize);
211 ctx->uc.uc_stack.ss_size = (size_t) STACK_ADJUST_SIZE (sptr,ssize);
212 ctx->uc.uc_stack.ss_flags = 0;
213
214 makecontext (&(ctx->uc), (void (*)()) coro, 1, arg);
215
216#elif CORO_SJLJ || CORO_LOSER || CORO_LINUX || CORO_IRIX || CORO_ASM
217
218# if CORO_SJLJ 334# if CORO_SJLJ
219 stack_t ostk, nstk; 335 stack_t ostk, nstk;
220 struct sigaction osa, nsa; 336 struct sigaction osa, nsa;
221 sigset_t nsig, osig; 337 sigset_t nsig, osig;
222# endif 338# endif
223 coro_context nctx; 339
340 if (!coro)
341 return;
224 342
225 coro_init_func = coro; 343 coro_init_func = coro;
226 coro_init_arg = arg; 344 coro_init_arg = arg;
227 345
228 new_coro = ctx; 346 new_coro = ctx;
… …
244 perror ("sigaction"); 362 perror ("sigaction");
245 abort (); 363 abort ();
246 } 364 }
247 365
248 /* set the new stack */ 366 /* set the new stack */
249 nstk.ss_sp = STACK_ADJUST_PTR (sptr,ssize); /* yes, some platforms (IRIX) get this wrong. */ 367 nstk.ss_sp = STACK_ADJUST_PTR (sptr, ssize); /* yes, some platforms (IRIX) get this wrong. */
250 nstk.ss_size = STACK_ADJUST_SIZE (sptr,ssize); 368 nstk.ss_size = STACK_ADJUST_SIZE (sptr, ssize);
251 nstk.ss_flags = 0; 369 nstk.ss_flags = 0;
252 370
253 if (sigaltstack (&nstk, &ostk) < 0) 371 if (sigaltstack (&nstk, &ostk) < 0)
254 { 372 {
255 perror ("sigaltstack"); 373 perror ("sigaltstack");
256 abort (); 374 abort ();
257 } 375 }
258 376
259 trampoline_count = 0; 377 trampoline_done = 0;
260 kill (getpid (), SIGUSR2); 378 kill (getpid (), SIGUSR2);
261 sigfillset (&nsig); sigdelset (&nsig, SIGUSR2); 379 sigfillset (&nsig); sigdelset (&nsig, SIGUSR2);
262 380
263 while (!trampoline_count) 381 while (!trampoline_done)
264 sigsuspend (&nsig); 382 sigsuspend (&nsig);
265 383
266 sigaltstack (0, &nstk); 384 sigaltstack (0, &nstk);
267 nstk.ss_flags = SS_DISABLE; 385 nstk.ss_flags = SS_DISABLE;
268 if (sigaltstack (&nstk, 0) < 0) 386 if (sigaltstack (&nstk, 0) < 0)
… …
274 392
275 if (~ostk.ss_flags & SS_DISABLE) 393 if (~ostk.ss_flags & SS_DISABLE)
276 sigaltstack (&ostk, 0); 394 sigaltstack (&ostk, 0);
277 395
278 sigaction (SIGUSR2, &osa, 0); 396 sigaction (SIGUSR2, &osa, 0);
279
280 sigprocmask (SIG_SETMASK, &osig, 0); 397 sigprocmask (SIG_SETMASK, &osig, 0);
281 398
282# elif CORO_LOSER 399# elif CORO_LOSER
283 400
284 setjmp (ctx->env); 401 coro_setjmp (ctx->env);
285#if __CYGWIN__ 402 #if __CYGWIN__ && __i386__
286 ctx->env[7] = (long)((char *)sptr + ssize); 403 ctx->env[8] = (long) coro_init;
287 ctx->env[8] = (long)coro_init; 404 ctx->env[7] = (long) ((char *)sptr + ssize) - sizeof (long);
405 #elif __CYGWIN__ && __x86_64__
406 ctx->env[7] = (long) coro_init;
407 ctx->env[6] = (long) ((char *)sptr + ssize) - sizeof (long);
408 #elif defined __MINGW32__
409 ctx->env[5] = (long) coro_init;
410 ctx->env[4] = (long) ((char *)sptr + ssize) - sizeof (long);
288#elif defined(_M_IX86) 411 #elif defined _M_IX86
289 ((_JUMP_BUFFER *)&ctx->env)->Eip = (long)coro_init; 412 ((_JUMP_BUFFER *)&ctx->env)->Eip = (long) coro_init;
290 ((_JUMP_BUFFER *)&ctx->env)->Esp = (long)STACK_ADJUST_PTR (sptr,ssize); 413 ((_JUMP_BUFFER *)&ctx->env)->Esp = (long) STACK_ADJUST_PTR (sptr, ssize) - sizeof (long);
291#elif defined(_M_AMD64) 414 #elif defined _M_AMD64
292 ((_JUMP_BUFFER *)&ctx->env)->Rip = (__int64)coro_init; 415 ((_JUMP_BUFFER *)&ctx->env)->Rip = (__int64) coro_init;
293 ((_JUMP_BUFFER *)&ctx->env)->Rsp = (__int64)STACK_ADJUST_PTR (sptr,ssize); 416 ((_JUMP_BUFFER *)&ctx->env)->Rsp = (__int64) STACK_ADJUST_PTR (sptr, ssize) - sizeof (__int64);
294#elif defined(_M_IA64) 417 #elif defined _M_IA64
295 ((_JUMP_BUFFER *)&ctx->env)->StIIP = (__int64)coro_init; 418 ((_JUMP_BUFFER *)&ctx->env)->StIIP = (__int64) coro_init;
296 ((_JUMP_BUFFER *)&ctx->env)->IntSp = (__int64)STACK_ADJUST_PTR (sptr,ssize); 419 ((_JUMP_BUFFER *)&ctx->env)->IntSp = (__int64) STACK_ADJUST_PTR (sptr, ssize) - sizeof (__int64);
297#else 420 #else
298# error "microsoft libc or architecture not supported" 421 #error "microsoft libc or architecture not supported"
299#endif 422 #endif
300 423
301# elif CORO_LINUX 424# elif CORO_LINUX
302 425
303 _setjmp (ctx->env); 426 coro_setjmp (ctx->env);
304#if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 0 && defined (JB_PC) && defined (JB_SP) 427 #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 0 && defined (JB_PC) && defined (JB_SP)
305 ctx->env[0].__jmpbuf[JB_PC] = (long)coro_init; 428 ctx->env[0].__jmpbuf[JB_PC] = (long) coro_init;
306 ctx->env[0].__jmpbuf[JB_SP] = (long)STACK_ADJUST_PTR (sptr, ssize); 429 ctx->env[0].__jmpbuf[JB_SP] = (long) STACK_ADJUST_PTR (sptr, ssize) - sizeof (long);
307#elif __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 0 && defined (__mc68000__) 430 #elif __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 0 && defined (__mc68000__)
308 ctx->env[0].__jmpbuf[0].__aregs[0] = (long int)coro_init; 431 ctx->env[0].__jmpbuf[0].__aregs[0] = (long int)coro_init;
309 ctx->env[0].__jmpbuf[0].__sp = (int *)((char *)sptr + ssize); 432 ctx->env[0].__jmpbuf[0].__sp = (int *) ((char *)sptr + ssize) - sizeof (long);
310#elif defined (__GNU_LIBRARY__) && defined (__i386__) 433 #elif defined (__GNU_LIBRARY__) && defined (__i386__)
311 ctx->env[0].__jmpbuf[0].__pc = (char *)coro_init; 434 ctx->env[0].__jmpbuf[0].__pc = (char *) coro_init;
312 ctx->env[0].__jmpbuf[0].__sp = (void *)((char *)sptr + ssize); 435 ctx->env[0].__jmpbuf[0].__sp = (void *) ((char *)sptr + ssize) - sizeof (long);
313#elif defined (__GNU_LIBRARY__) && defined (__amd64__) 436 #elif defined (__GNU_LIBRARY__) && defined (__x86_64__)
314 ctx->env[0].__jmpbuf[JB_PC] = (long)coro_init; 437 ctx->env[0].__jmpbuf[JB_PC] = (long) coro_init;
315 ctx->env[0].__jmpbuf[JB_RSP] = (long)STACK_ADJUST_PTR (sptr, ssize); 438 ctx->env[0].__jmpbuf[0].__sp = (void *) ((char *)sptr + ssize) - sizeof (long);
316#else 439 #else
317# error "linux libc or architecture not supported" 440 #error "linux libc or architecture not supported"
318#endif 441 #endif
319 442
320# elif CORO_IRIX 443# elif CORO_IRIX
321 444
322 setjmp (ctx->env); 445 coro_setjmp (ctx->env, 0);
323 ctx->env[JB_PC] = (__uint64_t)coro_init; 446 ctx->env[JB_PC] = (__uint64_t)coro_init;
324 ctx->env[JB_SP] = (__uint64_t)STACK_ADJUST_PTR (sptr, ssize); 447 ctx->env[JB_SP] = (__uint64_t)STACK_ADJUST_PTR (sptr, ssize) - sizeof (long);
325 448
326# elif CORO_ASM 449# elif CORO_ASM
327 450
451 #if __i386__ || __x86_64__
328 ctx->sp = (volatile void **)(ssize + (char *)sptr); 452 ctx->sp = (void **)(ssize + (char *)sptr);
453 *--ctx->sp = (void *)abort; /* needed for alignment only */
329 *--ctx->sp = (void *)coro_init; 454 *--ctx->sp = (void *)coro_init;
330 *--ctx->sp = (void *)coro_init; // this is needed when the prologue saves ebp 455 #if CORO_WIN_TIB
456 *--ctx->sp = 0; /* ExceptionList */
457 *--ctx->sp = (char *)sptr + ssize; /* StackBase */
458 *--ctx->sp = sptr; /* StackLimit */
459 #endif
460 #elif CORO_ARM
461 /* return address stored in lr register, don't push anything */
462 #else
463 #error unsupported architecture
464 #endif
465
331 ctx->sp -= NUM_CLOBBERED; 466 ctx->sp -= NUM_SAVED;
467 memset (ctx->sp, 0, sizeof (*ctx->sp) * NUM_SAVED);
468
469 #if __i386__ || __x86_64__
470 /* done already */
471 #elif CORO_ARM
472 ctx->sp[0] = coro; /* r4 */
473 ctx->sp[1] = arg; /* r5 */
474 ctx->sp[8] = (char *)coro_init; /* lr */
475 #else
476 #error unsupported architecture
477 #endif
478
479# elif CORO_UCONTEXT
480
481 getcontext (&(ctx->uc));
482
483 ctx->uc.uc_link = 0;
484 ctx->uc.uc_stack.ss_sp = sptr;
485 ctx->uc.uc_stack.ss_size = (size_t)ssize;
486 ctx->uc.uc_stack.ss_flags = 0;
487
488 makecontext (&(ctx->uc), (void (*)())coro_init, 0);
332 489
333# endif 490# endif
334 491
335 coro_transfer ((coro_context *)create_coro, (coro_context *)new_coro); 492 coro_transfer (create_coro, new_coro);
493}
336 494
495/*****************************************************************************/
496/* pthread backend */
497/*****************************************************************************/
337# elif CORO_PTHREAD 498#elif CORO_PTHREAD
338 499
339 pthread_t id; 500/* this mutex will be locked by the running coroutine */
340 pthread_attr_t attr; 501pthread_mutex_t coro_mutex = PTHREAD_MUTEX_INITIALIZER;
502
503struct coro_init_args
504{
505 coro_func func;
506 void *arg;
507 coro_context *self, *main;
508};
509
510static pthread_t null_tid;
511
512/* I'd so love to cast pthread_mutex_unlock to void (*)(void *)... */
513static void
514mutex_unlock_wrapper (void *arg)
515{
516 pthread_mutex_unlock ((pthread_mutex_t *)arg);
517}
518
519static void *
520coro_init (void *args_)
521{
522 struct coro_init_args *args = (struct coro_init_args *)args_;
523 coro_func func = args->func;
524 void *arg = args->arg;
525
526 pthread_mutex_lock (&coro_mutex);
527
528 /* we try to be good citizens and use deferred cancellation and cleanup handlers */
529 pthread_cleanup_push (mutex_unlock_wrapper, &coro_mutex);
530 coro_transfer (args->self, args->main);
531 func (arg);
532 pthread_cleanup_pop (1);
533
534 return 0;
535}
536
537void
538coro_transfer (coro_context *prev, coro_context *next)
539{
540 pthread_cond_signal (&next->cv);
541 pthread_cond_wait (&prev->cv, &coro_mutex);
542#if __FreeBSD__ /* freebsd is of course broken and needs manual testcancel calls... yay... */
543 pthread_testcancel ();
544#endif
545}
546
547void
548coro_create (coro_context *ctx, coro_func coro, void *arg, void *sptr, size_t ssize)
549{
341 coro_context nctx; 550 static coro_context nctx;
342 struct coro_init_args args;
343 static int once; 551 static int once;
344 552
345 if (!once) 553 if (!once)
346 { 554 {
555 once = 1;
556
347 pthread_mutex_lock (&coro_mutex); 557 pthread_mutex_lock (&coro_mutex);
348 once = 1; 558 pthread_cond_init (&nctx.cv, 0);
559 null_tid = pthread_self ();
349 } 560 }
350 561
562 pthread_cond_init (&ctx->cv, 0);
563
564 if (coro)
565 {
566 pthread_attr_t attr;
567 struct coro_init_args args;
568
351 args.func = coro; 569 args.func = coro;
352 args.arg = arg; 570 args.arg = arg;
353 args.self = ctx; 571 args.self = ctx;
354 args.main = &nctx; 572 args.main = &nctx;
355 573
356 pthread_attr_init (&attr); 574 pthread_attr_init (&attr);
357 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); 575#if __UCLIBC__
576 /* exists, but is borked */
577 /*pthread_attr_setstacksize (&attr, (size_t)ssize);*/
578#elif __CYGWIN__
579 /* POSIX, not here */
358 pthread_attr_setstack (&attr, sptr, (size_t)ssize); 580 pthread_attr_setstacksize (&attr, (size_t)ssize);
359 pthread_create (&id, &attr, trampoline, &args);
360
361 pthread_cond_init (&args.self->c, 0);
362 coro_transfer (args.main, args.self);
363
364#else 581#else
582 pthread_attr_setstack (&attr, sptr, (size_t)ssize);
583#endif
584 pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
585 pthread_create (&ctx->id, &attr, coro_init, &args);
586
587 coro_transfer (args.main, args.self);
588 }
589 else
590 ctx->id = null_tid;
591}
592
593void
594coro_destroy (coro_context *ctx)
595{
596 if (!pthread_equal (ctx->id, null_tid))
597 {
598 pthread_cancel (ctx->id);
599 pthread_mutex_unlock (&coro_mutex); /* let the other coro run */
600 pthread_join (ctx->id, 0);
601 pthread_mutex_lock (&coro_mutex);
602 }
603
604 pthread_cond_destroy (&ctx->cv);
605}
606
607/*****************************************************************************/
608/* fiber backend */
609/*****************************************************************************/
610#elif CORO_FIBER
611
612#define WIN32_LEAN_AND_MEAN
613#if _WIN32_WINNT < 0x0400
614 #undef _WIN32_WINNT
615 #define _WIN32_WINNT 0x0400
616#endif
617#include <windows.h>
618
619VOID CALLBACK
620coro_init (PVOID arg)
621{
622 coro_context *ctx = (coro_context *)arg;
623
624 ctx->coro (ctx->arg);
625}
626
627void
628coro_transfer (coro_context *prev, coro_context *next)
629{
630 if (!prev->fiber)
631 {
632 prev->fiber = GetCurrentFiber ();
633
634 if (prev->fiber == 0 || prev->fiber == (void *)0x1e00)
635 prev->fiber = ConvertThreadToFiber (0);
636 }
637
638 SwitchToFiber (next->fiber);
639}
640
641void
642coro_create (coro_context *ctx, coro_func coro, void *arg, void *sptr, size_t ssize)
643{
644 ctx->fiber = 0;
645 ctx->coro = coro;
646 ctx->arg = arg;
647
648 if (!coro)
649 return;
650
651 ctx->fiber = CreateFiber (ssize, coro_init, ctx);
652}
653
654void
655coro_destroy (coro_context *ctx)
656{
657 DeleteFiber (ctx->fiber);
658}
659
660#else
365# error unsupported backend 661 #error unsupported backend
662#endif
663
664/*****************************************************************************/
665/* stack management */
666/*****************************************************************************/
667#if CORO_STACKALLOC
668
669#include <stdlib.h>
670
671#ifndef _WIN32
672# include <unistd.h>
673#endif
674
675#if CORO_USE_VALGRIND
676# include <valgrind/valgrind.h>
677#endif
678
679#if _POSIX_MAPPED_FILES
680# include <sys/mman.h>
681# define CORO_MMAP 1
682# ifndef MAP_ANONYMOUS
683# ifdef MAP_ANON
684# define MAP_ANONYMOUS MAP_ANON
685# else
686# undef CORO_MMAP
687# endif
366#endif 688# endif
367} 689# include <limits.h>
690#else
691# undef CORO_MMAP
692#endif
368 693
694#if _POSIX_MEMORY_PROTECTION
695# ifndef CORO_GUARDPAGES
696# define CORO_GUARDPAGES 4
697# endif
698#else
699# undef CORO_GUARDPAGES
700#endif
701
702#if !CORO_MMAP
703# undef CORO_GUARDPAGES
704#endif
705
706#if !__i386__ && !__x86_64__ && !__powerpc__ && !__arm__ && !__aarch64__ && !__m68k__ && !__alpha__ && !__mips__ && !__sparc64__
707# undef CORO_GUARDPAGES
708#endif
709
710#ifndef CORO_GUARDPAGES
711# define CORO_GUARDPAGES 0
712#endif
713
714#if !PAGESIZE
715 #if !CORO_MMAP
716 #define PAGESIZE 4096
717 #else
718 static size_t
719 coro_pagesize (void)
720 {
721 static size_t pagesize;
722
723 if (!pagesize)
724 pagesize = sysconf (_SC_PAGESIZE);
725
726 return pagesize;
727 }
728
729 #define PAGESIZE coro_pagesize ()
730 #endif
731#endif
732
733int
734coro_stack_alloc (struct coro_stack *stack, unsigned int size)
735{
736 if (!size)
737 size = 256 * 1024;
738
739 stack->sptr = 0;
740 stack->ssze = ((size_t)size * sizeof (void *) + PAGESIZE - 1) / PAGESIZE * PAGESIZE;
741
742#if CORO_FIBER
743
744 stack->sptr = (void *)stack;
745 return 1;
746
747#else
748
749 size_t ssze = stack->ssze + CORO_GUARDPAGES * PAGESIZE;
750 void *base;
751
752 #if CORO_MMAP
753 /* mmap supposedly does allocate-on-write for us */
754 base = mmap (0, ssze, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
755
756 if (base == (void *)-1)
757 {
758 /* some systems don't let us have executable heap */
759 /* we assume they won't need executable stack in that case */
760 base = mmap (0, ssze, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
761
762 if (base == (void *)-1)
763 return 0;
764 }
765
766 #if CORO_GUARDPAGES
767 mprotect (base, CORO_GUARDPAGES * PAGESIZE, PROT_NONE);
768 #endif
769
770 base = (void*)((char *)base + CORO_GUARDPAGES * PAGESIZE);
771 #else
772 base = malloc (ssze);
773 if (!base)
774 return 0;
775 #endif
776
777 #if CORO_USE_VALGRIND
778 stack->valgrind_id = VALGRIND_STACK_REGISTER ((char *)base, ((char *)base) + ssze - CORO_GUARDPAGES * PAGESIZE);
779 #endif
780
781 stack->sptr = base;
782 return 1;
783
784#endif
785}
786
787void
788coro_stack_free (struct coro_stack *stack)
789{
790#if CORO_FIBER
791 /* nop */
792#else
793 #if CORO_USE_VALGRIND
794 VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
795 #endif
796
797 #if CORO_MMAP
798 if (stack->sptr)
799 munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
800 stack->ssze + CORO_GUARDPAGES * PAGESIZE);
801 #else
802 free (stack->sptr);
803 #endif
804#endif
805}
806
807#endif
808

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines