Expose methods for inspecting Micro JIT code blocks

This commit adds a module `UJIT`.  The module allows you to insert the
initial Micro JIT instruction in to an arbitrary iseq like this:

```ruby
def foo(x)
  if x < 1
    "less than one"
  else
    "something else"
  end
end

iseq = RubyVM::InstructionSequence.of(method(:foo))

UJIT.insert(iseq) # Add initial jump
```

After the initial jump is added, we can make Micro JIT do some work:

```ruby
100.times { foo(0) }
```

The `UJIT` module also exposes a method for finding all compiled blocks
for a given iseq, like this:

```ruby
blocks = UJIT.blocks_for(iseq)
```

We can sort the blocks by address and use the Crabstone gem (which is a
wrapper around `capstone`) to disassemble the generated code.

Here is the full code example:

```ruby
def foo(x)
  if x < 1
    "less than one"
  else
    "something else"
  end
end

iseq = RubyVM::InstructionSequence.of(method(:foo))

UJIT.insert(iseq) # Add initial jump

100.times { foo(0) }

blocks = UJIT.blocks_for(iseq)

 # brew install capstone
 # gem install crabstone
require "crabstone"

cs = Crabstone::Disassembler.new(Crabstone::ARCH_X86, Crabstone::MODE_64)

puts iseq.disasm

blocks.sort_by(&:address).reverse.each do |block|
  puts "== ISEQ RANGE: #{block.iseq_start_index} -> #{block.iseq_end_index} ".ljust(80, "=")
  cs.disasm(block.code, 0).each do |i|
    printf(
      "\t0x%<address>x:\t%<instruction>s\t%<details>s\n",
      address: i.address,
      instruction: i.mnemonic,
      details: i.op_str
    )
  end
end
```

Here is the output:

```
$ ./ruby test.rb
== disasm: #<ISeq:foo@test.rb:1 (1,0)-(7,3)> (catch: FALSE)
local table (size: 1, argc: 1 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1])
[ 1] x@0<Arg>
0000 getlocal_WC_0                          x@0                       (   2)[LiCa]
0002 putobject_INT2FIX_1_
0003 opt_lt                                 <calldata!mid:<, argc:1, ARGS_SIMPLE>
0005 branchunless                           10
0007 putstring                              "less than one"           (   3)[Li]
0009 leave                                                            (   7)[Re]
0010 putstring                              "something else"          (   5)[Li]
0012 leave                                                            (   7)[Re]
== ISEQ RANGE: 7 -> 7 ==========================================================
	0x0:	movabs	rax, 0x7fcd014cd518
	0xa:	mov	qword ptr [rdi], rax
	0xd:	mov	r8, rax
	0x10:	mov	r9, rax
	0x13:	mov	r11, r12
	0x16:	jmp	qword ptr [rax]
== ISEQ RANGE: 0 -> 7 ==========================================================
	0x0:	mov	rax, qword ptr [rdi + 0x20]
	0x4:	mov	rax, qword ptr [rax - 0x18]
	0x8:	mov	qword ptr [rdx], rax
	0xb:	mov	qword ptr [rdx + 8], 3
	0x13:	movabs	rax, 0x7fcd0180ac00
	0x1d:	test	byte ptr [rax + 0x3e6], 1
	0x24:	jne	0x3ffe0da
	0x2a:	test	byte ptr [rdx], 1
	0x2d:	je	0x3ffe0da
	0x33:	test	byte ptr [rdx + 8], 1
	0x37:	je	0x3ffe0da
	0x3d:	mov	rax, qword ptr [rdx]
	0x40:	cmp	rax, qword ptr [rdx + 8]
	0x44:	movabs	rax, 0
	0x4e:	movabs	rcx, 0x14
	0x58:	cmovl	rax, rcx
	0x5c:	mov	qword ptr [rdx], rax
	0x5f:	test	qword ptr [rdx], -9
	0x66:	je	0x3ffe111
	0x6c:	jmp	0xffffffffffffffa3
```

Author: tenderlove

common.mk

@@ -155,6 +155,7 @@ COMMONOBJS    = array.$(OBJEXT) \
 		ujit_core.$(OBJEXT) \
 		ujit_codegen.$(OBJEXT) \
 		ujit_iface.$(OBJEXT) \
+		ujit_ruby.$(OBJEXT) \
 		$(COROUTINE_OBJ) \
 		$(DTRACE_OBJ) \
 		$(BUILTIN_ENCOBJS) \

