HaiwaiAdv2/NatureSDK/XenonSDK/XenonModel/NewAd/fq/.rvm/patches/ruby/1.8.6/hs.patch

diff --git a/eval.c b/eval.c
index 4098b83..c70f270 100644
--- a/eval.c
+++ b/eval.c
@@ -73,6 +73,7 @@ char *strrchr _((const char*,const char));
 #endif
 
 #include <time.h>
+#include <sys/mman.h>
 
 #ifdef __BEOS__
 #include <net/socket.h>
@@ -1025,7 +1026,7 @@ static struct tag *prot_tag;
     _tag.blkid = 0;			\
     prot_tag = &_tag
 
-#define PROT_NONE   Qfalse	/* 0 */
+#define PROT_EMPTY  Qfalse	/* 0 */
 #define PROT_THREAD Qtrue	/* 2 */
 #define PROT_FUNC   INT2FIX(0)	/* 1 */
 #define PROT_LOOP   INT2FIX(1)	/* 3 */
@@ -1236,7 +1237,7 @@ error_print()
 
     if (NIL_P(ruby_errinfo)) return;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if (EXEC_TAG() == 0) {
 	errat = get_backtrace(ruby_errinfo);
     }
@@ -1396,7 +1397,7 @@ ruby_init()
     /* default visibility is private at toplevel */
     SCOPE_SET(SCOPE_PRIVATE);
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	rb_call_inits();
 	ruby_class = rb_cObject;
@@ -1530,7 +1531,7 @@ ruby_options(argc, argv)
     int state;
 
     Init_stack((void*)&state);
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	ruby_process_options(argc, argv);
     }
