rb-threadframe 0.36 → 0.37

data/NEWS

@@ -1,4 +1,9 @@
-December 25, 2010 (0.35)
+Feb 1, 2011 (0.37)
+ - 1.9.2 patches:
+   * Mark VM Instruction sequences for no garbage collection if they are
+     referred to by a ThreadFrame Object or are in ISEQS__ or ISEQ_SCRIPTS__
+
+December 25, 2010 (0.35, 0.36)
   - 1.9.2 patches:
    * Add new compile-option flags: save_tree_node and save_compile_opts
    * Start saving parse tree node. (More cases need to be done.)

data/ext/thread_frame.c

@@ -1,12 +1,12 @@
 /* 
- * Copyright (C) 2010 Rocky Bernstein
+ * Copyright (C) 2010, 2011 Rocky Bernstein
  *
  *  Access to Ruby's rb_control_frame_t and methods for working with that.
  *  Things like getting a binding for a control frame.
  */
 
 /* What release we got? */
-#define THREADFRAME_VERSION "0.36"
+#define THREADFRAME_VERSION "0.37"
 
 #include <string.h>
 #include "../include/vm_core_mini.h"   /* Pulls in ruby.h and node.h */
@@ -14,6 +14,51 @@
 #include "iseq_extra.h"
 #include "thread_extra.h"
 
+/* for GC debug */
+
+#ifndef RUBY_MARK_FREE_DEBUG
+#define RUBY_MARK_FREE_DEBUG 0
+#endif
+
+#if RUBY_MARK_FREE_DEBUG
+extern int ruby_gc_debug_indent;
+
+static void
+rb_gc_debug_indent(void)
+{
+    printf("%*s", ruby_gc_debug_indent, "");
+}
+
+static void
+rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
+{
+    if (st == 0) {
+	ruby_gc_debug_indent--;
+    }
+    rb_gc_debug_indent();
+    printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
+
+    if (st) {
+	ruby_gc_debug_indent++;
+    }
+
+    fflush(stdout);
+}
+
+#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", msg, 1, ptr)
+#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", msg, 0, ptr)
+#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", msg, 1, ptr)
+#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", msg, 0, ptr)
+#define RUBY_GC_INFO         rb_gc_debug_indent(); printf
+
+#else
+#define RUBY_MARK_ENTER(msg)
+#define RUBY_MARK_LEAVE(msg)
+#define RUBY_FREE_ENTER(msg)
+#define RUBY_FREE_LEAVE(msg)
+#define RUBY_GC_INFO if(0)printf
+#endif
+
 /* Frames can't be detached from the control frame they live in.
    So we create a structure to contain the pair. 
 
@@ -45,20 +90,51 @@ static int   thread_frame_stack_size_internal(rb_control_frame_t *cfp,
 static VALUE thread_frame_type(VALUE klass);
 
 
+extern void iseq_mark(void *ptr); /* in iseq.c */
+
+/* 
+  FIXME: I've never seen the following routine get called.
+  Why? 
+ */
+static void
+thread_frame_mark(void *ptr)
+{
+    RUBY_MARK_ENTER("thread_frame");
+    if (ptr) {
+	thread_frame_t *tf = ptr;
+	if (tf && tf->cfp && RUBY_VM_NORMAL_ISEQ_P(tf->cfp->iseq)) {
+	    iseq_mark(tf->cfp->iseq);
+	}
+    }
+}
+
+static void
+tf_free(void *ptr) 
+{
+    thread_frame_t *tf;
+    if (ptr) {
+	tf = ptr;
+	if (RUBY_VM_NORMAL_ISEQ_P(tf->cfp->iseq)) 
+	    tf->cfp->iseq->in_use--;
+	xfree(ptr);
+    }
+}
+
 /* 
    Allocate a RubyVM::ThreadFrame used by new. Less common than
-   thread_frame_t_alloc().
+   thread_frame_t_alloc(). The caller is responsible for filling in
+   the C struct data. Below we wrap NULL.
  */
 static VALUE
 thread_frame_alloc(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, NULL, xfree, 0);
