From 4b1d654efb3395bc768ed5b034a7b311bea76185 Mon Sep 17 00:00:00 2001 From: Marcel Moolenaar Date: Mon, 6 Jan 2003 00:56:23 +0000 Subject: [PATCH] Port libc_r to ia64. We need to do things slightly different because we have 2 stacks per thread: the regular downward memory stack and the irregular upward register stack. This implementation lets both stacks grow toward each other. An alternative scheme is to have them grow away from each other. The alternate scheme has the advantage that both stack grow toward guard pages. Since libc_r is virtually dead and we really want the *context stuff for thread switching, we don't try to be perfect, just functional. --- lib/Makefile | 2 +- lib/libc_r/uthread/pthread_private.h | 23 +++++++++++++++++++++++ lib/libc_r/uthread/uthread_create.c | 5 +++++ lib/libc_r/uthread/uthread_init.c | 5 +++++ lib/libc_r/uthread/uthread_sig.c | 11 +++++++++++ 5 files changed, 45 insertions(+), 1 deletion(-) diff --git a/lib/Makefile b/lib/Makefile index 4827e3ad478d..9b687827bf3d 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -40,7 +40,7 @@ _csu=csu/${MACHINE_ARCH} _csu=csu .endif -.if !defined(NOLIBC_R) && ${MACHINE_ARCH} != ia64 +.if !defined(NOLIBC_R) _libc_r= libc_r .endif diff --git a/lib/libc_r/uthread/pthread_private.h b/lib/libc_r/uthread/pthread_private.h index e8e85b0a3ea0..b2f7a61afa4a 100644 --- a/lib/libc_r/uthread/pthread_private.h +++ b/lib/libc_r/uthread/pthread_private.h @@ -102,6 +102,21 @@ (jb)[0]._jb[R_RA + 4] = (long)(ra); \ (jb)[0]._jb[R_T12 + 4] = (long)(ra); \ } while (0) +#elif defined(__ia64__) +#define GET_BSP_JB(jb) (*((unsigned long*)JMPBUF_ADDR_OF(jb,J_BSP))) +#define GET_STACK_JB(jb) (*((unsigned long*)JMPBUF_ADDR_OF(jb,J_SP))) +#define GET_STACK_SJB(sjb) GET_STACK_JB(sjb) +#define SET_RETURN_ADDR_JB(jb, ra) \ +do { \ + *((unsigned long*)JMPBUF_ADDR_OF(jb,J_B0)) = ((long*)(ra))[0]; \ + *((unsigned long*)JMPBUF_ADDR_OF(jb,J_PFS)) &= ~0x1FFFFFFFFFUL; \ +} while (0) +#define SET_STACK_JB(jb, stk, sz) \ +do { \ + UPD_STACK_JB(jb, stk + sz - 16); \ + GET_BSP_JB(jb) = (long)(stk); \ +} while (0) +#define UPD_STACK_JB(jb, stk) GET_STACK_JB(jb) = (long)(stk) #elif defined(__sparc64__) #include @@ -432,7 +447,11 @@ struct pthread_attr { /* * Miscellaneous definitions. */ +#if !defined(__ia64__) #define PTHREAD_STACK_DEFAULT 65536 +#else +#define PTHREAD_STACK_DEFAULT 0x40000 +#endif /* * Size of default red zone at the end of each stack. In actuality, this "red * zone" is merely an unmapped region, except in the case of the initial stack. @@ -450,7 +469,11 @@ extern int _pthread_page_size; * than the stacks of other threads, since many applications are likely to run * almost entirely on this stack. */ +#if !defined(__ia64__) #define PTHREAD_STACK_INITIAL 0x100000 +#else +#define PTHREAD_STACK_INITIAL 0x400000 +#endif /* * Define the different priority ranges. All applications have thread diff --git a/lib/libc_r/uthread/uthread_create.c b/lib/libc_r/uthread/uthread_create.c index d101721c9b78..2ea87b297cdd 100644 --- a/lib/libc_r/uthread/uthread_create.c +++ b/lib/libc_r/uthread/uthread_create.c @@ -144,10 +144,15 @@ _pthread_create(pthread_t *thread, const pthread_attr_t *attr, */ SET_RETURN_ADDR_JB(new_thread->ctx.jb, _thread_start); +#if !defined(__ia64__) /* The stack starts high and builds down: */ SET_STACK_JB(new_thread->ctx.jb, (long)new_thread->stack + pattr->stacksize_attr - sizeof(double)); +#else + SET_STACK_JB(new_thread->ctx.jb, + (long)new_thread->stack, pattr->stacksize_attr); +#endif /* Copy the thread attributes: */ memcpy(&new_thread->attr, pattr, sizeof(struct pthread_attr)); diff --git a/lib/libc_r/uthread/uthread_init.c b/lib/libc_r/uthread/uthread_init.c index d1d116e25ede..41737b198b77 100644 --- a/lib/libc_r/uthread/uthread_init.c +++ b/lib/libc_r/uthread/uthread_init.c @@ -373,8 +373,13 @@ _thread_init(void) /* Setup the context for the scheduler: */ _setjmp(_thread_kern_sched_jb); +#if !defined(__ia64__) SET_STACK_JB(_thread_kern_sched_jb, _thread_kern_sched_stack + sched_stack_size - sizeof(double)); +#else + SET_STACK_JB(_thread_kern_sched_jb, _thread_kern_sched_stack, + sched_stack_size); +#endif SET_RETURN_ADDR_JB(_thread_kern_sched_jb, _thread_kern_scheduler); /* diff --git a/lib/libc_r/uthread/uthread_sig.c b/lib/libc_r/uthread/uthread_sig.c index 5e3c9b955f40..b99c64d440ff 100644 --- a/lib/libc_r/uthread/uthread_sig.c +++ b/lib/libc_r/uthread/uthread_sig.c @@ -1043,15 +1043,20 @@ thread_sigframe_add(struct pthread *thread, int sig, int has_args) /* Get the top of the threads stack: */ stackp = GET_STACK_JB(thread->ctx.jb); +#if !defined(__ia64__) /* * Leave a little space on the stack and round down to the * nearest aligned word: */ stackp -= sizeof(double); stackp &= ~0x3UL; +#endif /* Allocate room on top of the stack for a new signal frame: */ stackp -= sizeof(struct pthread_signal_frame); +#if defined(__ia64__) + stackp &= ~0xFUL; +#endif psf = (struct pthread_signal_frame *) stackp; @@ -1080,9 +1085,15 @@ thread_sigframe_add(struct pthread *thread, int sig, int has_args) /* * Set up the context: */ +#if !defined(__ia64__) stackp -= sizeof(double); +#endif _setjmp(thread->ctx.jb); +#if !defined(__ia64__) SET_STACK_JB(thread->ctx.jb, stackp); +#else + UPD_STACK_JB(thread->ctx.jb, stackp - 16); +#endif SET_RETURN_ADDR_JB(thread->ctx.jb, _thread_sig_wrapper); }