* eval.c (ruby_vm_init): split from ruby_init.

* eval.c (ruby_vm_run): cleans up VM always.

* inits.c (rb_call_inits): separated per-process and per-VM
  intializations.

* parse.y (sym_str_new): creates VM-neutral string.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/mvm@19258 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

46 files changed, 514 insertions, 230 deletions

diff --git a/ChangeLog b/ChangeLog
index a2fe76fec9..5acb70282f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,13 @@
-Tue Sep  9 00:37:45 2008  Nobuyoshi Nakada  <nobu@ruby-lang.org>
+Tue Sep  9 00:55:34 2008  Nobuyoshi Nakada  <nobu@ruby-lang.org>
+
+	* eval.c (ruby_vm_init): split from ruby_init.
+
+	* eval.c (ruby_vm_run): cleans up VM always.
+
+	* inits.c (rb_call_inits): separated per-process and per-VM
+	  intializations.
+
+	* parse.y (sym_str_new): creates VM-neutral string.
 
 	* vm_core.h (struct rb_vm_struct): includes method cache.
 
diff --git a/array.c b/array.c
index d6912c3781..6195d27d07 100644
--- a/array.c
+++ b/array.c
@@ -3513,6 +3513,12 @@ Init_Array(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    id_cmp = rb_intern("<=>");
+}
+
+void
+InitVM_Array(rb_vm_t *vm)
+{
     rb_cArray  = rb_define_class("Array", rb_cObject);
     rb_include_module(rb_cArray, rb_mEnumerable);
 
@@ -3610,6 +3616,4 @@ Init_Array(void)
     rb_define_method(rb_cArray, "take_while", rb_ary_take_while, 0);
     rb_define_method(rb_cArray, "drop", rb_ary_drop, 1);
     rb_define_method(rb_cArray, "drop_while", rb_ary_drop_while, 0);
-
-    id_cmp = rb_intern("<=>");
 }
