From 3cd5af52e9b321be3d3e4071359c637f0eb3bf34 Mon Sep 17 00:00:00 2001 From: akr Date: Thu, 14 Jun 2007 08:35:20 +0000 Subject: * eval_load.c (Init_load): delay allocating an array for rb_load_path to avoid GC problem in very early stage. (RUBY_GC_STRESS causes GC in such stage.) * variable.c (rb_gc_mark_global_tbl): rb_global_tbl may be 0 in very early stage. * thread.c (thread_cleanup_func) [IA64]: clear register stack position. (thread_start_func_2) [IA64]: record the beginning of register stack using extra argument. (rb_gc_save_machine_context) [IA64]: record the end of register stack. * gc.c [IA64] (SET_STACK_END): record the end of register stack. (garbage_collect) [IA64]: use recorded register stack area for GC marking. (yarv_machine_stack_mark) [IA64]: GC mark from the register stack area. * yarvcore.c [IA64] (rb_gc_register_stack_start): defined. (Init_VM): store th->self on stack to fix GC problem. (Init_yarv) [IA64]: initialize the beginning of register stack. * yarvcore.h (struct rb_thread_struct) [IA64]: new members for register stack area. * thread_pthread.ci (thread_start_func_1) [IA64]: call thread_start_func_2 with the end of register stack. * cont.c (struct rb_context_struct) [IA64]: new members for register stack area. (cont_mark) [IA64]: GC mark from register stack area. (cont_free) [IA64]: free saved register stack. (cont_save_machine_stack) [IA64]: record the position and contents of the register stack. (cont_capture): store cont->self on stack to fix GC problem. (cont_restore_1) [IA64]: restore the register stack. [IA64] (register_stack_extend): new function. (cont_restore_0) [IA64]: call register_stack_extend instead of cont_restore_1. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12537 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- cont.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) (limited to 'cont.c') diff --git a/cont.c b/cont.c index 58149979ca..6e37f84707 100644 --- a/cont.c +++ b/cont.c @@ -22,6 +22,11 @@ typedef struct rb_context_struct { VALUE *vm_stack; VALUE *machine_stack; VALUE *machine_stack_src; +#ifdef __ia64 + VALUE *machine_register_stack; + VALUE *machine_register_stack_src; + int machine_register_stack_size; +#endif rb_thread_t saved_thread; rb_jmpbuf_t jmpbuf; int machine_stack_size; @@ -59,6 +64,12 @@ cont_mark(void *ptr) rb_gc_mark_locations(cont->machine_stack, cont->machine_stack + cont->machine_stack_size); } +#ifdef __ia64 + if (cont->machine_register_stack) { + rb_gc_mark_locations(cont->machine_register_stack, + cont->machine_register_stack + cont->machine_register_stack_size); + } +#endif } MARK_REPORT_LEAVE("cont"); } @@ -71,6 +82,9 @@ cont_free(void *ptr) rb_context_t *cont = ptr; FREE_UNLESS_NULL(cont->saved_thread.stack); FREE_UNLESS_NULL(cont->machine_stack); +#ifdef __ia64 + FREE_UNLESS_NULL(cont->machine_register_stack); +#endif FREE_UNLESS_NULL(cont->vm_stack); ruby_xfree(ptr); } @@ -83,6 +97,10 @@ cont_save_machine_stack(rb_thread_t *th, rb_context_t *cont) int size; rb_gc_set_stack_end(&th->machine_stack_end); +#ifdef __ia64 + th->machine_register_stack_end = rb_ia64_bsp(); +#endif + if (th->machine_stack_start > th->machine_stack_end) { size = cont->machine_stack_size = th->machine_stack_start - th->machine_stack_end; cont->machine_stack_src = th->machine_stack_end; @@ -100,6 +118,20 @@ cont_save_machine_stack(rb_thread_t *th, rb_context_t *cont) } MEMCPY(cont->machine_stack, cont->machine_stack_src, VALUE, size); + +#ifdef __ia64 + rb_ia64_flushrs(); + size = cont->machine_register_stack_size = th->machine_register_stack_end - th->machine_register_stack_start; + cont->machine_register_stack_src = th->machine_register_stack_start; + if (cont->machine_register_stack) { + REALLOC_N(cont->machine_register_stack, VALUE, size); + } + else { + cont->machine_register_stack = ALLOC_N(VALUE, size); + } + + MEMCPY(cont->machine_register_stack, cont->machine_register_stack_src, VALUE, size); +#endif } static rb_context_t * @@ -132,9 +164,11 @@ cont_capture(volatile int *stat) { rb_context_t *cont; rb_thread_t *th; + volatile VALUE contval; th_stack_to_heap(GET_THREAD()); cont = cont_new(rb_cCont); + contval = cont->self; th = &cont->saved_thread; cont->vm_stack = ALLOC_N(VALUE, th->stack_size); @@ -203,11 +237,50 @@ cont_restore_1(rb_context_t *cont) VALUE, cont->machine_stack_size); } +#ifdef __ia64 + if (cont->machine_register_stack_src) { + MEMCPY(cont->machine_register_stack_src, cont->machine_register_stack, + VALUE, cont->machine_register_stack_size); + } +#endif + ruby_longjmp(cont->jmpbuf, 1); } NORETURN(NOINLINE(static void cont_restore_0(rb_context_t *, VALUE *))); +#ifdef __ia64 +#define C(a) rse_##a##0, rse_##a##1, rse_##a##2, rse_##a##3, rse_##a##4 +#define E(a) rse_##a##0= rse_##a##1= rse_##a##2= rse_##a##3= rse_##a##4 +static volatile int C(a), C(b), C(c), C(d), C(e); +static volatile int C(f), C(g), C(h), C(i), C(j); +static volatile int C(k), C(l), C(m), C(n), C(o); +static volatile int C(p), C(q), C(r), C(s), C(t); +int rb_dummy_false = 0; +NORETURN(NOINLINE(static void register_stack_extend(rb_context_t *, VALUE *))); +static void +register_stack_extend(rb_context_t *cont, VALUE *curr_bsp) +{ + if (rb_dummy_false) { + /* use registers as much as possible */ + E(a) = E(b) = E(c) = E(d) = E(e) = + E(f) = E(g) = E(h) = E(i) = E(j) = + E(k) = E(l) = E(m) = E(n) = E(o) = + E(p) = E(q) = E(r) = E(s) = E(t) = 0; + E(a) = E(b) = E(c) = E(d) = E(e) = + E(f) = E(g) = E(h) = E(i) = E(j) = + E(k) = E(l) = E(m) = E(n) = E(o) = + E(p) = E(q) = E(r) = E(s) = E(t) = 0; + } + if (curr_bsp < cont->machine_register_stack_src+cont->machine_register_stack_size) { + register_stack_extend(cont, (VALUE*)rb_ia64_bsp()); + } + cont_restore_1(cont); +} +#undef C +#undef E +#endif + static void cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame) { @@ -238,7 +311,11 @@ cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame) } #endif } +#ifdef __ia64 + register_stack_extend(cont, (VALUE*)rb_ia64_bsp()); +#else cont_restore_1(cont); +#endif } /* -- cgit v1.2.3