support builtin features with Ruby and C.

Support loading builtin features written in Ruby, which implement
with C builtin functions.
[Feature #16254]

Several features:

(1) Load .rb file at boottime with native binary.

Now, prelude.rb is loaded at boottime. However, this file is contained
into the interpreter as a text format and we need to compile it.
This patch contains a feature to load from binary format.

(2) __builtin_func() in Ruby call func() written in C.

In Ruby file, we can write `__builtin_func()` like method call.
However this is not a method call, but special syntax to call
a function `func()` written in C. C functions should be defined
in a file (same compile unit) which load this .rb file.

Functions (`func` in above example) should be defined with
  (a) 1st parameter: rb_execution_context_t *ec
  (b) rest parameters (0 to 15).
  (c) VALUE return type.
This is very similar requirements for functions used by
rb_define_method(), however `rb_execution_context_t *ec`
is new requirement.

(3) automatic C code generation from .rb files.

tool/mk_builtin_loader.rb creates a C code to load .rb files
needed by miniruby and ruby command. This script is run by
BASERUBY, so *.rb should be written in BASERUBY compatbile
syntax. This script load a .rb file and find all of __builtin_
prefix method calls, and generate a part of C code to export
functions.

tool/mk_builtin_binary.rb creates a C code which contains
binary compiled Ruby files needed by ruby command.

tool/mk_builtin_loader.rb

@@ -0,0 +1,76 @@
+
+def collect_builtin iseq_ary, bs
+  code = iseq_ary[13]
+
+  code.each{|insn|
+    next unless Array === insn
+    case insn[0]
+    when :send
+      ci = insn[1]
+      if /\A__builtin_(.+)/ =~ ci[:mid]
+        func_name = $1
+        argc = ci[:orig_argc]
+
+        if bs[func_name] && bs[func_name] != argc
+          raise
+        end
+        bs[func_name] = argc
+      end
+    else
+      insn[1..-1].each{|op|
+        if op[0] == "YARVInstructionSequence/SimpleDataFormat"
+          collect_builtin op, bs
+        end
+      }
+    end
+  }
+end
+# ruby mk_builtin_loader.rb TARGET_FILE.rb
+# #=> generate load_TARGET_FILE.inc
+#
+
+def mk_builtin_header file
+  base = File.basename(file, '.rb')
+  ofile = File.join("load_#{base}.inc")
+
+  collect_builtin(RubyVM::InstructionSequence.compile_file(file, false).to_a, bs = {})
+
+  open(ofile, 'w'){|f|
+    f.puts "// DO NOT MODIFY THIS FILE DIRECTLY."
+    f.puts "// auto-generated file"
+    f.puts "//   by #{__FILE__}"
+    f.puts "//   with #{file}"
+    f.puts
+
+    f.puts "static void load_#{base}(void)"
+    f.puts "{"
+
+    table = "#{base}_table"
+    f.puts "  // table definition"
+    f.puts "  static const struct rb_builtin_function #{table}[] = {"
+    bs.each.with_index{|(func, argc), i|
+      f.puts "    RB_BUILTIN_FUNCTION(#{i}, #{func}, #{argc}),"
+    }
+    f.puts "    RB_BUILTIN_FUNCTION(-1, NULL, 0),"
+    f.puts "  };"
+
+    f.puts
+    f.puts "  // arity_check"
+    bs.each{|func, argc|
+      f.puts "  if (0) rb_builtin_function_check_arity#{argc}(#{func});"
+    }
+
+    path = File.expand_path(file)
+    f.puts
+    f.puts "  // load"
+    f.puts "  rb_load_with_builtin_functions(\"#{base}\", \"#{file}\", #{table});"
+
+    f.puts "}"
+  }
+end
+
+ARGV.each{|file|
+  # feature.rb => load_feature.inc
+  path = File.expand_path(file)
+  mk_builtin_header path
+}