diff --git a/bignum.c b/bignum.c
index 5f63be404c..75975a6a9b 100644
--- a/bignum.c
+++ b/bignum.c
@@ -2681,6 +2681,11 @@ rb_big_even_p(VALUE num)
 void
 Init_Bignum(void)
 {
+}
+
+void
+InitVM_Bignum(rb_vm_t *vm)
+{
     rb_cBignum = rb_define_class("Bignum", rb_cInteger);
 
     rb_define_method(rb_cBignum, "to_s", rb_big_to_s, -1);
diff --git a/compar.c b/compar.c
index 8473385a14..b2b26298bd 100644
--- a/compar.c
+++ b/compar.c
@@ -199,6 +199,12 @@ Init_Comparable(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    cmp = rb_intern("<=>");
+}
+
+void
+InitVM_Comparable(rb_vm_t *vm)
+{
     rb_mComparable = rb_define_module("Comparable");
     rb_define_method(rb_mComparable, "==", cmp_equal, 1);
     rb_define_method(rb_mComparable, ">", cmp_gt, 1);
@@ -206,6 +212,4 @@ Init_Comparable(void)
     rb_define_method(rb_mComparable, "<", cmp_lt, 1);
     rb_define_method(rb_mComparable, "<=", cmp_le, 1);
     rb_define_method(rb_mComparable, "between?", cmp_between, 2);
-
-    cmp = rb_intern("<=>");
 }
diff --git a/complex.c b/complex.c
index 7ec506c8e3..dc1e8bae5e 100644
--- a/complex.c
+++ b/complex.c
@@ -1335,8 +1335,6 @@ Init_Complex(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
-    assert(fprintf(stderr, "assert() is now active\n"));
-
     id_Unify = rb_intern("Unify");
     id_abs = rb_intern("abs");
     id_abs2 = rb_intern("abs2");
@@ -1365,6 +1363,12 @@ Init_Complex(void)
     id_to_r = rb_intern("to_r");
     id_to_s = rb_intern("to_s");
     id_truncate = rb_intern("truncate");
+}
+
+void
+InitVM_Complex(rb_vm_t *vm)
+{
+    assert(fprintf(stderr, "assert() is now active\n"));
 
     rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric);
 
diff --git a/cont.c b/cont.c
index cc2f10b974..260a81f25e 100644
--- a/cont.c
+++ b/cont.c
@@ -748,6 +748,11 @@ rb_fiber_s_current(VALUE klass)
 void
 Init_Cont(void)
 {
+}
+
+void
+InitVM_Cont(rb_vm_t *vm)
+{
     rb_cFiber = rb_define_class("Fiber", rb_cObject);
     rb_undef_alloc_func(rb_cFiber);
     rb_eFiberError = rb_define_class("FiberError", rb_eStandardError);
diff --git a/dir.c b/dir.c
index 2d52b86f1e..791e8c8937 100644
--- a/dir.c
+++ b/dir.c
@@ -2378,6 +2378,11 @@ rb_dir_rmdir(VALUE dir, VALUE path)
 void
 Init_Dir(void)
 {
+}
+
+void
+InitVM_Dir(rb_vm_t *vm)
+{
     rb_cDir = rb_define_class("Dir", rb_cObject);
 
     rb_include_module(rb_cDir, rb_mEnumerable);
diff --git a/dmyext.c b/dmyext.c
index 4d273f7faf..2b48cd61cf 100644
--- a/dmyext.c
+++ b/dmyext.c
@@ -1,4 +1,11 @@
+#include "ruby/mvm.h"
+
 void
 Init_ext(void)
 {
 }
+
+void
+InitVM_ext(rb_vm_t *vm)
+{
+}
diff --git a/encoding.c b/encoding.c
index 555a8fbf6f..9b5c2b3e32 100644
--- a/encoding.c
+++ b/encoding.c
@@ -1184,10 +1184,15 @@ Init_Encoding(void)
 {
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
-    VALUE list;
-    int i;
 
     id_base_encoding = rb_intern("#base_encoding");
+}
+
+void
+InitVM_Encoding(rb_vm_t *vm)
+{
+    VALUE list;
+    int i;
 
     rb_cEncoding = rb_define_class("Encoding", rb_cObject);
     rb_undef_alloc_func(rb_cEncoding);
diff --git a/enum.c b/enum.c
index 446c4dc622..c57092a7e6 100644
--- a/enum.c
+++ b/enum.c
@@ -1805,6 +1805,16 @@ Init_Enumerable(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    id_eqq  = rb_intern("===");
+    id_each = rb_intern("each");
+    id_cmp  = rb_intern("<=>");
+    id_next = rb_intern("next");
+    id_size = rb_intern("size");
+}
+
+void
+InitVM_Enumerable(rb_vm_t *vm)
+{
     rb_mEnumerable = rb_define_module("Enumerable");
 
     rb_define_method(rb_mEnumerable, "to_a", enum_to_a, -1);
@@ -1847,11 +1857,4 @@ Init_Enumerable(void)
     rb_define_method(rb_mEnumerable, "drop", enum_drop, 1);
     rb_define_method(rb_mEnumerable, "drop_while", enum_drop_while, 0);
     rb_define_method(rb_mEnumerable, "cycle", enum_cycle, -1);
-
-    id_eqq  = rb_intern("===");
-    id_each = rb_intern("each");
-    id_cmp  = rb_intern("<=>");
-    id_next = rb_intern("next");
-    id_size = rb_intern("size");
 }
-
diff --git a/enumerator.c b/enumerator.c
index ee865d0d08..d325e97da4 100644
--- a/enumerator.c
+++ b/enumerator.c
@@ -757,6 +757,12 @@ generator_each(VALUE obj)
 void
 Init_Enumerator(void)
 {
+    sym_each = ID2SYM(rb_intern_const("each"));
+}
+
+void
+InitVM_Enumerator(rb_vm_t *vm)
+{
     rb_define_method(rb_mKernel, "to_enum", obj_to_enum, -1);
     rb_define_method(rb_mKernel, "enum_for", obj_to_enum, -1);
 
@@ -795,7 +801,5 @@ Init_Enumerator(void)
     rb_define_method(rb_cYielder, "yield", yielder_yield, -2);
     rb_define_method(rb_cYielder, "<<", yielder_yield, -2);
 
-    sym_each = ID2SYM(rb_intern("each"));
-
     rb_provide("enumerator.so");	/* for backward compatibility */
 }
diff --git a/error.c b/error.c
index 61bdb790dd..021293e7e3 100644
--- a/error.c
+++ b/error.c
@@ -980,6 +980,11 @@ errno_missing(VALUE self, VALUE id)
 void
 Init_Exception(void)
 {
+}
+
+void
+InitVM_Exception(rb_vm_t *vm)
+{
     rb_eException   = rb_define_class("Exception", rb_cObject);
     rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1);
     rb_define_method(rb_eException, "exception", exc_exception, -1);
@@ -1144,6 +1149,11 @@ rb_check_frozen(VALUE obj)
 void
 Init_syserr(void)
 {
+}
+
+void
+InitVM_syserr(rb_vm_t *vm)
+{
 #ifdef EPERM
     set_syserr(EPERM, "EPERM");
 #endif
diff --git a/eval.c b/eval.c
index 45cfda0e88..d39adfb970 100644
--- a/eval.c
+++ b/eval.c
@@ -33,6 +33,10 @@ void rb_call_inits(void);
 void Init_heap(void);
 void Init_ext(void);
 void Init_BareVM(void);
+void rb_vm_call_inits(rb_vm_t *vm);
+void InitVM_heap(rb_vm_t *vm);
+void InitVM_ext(rb_vm_t *vm);
+void ruby_vm_prog_init(rb_vm_t *vm);
 
 VALUE ruby_vm_process_options(rb_vm_t *vm, int argc, char **argv);
 
@@ -60,7 +64,6 @@ ruby_init(void)
 
     Init_stack((void *)&state);
     Init_BareVM();
-    Init_heap();
 
     PUSH_TAG();
     if ((state = EXEC_TAG()) == 0) {
@@ -71,8 +74,6 @@ ruby_init(void)
 #elif defined(__VMS)
 	_vmsruby_init();
 #endif
-
-	ruby_prog_init();
     }
     POP_TAG();
 
@@ -80,7 +81,28 @@ ruby_init(void)
 	error_print();
 	exit(EXIT_FAILURE);
     }
+}
+
+int
+ruby_vm_init(rb_vm_t *vm)
+{
+    int state;
+
+    InitVM_heap(vm);
+
+    PUSH_TAG();
+    if ((state = EXEC_TAG()) == 0) {
+	rb_vm_call_inits(vm);
+	ruby_vm_prog_init(vm);
+    }
+    POP_TAG();
+
+    if (state) {
+	error_print();
+	return state;
+    }
     GET_VM()->running = 1;
+    return 0;
 }
 
 static VALUE
@@ -132,18 +154,20 @@ ruby_vm_run(rb_vm_t *vm)
     rb_thread_set_current_raw(vm->main_thread);
 
     ruby_init();
-    iseq = vm_parse_options(vm);
-
-    switch (iseq) {
-      case Qtrue:  return EXIT_SUCCESS; /* -v */
-      case Qfalse: return EXIT_FAILURE;
-    }
-
-    if (FIXNUM_P(iseq)) {
-	return FIX2INT(iseq);
+    if ((status = ruby_vm_init(vm)) == 0) {
+	iseq = vm_parse_options(vm);
+
+	switch (iseq) {
+	  case Qtrue:  status = EXIT_SUCCESS; break; /* -v */
+	  case Qfalse: status = EXIT_FAILURE; break;
+	  default:
+	    if (FIXNUM_P(iseq)) {
+		status = FIX2INT(iseq);
+		break;
+	    }
+	    status = th_exec_iseq(vm->main_thread, iseq);
+	}
     }
-
-    status = th_exec_iseq(vm->main_thread, iseq);
     return ruby_vm_cleanup(vm, status);
 }
 
@@ -1138,6 +1162,11 @@ rb_f_method_name(void)
 void
 Init_eval(void)
 {
+}
+
+void
+InitVM_eval(rb_vm_t *vm)
+{
     rb_define_virtual_variable("$@", errat_getter, errat_setter);
     rb_define_virtual_variable("$!", errinfo_getter, 0);
 
diff --git a/eval_jump.c b/eval_jump.c
index a3257a8c7a..3f215c6e2f 100644
--- a/eval_jump.c
+++ b/eval_jump.c
@@ -123,5 +123,10 @@ rb_exec_end_proc(struct end_proc_data **end_procs)
 void
 Init_jump(void)
 {
+}
+
+void
+InitVM_jump(rb_vm_t *vm)
+{
     rb_define_global_function("at_exit", rb_f_at_exit, 0);
 }
diff --git a/ext/ripper/eventids2.c b/ext/ripper/eventids2.c
index 74ec1ce065..47e195d084 100644
--- a/ext/ripper/eventids2.c
+++ b/ext/ripper/eventids2.c
@@ -59,7 +59,7 @@ static ID ripper_id_CHAR;
 #include "eventids2table.c"
 
 static void
-ripper_init_eventids2(VALUE self)
+ripper_init_eventids2(void)
 {
     ripper_id_backref = rb_intern_const("on_backref");
     ripper_id_backtick = rb_intern_const("on_backtick");
@@ -108,8 +108,6 @@ ripper_init_eventids2(VALUE self)
     ripper_id_heredoc_end = rb_intern_const("on_heredoc_end");
     ripper_id___end__ = rb_intern_const("on___end__");
     ripper_id_CHAR = rb_intern_const("on_CHAR");
-
-    ripper_init_eventids2_table(self);
 }
 
 static const struct token_assoc {
diff --git a/ext/ripper/tools/generate.rb b/ext/ripper/tools/generate.rb
index 22c3ac0eb7..1f5d1bf220 100755
--- a/ext/ripper/tools/generate.rb
+++ b/ext/ripper/tools/generate.rb
@@ -74,14 +74,18 @@ def generate_eventids1(ids)
   end
   buf << %Q[\n]
   buf << %Q[static void\n]
-  buf << %Q[ripper_init_eventids1(VALUE self)\n]
+  buf << %Q[ripper_init_eventids1(void)\n]
   buf << %Q[{\n]
-  buf << %Q[    VALUE h;\n]
-  buf << %Q[    ID id;\n]
   ids.each do |id, arity|
     buf << %Q[    ripper_id_#{id} = rb_intern_const("on_#{id}");\n]
   end
+  buf << %Q[}\n]
   buf << %Q[\n]
+  buf << %Q[static void\n]
+  buf << %Q[ripper_init_eventids1_table(VALUE self)\n]
+  buf << %Q[{\n]
+  buf << %Q[    VALUE h;\n]
+  buf << %Q[    ID id;\n]
   buf << %Q[    h = rb_hash_new();\n]
   buf << %Q[    rb_define_const(self, "PARSER_EVENT_TABLE", h);\n]
   ids.each do |id, arity|
diff --git a/file.c b/file.c
index 09599ccedd..564930dbb4 100644
--- a/file.c
+++ b/file.c
@@ -4712,6 +4712,11 @@ define_filetest_function(const char *name, VALUE (*func)(ANYARGS), int argc)
 void
 Init_File(void)
 {
+}
+
+void
+InitVM_File(rb_vm_t *vm)
+{
     VALUE separator;
 
     rb_mFileTest = rb_define_module("FileTest");
diff --git a/gc.c b/gc.c
index 72f9c8e36e..54afb657c8 100644
--- a/gc.c
+++ b/gc.c
@@ -370,6 +370,8 @@ int *ruby_initial_gc_stress_ptr = &rb_objspace.gc_stress;
 
 #define need_call_final 	(finalizer_table && finalizer_table->num_entries)
 
+static void init_heap(rb_objspace_t *objspace);
+
 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
 rb_objspace_t *
 rb_objspace_alloc(void)
@@ -378,6 +380,7 @@ rb_objspace_alloc(void)
     memset(objspace, 0, sizeof(*objspace));
     malloc_limit = GC_MALLOC_LIMIT;
     ruby_gc_stress = ruby_initial_gc_stress;
+    init_heap(objspace);
 
     return objspace;
 }
@@ -884,11 +887,11 @@ heaps_increment(rb_objspace_t *objspace)
 
 #define RANY(o) ((RVALUE*)(o))
 
-static VALUE
+VALUE
 rb_newobj_from_heap(rb_objspace_t *objspace)
 {
     VALUE obj;
-	
+
     if ((ruby_gc_stress && !ruby_disable_gc_stress) || !freelist) {
     	if (!heaps_increment(objspace) && !garbage_collect(objspace)) {
 	    during_gc = 0;
@@ -2092,7 +2095,14 @@ Init_stack(VALUE *addr)
 void
 Init_heap(void)
 {
-    init_heap(&rb_objspace);
+}
+
+void
+InitVM_heap(rb_vm_t *vm)
+{
+#if !(defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE)
+    init_heap(vm->objspace);
+#endif
 }
 
 static VALUE
@@ -2800,6 +2810,11 @@ gc_profile_report(int argc, VALUE *argv, VALUE self)
 void
 Init_GC(void)
 {
+}
+
+void
+InitVM_GC(rb_vm_t *vm)
+{
     VALUE rb_mObSpace;
     VALUE rb_mProfiler;
 
diff --git a/hash.c b/hash.c
index e0b47c6ce1..08ecb00bff 100644
--- a/hash.c
+++ b/hash.c
@@ -2593,7 +2593,11 @@ Init_Hash(void)
     id_hash = rb_intern("hash");
     id_yield = rb_intern("yield");
     id_default = rb_intern("default");
+}
 
+void
+InitVM_Hash(rb_vm_t *vm)
+{
     rb_cHash = rb_define_class("Hash", rb_cObject);
 
     rb_include_module(rb_cHash, rb_mEnumerable);
diff --git a/inits.c b/inits.c
index 291fcb11bc..60bd0f1d5a 100644
--- a/inits.c
+++ b/inits.c
@@ -9,96 +9,64 @@
 
 **********************************************************************/
 
+#ifndef INIT_FOR_VM
 #include "ruby/ruby.h"
 
-void Init_Array(void);
-void Init_Bignum(void);
-void Init_Binding(void);
-void Init_Comparable(void);
-void Init_Complex(void);
-void Init_transcode(void);
-void Init_Dir(void);
-void Init_Enumerable(void);
-void Init_Enumerator(void);
-void Init_Exception(void);
-void Init_syserr(void);
-void Init_eval(void);
-void Init_load(void);
-void Init_Proc(void);
-void Init_File(void);
-void Init_GC(void);
-void Init_Hash(void);
-void Init_IO(void);
-void Init_Math(void);
-void Init_marshal(void);
-void Init_Numeric(void);
-void Init_Object(void);
-void Init_pack(void);
-void Init_Precision(void);
-void Init_sym(void);
-void Init_process(void);
-void Init_RandomSeed(void);
-void Init_Random(void);
-void Init_Range(void);
-void Init_Rational(void);
-void Init_Regexp(void);
-void Init_signal(void);
-void Init_String(void);
-void Init_Struct(void);
-void Init_Time(void);
-void Init_var_tables(void);
-void Init_version(void);
-void Init_ISeq(void);
-void Init_VM(void);
-void Init_Thread(void);
-void Init_Cont(void);
-void Init_top_self(void);
-void Init_Encoding(void);
+#define INIT_FOR_VM 1
+#include "inits.c"
+#define CALL(n) {void Init_##n(void); Init_##n();}
+#define rb_call_inits() rb_call_inits(void)
+#else
+#define CALL(n) {void InitVM_##n(rb_vm_t *); InitVM_##n(vm);}
+#define rb_call_inits() rb_vm_call_inits(rb_vm_t *vm)
+#endif
 
 void
 rb_call_inits()
 {
-    Init_RandomSeed();
-    Init_sym();
-    Init_var_tables();
-    Init_Object();
-    Init_top_self();
-    Init_Encoding();
-    Init_Comparable();
-    Init_Enumerable();
-    Init_Precision();
-    Init_String();
-    Init_Exception();
-    Init_eval();
-    Init_jump();
-    Init_Numeric();
-    Init_Bignum();
-    Init_syserr();
-    Init_Array();
-    Init_Hash();
-    Init_Struct();
-    Init_Regexp();
-    Init_pack();
-    Init_transcode();
-    Init_marshal();
-    Init_Range();
-    Init_IO();
-    Init_Dir();
-    Init_Time();
-    Init_Random();
-    Init_signal();
-    Init_process();
-    Init_load();
-    Init_Proc();
-    Init_Binding();
-    Init_Math();
-    Init_GC();
-    Init_Enumerator();
-    Init_VM();
-    Init_ISeq();
-    Init_Thread();
-    Init_Cont();
-    Init_Rational();
-    Init_Complex();
-    Init_version();
+    CALL(RandomSeed);
+    CALL(sym);
+    CALL(var_tables);
+    CALL(Object);
+    CALL(top_self);
+    CALL(Encoding);
+    CALL(Comparable);
+    CALL(Enumerable);
+    CALL(Precision);
+    CALL(String);
+    CALL(Exception);
+    CALL(eval);
+    CALL(jump);
+    CALL(Numeric);
+    CALL(Bignum);
+    CALL(syserr);
+    CALL(Array);
+    CALL(Hash);
+    CALL(Struct);
+    CALL(Regexp);
+    CALL(pack);
+    CALL(transcode);
+    CALL(marshal);
+    CALL(Range);
+    CALL(IO);
+    CALL(Dir);
+    CALL(Time);
+    CALL(Random);
+    CALL(signal);
+    CALL(process);
+    CALL(load);
+    CALL(Proc);
+    CALL(Binding);
+    CALL(Math);
+    CALL(GC);
+    CALL(Enumerator);
+    CALL(VM);
+    CALL(ISeq);
+    CALL(Thread);
+    CALL(Cont);
+    CALL(Rational);
+    CALL(Complex);
+    CALL(version);
 }
+#undef rb_call_inits
+#undef CALL
diff --git a/io.c b/io.c
index 7afc570295..b7167dcc3d 100644
--- a/io.c
+++ b/io.c
@@ -83,6 +83,7 @@
 #endif
 
 extern void Init_File(void);
+extern void InitVM_File(rb_vm_t *);
 
 #ifdef __BEOS__
 # ifndef NOFILE
@@ -8275,6 +8276,12 @@ argf_stdout_set(VALUE argf, VALUE f)
 void
 Init_IO(void)
 {
+    Init_File();
+}
+
+void
+InitVM_IO(rb_vm_t *vm)
+{
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
@@ -8536,7 +8543,7 @@ Init_IO(void)
     atexit(pipe_atexit);
 #endif
 
-    Init_File();
+    InitVM_File(vm);
 
     rb_define_method(rb_cFile, "initialize",  rb_file_initialize, -1);
 
diff --git a/iseq.c b/iseq.c
index 751ba8c6f9..bf19507d1b 100644
--- a/iseq.c
+++ b/iseq.c
@@ -1316,6 +1316,11 @@ rb_iseq_build_for_ruby2cext(
 void
 Init_ISeq(void)
 {
+}
+
+void
+InitVM_ISeq(rb_vm_t *vm)
+{
     /* declare ::VM::InstructionSequence */
     rb_cISeq = rb_define_class_under(rb_cRubyVM, "InstructionSequence", rb_cObject);
     rb_define_alloc_func(rb_cISeq, iseq_alloc);
diff --git a/load.c b/load.c
index a6daff43f6..3e10a60823 100644
--- a/load.c
+++ b/load.c
@@ -675,9 +675,11 @@ rb_f_autoload_p(VALUE obj, VALUE sym)
 void
 Init_load()
 {
-#undef rb_intern
-#define rb_intern(str) rb_intern2(str, strlen(str))
-    rb_vm_t *vm = GET_VM();
+}
+
+void
+InitVM_load(rb_vm_t *vm)
+{
     static const char var_load_path[] = "$:";
     ID id_load_path = rb_intern2(var_load_path, sizeof(var_load_path)-1);
 
diff --git a/marshal.c b/marshal.c
index bcedb2dfdf..516be7e85e 100644
--- a/marshal.c
+++ b/marshal.c
@@ -1704,8 +1704,6 @@ Init_marshal(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
-    VALUE rb_mMarshal = rb_define_module("Marshal");
-
     s_dump = rb_intern("_dump");
     s_load = rb_intern("_load");
     s_mdump = rb_intern("marshal_dump");
@@ -1717,6 +1715,12 @@ Init_marshal(void)
     s_read = rb_intern("read");
     s_write = rb_intern("write");
     s_binmode = rb_intern("binmode");
+}
+
+void
+InitVM_marshal(rb_vm_t *vm)
+{
+    VALUE rb_mMarshal = rb_define_module("Marshal");
 
     rb_define_module_function(rb_mMarshal, "dump", marshal_dump, -1);
     rb_define_module_function(rb_mMarshal, "load", marshal_load, -1);
diff --git a/math.c b/math.c
index b314bb9ebf..ad7e863f46 100644
--- a/math.c
+++ b/math.c
@@ -662,6 +662,11 @@ math_lgamma(VALUE obj, VALUE x)
 void
 Init_Math(void)
 {
+}
+
+void
+InitVM_Math(rb_vm_t *vm)
+{
     rb_mMath = rb_define_module("Math");
 
 #ifdef M_PI
diff --git a/numeric.c b/numeric.c
index ed703f5e1c..354db12fcc 100644
--- a/numeric.c
+++ b/numeric.c
@@ -3113,7 +3113,11 @@ Init_Numeric(void)
     id_coerce = rb_intern("coerce");
     id_to_i = rb_intern("to_i");
     id_eq = rb_intern("==");
+}
 
+void
+InitVM_Numeric(rb_vm_t *vm)
+{
     rb_eZeroDivError = rb_define_class("ZeroDivisionError", rb_eStandardError);
     rb_eFloatDomainError = rb_define_class("FloatDomainError", rb_eRangeError);
     rb_cNumeric = rb_define_class("Numeric", rb_cObject);
diff --git a/object.c b/object.c
index f6c539b27d..257d94b3e4 100644
--- a/object.c
+++ b/object.c
@@ -2445,11 +2445,24 @@ boot_defclass(const char *name, VALUE super)
 void
 Init_Object(void)
 {
-    int i;
-
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
+    int i;
+
+    id_eq = rb_intern("==");
+    id_eql = rb_intern("eql?");
+    id_match = rb_intern("=~");
+    id_inspect = rb_intern("inspect");
+    id_init_copy = rb_intern("initialize_copy");
+
+    for (i=0; conv_method_names[i].method; i++) {
+	conv_method_names[i].id = rb_intern(conv_method_names[i].method);
+    }
+}
 
+void
+InitVM_Object(rb_vm_t *vm)
+{
     VALUE metaclass;
 
     rb_cBasicObject = boot_defclass("BasicObject", 0);
@@ -2620,14 +2633,4 @@ Init_Object(void)
     rb_undef_alloc_func(rb_cFalseClass);
     rb_undef_method(CLASS_OF(rb_cFalseClass), "new");
     rb_define_global_const("FALSE", Qfalse);
-
-    id_eq = rb_intern("==");
-    id_eql = rb_intern("eql?");
-    id_match = rb_intern("=~");
-    id_inspect = rb_intern("inspect");
-    id_init_copy = rb_intern("initialize_copy");
-
-    for (i=0; conv_method_names[i].method; i++) {
-	conv_method_names[i].id = rb_intern(conv_method_names[i].method);
-    }
 }
diff --git a/pack.c b/pack.c
index 37f6b8da3c..11c8ac80f8 100644
--- a/pack.c
+++ b/pack.c
@@ -2124,6 +2124,11 @@ utf8_to_uv(const char *p, long *lenp)
 void
 Init_pack(void)
 {
+}
+
+void
+InitVM_pack(rb_vm_t *vm)
+{
     rb_define_method(rb_cArray, "pack", pack_pack, 1);
     rb_define_method(rb_cString, "unpack", pack_unpack, 1);
 }
diff --git a/parse.y b/parse.y
index eab982b75f..d60133891f 100644
--- a/parse.y
+++ b/parse.y
@@ -19,6 +19,7 @@
 #include "ruby/node.h"
 #include "ruby/st.h"
 #include "ruby/encoding.h"
+#include "eval_intern.h"
 #include "id.h"
 #include "regenc.h"
 #include <stdio.h>
@@ -9091,11 +9092,16 @@ static struct symbols {
     ID last_id;
     st_table *sym_id;
     st_table *id_str;
-    st_table *ivar2_id;
-    st_table *id_ivar2;
     VALUE op_sym[tLAST_TOKEN];
+    rb_thread_lock_t lock;
+    struct rb_objspace_t *objspace;
 } global_symbols = {tLAST_ID};
 
+struct ivar_symbols {
+    st_table *ivar2_id;
+    st_table *id_ivar2;
+};
+
 static const struct st_hash_type symhash = {
     rb_str_hash_cmp,
     rb_str_hash,
@@ -9107,6 +9113,30 @@ struct ivar2_key {
 };
 
 static int
+ivar2_key_mark(st_data_t key, st_data_t val, st_data_t arg)
+{
+    struct ivar2_key *k = (struct ivar2_key *)key;
+    rb_gc_mark(k->klass);
+    return ST_CONTINUE;
+}
+
+static void
+ivar2_mark(void *ptr)
+{
+    struct ivar_symbols *isym = ptr;
+    if (isym->ivar2_id) st_foreach(isym->ivar2_id, ivar2_key_mark, 0);
+}
+
+static void
+ivar2_free(void *ptr)
+{
+    struct ivar_symbols *isym = ptr;
+    if (isym->ivar2_id) st_free_table(isym->ivar2_id);
+    if (isym->id_ivar2) st_free_table(isym->id_ivar2);
+    xfree(isym);
+}
+
+static int
 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
 {
     if (key1->id == key2->id && key1->klass == key2->klass) {
@@ -9129,20 +9159,34 @@ static const struct st_hash_type ivar2_hash_type = {
 void
 Init_sym(void)
 {
+    struct rb_objspace_t *rb_objspace_alloc(void);
+    ruby_native_thread_lock_initialize(&global_symbols.lock);
+    ruby_native_thread_lock(&global_symbols.lock);
+    global_symbols.objspace = rb_objspace_alloc();
     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
     global_symbols.id_str = st_init_numtable_with_size(1000);
-    global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
-    global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
-
     Init_id();
+    ruby_native_thread_unlock(&global_symbols.lock);
+}
+
+void
+InitVM_sym(rb_vm_t *vm)
+{
+    struct ivar_symbols *isym = ALLOC(struct ivar_symbols);
+    VALUE iw = Data_Wrap_Struct(0, ivar2_mark, ivar2_free, isym);
+    isym->ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
+    isym->id_ivar2 = st_init_numtable_with_size(1000);
+    *(VALUE *)ruby_vm_specific_ptr(vm, rb_vmkey_ivar_symbols) = iw;
 }
 
 void
 rb_gc_mark_symbols(void)
 {
+#if 0
     rb_mark_tbl(global_symbols.id_str);
     rb_gc_mark_locations(global_symbols.op_sym,
 			 global_symbols.op_sym + tLAST_TOKEN);
+#endif
 }
 
 static ID
@@ -9279,11 +9323,24 @@ rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
     return *m ? Qfalse : Qtrue;
 }
 
+static VALUE
+sym_str_new(const char *name, long len, rb_encoding *enc)
+{
+    extern VALUE rb_newobj_from_heap(struct rb_objspace_t *);
+    VALUE str = rb_newobj_from_heap(global_symbols.objspace);
+
+    RSTRING(str)->basic.flags = T_STRING;
+    RSTRING(str)->basic.klass = 0;
+    rb_enc_associate(str, enc);
+    rb_str_cat(str, name, len);
+    OBJ_FREEZE(str);
+    return str;
+}
+
 static ID
 register_symid(ID id, const char *name, long len, rb_encoding *enc)
 {
-    VALUE str = rb_enc_str_new(name, len, enc);
-    OBJ_FREEZE(str);
+    VALUE str = sym_str_new(name, len, enc);
     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
     return id;
@@ -9299,17 +9356,18 @@ rb_intern3(const char *name, long len, rb_encoding *enc)
     ID id;
     int last;
     int mb;
+    st_data_t data;
     struct RString fake_str;
     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED|FL_FREEZE;
-    fake_str.basic.klass = rb_cString;
+    fake_str.basic.klass = 0;
     fake_str.as.heap.len = len;
     fake_str.as.heap.ptr = (char *)name;
     fake_str.as.heap.aux.capa = len;
     str = (VALUE)&fake_str;
     rb_enc_associate(str, enc);
 
-    if (st_lookup(global_symbols.sym_id, str, (st_data_t *)&id))
-	return id;
+    if (st_lookup(global_symbols.sym_id, str, &data))
+	return (ID)data;
 
     if (rb_cString && !rb_enc_asciicompat(enc)) {
 	id = ID_JUNK;
@@ -9448,8 +9506,7 @@ rb_id2str(ID id)
 		char name[2];
 		name[0] = (char)id;
 		name[1] = 0;
-		str = rb_usascii_str_new(name, 1);
-		OBJ_FREEZE(str);
+		str = sym_str_new(name, 1, rb_usascii_encoding());
 		global_symbols.op_sym[i] = str;
 	    }
 	    return str;
@@ -9458,8 +9515,8 @@ rb_id2str(ID id)
 	    if (op_tbl[i].token == id) {
 		VALUE str = global_symbols.op_sym[i];
 		if (!str) {
-		    str = rb_usascii_str_new2(op_tbl[i].name);
-		    OBJ_FREEZE(str);
+		    const char *name = op_tbl[i].name;
+		    str = sym_str_new(name, strlen(name), rb_usascii_encoding());
 		    global_symbols.op_sym[i] = str;
 		}
 		return str;
@@ -10243,6 +10300,17 @@ ripper_value(VALUE self, VALUE obj)
 void
 Init_ripper(void)
 {
+    ripper_id_gets = rb_intern("gets");
+    /* ensure existing in symbol table */
+    rb_intern("||");
+    rb_intern("&&");
+    ripper_init_eventids1();
+    ripper_init_eventids2();
+}
+
+void
+InitVM_ripper(rb_vm_t *vm)
+{
     VALUE Ripper;
 
     Ripper = rb_define_class("Ripper", rb_cObject);
@@ -10262,11 +10330,7 @@ Init_ripper(void)
     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
 #endif
 
-    ripper_id_gets = rb_intern("gets");
-    ripper_init_eventids1(Ripper);
-    ripper_init_eventids2(Ripper);
-    /* ensure existing in symbol table */
-    rb_intern("||");
-    rb_intern("&&");
+    ripper_init_eventids1_table(Ripper);
+    ripper_init_eventids2_table(Ripper);
 }
 #endif /* RIPPER */
diff --git a/prec.c b/prec.c
index 1d0febd0b2..7b79fc1be6 100644
--- a/prec.c
+++ b/prec.c
@@ -125,12 +125,16 @@ Init_Precision(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    prc_pr = rb_intern("prec");
+    prc_if = rb_intern("induced_from");
+}
+
+void
+InitVM_Precision(rb_vm_t *vm)
+{
     rb_mPrecision = rb_define_module("Precision");
     rb_define_singleton_method(rb_mPrecision, "included", prec_included, 1);
     rb_define_method(rb_mPrecision, "prec", prec_prec, 1);
     rb_define_method(rb_mPrecision, "prec_i", prec_prec_i, 0);
     rb_define_method(rb_mPrecision, "prec_f", prec_prec_f, 0);
-
-    prc_pr = rb_intern("prec");
-    prc_if = rb_intern("induced_from");
 }
diff --git a/private_object.h b/private_object.h
index 91bac0df63..b61805d648 100644
--- a/private_object.h
+++ b/private_object.h
@@ -62,6 +62,8 @@ enum ruby_private_object_vmkey {
     rb_vmkey_big2str_power_cache,
 #define rb_big2str_power_cache (*rb_vm_specific_ptr(rb_vmkey_big2str_power_cache))
 
+    rb_vmkey_ivar_symbols,
+
     ruby_builtin_object_count,
     ruby_private_object_count = ruby_builtin_object_count - ruby_private_object_vmkey_begin + 1
 };
diff --git a/proc.c b/proc.c
index 9b4ca53b32..11595d7669 100644
--- a/proc.c
+++ b/proc.c
@@ -1744,6 +1744,11 @@ proc_curry(int argc, VALUE *argv, VALUE self)
 void
 Init_Proc(void)
 {
+}
+
+void
+InitVM_Proc(rb_vm_t *vm)
+{
     /* Proc */
     rb_cProc = rb_define_class("Proc", rb_cObject);
     rb_undef_alloc_func(rb_cProc);
@@ -1862,6 +1867,11 @@ Init_Proc(void)
 void
 Init_Binding(void)
 {
+}
+
+void
+InitVM_Binding(rb_vm_t *vm)
+{
     rb_cBinding = rb_define_class("Binding", rb_cObject);
     rb_undef_alloc_func(rb_cBinding);
     rb_undef_method(CLASS_OF(rb_cBinding), "new");
diff --git a/process.c b/process.c
index ba3d737db8..0a87fa9a2d 100644
--- a/process.c
+++ b/process.c
@@ -5068,6 +5068,11 @@ rb_proc_times(VALUE obj)
 void
 Init_process(void)
 {
+}
+
+void
+InitVM_process(rb_vm_t *vm)
+{
     VALUE rb_mProcUID;
     VALUE rb_mProcGID;
     VALUE rb_mProcID_Syscall;
diff --git a/random.c b/random.c
index b0d2d03a01..27612ce236 100644
--- a/random.c
+++ b/random.c
@@ -203,7 +203,15 @@ struct Random {
     struct RandSeed seed;
 };
 
-static struct Random default_mt;
+static int vmkey_default_mt;
+#define default_mt (*(struct Random *)DATA_PTR(*rb_vm_specific_ptr(vmkey_default_mt)))
+
+static void
+random_mark(void *ptr)
+{
+    struct Random *r = ptr;
+    rb_gc_mark(r->seed.value);
+}
 
 unsigned long
 rb_genrand_int32(void)
@@ -355,6 +363,7 @@ static VALUE
 rb_f_srand(int argc, VALUE *argv, VALUE obj)
 {
     VALUE seed, old;
+    struct Random *r = &default_mt;
 
     rb_secure(4);
     if (argc == 0) {
@@ -363,8 +372,8 @@ rb_f_srand(int argc, VALUE *argv, VALUE obj)
     else {
 	rb_scan_args(argc, argv, "01", &seed);
     }
-    old = default_mt.seed.value;
-    default_mt.seed.value = rand_init(&default_mt.mt, seed);
+    old = r->seed.value;
+    r->seed.value = rand_init(&r->mt, seed);
 
     return old;
 }
@@ -532,29 +541,44 @@ rb_f_rand(int argc, VALUE *argv, VALUE obj)
 void
 Init_RandomSeed(void)
 {
-    fill_random_seed(default_mt.seed.initial);
-    init_by_array(&default_mt.mt, default_mt.seed.initial, DEFAULT_SEED_CNT);
+    vmkey_default_mt = rb_vm_key_create();
+}
+
+void
+InitVM_RandomSeed(rb_vm_t *vm)
+{
 }
 
 static void
-Init_RandomSeed2(void)
+InitVM_RandomSeed2(rb_vm_t *vm)
 {
-    default_mt.seed.value = make_seed_value(default_mt.seed.initial);
-    memset(default_mt.seed.initial, 0, DEFAULT_SEED_LEN);
+    struct Random *r;
+    VALUE rv = Data_Make_Struct(rb_cData, struct Random, random_mark, -1, r);
+
+    *(VALUE *)ruby_vm_specific_ptr(vm, vmkey_default_mt) = rv;
+    fill_random_seed(r->seed.initial);
+    init_by_array(&r->mt, r->seed.initial, DEFAULT_SEED_CNT);
+    r->seed.value = make_seed_value(r->seed.initial);
+    memset(r->seed.initial, 0, DEFAULT_SEED_LEN);
 }
 
 void
 rb_reset_random_seed(void)
 {
-    uninit_genrand(&default_mt.mt);
-    default_mt.seed.value = INT2FIX(0);
+    struct Random *r = &default_mt;
+    uninit_genrand(&r->mt);
+    r->seed.value = INT2FIX(0);
 }
 
 void
 Init_Random(void)
 {
-    Init_RandomSeed2();
+}
+
+void
+InitVM_Random(rb_vm_t *vm)
+{
+    InitVM_RandomSeed2(vm);
     rb_define_global_function("srand", rb_f_srand, -1);
     rb_define_global_function("rand", rb_f_rand, -1);
-    rb_global_variable(&default_mt.seed.value);
 }
diff --git a/range.c b/range.c
index b8d31b4dfa..2fcf5cfaba 100644
--- a/range.c
+++ b/range.c
@@ -906,7 +906,11 @@ Init_Range(void)
     id_beg = rb_intern("begin");
     id_end = rb_intern("end");
     id_excl = rb_intern("excl");
+}
 
+void
+InitVM_Range(rb_vm_t *vm)
+{
     rb_cRange = rb_struct_define_without_accessor(
         "Range", rb_cObject, range_alloc,
         "begin", "end", "excl", NULL);
diff --git a/rational.c b/rational.c
index 24ccf8c12d..f2ab575379 100644
--- a/rational.c
+++ b/rational.c
@@ -1020,7 +1020,7 @@ i_ilog2(VALUE x)
     return q + r;
 }
 
-static long ml;
+#define ml DBL_MAX_EXP
 
 static VALUE
 nurat_to_f(VALUE self)
@@ -1251,20 +1251,15 @@ make_patterns(void)
     vmkey_an_underscore = rb_vm_key_create();
 
     rat_pat = rb_reg_new(rat_pat_source, sizeof rat_pat_source - 1, 0);
-    rb_global_variable(&rat_pat);
 
     an_e_pat = rb_reg_new(an_e_pat_source, sizeof an_e_pat_source - 1, 0);
-    rb_global_variable(&an_e_pat);
 
     a_dot_pat = rb_reg_new(a_dot_pat_source, sizeof a_dot_pat_source - 1, 0);
-    rb_global_variable(&a_dot_pat);
 
     underscores_pat = rb_reg_new(underscores_pat_source,
 				 sizeof underscores_pat_source - 1, 0);
-    rb_global_variable(&underscores_pat);
 
     an_underscore = rb_str_new2("_");
-    rb_global_variable(&an_underscore);
 }
 
 #define id_match rb_intern("match")
@@ -1476,8 +1471,6 @@ Init_Rational(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
-    assert(fprintf(stderr, "assert() is now active\n"));
-
     id_Unify = rb_intern("Unify");
     id_abs = rb_intern("abs");
     id_cmp = rb_intern("<=>");
@@ -1495,8 +1488,12 @@ Init_Rational(void)
     id_to_i = rb_intern("to_i");
     id_to_s = rb_intern("to_s");
     id_truncate = rb_intern("truncate");
+}
 
-    ml = (long)(log(DBL_MAX) / log(2.0) - 1);
+void
+InitVM_Rational(rb_vm_t *vm)
+{
+    assert(fprintf(stderr, "assert() is now active\n"));
 
     rb_cRational = rb_define_class(RATIONAL_NAME, rb_cNumeric);
 
diff --git a/re.c b/re.c
index 3ef02c01a5..4394178942 100644
--- a/re.c
+++ b/re.c
@@ -2427,18 +2427,20 @@ rb_reg_compile(VALUE str, int options)
     return re;
 }
 
-static VALUE reg_cache;
+static int vmkey_reg_cache;
+#define vm_reg_cache (*rb_vm_specific_ptr(vmkey_reg_cache))
 
 VALUE
 rb_reg_regcomp(VALUE str)
 {
     volatile VALUE save_str = str;
+    VALUE reg_cache = vm_reg_cache;
     if (reg_cache && RREGEXP_SRC_LEN(reg_cache) == RSTRING_LEN(str)
 	&& ENCODING_GET(reg_cache) == ENCODING_GET(str)
 	&& memcmp(RREGEXP_SRC_PTR(reg_cache), RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
 	return reg_cache;
 
-    return reg_cache = rb_reg_new_str(save_str, 0);
+    return vm_reg_cache = rb_reg_new_str(save_str, 0);
 }
 
 /*
@@ -3338,12 +3340,18 @@ re_warn(const char *s)
 void
 Init_Regexp(void)
 {
-    rb_eRegexpError = rb_define_class("RegexpError", rb_eStandardError);
+    vmkey_reg_cache = rb_vm_key_create();
 
     onigenc_set_default_caseconv_table((UChar*)casetable);
     onigenc_set_default_encoding(ONIG_ENCODING_ASCII);
     onig_set_warn_func(re_warn);
     onig_set_verb_warn_func(re_warn);
+}
+
+void
+InitVM_Regexp(rb_vm_t *vm)
+{
+    rb_eRegexpError = rb_define_class("RegexpError", rb_eStandardError);
 
     rb_define_virtual_variable("$~", match_getter, match_setter);
     rb_define_virtual_variable("$&", last_match_getter, 0);
@@ -3387,8 +3395,6 @@ Init_Regexp(void)
     rb_define_const(rb_cRegexp, "EXTENDED", INT2FIX(ONIG_OPTION_EXTEND));
     rb_define_const(rb_cRegexp, "MULTILINE", INT2FIX(ONIG_OPTION_MULTILINE));
 
-    rb_global_variable(&reg_cache);
-
     rb_cMatch  = rb_define_class("MatchData", rb_cObject);
     rb_define_alloc_func(rb_cMatch, match_alloc);
     rb_undef_method(CLASS_OF(rb_cMatch), "new");
diff --git a/signal.c b/signal.c
index 90d3dc152e..012d0d759c 100644
--- a/signal.c
+++ b/signal.c
@@ -1094,16 +1094,6 @@ void
 Init_signal(void)
 {
 #ifndef MACOS_UNUSE_SIGNAL
-    VALUE mSignal = rb_define_module("Signal");
-
-    rb_define_global_function("trap", sig_trap, -1);
-    rb_define_module_function(mSignal, "trap", sig_trap, -1);
-    rb_define_module_function(mSignal, "list", sig_list, 0);
-
-    rb_define_method(rb_eSignal, "initialize", esignal_init, -1);
-    rb_define_method(rb_eSignal, "signo", esignal_signo, 0);
-    rb_alias(rb_eSignal, rb_intern("signm"), rb_intern("message"));
-    rb_define_method(rb_eInterrupt, "initialize", interrupt_init, -1);
 
     install_sighandler(SIGINT, sighandler);
 #ifdef SIGHUP
@@ -1149,3 +1139,20 @@ Init_signal(void)
 
 #endif /* MACOS_UNUSE_SIGNAL */
 }
+
+void
+InitVM_signal(rb_vm_t *vm)
+{
+#ifndef MACOS_UNUSE_SIGNAL
+    VALUE mSignal = rb_define_module("Signal");
+
+    rb_define_global_function("trap", sig_trap, -1);
+    rb_define_module_function(mSignal, "trap", sig_trap, -1);
+    rb_define_module_function(mSignal, "list", sig_list, 0);
+
+    rb_define_method(rb_eSignal, "initialize", esignal_init, -1);
+    rb_define_method(rb_eSignal, "signo", esignal_signo, 0);
+    rb_alias(rb_eSignal, rb_intern("signm"), rb_intern("message"));
+    rb_define_method(rb_eInterrupt, "initialize", interrupt_init, -1);
+#endif /* MACOS_UNUSE_SIGNAL */
+}
diff --git a/string.c b/string.c
index cebf83c383..635d148d8c 100644
--- a/string.c
+++ b/string.c
@@ -1869,7 +1869,7 @@ rb_memhash(const void *ptr, long len)
     static unsigned int hashseed;
 
     if (!hashseed_init) {
-        hashseed = rb_genrand_int32();
+        /*hashseed = rb_genrand_int32();*/
         hashseed_init = 1;
     }
 
@@ -6657,6 +6657,12 @@ Init_String(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    id_to_s = rb_intern("to_s");
+}
+
+void
+InitVM_String(rb_vm_t *vm)
+{
     rb_cString  = rb_define_class("String", rb_cObject);
     rb_include_module(rb_cString, rb_mComparable);
     rb_define_alloc_func(rb_cString, str_alloc);
@@ -6779,8 +6785,6 @@ Init_String(void)
     rb_define_method(rb_cString, "valid_encoding?", rb_str_valid_encoding_p, 0);
     rb_define_method(rb_cString, "ascii_only?", rb_str_is_ascii_only_p, 0);
 
-    id_to_s = rb_intern("to_s");
-
     rb_fs = Qnil;
     rb_define_variable("$;", &rb_fs);
     rb_define_variable("$-F", &rb_fs);
diff --git a/struct.c b/struct.c
index 1b619a31be..41833b08da 100644
--- a/struct.c
+++ b/struct.c
@@ -871,6 +871,11 @@ rb_struct_size(VALUE s)
 void
 Init_Struct(void)
 {
+}
+
+void
+InitVM_Struct(rb_vm_t *vm)
+{
     rb_cStruct = rb_define_class("Struct", rb_cObject);
     rb_include_module(rb_cStruct, rb_mEnumerable);
 
diff --git a/thread.c b/thread.c
index 2e36a30fb4..563c4e4bac 100644
--- a/thread.c
+++ b/thread.c
@@ -3686,6 +3686,12 @@ Init_Thread(void)
 #undef rb_intern
 #define rb_intern(str) rb_intern_const(str)
 
+    recursive_key = rb_intern("__recursive_key__");
+}
+
+void
+InitVM_Thread(rb_vm_t *vm)
+{
     VALUE cThGroup;
 
     rb_define_singleton_method(rb_cThread, "new", thread_s_new, -1);
@@ -3752,7 +3758,6 @@ Init_Thread(void)
     rb_define_method(rb_cMutex, "unlock", rb_mutex_unlock, 0);
     rb_define_method(rb_cMutex, "sleep", mutex_sleep, -1);
 
-    recursive_key = rb_intern("__recursive_key__");
     rb_eThreadError = rb_define_class("ThreadError", rb_eStandardError);
     rb_eMutex_OrphanLock = rb_define_class_under(rb_cMutex, "OrphanLock", rb_eThreadError);
 
diff --git a/time.c b/time.c
index 4d5480b4a9..89bbc3425d 100644
--- a/time.c
+++ b/time.c
@@ -2384,7 +2384,11 @@ Init_Time(void)
     id_divmod = rb_intern("divmod");
     id_mul = rb_intern("*");
     id_submicro = rb_intern("submicro");
+}
 
+void
+InitVM_Time(rb_vm_t *vm)
+{
     rb_cTime = rb_define_class("Time", rb_cObject);
     rb_include_module(rb_cTime, rb_mComparable);
 
diff --git a/transcode.c b/transcode.c
index 49e8ed3856..2fa5309ea5 100644
--- a/transcode.c
+++ b/transcode.c
@@ -3532,9 +3532,6 @@ extern void Init_newline(void);
 void
 Init_transcode(void)
 {
-    rb_eConversionUndefined = rb_define_class_under(rb_cEncoding, "ConversionUndefined", rb_eStandardError);
-    rb_eInvalidByteSequence = rb_define_class_under(rb_cEncoding, "InvalidByteSequence", rb_eStandardError);
-    rb_eNoConverter = rb_define_class_under(rb_cEncoding, "NoConverter", rb_eStandardError);
 
     transcoder_table = st_init_strcasetable();
 
@@ -3558,6 +3555,16 @@ Init_transcode(void)
     sym_cr_newline_encoder = ID2SYM(rb_intern("cr_newline_encoder"));
     sym_partial_input = ID2SYM(rb_intern("partial_input"));
 
+    Init_newline();
+}
+
+void
+InitVM_transcode(rb_vm_t *vm)
+{
+    rb_eConversionUndefined = rb_define_class_under(rb_cEncoding, "ConversionUndefined", rb_eStandardError);
+    rb_eInvalidByteSequence = rb_define_class_under(rb_cEncoding, "InvalidByteSequence", rb_eStandardError);
+    rb_eNoConverter = rb_define_class_under(rb_cEncoding, "NoConverter", rb_eStandardError);
+
     rb_define_method(rb_cString, "encode", str_encode, -1);
     rb_define_method(rb_cString, "encode!", str_encode_bang, -1);
 
@@ -3605,6 +3612,4 @@ Init_transcode(void)
     rb_define_method(rb_eInvalidByteSequence, "error_bytes", ecerr_error_bytes, 0);
     rb_define_method(rb_eInvalidByteSequence, "readagain_bytes", ecerr_readagain_bytes, 0);
     rb_define_method(rb_eInvalidByteSequence, "incomplete_input?", ecerr_incomplete_input, 0);
-
-    Init_newline();
 }
diff --git a/variable.c b/variable.c
index e83c8ee74e..5e706add22 100644
--- a/variable.c
+++ b/variable.c
@@ -24,15 +24,19 @@ static ID autoload, classpath, tmp_classpath, id_const_missing;
 void
 Init_var_tables(void)
 {
-    rb_vm_t *vm = GET_VM();
-    vm->mark_object_ary = rb_ary_new();
-    vm->global_tbl = st_init_numtable();
     CONST_ID(autoload, "__autoload__");
     CONST_ID(classpath, "__classpath__");
     CONST_ID(tmp_classpath, "__tmp_classpath__");
     CONST_ID(id_const_missing, "const_missing");
 }
 
+void
+InitVM_var_tables(rb_vm_t *vm)
+{
+    vm->mark_object_ary = rb_ary_new();
+    vm->global_tbl = st_init_numtable();
+}
+
 struct fc_result {
     ID name;
     VALUE klass;
diff --git a/version.c b/version.c
index 53edf02574..4d0250ab92 100644
--- a/version.c
+++ b/version.c
@@ -27,6 +27,11 @@ const char ruby_engine[] = "ruby";
 void
 Init_version(void)
 {
+}
+
+void
+InitVM_version(rb_vm_t *vm)
+{
     rb_define_global_const("RUBY_VERSION", MKSTR(version));
     rb_define_global_const("RUBY_RELEASE_DATE", MKSTR(release_date));
     rb_define_global_const("RUBY_PLATFORM", MKSTR(platform));
diff --git a/vm.c b/vm.c
index f05d20d27f..82bd6f0255 100644
--- a/vm.c
+++ b/vm.c
@@ -1582,7 +1582,7 @@ thread_alloc(VALUE klass)
 }
 
 static void
-th_init2(rb_thread_t *th, VALUE self)
+th_init(rb_thread_t *th, VALUE self)
 {
     th->self = self;
 
@@ -1607,12 +1607,6 @@ th_init2(rb_thread_t *th, VALUE self)
 #endif
 }
 
-static void
-th_init(rb_thread_t *th, VALUE self)
-{
-    th_init2(th, self);
-}
-
 static VALUE
 ruby_thread_init(VALUE self)
 {
@@ -1790,6 +1784,11 @@ nsdr(void)
 void
 Init_VM(void)
 {
+}
+
+void
+InitVM_VM(rb_vm_t *vm)
+{
     VALUE opts;
     VALUE klass;
     VALUE fcore;
@@ -1920,15 +1919,14 @@ ruby_make_bare_vm(void)
 	exit(EXIT_FAILURE);
     }
     MEMZERO(th, rb_thread_t, 1);
+    th->vm = vm;
+    rb_thread_set_current_raw(th);
     vm_init2(vm);
     vm->main_thread = th;
 
-    rb_thread_set_current_raw(th);
-    {
-	th->vm = vm;
-	th_init2(th, 0);
-	ruby_thread_init_stack(th);
-    }
+    th_init(th, 0);
+    ruby_thread_init_stack(th);
+
     rb_thread_set_current_raw(old_th);
 
     return vm;
@@ -1957,8 +1955,11 @@ rb_vm_top_self(void)
 void
 Init_top_self(void)
 {
-    rb_vm_t *vm = GET_VM();
+}
 
+void
+InitVM_top_self(rb_vm_t *vm)
+{
     vm->top_self = rb_obj_alloc(rb_cObject);
     rb_define_singleton_method(rb_vm_top_self(), "to_s", main_to_s, 0);
 }