+    return Data_Wrap_Struct(klass, thread_frame_mark, tf_free, NULL);
 }
 
 /* 
    Allocate a RubyVM::ThreadFrame and set its threadframe structure.
    This is the more common allocate routine since one normally doesn't
-   create a threadframe without <i>first</i> having seomthing to put in it.
+   create a threadframe without <i>first</i> having something to put in it.
  */
 static thread_frame_t *
 thread_frame_t_alloc(VALUE tfval)
@@ -69,6 +145,13 @@ thread_frame_t_alloc(VALUE tfval)
     return tf;
 }
 
+/* 
+   Check to see if tf is valid. +true+ is returned if we can't prove
+   the frame is invalide. +nil+ or +false+ is returned if something is not
+   right. In those cases where we don't know that we have a valid frame,
+   we also NULL out the cfp if that hasn't been done already. This will
+   keep garbage collection from marking bad data.
+ */
 static VALUE
 thread_frame_invalid_internal(thread_frame_t *tf)
 {
@@ -77,16 +160,24 @@ thread_frame_invalid_internal(thread_frame_t *tf)
     /* All valid frame types have 0x1 set so we will use this.
        Warning: this is an undocumented assumption which may someday
        be wrong. */
-    if ((tf->cfp->flag & 0x1) == 0) return Qtrue;
+    if (!tf->cfp) return Qtrue;
+    if ((tf->cfp->flag & 0x1) == 0) {
+	tf->cfp = NULL;
+	return Qtrue;
+    }
 
-    if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(tf->th, tf->cfp))
+    if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(tf->th, tf->cfp)) {
+	tf->cfp = NULL;
 	return Qtrue;
+    }
     if (RUBY_VM_NORMAL_ISEQ_P(tf->cfp->iseq)) {
 	cmp = (0 == memcmp(tf->signature1, &(tf->cfp->iseq), 
 			   sizeof(tf->signature1)) &&
 	       0 == memcmp(tf->signature2, &(tf->cfp->proc), 
 			   sizeof(tf->signature2)));
-	return cmp ? Qfalse : Qtrue;
+	if (cmp) return Qfalse;
+	tf->cfp = NULL;
+	return Qtrue;
     } else {
 	/* FIXME: figure out what to do here. Probably more work is
 	 * needed in thread_frame_prev_internal.
@@ -114,6 +205,7 @@ thread_frame_invalid_internal(thread_frame_t *tf)
 #define SAVE_FRAME(TF, TH)						\
     tf->th = TH;							\
     tf->cfp = thread_control_frame(tf->th);				\
+    tf->cfp->iseq->in_use++;						\
     COPY_SIGNATURE(tf, tf->cfp);					\
 
 #define GET_THREAD_PTR \
@@ -134,7 +226,7 @@ thread_frame_threadframe(VALUE thval)
     GET_THREAD_PTR;
     memset(tf, 0, sizeof(thread_frame_t));
     SAVE_FRAME(tf, th) ;
-    return Data_Wrap_Struct(rb_cThreadFrame, NULL, xfree, tf);
+    return Data_Wrap_Struct(rb_cThreadFrame, thread_frame_mark, tf_free, tf);
 }
 
 #define THREAD_FRAME_SETUP \
@@ -714,7 +806,7 @@ thread_frame_s_current(VALUE klass)
 {
     thread_frame_t *tf = thread_frame_t_alloc(klass);
     SAVE_FRAME(tf, ruby_current_thread) ;
-    return Data_Wrap_Struct(klass, NULL, xfree, tf);
+    return Data_Wrap_Struct(klass, thread_frame_mark, tf_free, tf);
 }
 
 /*

data/include/vm_core_mini.h

@@ -94,13 +94,13 @@ typedef struct rb_iseq_struct {
     /***************/
 
     VALUE type;          /* instruction sequence type */
-    VALUE name;          /* String: iseq name */
+    VALUE name;	         /* String: iseq name */
     VALUE filename;      /* file information where this sequence from */
     VALUE filepath;      /* real file path or nil */
     VALUE *iseq;         /* iseq (insn number and operands) */
     VALUE *iseq_encoded; /* encoded iseq */
     unsigned long iseq_size;
-    VALUE mark_ary;     /* Array: includes operands which should be GC marked */
+    VALUE mark_ary;	/* Array: includes operands which should be GC marked */
     VALUE coverage;     /* coverage array */
     unsigned short line_no;
 
@@ -108,7 +108,7 @@ typedef struct rb_iseq_struct {
     struct iseq_insn_info_entry *insn_info_table;
     size_t insn_info_size;
 
-    ID *local_table;            /* must free */
+    ID *local_table;		/* must free */
     int local_table_size;
 
     /* method, class frame: sizeof(vars) + 1, block frame: sizeof(vars) */
@@ -165,7 +165,7 @@ typedef struct rb_iseq_struct {
     /****************/
 
     VALUE self;
-    VALUE orig;                 /* non-NULL if its data have origin */
+    VALUE orig;			/* non-NULL if its data have origin */
 
     /* block inlining */
     /*
@@ -189,13 +189,17 @@ typedef struct rb_iseq_struct {
 
     /* If this instruction sequence came from eval, the string of the
        source as a String. */
-    VALUE source;
+    VALUE eval_source;
 
     /* If we are saving tree nodes (a compile option), then tree_node
        is the internal parse tree node representation for this
        instruction sequence.
     */
     NODE *tree_node;
+    int in_use;  /* Reference count of number of times and instruction
+		    sequence is in use such as via thread_frame object
+		    access or is stored in ISEQS__ or SCRIPT_ISEQS.
+		  */
 } rb_iseq_t;
 
 enum ruby_special_exceptions {
@@ -234,8 +238,8 @@ typedef struct rb_vm_struct {
 
     /* signal */
     struct {
-        VALUE cmd;
-        int safe;
+	VALUE cmd;
+	int safe;
     } trap_list[RUBY_NSIG];
 
     /* hook */
@@ -308,8 +312,8 @@ typedef struct rb_thread_struct
     rb_event_flag_t event_flags;
     int tracing;  /* 0 if not tracing. If less than 0, skip that many
                      C call/return pairs */
+
     int exec_event_tracing;  /* 0 if not in rb_threadptr_evec_event_hooks. */
-    int trace_skip_insn_count; /* # of VM instructions to skip */
 
     /* misc */
     int method_missing_reason;

data/test/ruby/test_brkpt.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+
+class TestISeqBrkpt < Test::Unit::TestCase
+
+  def setup
+    @original_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :trace_instruction => false,
+      :specialized_instruction => false
+    }
+  end
+
+  def teardown
+    set_trace_func(nil)
+    RubyVM::InstructionSequence.compile_option = @original_compile_option
+  end
+
+  def test_iseq_brkpt
+    iseq = RubyVM::InstructionSequence.compile('x=1; y=2')
+    assert iseq
+    assert_equal(nil, iseq.brkpts)
+    assert_equal(true, iseq.brkpt_alloc)
+    assert_equal([], iseq.brkpts)
+    assert_equal(false, iseq.brkpt_alloc)
+    
+    assert_equal(true, iseq.brkpt_set(0))
+    assert_equal(1,    iseq.brkpts.size)
+    assert_equal(true, iseq.brkpt_get(0), 'Offset 0 should be set')
+    assert_equal(true, iseq.brkpt_unset(0),'Offset 0 should be unset')
+    assert_equal(false, iseq.brkpt_get(0), 'Offset 0 should be unset now')
+    assert_equal(true, iseq.brkpt_unset(0), 
+                 'Offset 0 should be unset again')
+    assert_raises TypeError do iseq.brkpt_get(100) end
+    assert_equal(true, iseq.brkpt_dealloc)
+    assert_equal(false, iseq.brkpt_dealloc)
+    assert_equal(true, iseq.brkpt_unset(0),
+                 'Offset 0 should be unset even when deallocated')
+
+    assert_raises TypeError do iseq.brkpt_set('a') end
+
+    iseq.brkpt_set(2)    
+    iseq.brkpt_set(4)    
+    events = []
+    eval <<-EOF.gsub(/^.*?: /, "")
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   events << [event, lineno, mid, klass]
+     3: })
+     4: iseq.eval
+     5: set_trace_func(nil)
+    EOF
+    # puts iseq.disassemble
+    brkpt_events = events.select{|item| item[0] == 'brkpt'}
+    assert_equal(2, brkpt_events.size, 
+                 "Expecting to see 2 brkpts in #{events}.inspect")
+    assert_equal(true, iseq.brkpt_dealloc)
+  end
+end
+
+# We want to double-check we didn't mess up any pointers somewhere.
+at_exit { GC.start  }

data/test/ruby/test_disasm.rb

@@ -0,0 +1,17 @@
+# Some simple tests of RubyVM::InstructionSequence#disasm, and
+# #disasm_nochildren
+require 'test/unit'
+
+class TestDisasmClass < Test::Unit::TestCase
+
+  def test_basic
+    assert_equal(RubyVM::InstructionSequence.compile('1+2').disassemble,
+                 RubyVM::InstructionSequence.compile('1+2').disasm)
+
+    p='def five; 5 end; five'
+    s1=RubyVM::InstructionSequence.compile(p).disasm
+    assert_equal String, s1.class, 'disasm output should be a string'
+    s2=RubyVM::InstructionSequence.compile(p).disasm_nochildren
+    assert_equal true, s1.size > s2.size
+  end
+end

data/test/ruby/test_iseq.rb

@@ -0,0 +1,50 @@
+# See that setting ISEQS__ and SCRIPT_ISEQS__ saves 
+# RubyVM::Instruction_sequenses
+require 'test/unit'
+
+class TestIseqAccess < Test::Unit::TestCase
+  def setup
+    old_verbosity = $VERBOSE
+    $VERBOSE = nil
+    Kernel.const_set(:ISEQS__, {})
+    Kernel.const_set(:SCRIPT_ISEQS__, {})
+    $VERBOSE = old_verbosity
+  end
+
+  def teardown
+    old_verbosity = $VERBOSE
+    $VERBOSE = nil
+    Kernel.const_set(:ISEQS__, nil)
+    Kernel.const_set(:SCRIPT_ISEQS__, nil)
+    $VERBOSE = old_verbosity
+  end
+
+  def test_basic
+    sizes=[]
+    [ISEQS__, SCRIPT_ISEQS__].each do |iseq_hash|
+      sizes << iseq_hash.size
+    end
+    # defining five should trigger five instruction sequence additions
+    # to ISEQS__ and SCRIPT_ISEQS__
+    # 
+    eval 'def five; 5 end'
+    assert_equal sizes[0], sizes[1]
+    [SCRIPT_ISEQS__, ISEQS__].each do |iseq_hash|
+      assert_equal true, iseq_hash.size > sizes.pop
+      assert_equal Hash, iseq_hash.class
+      a = iseq_hash.first
+      assert_equal Array, a.class
+      assert_equal RubyVM::InstructionSequence, iseq_hash.values[0][0].class
+    end
+  end
+
+  # Check RubyVM::InstructionSequence#arity
+  def test_arity
+    eval 'def five; 5 end'
+    eval 'def add(a,b); a+b end'
+    eval 'def splat(*a); 5 end'
+    [['five', 0,], ['add', 2], ['splat', -1]].each do |meth, expect|
+      assert_equal(expect, ISEQS__[meth][0].arity)
+    end
+  end
+end

data/test/ruby/test_tracefunc_adds.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+
+# tests set_trace_func with event bitmasks, clear_trace_func, 
+# Newer changes
+class TestSetTraceFuncAdds < Test::Unit::TestCase
+
+  # Some of the below setup is similar to what is in lib/trace_mod.rb of 
+  # rb-trace
+  @@NO_EVENT_MASK        = 0x0000
+  @@LINE_EVENT_MASK      = 0x0001
+  @@CLASS_EVENT_MASK     = 0x0002
+  @@END_EVENT_MASK       = 0x0004
+  @@CALL_EVENT_MASK      = 0x0008
+  @@RETURN_EVENT_MASK    = 0x0010
+  @@C_CALL_EVENT_MASK    = 0x0020
+  @@C_RETURN_EVENT_MASK  = 0x0040
+  @@RAISE_EVENT_MASK     = 0x0080
+  @@INSN_EVENT_MASK      = 0x0100
+  @@ALL_EVENTS_MASK      = (0xffff & ~@@INSN_EVENT_MASK)
+  
+  @@EVENT2MASK = {
+    'line'     => @@LINE_EVENT_MASK,
+    'call'     => @@CALL_EVENT_MASK,
+    'return'   => @@RETURN_EVENT_MASK,
+    'c-call'   => @@C_CALL_EVENT_MASK,
+    'c-return' => @@C_RETURN_EVENT_MASK,
+    'c-raise'  => @@RAISE_EVENT_MASK
+  }
+
+  # Convert +events+ into a Fixnum bitmask used internally by Ruby.
+  # Parameter +events+ should be Enumerable and each element should
+  # either be a Fixnum mask value or something that can be converted
+  # to a symbol. If the latter, the case is not important as we'll
+  # downcase the string representation.
+  def events2bitmask(event_list)
+    bitmask = @@NO_EVENT_MASK
+    event_list.each do |event|
+      bitmask |= @@EVENT2MASK[event]
+    end
+    return bitmask
+  end
+
+  def setup
+    @original_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :trace_instruction => true,
+      :specialized_instruction => false
+    }
+    @proc_template = 'Proc.new { |event, file, lineno, mid, binding, klass|
+      %s << [event, lineno, mid, klass]}'
+  end
+
+  def teardown
+    clear_trace_func
+    RubyVM::InstructionSequence.compile_option = @original_compile_option
+  end
+
+  def test_eventmask
+    returned_tuples = 
+      [['line', 5, :test_eventmask, self.class],
+       ['class', 5, nil, nil],
+       ['end', 5, nil, nil],
+       ['line', 6, :test_eventmask, self.class],
+       ['call', 1, :five, self.class],
+       ['line', 1, :five, self.class],
+       ['return', 1, :five, self.class],
+       ['c-call', 6, :any?, Enumerable],
+       ['c-call', 6, :each, Array],
+       ['line', 6, :test_eventmask, self.class],
+       ['c-return', 6, :each, Array],
+       ['c-return', 6, :any?, Enumerable],
+       ['line', 7, :test_eventmask, self.class],
+       ['c-call', 7, :clear_trace_func, Kernel]]
+
+    [[], nil, 
+     %w(line),
+     %w(call line),
+     %w(c-call c-return line),
+    ].each do |event_list|
+      tuples = []
+      event_mask = if event_list
+                     events2bitmask(event_list)
+                   else
+                     @@ALL_EVENTS_MASK
+                   end
+      cmd = <<-EOF.gsub(/^.*?: /, '')
+        1: def five; 5 end
+        2: p1 = #{@proc_template}
+        3: set_trace_func(p1, #{event_mask})
+        4: class Foo; end
+        5: [1,2,five].any? {|n| n}
+        6: clear_trace_func
+      EOF
+      eval(cmd % 'tuples')
+      expected = if event_list
+                   returned_tuples.select{|x| !([x[0]] & event_list).empty?}
+                 else
+                   returned_tuples
+                 end
+      assert_equal(expected, tuples, 
+                   "Error filtering #{event_list}")
+     # p tuples
+    end
+  end
+
+  def test_chained_hook
+    tuples1 = []
+    tuples2 = []
+    cmd = <<-EOF.gsub(/^.*?: /, '')
+        1: def five; 5 end
+        2: p1 = #{@proc_template}
+        3: p2 = #{@proc_template}
+        4: add_trace_func(p1, @@LINE_EVENT_MASK)
+        5: add_trace_func(p2, @@CALL_EVENT_MASK)
+        6: class Foo; end
+        7: [1,2,five].any? {|n| n}
+      EOF
+    eval(cmd % %w(tuples1 tuples2))
+    clear_trace_func
+    assert_equal([
+                  ["line", 7, :test_chained_hook, self.class], 
+                  ["line", 8, :test_chained_hook, self.class], 
+                  ["line", 9, :test_chained_hook, self.class], 
+                  ["line", 1, :five, self.class], 
+                  ["line", 9, :test_chained_hook, self.class], 
+                 ], tuples1[0..-2],
+                 'line filtering')
+    assert_equal([["call", 1, :five, self.class]], tuples2, 
+                 'call filtering')
+  end
+
+  def test_trace_insn
+    tuples = []
+    cmd = <<-EOF.gsub(/^.*?: /, '')
+        1: p = #{@proc_template}
+        2: add_trace_func(p, @@INSN_EVENT_MASK)
+        4: x = 1
+        3: y = 2
+      EOF
+    eval cmd % 'tuples'
+    clear_trace_func
+    assert_equal true, !tuples.empty?, 'triggered instruction events'
+    assert_equal true, tuples.all?{|t| 'vm-insn' == t[0]}, 'instruction events'
+  end
+end

data/test/ruby/test_tracefunc_raise.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+# tests that we a trace hook has access to the runtime exception Object
+# when it is called through a raise event
+
+class TestTracefuncRaise < Test::Unit::TestCase
+
+  def test_basic
+    tuples = []
+    p = Proc.new { 
+      |event, file, lineno, mid, binding, klass|
+      tuples << klass
+    }
+    msg = 'this is a message'
+    set_trace_func(p, 0x0080)
+    begin ; x = 1/0; rescue; end
+    begin ; raise RuntimeError, msg; rescue; end
+    clear_trace_func
+    assert_equal(2, tuples.size, 
+                 "Wrong number of tuples captured #{tuples.inspect}")
+    assert_equal msg, tuples[1].message
+    assert_equal([ZeroDivisionError, RuntimeError], tuples.map{|t| t.class},
+                 "Mismatched tuples classes in #{tuples.inspect}")
+    
+  end
+end

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 36
-  version: "0.36"
+  - 37
+  version: "0.37"
 platform: ruby
 authors: 
 - R. Bernstein
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-25 00:00:00 -05:00
+date: 2011-02-01 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -33,42 +33,46 @@ files:
 - Makefile
 - LICENSE
 - NEWS
-- include/thread_pthread.h
 - include/node.h
-- include/method_mini.h
 - include/ruby19_externs.h
+- include/method_mini.h
+- include/thread_pthread.h
 - include/vm_core_mini.h
-- lib/iseq_extra.rb
 - lib/thread_frame.rb
+- lib/iseq_extra.rb
 - ext/iseq_extra.c
 - ext/thread_frame.c
-- ext/proc_extra.c
 - ext/thread_extra.c
-- ext/thread_frame.h
-- ext/proc_extra.h
-- ext/thread_pthread.h
-- ext/node.h
+- ext/proc_extra.c
 - ext/thread_extra.h
-- ext/iseq_extra.h
 - ext/iseq_mini.h
-- test/unit/test-trace.rb
+- ext/iseq_extra.h
+- ext/node.h
+- ext/thread_pthread.h
+- ext/proc_extra.h
+- test/ruby/test_tracefunc_adds.rb
+- test/ruby/test_brkpt.rb
+- test/ruby/test_disasm.rb
+- test/ruby/test_iseq.rb
+- test/ruby/test_tracefunc_raise.rb
+- test/unit/test-sp-size.rb
+- test/unit/test-iseq-brkpt.rb
 - test/unit/test-iseq-save.rb
+- test/unit/test-binding.rb
 - test/unit/test-prev.rb
-- test/unit/test-source.rb
 - test/unit/test-lib-iseq.rb
 - test/unit/test-return-stop.rb
-- test/unit/test-proc.rb
-- test/unit/test-invalid.rb
-- test/unit/test-argc.rb
+- test/unit/test-iseq.rb
 - test/unit/cfunc-use.rb
-- test/unit/test-binding.rb
+- test/unit/test-argc.rb
+- test/unit/test-invalid.rb
 - test/unit/test-lib-iseq-extra.rb
-- test/unit/test-thread.rb
-- test/unit/test-iseq-brkpt.rb
-- test/unit/test-iseq.rb
 - test/unit/test-thread-trace-masks.rb
+- test/unit/test-proc.rb
+- test/unit/test-thread.rb
 - test/unit/test-settracefunc.rb
-- test/unit/test-sp-size.rb
+- test/unit/test-trace.rb
+- test/unit/test-source.rb
 - threadframe.rd
 - ext/extconf.rb
 has_rdoc: true
@@ -80,7 +84,7 @@ rdoc_options:
 - --main
 - README.md
 - --title
-- ThreadFrame 0.36 Documentation
+- ThreadFrame 0.37 Documentation
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/ext/thread_frame.h

@@ -1,4 +0,0 @@
-VALUE thread_frame_sp(VALUE klass, VALUE index) ;
-VALUE thread_frame_prev(int argc, VALUE *argv, VALUE klass);
-
-