ruby-internal 0.6.0

data/ext/internal/vm/instruction/extconf.rb

@@ -0,0 +1,6 @@
+$: << '../../..'
+require 'mkmf-ruby-internal'
+
+have_header('vm.h')
+
+create_ruby_internal_makefile 'internal/vm/instruction/instruction'

data/ext/internal/vm/instruction/insns_info.c.rpp

@@ -0,0 +1,213 @@
+#include "insns_info.h"
+
+#ifdef RUBY_VM
+
+#ruby <<END
+  $:.unshift '../../..'
+  require 'ruby_source_dir'
+  insns_location = "#{RUBY_SOURCE_DIR}/insns.inc"
+  insns_info_location = "#{RUBY_SOURCE_DIR}/insns_info.inc"
+  insns_def_location = "#{RUBY_SOURCE_DIR}/insns.def"
+  iseq_c_location = "#{RUBY_SOURCE_DIR}/iseq.c"
+
+  INSTRUCTION_NAMES = []
+  record_instruction_names = false
+
+  [ insns_location, insns_info_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        if line =~ /^\}/ then
+          record_instruction_names = false
+        end
+        if record_instruction_names then
+          name = line.chomp(',').gsub(/"/, '').lstrip.upcase
+          INSTRUCTION_NAMES.push(name) if name != ''
+        end
+        if line =~ /static.*insn_name_info.*=/ then
+          record_instruction_names = true
+        end
+      end
+    end
+  end
+
+  write = false
+
+  [ iseq_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        case line
+        when /^make_compile_option\(/
+          puts 'void'
+          write = true
+        when /^static.*COMPILE_OPTION_DEFAULT.*=/
+          write = true
+        when /^static.*COMPILE_OPTION_FALSE.*;/
+          puts line
+        end
+        puts line if write
+        if line =~ /^\}/ then
+          write = false
+        end
+      end
+    end
+  end
+
+  INSTRUCTION_OPERAND_NAMES = {}
+
+  [ insns_def_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      if input.respond_to?(:set_encoding) then
+        input.set_encoding(Encoding::ASCII_8BIT)
+      end
+      while (line = input.gets) != nil do
+        line.chomp!
+        case line
+        when /^DEFINE_INSN/
+          name = input.gets.chomp
+          operand_line = input.gets.chomp
+          operand_line.gsub!(/\((.*)\)/, '\1')
+          operands = operand_line.split(',')
+          operand_names = operands.map { |x| x.split[1] }
+          INSTRUCTION_OPERAND_NAMES[name] = operand_names
+        end
+      end
+    end
+  end
+
+  nil
+END
+
+VALUE instruction_class[VM_INSTRUCTION_SIZE];
+
+static ID operand_type_name_of(int operand_type)
+{
+  char const * retval = "????";
+
+  switch(operand_type)
+  {
+    case TS_ISEQ: retval = "iseq"; break;
+    case TS_GENTRY: retval = "gentry"; break;
+    case TS_OFFSET: retval = "operand"; break;
+    case TS_DINDEX: retval = "dindex"; break;
+    case TS_VARIABLE: retval = "variable"; break;
+    case TS_CDHASH: retval = "cdhash"; break;
+    case TS_IC: retval = "ic"; break;
+    case TS_ID: retval = "id"; break;
+    case TS_VALUE: retval = "value"; break;
+    case TS_LINDEX: retval = "lindex"; break;
+    case TS_NUM: retval = "num"; break;
+  }
+
+  return rb_intern(retval);
+}
+
+#ruby <<END
+INSTRUCTION_NAMES.each_with_index do |name, index|
+  $operand_names = INSTRUCTION_OPERAND_NAMES[name.downcase]
+
+# 1 #<VM::Instruction::TRACE:0x402d991c @length=2, @operands=[1],
+#   @instruction=45, @operand_types=[:num], @name=:trace>
+  puts <<-END
+/*
+ * call-seq:
+ *   insn.length => Integer
+ *
+ * Returns the length of the instruction.
+ */
+static VALUE insn_#{name}_length(VALUE self)
+{
+  return LONG2NUM(insn_len(#{index}));
+}
+
+/*
+ * call-seq:
+ *   insn.to_i => Integer
+ *
+ * Returns the numeric instruction number.
+ */
+static VALUE insn_#{name}_to_i(VALUE self)
+{
+  return NUM2LONG(#{index});
+}
+
+/*
+ * call-seq:
+ *   insn.operand_types => Array of Symbol
+ *
+ * Returns an array containing the types of the operands.
+ */
+static VALUE insn_#{name}_operand_types(VALUE self)
+{
+  VALUE operand_types = rb_ary_new();
+  char const * s;
+
+  for(s = insn_op_types(#{index}); *s != '\\0'; ++s)
+  {
+    rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
+  }
+
+  return operand_types;
+}
+
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the instruction.
+ */
+static VALUE insn_#{name}_name(VALUE self)
+{
+  return rb_intern("#{name}");
+}
+
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the operands for this instruction.
+ */
+static VALUE insn_#{name}_operand_names(VALUE self)
+{
+  VALUE v[] = {
+    #{$operand_names.map { |x| "ID2SYM(rb_intern(\"#{x}\"))" }.join(', ')}
+  };
+  return rb_ary_new4(#{$operand_names.size}, v);
+}
+
+  END
+end
+nil
+END
+
+void define_instruction_subclasses(VALUE rb_cInstruction)
+{
+  /* For rdoc: rb_cVM = rb_define_class("VM", rb_cObject); */
+  /* For rdoc: rb_cInstruction = rb_define_class_under(rb_cVM, "Instruction", rb_cObject); */
+
+#ruby <<END
+  INSTRUCTION_NAMES.each_with_index do |name, index|
+    puts <<-END
+  {
+    VALUE rb_cInstruction_#{name} = instruction_class[#{index}] = rb_define_class_under(rb_cInstruction, "#{name}", rb_cInstruction);
+    rb_define_method(rb_cInstruction_#{name}, "length", insn_#{name}_length, 0);
+    rb_define_method(rb_cInstruction_#{name}, "to_i", insn_#{name}_to_i, 0);
+    rb_define_method(rb_cInstruction_#{name}, "operand_types", insn_#{name}_operand_types, 0);
+    rb_define_method(rb_cInstruction_#{name}, "operand_names", insn_#{name}_operand_names, 0);
+    rb_define_method(rb_cInstruction_#{name}, "name", insn_#{name}_name, 0);
+  }
+    END
+  end
+  nil
+END
+}
+
+#endif
+

data/ext/internal/vm/instruction/insns_info.h.rpp

@@ -0,0 +1,53 @@
+#ifndef insns_info__h_
+#define insns_info__h_
+
+#include "ruby.h"
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+#ifdef HAVE_VM_H
+#include "vm.h"
+#endif
+
+#ruby <<END
+  $:.unshift '../../..'
+  require 'ruby_source_dir'
+  insns_location = "#{RUBY_SOURCE_DIR}/insns.inc"
+  insns_info_location = "#{RUBY_SOURCE_DIR}/insns_info.inc"
+  iseq_c_location = "#{RUBY_SOURCE_DIR}/iseq.c"
+
+  [ insns_location, insns_info_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        puts line
+      end
+    end
+  end
+
+  [ iseq_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        if line =~ /^make_compile_option/ then
+          puts 'void'
+          puts "#{line};"
+        end
+      end
+    end
+  end
+  nil
+END
+
+extern VALUE instruction_class[VM_INSTRUCTION_SIZE];
+void define_instruction_subclasses(VALUE rb_cInstruction);
+
+#endif
+
+#endif
+

data/ext/internal/vm/instruction/instruction.c

@@ -0,0 +1,78 @@
+#include "instruction.h"
+#include "insns_info.h"
+#include <ruby.h>
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+#ifdef RUBY_VM
+
+/*
+ * call-seq:
+ *   Instruction.new(*operands) => Instruction
+ *
+ * Create a new instruction with the given operands.
+ */
+static VALUE instruction_initialize(int argc, VALUE * argv, VALUE self)
+{
+  VALUE operands = rb_ary_new4(argc, argv);
+  rb_iv_set(self, "@operands", operands);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   instruction.operands => Array
+ *
+ * Returns the instructions operands.
+ */
+static VALUE instruction_operands(VALUE self)
+{
+  return rb_iv_get(self, "@operands");
+}
+
+VALUE allocate_instruction(int instruction, VALUE args)
+{
+  return rb_class_new_instance(
+      RARRAY_LEN(args),
+      RARRAY_PTR(args),
+      instruction_class[instruction]);
+}
+
+#endif
+
+void Init_instruction(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+  VALUE rb_cInstruction;
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+
+  rb_cInstruction = rb_define_class_under(rb_cRubyVM, "Instruction", rb_cObject);
+  rb_define_method(rb_cInstruction, "initialize", instruction_initialize, -1);
+  rb_define_method(rb_cInstruction, "operands", instruction_operands, 0);
+  rb_undef_method(rb_cInstruction, "new");
+
+  define_instruction_subclasses(rb_cInstruction);
+
+  /* Silence compiler warnings about unused static functions */
+  insn_name(0);
+  insn_op_type(0, 0);
+  insn_op_types(0);
+#endif
+}
+

data/ext/internal/vm/instruction/instruction.h

@@ -0,0 +1,10 @@
+#ifndef ruby_internal_vm__instruction__h_
+#define ruby_internal_vm__instruction__h_
+
+#ifdef RUBY_VM
+
+VALUE allocate_instruction(int instruction, VALUE args);
+
+#endif
+
+#endif

data/ext/internal/vm/iseq/extconf.rb

@@ -0,0 +1,7 @@
+$: << '../../..'
+require 'mkmf-ruby-internal'
+
+have_header('iseq.h')
+have_header('ruby/node.h') or have_header('node.h')
+
+create_ruby_internal_makefile 'internal/vm/iseq/iseq'

data/ext/internal/vm/iseq/insns_info.inc.rpp

@@ -0,0 +1,30 @@
+#ifndef ruby_internal_insns_info__inc_
+#define ruby_internal_insns_info__inc_
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include "env.h"
+#endif
+
+#ruby <<END
+  ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+
+  if ruby_version_code >= 190 then
+
+    $: << '../../..'
+    require 'ruby_source_dir'
+    insns_info_location = "#{RUBY_SOURCE_DIR}/insns_info.inc"
+
+    File.open(insns_info_location) do |input|
+      input.each_line do |line|
+        puts line
+      end
+    end
+  end
+
+  nil
+END
+
+#endif
+

data/ext/internal/vm/iseq/internal_iseq.h

@@ -0,0 +1,9 @@
+#ifndef ruby_internal_vm__internal_iseq_h_
+#define ruby_internal_vm__internal_iseq_h_
+
+#include <ruby.h>
+
+void dump_iseq_to_hash(VALUE iseq, VALUE node_hash);
+VALUE load_iseq_from_hash(VALUE iseq, VALUE orig_node_id, VALUE node_hash, VALUE id_hash);
+
+#endif

data/ext/internal/vm/iseq/iseq.c

@@ -0,0 +1,555 @@
+#include "internal_iseq.h"
+#include "insns_info.inc"
+
+#include "internal/node/ruby_internal_node.h"
+#include "internal/module/module.h"
+#include "internal/vm/instruction/instruction.h"
+
+#include <ruby.h>
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+#ifdef HAVE_ISEQ_H
+#include "iseq.h"
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+// Defined but not declared by ruby
+VALUE iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt);
+
+static VALUE rb_cModulePlaceholder;
+
+static VALUE rb_mMarshal;
+
+static VALUE rb_cInlineCache;
+
+static VALUE rb_cCatchTableEntry;
+
+static VALUE marshal_dump(VALUE obj, VALUE limit)
+{
+  return rb_funcall(rb_mMarshal, rb_intern("dump"), 2, obj, limit);
+}
+
+static VALUE marshal_load(VALUE obj)
+{
+  return rb_funcall(rb_mMarshal, rb_intern("load"), 1, obj);
+}
+
+static rb_iseq_t *
+iseq_check(VALUE val)
+{
+  rb_iseq_t *iseq;
+  if(!rb_obj_is_kind_of(val, rb_cISeq))
+  {
+    rb_raise(
+        rb_eTypeError,
+        "Expected VM::InstructionSequence, but got %s",
+        rb_class2name(CLASS_OF(val)));
+  }
+  GetISeqPtr(val, iseq);
+  if (!iseq->name) {
+    rb_raise(rb_eTypeError, "uninitialized InstructionSequence");
+  }
+  return iseq;
+}
+
+/* call-seq:
+ *   iseq.self => VM::InstructionSequence
+ *
+ * Returns the self member of the instruction sequence.
+ */
+static VALUE iseq_self(VALUE self)
+{
+  rb_iseq_t * iseqdat = iseq_check(self);
+  return iseqdat->self;
+}
+
+/* call-seq:
+ *   iseq.parent_iseq => VM::InstructionSequence or nil
+ *
+ * Returns the parent instruction sequence.
+ */
+static VALUE iseq_parent_iseq(VALUE self)
+{
+  rb_iseq_t * iseqdat = iseq_check(self);
+  rb_iseq_t * parent = iseqdat->parent_iseq;
+  if(parent)
+  {
+    return parent->self;
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+
+/* call-seq:
+ *   iseq.local_iseq => VM::InstructionSequence or nil
+ *
+ * Returns the instruction sequence that contains the local variables.
+ */
+static VALUE iseq_local_iseq(VALUE self)
+{
+  rb_iseq_t * iseqdat = iseq_check(self);
+  rb_iseq_t * local_iseq = iseqdat->local_iseq;
+  if(local_iseq)
+  {
+    return local_iseq->self;
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+/* call-seq:
+ *   iseq.name => String
+ *
+ * Returns the name of the instruction sequence.
+ */
+static VALUE iseq_name(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return iseqdat->name;
+}
+
+/* call-seq:
+ *   iseq.filename => String
+ *
+ * Returns the filename of the instruction sequence.
+ */
+static VALUE iseq_filename(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return iseqdat->filename;
+}
+
+/* call-seq:
+ *   iseq.local_table => String
+ *
+ * Returns the sequence's local table.
+ */
+static VALUE iseq_local_table(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  VALUE ary = rb_ary_new();
+  int j;
+
+  for(j = 0; j < iseqdat->local_table_size; ++j)
+  {
+    ID id = iseqdat->local_table[j];
+    if(rb_id2name(id))
+    {
+      rb_ary_push(ary, ID2SYM(id));
+    }
+    else
+    {
+      // Temporary
+      rb_ary_push(ary, Qnil);
+    }
+  }
+
+  return ary;
+}
+
+/* call-seq:
+ *   iseq.argc => String
+ *
+ * Returns the number of non-optional arguments.
+ */
+static VALUE iseq_argc(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return INT2NUM(iseqdat->argc);
+}
+
+/* call-seq:
+ *   iseq.arg_simple => true or false
+ *
+ * Returns true if this sequence takes only simple (non-rest, non-opt,
+ * non-block) args.
+ */
+static VALUE iseq_arg_simple(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return iseqdat->arg_simple ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *   iseq.arg_rest => true or false
+ *
+ * Returns the index of the rest (*x) arg.
+ */
+static VALUE iseq_arg_rest(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return INT2NUM(iseqdat->arg_rest);
+}
+
+/* call-seq:
+ *   iseq.arg_block => true or false
+ *
+ * Returns the index of the block (&x) arg.
+ */
+static VALUE iseq_arg_block(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  return INT2NUM(iseqdat->arg_block);
+}
+
+/* call-seq:
+ *   iseq.arg_opt_table => Array of Integer
+ *
+ * Returns optional argument table.  The value in the table represent
+ * the index into the instruction sequence of the code to set the
+ * optional argument.  The last element is the index of the start of the
+ * code sequence.
+ */
+static VALUE iseq_arg_opt_table(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  VALUE ary = rb_ary_new();
+  int j;
+
+  for(j = 0; j < iseqdat->arg_opts; ++j)
+  {
+    rb_ary_push(ary, INT2NUM(iseqdat->arg_opt_table[j]));
+  }
+
+  return ary;
+}
+
+/* call-seq:
+ *   iseq.each(pc_start=0, &block) => nil
+ *
+ * Yields each instruction in the sequence.
+ *
+ * If pc_start is supplied, begins iteration at the given offset from
+ * the beginning of the sequence.
+ *
+ */
+static VALUE iseq_each(int argc, VALUE * argv, VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  VALUE * seq;
+  VALUE pc_start_v = Qnil;
+  unsigned long pc_start = 0;
+
+  rb_scan_args(argc, argv, "01", &pc_start_v);
+
+  if(RTEST(pc_start_v))
+  {
+    pc_start = NUM2ULONG(pc_start_v);
+  }
+
+  for(seq = iseqdat->iseq + pc_start;
+      seq < iseqdat->iseq + iseqdat->iseq_size;
+      )
+  {
+    VALUE insn = *seq++;
+    int op_type_idx;
+    int len = insn_len(insn);
+    VALUE args = rb_ary_new();
+
+    for(op_type_idx = 0; op_type_idx < len-1; ++op_type_idx, ++seq)
+    {
+      switch(insn_op_type(insn, op_type_idx))
+      {
+        case TS_VALUE:
+          rb_ary_push(args, *seq);
+          break;
+
+        case TS_LINDEX:
+        case TS_DINDEX:
+        case TS_NUM:
+          rb_ary_push(args, INT2FIX(*seq));
+          break;
+
+        case TS_ISEQ:
+        {
+          rb_iseq_t * iseq = (rb_iseq_t *)*seq;
+          if(iseq)
+          {
+            rb_ary_push(args, iseq->self);
+          }
+          else
+          {
+            rb_ary_push(args, Qnil);
+          }
+          break;
+        }
+
+        case TS_GENTRY:
+        {
+          struct global_entry *entry = (struct global_entry *)*seq;
+          rb_ary_push(args, ID2SYM(rb_intern(rb_id2name(entry->id))));
+          break;
+        }
+
+        case TS_OFFSET:
+          rb_ary_push(args, LONG2NUM(*seq));
+          /* TODO */
+          break;
+
+        case TS_VARIABLE:
+          rb_ary_push(args, Qnil);
+          /* TODO */
+          break;
+
+        case TS_CDHASH:
+          rb_ary_push(args, Qnil);
+          /* TODO */
+          break;
+
+        case TS_IC:
+        {
+          NODE * ic = (NODE *)*seq;
+          rb_ary_push(args, wrap_node_as(ic, rb_cInlineCache));
+          break;
+        }
+
+        case TS_ID:
+          rb_ary_push(args, ID2SYM(*seq));
+          break;
+      }
+    }
+
+    rb_yield(allocate_instruction(insn, args));
+  }
+
+  return Qnil;
+}
+
+/* call-seq:
+ *   iseq.insn_line(n) => Integer
+ *
+ * Returns the line number of the nth instruction in the sequence.
+ */
+static VALUE iseq_insn_line(VALUE self, VALUE n)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  unsigned long pos = NUM2LONG(n);
+  unsigned long i, size = iseqdat->insn_info_size;
+  struct iseq_insn_info_entry *iiary = iseqdat->insn_info_table;
+
+  for (i = 0; i < size; i++) {
+      if (iiary[i].position == pos) {
+          return INT2NUM(iiary[i].line_no);
+      }
+  }
+  return Qnil;
+}
+
+/* call-seq:
+ *   iseq.catch_table => Array of CatchTableEntry
+ *
+ * Returns the catch table for the sequence
+ */
+static VALUE iseq_catch_table(VALUE self)
+{
+  rb_iseq_t *iseqdat = iseq_check(self);
+  unsigned long j;
+
+  VALUE catch_table = rb_ary_new();
+
+  for(j = 0; j < iseqdat->catch_table_size; ++j)
+  {
+    VALUE catch_table_entry = rb_struct_new(
+        rb_cCatchTableEntry,
+        iseqdat->catch_table[j].type,
+        iseqdat->catch_table[j].iseq,
+        ULONG2NUM(iseqdat->catch_table[j].start),
+        ULONG2NUM(iseqdat->catch_table[j].end),
+        ULONG2NUM(iseqdat->catch_table[j].cont),
+        ULONG2NUM(iseqdat->catch_table[j].sp));
+    rb_ary_push(catch_table, catch_table_entry);
+  }
+
+  return catch_table;
+}
+
+/* The putobject instruction takes a VALUE as a parameter.  But if this
+ * value is a class, we'll end up trying to dump the class!  That's
+ * probably not what we want, so we use a placeholder instead.
+ */
+void convert_modules_to_placeholders(VALUE array)
+{
+  int j;
+
+  for(j = 0; j < RARRAY_LEN(array); ++j)
+  {
+    VALUE v = RARRAY_PTR(array)[j];
+    if(TYPE(v) == T_ARRAY)
+    {
+      convert_modules_to_placeholders(v);
+    }
+    else if(TYPE(v) == T_MODULE || TYPE(v) == T_CLASS)
+    {
+      VALUE p = rb_class_new_instance(0, 0, rb_cModulePlaceholder);
+      VALUE sym = rb_mod_name(v);
+      rb_iv_set(p, "name", sym);
+      RARRAY_PTR(array)[j] = p;
+    }
+  }
+}
+
+void convert_placeholders_to_modules(VALUE array)
+{
+  int j;
+
+  for(j = 0; j < RARRAY_LEN(array); ++j)
+  {
+    VALUE v = RARRAY_PTR(array)[j];
+    if(TYPE(v) == T_ARRAY)
+    {
+      convert_placeholders_to_modules(v);
+    }
+    else if(CLASS_OF(v) == rb_cModulePlaceholder)
+    {
+      VALUE sym = rb_ivar_get(v, rb_intern("name"));
+      VALUE klass = lookup_module(sym);
+      RARRAY_PTR(array)[j] = klass;
+    }
+  }
+}
+
+/*
+ * call-seq:
+ *   iseq.dump(limit) => String
+ *
+ * Dumps VM::InstuctionSequence to a string (only available on YARV).
+ */
+static VALUE iseq_marshal_dump(VALUE self, VALUE limit)
+{
+  VALUE arr;
+
+  if(rb_safe_level() >= 4)
+  {
+    /* no access to potentially sensitive data from the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't dump iseq");
+  }
+
+  arr = rb_funcall(self, rb_intern("to_a"), 0);
+  convert_modules_to_placeholders(arr);
+
+  return marshal_dump(arr, limit);
+}
+
+/*
+ * call-seq:
+ *   VM::InstructionSequence.load(String) => VM::InstructionSequence
+ *
+ * Load a VM::InstuctionSequence from a string (only available on YARV).
+ */
+static VALUE iseq_marshal_load(VALUE klass, VALUE str)
+{
+  VALUE arr;
+
+  if(   rb_safe_level() >= 4
+     || (rb_safe_level() >= 1 && OBJ_TAINTED(str)))
+  {
+    /* no playing with knives in the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't load iseq");
+  }
+
+  arr = marshal_load(str);
+  convert_placeholders_to_modules(arr);
+
+  VALUE iseq = iseq_load(Qnil, arr, 0, Qnil);
+  return iseq;
+}
+
+void dump_iseq_to_hash(VALUE iseq, VALUE node_hash)
+{
+  if(RTEST(rb_hash_aref(node_hash, rb_obj_id(iseq))))
+  {
+    return;
+  }
+
+  rb_hash_aset(node_hash, rb_obj_id(iseq), iseq);
+}
+
+VALUE load_iseq_from_hash(VALUE iseq, VALUE orig_node_id, VALUE node_hash, VALUE id_hash)
+{
+  rb_hash_aset(id_hash, orig_node_id, rb_obj_id(iseq));
+  return iseq;
+}
+
+#endif
+
+void Init_iseq(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+
+  rb_require("internal/node");
+  rb_require("internal/module");
+  rb_require("internal/vm/instruction");
+  rb_require("internal/vm/inline_cache");
+
+  rb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
+
+  rb_cModulePlaceholder = rb_define_class("ModulePlaceholder", rb_cObject);
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  rb_cInlineCache = rb_const_get(rb_cRubyVM, rb_intern("InlineCache"));
+
+  /* For rdoc: rb_cISeq = rb_define_class_under(rb_cRubyVM, "InstructionSequence", rb_cObject) */
+  rb_define_method(rb_cISeq, "self", iseq_self, 0);
+  rb_define_method(rb_cISeq, "parent_iseq", iseq_parent_iseq, 0);
+  rb_define_method(rb_cISeq, "local_iseq", iseq_local_iseq, 0);
+  rb_define_method(rb_cISeq, "name", iseq_name, 0);
+  rb_define_method(rb_cISeq, "filename", iseq_filename, 0);
+  rb_define_method(rb_cISeq, "local_table", iseq_local_table, 0);
+  rb_define_method(rb_cISeq, "argc", iseq_argc, 0);
+  rb_define_method(rb_cISeq, "arg_simple", iseq_arg_simple, 0);
+  rb_define_method(rb_cISeq, "arg_rest", iseq_arg_rest, 0);
+  rb_define_method(rb_cISeq, "arg_block", iseq_arg_block, 0);
+  rb_define_method(rb_cISeq, "arg_opt_table", iseq_arg_opt_table, 0);
+  rb_define_method(rb_cISeq, "each", iseq_each, -1);
+  rb_define_method(rb_cISeq, "insn_line", iseq_insn_line, 1);
+  rb_define_method(rb_cISeq, "catch_table", iseq_catch_table, 0);
+  rb_include_module(rb_cISeq, rb_mEnumerable);
+  rb_define_method(rb_cISeq, "_dump", iseq_marshal_dump, 1);
+  rb_define_singleton_method(rb_cISeq, "_load", iseq_marshal_load, 1);
+
+  rb_cCatchTableEntry = rb_struct_define(
+      0,
+      "type",
+      "iseq",
+      "start",
+      "end",
+      "cont",
+      "sp",
+      0);
+  rb_const_set(rb_cISeq, rb_intern("CatchTableEntry"), rb_cCatchTableEntry);
+
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_RESCUE"), CATCH_TYPE_RESCUE);
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_ENSURE"), CATCH_TYPE_ENSURE);
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_RETRY"), CATCH_TYPE_RETRY);
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_BREAK"), CATCH_TYPE_BREAK);
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_REDO"), CATCH_TYPE_REDO);
+  rb_const_set(rb_cISeq, rb_intern("CATCH_TYPE_NEXT"), CATCH_TYPE_NEXT);
+      
+  /* Prevent compiler warnings about unused static functions */
+  insn_name(0);
+  insn_op_types(0);
+#endif
+}
+