@@ -1547,7 +1548,7 @@ void rb_exec_end_proc _((void));
 static void
 ruby_finalize_0()
 {
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if (EXEC_TAG() == 0) {
 	rb_trap_exit();
     }
@@ -1585,7 +1586,7 @@ ruby_cleanup(ex)
     Init_stack((void *)&state);
     ruby_finalize_0();
     errs[0] = ruby_errinfo;
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     PUSH_ITER(ITER_NOT);
     if ((state = EXEC_TAG()) == 0) {
 	rb_thread_cleanup();
@@ -1636,7 +1637,7 @@ ruby_exec_internal()
 {
     int state;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     PUSH_ITER(ITER_NOT);
     /* default visibility is private at toplevel */
     SCOPE_SET(SCOPE_PRIVATE);
@@ -1858,7 +1859,7 @@ rb_eval_cmd(cmd, arg, level)
     }
     if (TYPE(cmd) != T_STRING) {
 	PUSH_ITER(ITER_NOT);
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	ruby_safe_level = level;
 	if ((state = EXEC_TAG()) == 0) {
 	    val = rb_funcall2(cmd, rb_intern("call"), RARRAY(arg)->len, RARRAY(arg)->ptr);
@@ -1880,7 +1881,7 @@ rb_eval_cmd(cmd, arg, level)
 
     ruby_safe_level = level;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	val = eval(ruby_top_self, cmd, Qnil, 0, 0);
     }
@@ -2387,7 +2388,7 @@ is_defined(self, node, buf)
 	val = self;
 	if (node->nd_recv == (NODE *)1) goto check_bound;
       case NODE_CALL:
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((state = EXEC_TAG()) == 0) {
 	    val = rb_eval(self, node->nd_recv);
 	}
@@ -2489,7 +2490,7 @@ is_defined(self, node, buf)
 	break;
 
       case NODE_COLON2:
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((state = EXEC_TAG()) == 0) {
 	    val = rb_eval(self, node->nd_head);
 	}
@@ -2538,7 +2539,7 @@ is_defined(self, node, buf)
 	goto again;
 
       default:
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((state = EXEC_TAG()) == 0) {
 	    rb_eval(self, node);
 	}
@@ -2742,7 +2743,7 @@ call_trace_func(event, node, self, id, klass)
 	    klass = rb_iv_get(klass, "__attached__");
 	}
     }
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     raised = rb_thread_reset_raised(th);
     if ((state = EXEC_TAG()) == 0) {
 	srcfile = rb_str_new2(ruby_sourcefile?ruby_sourcefile:"(ruby)");
@@ -3302,7 +3303,7 @@ rb_eval(self, n)
 	    volatile VALUE e_info = ruby_errinfo;
 	    volatile int rescuing = 0;
 
-	    PUSH_TAG(PROT_NONE);
+	    PUSH_TAG(PROT_EMPTY);
 	    if ((state = EXEC_TAG()) == 0) {
 	      retry_entry:
 		result = rb_eval(self, node->nd_head);
@@ -3351,7 +3352,7 @@ rb_eval(self, n)
 	break;
 
       case NODE_ENSURE:
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((state = EXEC_TAG()) == 0) {
 	    result = rb_eval(self, node->nd_head);
 	}
@@ -3569,7 +3570,7 @@ rb_eval(self, n)
 	    ruby_frame = &frame;
 
 	    PUSH_SCOPE();
-	    PUSH_TAG(PROT_NONE);
+	    PUSH_TAG(PROT_EMPTY);
 	    if (node->nd_rval) {
 		saved_cref = ruby_cref;
 		ruby_cref = (NODE*)node->nd_rval;
@@ -4195,7 +4196,7 @@ module_setup(module, n)
     }
 
     PUSH_CREF(module);
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	EXEC_EVENT_HOOK(RUBY_EVENT_CLASS, n, ruby_cbase,
 			ruby_frame->last_func, ruby_frame->last_class);
@@ -4602,7 +4603,7 @@ rb_longjmp(tag, mesg)
 	VALUE e = ruby_errinfo;
 	int status;
 
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((status = EXEC_TAG()) == 0) {
 	    StringValue(e);
 	    warn_printf("Exception `%s' at %s:%d - %s\n",
@@ -4974,7 +4975,7 @@ rb_yield_0(val, self, klass, flags, avalue)
     node = block->body;
 
     if (block->var) {
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((state = EXEC_TAG()) == 0) {
 	    if (block->var == (NODE*)1) { /* no parameter || */
 		if (lambda && RARRAY(val)->len != 0) {
@@ -5032,7 +5033,7 @@ rb_yield_0(val, self, klass, flags, avalue)
     ruby_current_node = node;
 
     PUSH_ITER(block->iter);
-    PUSH_TAG(lambda ? PROT_NONE : PROT_YIELD);
+    PUSH_TAG(lambda ? PROT_EMPTY : PROT_YIELD);
     if ((state = EXEC_TAG()) == 0) {
       redo:
 	if (nd_type(node) == NODE_CFUNC || nd_type(node) == NODE_IFUNC) {
@@ -5430,7 +5431,7 @@ rb_rescue2(b_proc, data1, r_proc, data2, va_alist)
     VALUE eclass;
     va_list args;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     switch (state = EXEC_TAG()) {
       case TAG_RETRY:
 	if (!handle) break;
@@ -5488,7 +5489,7 @@ rb_protect(proc, data, state)
     VALUE result = Qnil;	/* OK */
     int status;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     cont_protect = (VALUE)rb_node_newnode(NODE_MEMO, cont_protect, 0, 0);
     if ((status = EXEC_TAG()) == 0) {
 	result = (*proc)(data);
@@ -5516,7 +5517,7 @@ rb_ensure(b_proc, data1, e_proc, data2)
     volatile VALUE result = Qnil;
     VALUE retval;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	result = (*b_proc)(data1);
     }
@@ -5543,7 +5544,7 @@ rb_with_disable_interrupt(proc, data)
 	int thr_critical = rb_thread_critical;
 
 	rb_thread_critical = Qtrue;
-	PUSH_TAG(PROT_NONE);
+	PUSH_TAG(PROT_EMPTY);
 	if ((status = EXEC_TAG()) == 0) {
 	    result = (*proc)(data);
 	}
@@ -6230,7 +6231,7 @@ rb_funcall_rescue(recv, mid, n, va_alist)
 
     va_init_list(ar, n);
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((status = EXEC_TAG()) == 0) {
 	result = vafuncall(recv, mid, n, &ar);
     }
@@ -6499,7 +6500,7 @@ eval(self, src, scope, file, line)
     if (TYPE(ruby_class) == T_ICLASS) {
 	ruby_class = RBASIC(ruby_class)->klass;
     }
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	NODE *node;
 
@@ -6658,7 +6659,7 @@ exec_under(func, under, cbase, args)
 
     mode = scope_vmode;
     SCOPE_SET(SCOPE_PUBLIC);
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	val = (*func)(args);
     }
@@ -6889,7 +6890,7 @@ rb_load(fname, wrap)
     PUSH_SCOPE();
     /* default visibility is private at loading toplevel */
     SCOPE_SET(SCOPE_PRIVATE);
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     state = EXEC_TAG();
     last_func = ruby_frame->last_func;
     last_node = ruby_current_node;
@@ -6948,7 +6949,7 @@ rb_load_protect(fname, wrap, state)
 {
     int status;
 
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((status = EXEC_TAG()) == 0) {
 	rb_load(fname, wrap);
     }
@@ -7269,7 +7270,7 @@ rb_require_safe(fname, safe)
     saved.node = ruby_current_node;
     saved.func = ruby_frame->last_func;
     saved.safe = ruby_safe_level;
-    PUSH_TAG(PROT_NONE);
+    PUSH_TAG(PROT_EMPTY);
     if ((state = EXEC_TAG()) == 0) {
 	VALUE feature, path;
 	long handle;
@@ -7977,7 +7978,7 @@ rb_exec_end_proc()
 	tmp_end_procs = link = ephemeral_end_procs;
 	ephemeral_end_procs = 0;
 	while (link) {
-	    PUSH_TAG(PROT_NONE);
+	    PUSH_TAG(PROT_EMPTY);
 	    if ((status = EXEC_TAG()) == 0) {
 		ruby_safe_level = link->safe;
 		(*link->func)(link->data);
@@ -7995,7 +7996,7 @@ rb_exec_end_proc()
 	tmp_end_procs = link = end_procs;
 	end_procs = 0;
 	while (link) {
-	    PUSH_TAG(PROT_NONE);
+	    PUSH_TAG(PROT_EMPTY);
 	    if ((status = EXEC_TAG()) == 0) {
 		ruby_safe_level = link->safe;
 		(*link->func)(link->data);
@@ -8654,7 +8655,7 @@ proc_invoke(proc, args, self, klass)
     ruby_block = &_block;
     PUSH_ITER(ITER_CUR);
     ruby_frame->iter = ITER_CUR;
-    PUSH_TAG(pcall ? PROT_LAMBDA : PROT_NONE);
+    PUSH_TAG(pcall ? PROT_LAMBDA : PROT_EMPTY);
     state = EXEC_TAG();
     if (state == 0) {
 	proc_set_safe_level(proc);
@@ -9896,6 +9897,7 @@ win32_set_exception_list(p)
 int rb_thread_pending = 0;
 
 VALUE rb_cThread;
+static unsigned int rb_thread_stack_size;
 
 extern VALUE rb_last_status;
 
@@ -10123,12 +10125,20 @@ thread_mark(th)
     rb_gc_mark(th->thread);
     if (th->join) rb_gc_mark(th->join->thread);
 
-    rb_gc_mark(th->klass);
-    rb_gc_mark(th->wrapper);
-    rb_gc_mark((VALUE)th->cref);
+    if (curr_thread == th) {
+      rb_gc_mark(ruby_class);
+      rb_gc_mark(ruby_wrapper);
+      rb_gc_mark((VALUE)ruby_cref);
+      rb_gc_mark((VALUE)ruby_scope);
+      rb_gc_mark((VALUE)ruby_dyna_vars);
+    } else {
+      rb_gc_mark(th->klass);
+      rb_gc_mark(th->wrapper);
+      rb_gc_mark((VALUE)th->cref);
+      rb_gc_mark((VALUE)th->scope);
+      rb_gc_mark((VALUE)th->dyna_vars);
+    }
 
-    rb_gc_mark((VALUE)th->scope);
-    rb_gc_mark((VALUE)th->dyna_vars);
     rb_gc_mark(th->errinfo);
     rb_gc_mark(th->last_status);
     rb_gc_mark(th->last_line);
@@ -10138,11 +10148,11 @@ thread_mark(th)
     rb_gc_mark_maybe(th->sandbox);
 
     /* mark data in copied stack */
-    if (th == curr_thread) return;
+    if (th == main_thread) return;
     if (th->status == THREAD_KILLED) return;
     if (th->stk_len == 0) return;  /* stack not active, no need to mark. */
-    if (th->stk_ptr) {
-	rb_gc_mark_locations(th->stk_ptr, th->stk_ptr+th->stk_len);
+    if (th->stk_ptr && th != curr_thread) {
+      rb_gc_mark_locations(th->stk_pos, th->stk_base);
 #if defined(THINK_C) || defined(__human68k__)
 	rb_gc_mark_locations(th->stk_ptr+2, th->stk_ptr+th->stk_len+2);
 #endif
@@ -10152,24 +10162,30 @@ thread_mark(th)
 	}
 #endif
     }
-    frame = th->frame;
+
+    if (curr_thread == th)
+      frame = ruby_frame;
+    else
+      frame = th->frame;
+
     while (frame && frame != top_frame) {
-	frame = ADJ(frame);
 	rb_gc_mark_frame(frame);
 	if (frame->tmp) {
 	    struct FRAME *tmp = frame->tmp;
-
 	    while (tmp && tmp != top_frame) {
-		tmp = ADJ(tmp);
 		rb_gc_mark_frame(tmp);
 		tmp = tmp->prev;
 	    }
 	}
 	frame = frame->prev;
     }
-    block = th->block;
+
+    if (curr_thread == th)
+      block = ruby_block;
+    else
+      block = th->block;
+
     while (block) {
-	block = ADJ(block);
 	rb_gc_mark_frame(&block->frame);
 	block = block->prev;
     }
@@ -10232,7 +10248,7 @@ static inline void
 stack_free(th)
     rb_thread_t th;
 {
-    if (th->stk_ptr) free(th->stk_ptr);
+  if (th->stk_ptr) munmap(th->stk_ptr, th->stk_size);
     th->stk_ptr = 0;
 #ifdef __ia64
     if (th->bstr_ptr) free(th->bstr_ptr);
@@ -10293,35 +10309,8 @@ rb_thread_save_context(th)
     static VALUE tval;
 
     len = ruby_stack_length(&pos);
-    th->stk_len = 0;
-    th->stk_pos = pos;
-    if (len > th->stk_max) {
-	VALUE *ptr = realloc(th->stk_ptr, sizeof(VALUE) * len);
-	if (!ptr) rb_memerror();
-	th->stk_ptr = ptr;
-	th->stk_max = len;
-    }
     th->stk_len = len;
-    FLUSH_REGISTER_WINDOWS;
-    MEMCPY(th->stk_ptr, th->stk_pos, VALUE, th->stk_len);
-#ifdef __ia64
-    th->bstr_pos = rb_gc_register_stack_start;
-    len = (VALUE*)rb_ia64_bsp() - th->bstr_pos;
-    th->bstr_len = 0;
-    if (len > th->bstr_max) {
-        VALUE *ptr = realloc(th->bstr_ptr, sizeof(VALUE) * len);
-        if (!ptr) rb_memerror();
-        th->bstr_ptr = ptr;
-        th->bstr_max = len;
-    }
-    th->bstr_len = len;
-    rb_ia64_flushrs();
-    MEMCPY(th->bstr_ptr, th->bstr_pos, VALUE, th->bstr_len);
-#endif
-#ifdef SAVE_WIN32_EXCEPTION_LIST
-    th->win32_exception_list = win32_get_exception_list();
-#endif
-
+    th->stk_pos = pos;
     th->frame = ruby_frame;
     th->scope = ruby_scope;
     ruby_scope->flags |= SCOPE_DONT_RECYCLE;
@@ -10431,11 +10420,6 @@ rb_thread_restore_context_0(rb_thread_t th, int exit)
 #endif
     tmp = th;
     ex = exit;
-    FLUSH_REGISTER_WINDOWS;
-    MEMCPY(tmp->stk_pos, tmp->stk_ptr, VALUE, tmp->stk_len);
-#ifdef __ia64
-    MEMCPY(tmp->bstr_pos, tmp->bstr_ptr, VALUE, tmp->bstr_len);
-#endif
 
     tval = rb_lastline_get();
     rb_lastline_set(tmp->last_line);
@@ -10526,8 +10510,8 @@ rb_thread_restore_context(th, exit)
     rb_thread_t th;
     int exit;
 {
-    if (!th->stk_ptr) rb_bug("unsaved context");
-    stack_extend(th, exit);
+    if (!th->stk_ptr && th != main_thread) rb_bug("unsaved context");
+    rb_thread_restore_context_0(th, exit);
 }
 
 static void
@@ -10546,7 +10530,6 @@ rb_thread_die(th)
 {
     th->thgroup = 0;
     th->status = THREAD_KILLED;
-    stack_free(th);
 }
 
 static void
@@ -11822,6 +11805,7 @@ rb_thread_group(thread)
 \
     th->stk_ptr = 0;\
     th->stk_len = 0;\
+    th->stk_size = 0;\
     th->stk_max = 0;\
     th->wait_for = 0;\
     IA64_INIT(th->bstr_ptr = 0);\
@@ -11869,6 +11853,48 @@ rb_thread_alloc(klass)
     THREAD_ALLOC(th);
     th->thread = Data_Wrap_Struct(klass, thread_mark, thread_free, th);
 
+    /* if main_thread != NULL, then this is NOT the main thread, so
+     * we create a heap-stack
+     */
+    if (main_thread) {
+      /* Allocate stack, don't forget to add 1 extra word because of the MATH below */
+      unsigned int pagesize = getpagesize();
+      unsigned int total_size = rb_thread_stack_size + pagesize + sizeof(int);
+      void *stack_area = NULL;
+
+      stack_area = mmap(NULL, total_size, PROT_READ | PROT_WRITE | PROT_EXEC,
+			MAP_PRIVATE | MAP_ANON, -1, 0);
+
+      if (stack_area == MAP_FAILED) {
+	fprintf(stderr, "Thread stack allocation failed!\n");
+	rb_memerror();
+      }
+
+      th->stk_ptr = th->stk_pos = stack_area;
+      th->stk_size = total_size;
+
+      if (mprotect(th->stk_ptr, pagesize, PROT_NONE) == -1) {
+	fprintf(stderr, "Failed to create thread guard region: %s\n", strerror(errno));
+	rb_memerror();
+      }
+
+      th->guard = th->stk_ptr + (pagesize/sizeof(VALUE *));
+
+      /* point stk_base at the top of the stack */
+      /* ASSUMPTIONS:
+       * 1.) The address returned by malloc is "suitably aligned" for anything on this system
+       * 2.) Adding a value that is "aligned" for this platform should not unalign the address
+       *     returned from malloc.
+       * 3.) Don't push anything on to the stack, otherwise it'll get unaligned.
+       * 4.) x86_64 ABI says aligned AFTER arguments have been pushed. You *must* then do a call[lq]
+       *     or push[lq] something else on to the stack if you inted to do a ret.
+       */
+      th->stk_base = th->stk_ptr + ((total_size - sizeof(int))/sizeof(VALUE *));
+      th->stk_len = rb_thread_stack_size;
+    } else {
+      th->stk_ptr = th->stk_pos = rb_gc_stack_start;
+    }
+
     for (vars = th->dyna_vars; vars; vars = vars->next) {
 	if (FL_TEST(vars, DVAR_DONT_RECYCLE)) break;
 	FL_SET(vars, DVAR_DONT_RECYCLE);
@@ -12014,17 +12040,22 @@ rb_thread_cancel_timer()
 }
 #endif
 
+struct thread_start_args {
+  VALUE (*fn)();
+  void *arg;
+  rb_thread_t th;
+} new_th;
+
+static VALUE
+rb_thread_start_2();
+
 static VALUE
 rb_thread_start_0(fn, arg, th)
     VALUE (*fn)();
     void *arg;
     rb_thread_t th;
 {
-    volatile rb_thread_t th_save = th;
     volatile VALUE thread = th->thread;
-    struct BLOCK *volatile saved_block = 0;
-    enum rb_thread_status status;
-    int state;
 
     if (OBJ_FROZEN(curr_thread->thgroup)) {
 	rb_raise(rb_eThreadError,
@@ -12054,16 +12085,41 @@ rb_thread_start_0(fn, arg, th)
 	return thread;
     }
 
-    if (ruby_block) {		/* should nail down higher blocks */
-	struct BLOCK dummy;
+    new_th.fn = fn;
+    new_th.arg = arg;
+    new_th.th = th;
+
+#if defined(__i386__)
+    __asm__ __volatile__ ("movl %0, %%esp\n\t"
+                          "calll *%1\n"
+                          :: "r" (th->stk_base),
+                             "r" (rb_thread_start_2));
+#elif defined(__x86_64__)
+    __asm__ __volatile__ ("movq %0, %%rsp\n\t"
+                          "callq *%1\n"
+                          :: "r" (th->stk_base),
+                             "r" (rb_thread_start_2));
+#else
+    #error unsupported architecture!
+#endif
+    /* NOTREACHED */
+    return 0;
+}
 
-	dummy.prev = ruby_block;
-	blk_copy_prev(&dummy);
-	saved_block = ruby_block = dummy.prev;
-    }
-    scope_dup(ruby_scope);
+static VALUE
+rb_thread_start_2()
+{
+   volatile rb_thread_t th = new_th.th;
+   volatile rb_thread_t th_save = th;
+   volatile VALUE thread = th->thread;
+   struct BLOCK *volatile saved_block = 0;
+   enum rb_thread_status status;
+   int state;
+   struct tag *tag;
+   struct RVarmap *vars;
+   struct FRAME dummy_frame;
 
-    if (!th->next) {
+   if (!th->next) {
 	/* merge in thread list */
 	th->prev = curr_thread;
 	curr_thread->next->prev = th;
@@ -12071,13 +12127,27 @@ rb_thread_start_0(fn, arg, th)
 	curr_thread->next = th;
 	th->priority = curr_thread->priority;
 	th->thgroup = curr_thread->thgroup;
+   }
+   curr_thread = th;
+
+   dummy_frame = *ruby_frame;
+   dummy_frame.prev = top_frame;
+   ruby_frame = &dummy_frame;
+
+   if (ruby_block) {		/* should nail down higher blocks */
+	struct BLOCK dummy;
+
+	dummy.prev = ruby_block;
+	blk_copy_prev(&dummy);
+	saved_block = ruby_block = dummy.prev;
     }
 
+    scope_dup(ruby_scope);
+
     PUSH_TAG(PROT_THREAD);
     if ((state = EXEC_TAG()) == 0) {
 	if (THREAD_SAVE_CONTEXT(th) == 0) {
-	    curr_thread = th;
-	    th->result = (*fn)(arg, th);
+	    th->result = (*new_th.fn)(new_th.arg, th);
 	}
 	th = th_save;
     }
@@ -12414,6 +12484,43 @@ rb_thread_cleanup()
     END_FOREACH_FROM(curr, th);
 }
 
+/*
+ * call-seq:
+ *    Thread.stack_size    => fixnum
+ *
+ * Returns the thread stack size in bytes
+ */
+static VALUE
+rb_thread_stacksize_get()
+{
+  return INT2FIX(rb_thread_stack_size);
+}
+
+/*
+ * call-seq:
+ *    Thread.stack_size= fixnum => Qnil
+ *
+ * Sets the global thread stacksize and returns Qnil.
+ */
+static VALUE
+rb_thread_stacksize_set(obj, val)
+     VALUE obj;
+     VALUE val;
+{
+
+  unsigned int size = FIX2UINT(val);
+
+  /* 16byte alignment works for both x86 and x86_64 */
+  if (size & (~0xf)) {
+    size += 0x10;
+    size = size & (~0xf);
+  }
+
+  rb_thread_stack_size = size;
+
+  return Qnil;
+}
+
 int rb_thread_critical;
 
 
@@ -13167,6 +13274,8 @@ Init_Thread()
 {
     VALUE cThGroup;
 
+    rb_thread_stack_size = (1024 * 1024);
+
     rb_eThreadError = rb_define_class("ThreadError", rb_eStandardError);
     rb_cThread = rb_define_class("Thread", rb_cObject);
     rb_undef_alloc_func(rb_cThread);
@@ -13190,6 +13299,9 @@ Init_Thread()
     rb_define_singleton_method(rb_cThread, "abort_on_exception", rb_thread_s_abort_exc, 0);
     rb_define_singleton_method(rb_cThread, "abort_on_exception=", rb_thread_s_abort_exc_set, 1);
 
+    rb_define_singleton_method(rb_cThread, "stack_size", rb_thread_stacksize_get, 0);
+    rb_define_singleton_method(rb_cThread, "stack_size=", rb_thread_stacksize_set, 1);
+
     rb_define_method(rb_cThread, "run", rb_thread_run, 0);
     rb_define_method(rb_cThread, "wakeup", rb_thread_wakeup, 0);
     rb_define_method(rb_cThread, "kill", rb_thread_kill, 0);
diff --git a/gc.c b/gc.c
index 318e24c..0746834 100644
--- a/gc.c
+++ b/gc.c
@@ -466,12 +466,12 @@ stack_end_address(VALUE **stack_end_p)
 # define STACK_END (stack_end)
 #endif
 #if STACK_GROW_DIRECTION < 0
-# define STACK_LENGTH  (rb_gc_stack_start - STACK_END)
+# define STACK_LENGTH(start)  ((start) - STACK_END)
 #elif STACK_GROW_DIRECTION > 0
-# define STACK_LENGTH  (STACK_END - rb_gc_stack_start + 1)
+# define STACK_LENGTH(start)  (STACK_END - (start) + 1)
 #else
-# define STACK_LENGTH  ((STACK_END < rb_gc_stack_start) ? rb_gc_stack_start - STACK_END\
-                                           : STACK_END - rb_gc_stack_start + 1)
+# define STACK_LENGTH(start)  ((STACK_END < (start)) ? (start) - STACK_END\
+                                           : STACK_END - (start) + 1)
 #endif
 #if STACK_GROW_DIRECTION > 0
 # define STACK_UPPER(x, a, b) a
@@ -494,27 +494,36 @@ stack_grow_direction(addr)
 
 #define GC_WATER_MARK 512
 
-#define CHECK_STACK(ret) do {\
+#define CHECK_STACK(ret, start) do {\
     SET_STACK_END;\
-    (ret) = (STACK_LENGTH > STACK_LEVEL_MAX + GC_WATER_MARK);\
+    (ret) = (STACK_LENGTH(start) > STACK_LEVEL_MAX + GC_WATER_MARK);\
 } while (0)
 
 size_t
 ruby_stack_length(p)
     VALUE **p;
 {
-    SET_STACK_END;
-    if (p) *p = STACK_UPPER(STACK_END, rb_gc_stack_start, STACK_END);
-    return STACK_LENGTH;
+  SET_STACK_END;
+  VALUE *start;
+  if (rb_curr_thread == rb_main_thread) {
+    start = rb_gc_stack_start;
+  } else {
+    start = rb_curr_thread->stk_base;
+  }
+  if (p) *p = STACK_UPPER(STACK_END, start, STACK_END);
+  return STACK_LENGTH(start);
 }
 
 int
 ruby_stack_check()
 {
-    int ret;
-
-    CHECK_STACK(ret);
-    return ret;
+  int ret;
+  if (rb_curr_thread == rb_main_thread) {
+    CHECK_STACK(ret, rb_gc_stack_start);
+  } else {
+    CHECK_STACK(ret, rb_curr_thread->stk_base);
+  }
+  return ret;
 }
 
 #define MARK_STACK_MAX 1024
@@ -1404,10 +1413,13 @@ garbage_collect()
 
     init_mark_stack();
 
-    gc_mark((VALUE)ruby_current_node, 0);
-
     /* mark frame stack */
-    for (frame = ruby_frame; frame; frame = frame->prev) {
+    if (rb_curr_thread == rb_main_thread)
+      frame = ruby_frame;
+    else
+      frame = rb_main_thread->frame;
+
+    for (; frame; frame = frame->prev) {
 	rb_gc_mark_frame(frame);
 	if (frame->tmp) {
 	    struct FRAME *tmp = frame->tmp;
@@ -1417,16 +1429,35 @@ garbage_collect()
 	    }
 	}
     }
-    gc_mark((VALUE)ruby_scope, 0);
-    gc_mark((VALUE)ruby_dyna_vars, 0);
+
+    if (rb_curr_thread == rb_main_thread) {
+      gc_mark((VALUE)ruby_current_node, 0);
+      gc_mark((VALUE)ruby_scope, 0);
+      gc_mark((VALUE)ruby_dyna_vars, 0);
+    } else {
+      gc_mark((VALUE)rb_main_thread->node, 0);
+      gc_mark((VALUE)rb_main_thread->scope, 0);
+      gc_mark((VALUE)rb_main_thread->dyna_vars, 0);
+
+      /* scan the current thread's stack */
+      rb_gc_mark_locations((VALUE*)STACK_END, rb_curr_thread->stk_base);
+    }
+
     if (finalizer_table) {
-	mark_tbl(finalizer_table, 0);
+      mark_tbl(finalizer_table, 0);
     }
 
     FLUSH_REGISTER_WINDOWS;
     /* This assumes that all registers are saved into the jmp_buf (and stack) */
     setjmp(save_regs_gc_mark);
     mark_locations_array((VALUE*)save_regs_gc_mark, sizeof(save_regs_gc_mark) / sizeof(VALUE *));
+
+    /* If this is not the main thread, we need to scan the C stack, so
+     * set STACK_END to the end of the C stack.
+     */
+    if (rb_curr_thread != rb_main_thread)
+      STACK_END = rb_main_thread->stk_pos;
+
 #if STACK_GROW_DIRECTION < 0
     rb_gc_mark_locations((VALUE*)STACK_END, rb_gc_stack_start);
 #elif STACK_GROW_DIRECTION > 0
@@ -1446,6 +1477,7 @@ garbage_collect()
     rb_gc_mark_locations((VALUE*)((char*)STACK_END + 2),
 			 (VALUE*)((char*)rb_gc_stack_start + 2));
 #endif
+
     rb_gc_mark_threads();
 
     /* mark protected global variables */
diff --git a/lib/logger.rb b/lib/logger.rb
index e9ab171..2564c33 100644
--- a/lib/logger.rb
+++ b/lib/logger.rb
@@ -170,7 +170,7 @@ require 'monitor'
 
 class Logger
   VERSION = "1.2.6"
-  id, name, rev = %w$Id$
+  id, name, rev = %w$Id logger.rb 1234$
   ProgName = "#{name.chomp(",v")}/#{rev}"
 
   class Error < RuntimeError; end
diff --git a/node.h b/node.h
index 476a826..ecdc053 100644
--- a/node.h
+++ b/node.h
@@ -411,8 +411,11 @@ struct rb_thread {
 
     size_t stk_len;
     size_t stk_max;
+    size_t stk_size;
     VALUE *stk_ptr;
     VALUE *stk_pos;
+    VALUE *stk_base;
+    VALUE *guard;
 #ifdef __ia64
     size_t bstr_len;
     size_t bstr_max;
diff --git a/signal.c b/signal.c
index b6cad9d..116ac05 100644
--- a/signal.c
+++ b/signal.c
@@ -14,6 +14,7 @@
 
 #include "ruby.h"
 #include "rubysig.h"
+#include "node.h"
 #include <signal.h>
 #include <stdio.h>
 
@@ -425,15 +426,22 @@ typedef RETSIGTYPE (*sighandler_t)_((int));
 static sighandler_t
 ruby_signal(signum, handler)
     int signum;
-    sighandler_t handler;
+    void *handler;
 {
     struct sigaction sigact, old;
 
     rb_trap_accept_nativethreads[signum] = 0;
 
-    sigact.sa_handler = handler;
+    if (signum == SIGSEGV || signum == SIGBUS) {
+      sigact.sa_sigaction = handler;
+      sigact.sa_flags = (SA_ONSTACK | SA_RESETHAND | SA_SIGINFO);
+    } else {
+      sigact.sa_handler = handler;
+      sigact.sa_flags = 0;
+    }
+
     sigemptyset(&sigact.sa_mask);
-    sigact.sa_flags = 0;
+
 # ifdef SA_NOCLDWAIT
     if (signum == SIGCHLD && handler == SIG_IGN)
 	sigact.sa_flags |= SA_NOCLDWAIT;
@@ -596,7 +604,132 @@ sighandler(sig)
     }
 }
 
+#include <stdio.h>
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+
+void
+#ifdef HAVE_STDARG_PROTOTYPES
+sig_printf(const char *fmt, ...)
+#else
+  sig_printf(fmt, va_alist)
+     const char *fmt;
+    va_dcl
+#endif
+{
+  char buf[BUFSIZ];
+  va_list args;
+  FILE *out = stderr;
+
+  va_init_list(args, fmt);
+  vfprintf(out, fmt, args);
+  va_end(args);
+  fprintf(out, "\n");
+}
+
+static void
+dump_machine_state(uc)
+     ucontext_t *uc;
+{
+  const char *dump64 =
+    " ----------------- Register state dump ----------------------\n"
+    "rax = 0x%.16x  rbx    = 0x%.16x  rcx = 0x%.16x  rdx = 0x%.16x\n"
+    "rdi = 0x%.16x  rsi    = 0x%.16x  rbp = 0x%.16x  rsp = 0x%.16x\n"
+    "r8  = 0x%.16x  r9     = 0x%.16x  r10 = 0x%.16x  r11 = 0x%.16x\n"
+    "r12 = 0x%.16x  r13    = 0x%.16x  r14 = 0x%.16x  r15 = 0x%.16x\n"
+    "rip = 0x%.16x  rflags = 0x%.16x  cs  = 0x%.16x  fs  = 0x%.16x\n"
+    "gs  = 0x%.16x";
+
+  const char *dump32 =
+    " ----------------- Register state dump -------------------\n"
+    "eax = 0x%.8x  ebx    = 0x%.8x  ecx = 0x%.8x  edx = 0x%.8x\n"
+    "edi = 0x%.8x  esi    = 0x%.8x  ebp = 0x%.8x  esp = 0x%.8x\n"
+    "ss  = 0x%.8x  eflags = 0x%.8x  eip = 0x%.8x  cs  = 0x%.8x\n"
+    "ds  = 0x%.8x  es     = 0x%.8x  fs  = 0x%.8x  gs  = 0x%.8x\n";
+
+#if defined(__LP64__) && defined(__APPLE__)
+  sig_printf(dump64, uc->uc_mcontext->__ss.__rax, uc->uc_mcontext->__ss.__rbx,
+	     uc->uc_mcontext->__ss.__rcx, uc->uc_mcontext->__ss.__rdx, uc->uc_mcontext->__ss.__rdi,
+	     uc->uc_mcontext->__ss.__rsi, uc->uc_mcontext->__ss.__rbp, uc->uc_mcontext->__ss.__rsp,
+	     uc->uc_mcontext->__ss.__r8, uc->uc_mcontext->__ss.__r9, uc->uc_mcontext->__ss.__r10,
+	     uc->uc_mcontext->__ss.__r11, uc->uc_mcontext->__ss.__r12, uc->uc_mcontext->__ss.__r13,
+	     uc->uc_mcontext->__ss.__r14, uc->uc_mcontext->__ss.__r15, uc->uc_mcontext->__ss.__rip,
+	     uc->uc_mcontext->__ss.__rflags, uc->uc_mcontext->__ss.__cs, uc->uc_mcontext->__ss.__fs,
+	     uc->uc_mcontext->__ss.__gs);
+#elif !defined(__LP64__) && defined(__APPLE__)
+  sig_printf(dump32, uc->uc_mcontext->__ss.__eax, uc->uc_mcontext->__ss.__ebx,
+	     uc->uc_mcontext->__ss.__ecx, uc->uc_mcontext->__ss.__edx,
+	     uc->uc_mcontext->__ss.__edi, uc->uc_mcontext->__ss.__esi,
+	     uc->uc_mcontext->__ss.__ebp, uc->uc_mcontext->__ss.__esp,
+	     uc->uc_mcontext->__ss.__ss, uc->uc_mcontext->__ss.__eflags,
+	     uc->uc_mcontext->__ss.__eip, uc->uc_mcontext->__ss.__cs,
+	     uc->uc_mcontext->__ss.__ds, uc->uc_mcontext->__ss.__es,
+	     uc->uc_mcontext->__ss.__fs, uc->uc_mcontext->__ss.__gs);
+#elif defined(__i386__)
+  sig_printf(dump32, uc->uc_mcontext.gregs[REG_EAX], uc->uc_mcontext.gregs[REG_EBX],
+	     uc->uc_mcontext.gregs[REG_ECX], uc->uc_mcontext.gregs[REG_EDX],
+	     uc->uc_mcontext.gregs[REG_EDI], uc->uc_mcontext.gregs[REG_ESI],
+	     uc->uc_mcontext.gregs[REG_EBP], uc->uc_mcontext.gregs[REG_ESP],
+	     uc->uc_mcontext.gregs[REG_SS], uc->uc_mcontext.gregs[REG_EFL],
+	     uc->uc_mcontext.gregs[REG_EIP], uc->uc_mcontext.gregs[REG_EIP],
+	     uc->uc_mcontext.gregs[REG_DS], uc->uc_mcontext.gregs[REG_ES],
+	     uc->uc_mcontext.gregs[REG_FS], uc->uc_mcontext.gregs[REG_FS]);
+#elif defined(__x86_64__)
+  sig_printf(dump64, uc->uc_mcontext.gregs[REG_RAX], uc->uc_mcontext.gregs[REG_RBX],
+	     uc->uc_mcontext.gregs[REG_RCX], uc->uc_mcontext.gregs[REG_RDX],
+	     uc->uc_mcontext.gregs[REG_RDI], uc->uc_mcontext.gregs[REG_RSI],
+	     uc->uc_mcontext.gregs[REG_RBP], uc->uc_mcontext.gregs[REG_RSP],
+	     uc->uc_mcontext.gregs[REG_R8], uc->uc_mcontext.gregs[REG_R9],
+	     uc->uc_mcontext.gregs[REG_R10], uc->uc_mcontext.gregs[REG_R11],
+	     uc->uc_mcontext.gregs[REG_R12], uc->uc_mcontext.gregs[REG_R13],
+	     uc->uc_mcontext.gregs[REG_R14], uc->uc_mcontext.gregs[REG_R15],
+	     uc->uc_mcontext.gregs[REG_RIP], uc->uc_mcontext.gregs[REG_EFL],
+	     uc->uc_mcontext.gregs[REG_CSGSFS]);
+#else
+#endif
+}
+
+static int
+check_guard(caddr_t fault_addr, rb_thread_t th) {
+  if(fault_addr <= (caddr_t)rb_curr_thread->guard &&
+     fault_addr >= (caddr_t)rb_curr_thread->stk_ptr) {
+    return 1;
+  }
+  return 0;
+}
+
 #ifdef SIGBUS
+#ifdef POSIX_SIGNAL
+static void sigbus _((int, siginfo_t*, void*));
+static void
+sigbus(sig, ip, context)
+     int sig;
+     siginfo_t *ip;
+     void *context;
+{
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_NATIVETHREAD_KILL)
+  if (!is_ruby_native_thread() && !rb_trap_accept_nativethreads[sig]) {
+    sigsend_to_ruby_thread(sig);
+    return;
+  }
+#endif
+
+  dump_machine_state(context);
+  if (check_guard((caddr_t)ip->si_addr, rb_curr_thread)) {
+    /* we hit the guard page, print out a warning to help app developers */
+    rb_bug("Thread stack overflow! Try increasing it!");
+  } else {
+    rb_bug("Bus Error");
+  }
+}
+
+#else /* !defined(POSIX_SIGNAL) */
+
 static RETSIGTYPE sigbus _((int));
 static RETSIGTYPE
 sigbus(sig)
@@ -612,8 +745,36 @@ sigbus(sig)
     rb_bug("Bus Error");
 }
 #endif
+#endif
+
 
 #ifdef SIGSEGV
+#ifdef POSIX_SIGNAL
+static void sigsegv _((int, siginfo_t*, void*));
+static void
+sigsegv(sig, ip, context)
+     int sig;
+     siginfo_t *ip;
+     void *context;
+{
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_NATIVETHREAD_KILL)
+  if (!is_ruby_native_thread() && !rb_trap_accept_nativethreads[sig]) {
+    sigsend_to_ruby_thread(sig);
+    return;
+  }
+#endif
+
+  dump_machine_state(context);
+  if (check_guard((caddr_t)ip->si_addr, rb_curr_thread)) {
+    /* we hit the guard page, print out a warning to help app developers */
+    rb_bug("Thread stack overflow! Try increasing it!");
+  } else {
+    rb_bug("Segmentation fault");
+  }
+}
+
+#else /* !defined(POSIX_SIGNAL) */
+
 static RETSIGTYPE sigsegv _((int));
 static RETSIGTYPE
 sigsegv(sig)
@@ -629,6 +790,7 @@ sigsegv(sig)
     rb_bug("Segmentation fault");
 }
 #endif
+#endif
 
 #ifdef SIGPIPE
 static RETSIGTYPE sigpipe _((int));
@@ -698,7 +860,8 @@ static VALUE
 trap(arg)
     struct trap_arg *arg;
 {
-    sighandler_t func, oldfunc;
+    sighandler_t oldfunc;
+    void *func;
     VALUE command, oldcmd;
     int sig = -1;
     char *s;
@@ -945,6 +1108,20 @@ sig_list()
 }
 
 static void
+create_sigstack()
+{
+  stack_t ss;
+  ss.ss_size = SIGSTKSZ;
+  ss.ss_sp = malloc(ss.ss_size);
+  ss.ss_flags = 0;
+  if (sigaltstack(&ss, NULL) < 0) {
+    free(ss.ss_sp);
+    fprintf(stderr, "Couldn't create signal stack! Error %d: %s\n", errno, strerror(errno));
+    exit(1);
+  }
+}
+
+static void
 install_sighandler(signum, handler)
     int signum;
     sighandler_t handler;
@@ -953,7 +1130,7 @@ install_sighandler(signum, handler)
 
     old = ruby_signal(signum, handler);
     if (old != SIG_DFL) {
-	ruby_signal(signum, old);
+       ruby_signal(signum, old);
     }
 }
 
@@ -1080,6 +1257,8 @@ Init_signal()
     rb_alias(rb_eSignal, rb_intern("signm"), rb_intern("message"));
     rb_define_method(rb_eInterrupt, "initialize", interrupt_init, 1);
 
+    create_sigstack();
+
     install_sighandler(SIGINT, sighandler);
 #ifdef SIGHUP
     install_sighandler(SIGHUP, sighandler);