ujit_iface.c

@@ -288,6 +288,8 @@ rb_ujit_compile_iseq(const rb_iseq_t *iseq)
 #endif
 }
 
+void Init_ujit_ruby();
+
 void
 rb_ujit_init(void)
 {
@@ -300,6 +302,7 @@ rb_ujit_init(void)
 
     ujit_init_core();
     ujit_init_codegen();
+    Init_ujit_ruby();
 
     // Initialize the GC hooks
     method_lookup_dependency = st_init_numtable();

ujit_ruby.c

@@ -0,0 +1,111 @@
+#include <ruby.h>
+#include "vm_core.h"
+#include "ujit.h"
+#include "ujit_core.h"
+#include "iseq.h"
+
+extern st_table * version_tbl;
+extern codeblock_t *ocb;
+extern codeblock_t *cb;
+
+VALUE cUjitBlock;
+
+static const rb_data_type_t ujit_block_type = {
+    "UJIT/Block",
+    {0, 0, 0, },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+struct ujit_block_itr {
+    const rb_iseq_t *iseq;
+    VALUE list;
+};
+
+static int
+iseqw_ujit_collect_blocks(st_data_t key, st_data_t value, st_data_t argp)
+{
+    block_t * block = (block_t *)value;
+    struct ujit_block_itr * itr = (struct ujit_block_itr *)argp;
+
+    if (block->blockid.iseq == itr->iseq) {
+        VALUE rb_block = TypedData_Wrap_Struct(cUjitBlock, &ujit_block_type, block);
+        rb_ary_push(itr->list, rb_block);
+    }
+    return ST_CONTINUE;
+}
+
+/* Get a list of the UJIT blocks associated with `rb_iseq` */
+static VALUE
+ujit_blocks_for(VALUE mod, VALUE rb_iseq)
+{
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(rb_iseq);
+    st_table * vt = (st_table *)version_tbl;
+    struct ujit_block_itr itr;
+    itr.iseq = iseq;
+    itr.list = rb_ary_new();
+
+    rb_st_foreach(vt, iseqw_ujit_collect_blocks, (st_data_t)&itr);
+
+    return itr.list;
+}
+
+static VALUE
+ujit_insert(VALUE mod, VALUE iseq)
+{
+    rb_ujit_compile_iseq(rb_iseqw_to_iseq(iseq));
+    return iseq;
+}
+
+/* Get the address of the UJIT::Block */
+static VALUE
+block_address(VALUE self)
+{
+    block_t * block;
+    TypedData_Get_Struct(self, block_t, &ujit_block_type, block);
+    return LONG2NUM((intptr_t)block);
+}
+
+/* Get the machine code for UJIT::Block as a binary string */
+static VALUE
+block_code(VALUE self)
+{
+    block_t * block;
+    TypedData_Get_Struct(self, block_t, &ujit_block_type, block);
+
+    return rb_str_new(cb->mem_block + block->start_pos, block->end_pos - block->start_pos);
+}
+
+/* Get the start index in the Instruction Sequence that corresponds to this
+ * UJIT::Block */
+static VALUE
+iseq_start_index(VALUE self)
+{
+    block_t * block;
+    TypedData_Get_Struct(self, block_t, &ujit_block_type, block);
+
+    return INT2NUM(block->blockid.idx);
+}
+
+/* Get the end index in the Instruction Sequence that corresponds to this
+ * UJIT::Block */
+static VALUE
+iseq_end_index(VALUE self)
+{
+    block_t * block;
+    TypedData_Get_Struct(self, block_t, &ujit_block_type, block);
+
+    return INT2NUM(block->end_idx);
+}
+
+void Init_ujit_ruby(void)
+{
+    VALUE mUjit = rb_define_module("UJIT");
+    rb_define_module_function(mUjit, "insert", ujit_insert, 1);
+    rb_define_module_function(mUjit, "blocks_for", ujit_blocks_for, 1);
+
+    cUjitBlock = rb_define_class_under(mUjit, "Block", rb_cObject);
+    rb_define_method(cUjitBlock, "address", block_address, 0);
+    rb_define_method(cUjitBlock, "code", block_code, 0);
+    rb_define_method(cUjitBlock, "iseq_start_index", iseq_start_index, 0);
+    rb_define_method(cUjitBlock, "iseq_end_index", iseq_end_index, 0);
+}