rb-trace 0.2

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (C) 2010  Rocky Bernstein <rockyb@rubyforge.org>
+All rights reserved.
+ *
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ *
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/NEWS

@@ -0,0 +1,2 @@
+September 12 2010 (0.2)
+  First release on gemcutter

data/Rakefile

@@ -0,0 +1,121 @@
+#!/usr/bin/env rake
+# -*- Ruby -*-
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+SO_NAME = 'trace.so'
+
+PACKAGE_VERSION = open('ext/trace.c') do |f| 
+  f.grep(/^#define TRACE_VERSION/).first[/"(.+)"/,1]
+end
+
+EXT_FILES    = FileList[%w(ext/*.c ext/*.h)]
+LIB_FILES    = FileList['lib/*.rb']
+TEST_FILES   = FileList['test/**/*.rb']
+COMMON_FILES = FileList[%w(Rakefile NEWS LICENSE)]
+ALL_FILES    = COMMON_FILES + TEST_FILES + EXT_FILES + LIB_FILES
+
+desc "Create a GNU-style ChangeLog via git2cl"
+task :ChangeLog do
+  system("git log --pretty --numstat --summary | git2cl > ChangeLog")
+end
+
+desc 'Test units - the smaller tests'
+task :'test:unit' => [:ext] do |t|
+  Rake::TestTask.new(:'test:unit') do |t|
+    t.test_files = FileList['test/unit/**/*.rb']
+    # t.pattern = 'test/**/*test-*.rb' # instead of above
+    t.verbose = true
+  end
+end
+
+desc "Create the core ruby-debug shared library extension"
+task :ext do
+  Dir.chdir('ext') do
+    system("#{Gem.ruby} extconf.rb && make")
+  end
+end
+
+desc 'Remove built files'
+task :clean do
+  cd 'ext' do
+    if File.exist?('Makefile')
+      sh 'make clean'
+      rm  'Makefile'
+    end
+    derived_files = Dir.glob('.o') + Dir.glob('*.so')
+    rm derived_files unless derived_files.empty?
+  end
+end
+
+desc 'Test everything - unit tests for now.'
+task :test do
+  exceptions = ['test:unit'].collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      e
+    end
+  end.compact
+end
+
+desc "Test everything - same as test."
+task :check => :test
+task :default => [:test]
+
+# Base GEM Specification
+spec = Gem::Specification.new do |spec|
+  spec.name = "rb-trace"
+  
+  spec.homepage = "http://github.com/rocky/rb-trace/tree/master"
+  spec.summary = "Trace hook extensions"
+  spec.description = <<-EOF
+
+rb-trace adds a trace_hook object, translates hooks bitmasks to sets
+and vice versa, and extends set_trace_func to ignore frames or
+functions.
+EOF
+
+  spec.version = PACKAGE_VERSION
+  spec.extensions = ['ext/extconf.rb']
+
+  spec.author = "R. Bernstein"
+  spec.email = "rockyb@rubyforge.org"
+  spec.platform = Gem::Platform::RUBY
+  spec.files = ALL_FILES.to_a  
+  spec.add_dependency('rb-threadframe', '>= 0.32')
+
+  spec.required_ruby_version = '>= 1.9.2'
+  spec.date = Time.now
+  # spec.rubyforge_project = 'rocky-hacks'
+  
+  # rdoc
+  spec.has_rdoc = true
+  # spec.extra_rdoc_files = ['README', 'threadframe.rd']
+end
+
+# Rake task to build the default package
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end
+
+def install(spec, *opts)
+  args = ['gem', 'install', "pkg/#{spec.name}-#{spec.version}.gem"] + opts
+  system(*args)
+end
+
+desc 'Install locally'
+task :install => :package do
+  Dir.chdir(File::dirname(__FILE__)) do
+    # ri and rdoc take lots of time
+    install(spec, '--no-ri', '--no-rdoc')
+  end
+end    
+
+task :install_full => :package do
+  Dir.chdir(File::dirname(__FILE__)) do
+    install(spec)
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,8 @@
+require "mkmf"
+
+config_file = File.join(File.dirname(__FILE__), 'config_options')
+load config_file if File.exist?(config_file)
+
+# Temporary: to turn off optimization
+# $CFLAGS='-fno-strict-aliasing -g -fPIC'
+create_makefile("trace")

data/ext/thread_pthread.h

@@ -0,0 +1,24 @@
+/**********************************************************************
+
+  thread_pthread.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_THREAD_PTHREAD_H
+#define RUBY_THREAD_PTHREAD_H
+
+#include <pthread.h>
+typedef pthread_t rb_thread_id_t;
+typedef pthread_mutex_t rb_thread_lock_t;
+typedef pthread_cond_t rb_thread_cond_t;
+
+typedef struct native_thread_data_struct {
+    void *signal_thread_list;
+    pthread_cond_t sleep_cond;
+} native_thread_data_t;
+
+#endif /* RUBY_THREAD_PTHREAD_H */

data/ext/trace.c

@@ -0,0 +1,160 @@
+#include "vm_core_mini.h"  /* Pulls in ruby.h */
+
+/* What release we got? */
+#define TRACE_VERSION "0.2"  
+
+extern VALUE rb_cRubyVM;   /* RubyVM class */
+extern rb_vm_t *ruby_current_vm;
+extern VALUE rb_obj_is_proc(VALUE proc);
+
+VALUE rb_cTraceHook;       /* TraceHook class */
+VALUE rb_eTraceHookError;  /* Exception raised by TraceHook class */
+
+/* Extra information we need to save about a hook. 
+   FIXME: For now we will work only with vm hooks. When this
+   extends to thread hooks, we will need to use this.
+ */
+typedef struct 
+{
+  rb_thread_t *th;         /* If NULL, hook is in vm. Otherwise, this
+			      is the thread the hook belongs to. */
+  rb_event_hook_t *hook;
+} hook_info_t;
+
+static int is_hook_member(rb_event_hook_t *check_hook, rb_event_hook_t *hook);
+
+static void
+check_hook_valid(rb_event_hook_t *check_hook)
+{
+  /* FIXME: in the future use check_hook to find the hook head. */
+  rb_event_hook_t *hook_head = GET_VM()->event_hooks;
+  
+  if (!is_hook_member(check_hook, hook_head))
+    rb_raise(rb_eTraceHookError, "hook not found");
+}
+
+/* Return an Array of vm event hooks found from hook. */
+VALUE
+get_trace_hooks(rb_event_hook_t *hook)
+{
+    VALUE ary;
+    for (ary = rb_ary_new(); hook; hook = hook->next)
+	rb_ary_push(ary, Data_Wrap_Struct(rb_cTraceHook, NULL, NULL, hook));
+    return ary;
+}
+
+/* Return 1 if check_hook is found in the list of hooks pointed to by
+ 'hook', or 0 if not found. */
+static int 
+is_hook_member(rb_event_hook_t *check_hook, rb_event_hook_t *hook) 
+{
+    for (; hook; hook = hook->next) if (check_hook == hook) return 1;
+    return 0;  /* Not found */
+}
+
+/* Return an Array of VM event hooks objects. */
+VALUE
+trace_hook_s_trace_hooks()
+{
+  return get_trace_hooks(GET_VM()->event_hooks);
+}
+
+/*
+  Return the event mask value for a given hook. If no hook, then return nil.
+ */
+static VALUE
+trace_hook_event_mask(VALUE klass)
+{
+    rb_event_hook_t *hook;
+    Data_Get_Struct(klass, rb_event_hook_t, hook);
+    if (!hook) return Qnil;
+    check_hook_valid(hook);
+    return INT2FIX(hook->flag);
+}
+
+/* Set a new mask value for given hook and return the old mask
+   value. Can raise an error if there is no hook installed.  */
+static VALUE
+trace_hook_event_mask_set(VALUE klass, VALUE maskval)
+{
+    rb_event_hook_t *hook;
+    rb_event_flag_t flag;
+    Data_Get_Struct(klass, rb_event_hook_t, hook);
+    if (!hook) 
+	rb_raise(rb_eTraceHookError, "No hook installed");
+    if (!FIXNUM_P(maskval)) {
+	rb_raise(rb_eTypeError, "integer argument expected");
+    } 
+    check_hook_valid(hook);
+    flag = hook->flag;
+    hook->flag = FIX2INT(maskval);
+    return INT2FIX(flag);
+}
+
+/*
+  Return the event mask value for a given hook. If no hook, then return nil.
+ */
+static VALUE
+trace_hook_proc(VALUE klass)
+{
+    rb_event_hook_t *hook;
+    Data_Get_Struct(klass, rb_event_hook_t, hook);
+    if (!hook) return Qnil;
+    check_hook_valid(hook);
+    return hook->data;
+}
+
+/*
+  Return the event mask value for a given hook. If no hook, then return nil.
+ */
+static VALUE
+trace_hook_proc_set(VALUE klass, VALUE trace_proc)
+{
+    rb_event_hook_t *hook;
+    if (!rb_obj_is_proc(trace_proc)) {
+	rb_raise(rb_eTypeError, "trace_func needs to be Proc");
+    }
+
+    Data_Get_Struct(klass, rb_event_hook_t, hook);
+    if (!hook) return Qnil;
+    check_hook_valid(hook);
+    hook->data = trace_proc;
+    return trace_proc;
+}
+
+/*
+  Return true if hook is still valid or is nil), false otherwise.
+ */
+static VALUE
+trace_hook_valid(VALUE klass)
+{
+    rb_event_hook_t *hook;
+    Data_Get_Struct(klass, rb_event_hook_t, hook);
+    /* FIXME in the future we will need to extract whether this hook is
+       part of a thread or from the vm.
+    */
+    return is_hook_member(hook, GET_VM()->event_hooks) ? Qtrue : Qfalse;
+}
+
+void
+Init_trace(void)
+{
+  rb_eTraceHookError = rb_define_class_under(rb_cRubyVM, "TraceHookError",
+					     rb_eStandardError);
+  rb_cTraceHook      = rb_define_class_under(rb_cRubyVM, "TraceHook", 
+					     rb_cObject);
+
+  rb_define_singleton_method(rb_cTraceHook, "trace_hooks", 
+			     trace_hook_s_trace_hooks, 0);
+  
+  rb_define_method(rb_cTraceHook, "event_mask", 
+		   trace_hook_event_mask, 0);
+  rb_define_method(rb_cTraceHook, "event_mask=", 
+		   trace_hook_event_mask_set, 1);
+  rb_define_method(rb_cTraceHook, "proc", 
+		   trace_hook_proc, 0);
+  rb_define_method(rb_cTraceHook, "proc=", 
+		   trace_hook_proc_set, 1);
+  rb_define_method(rb_cTraceHook, "valid?", 
+		   trace_hook_valid, 0);
+}

data/ext/vm_core_mini.h

@@ -0,0 +1,133 @@
+/* Headers Exposing a little more of the 1.9 runtime and some 
+   method prototypes for extensions to the Thread class.
+*/
+#include <ruby.h>
+#include <signal.h>
+#include "thread_pthread.h"
+
+/* From vm_core.h: */
+
+#define GET_VM() ruby_current_vm
+#define GET_THREAD() ruby_current_thread
+
+#if 1
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    ptr = (type*)DATA_PTR(obj); \
+} while (0)
+#else
+#define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct(obj, type, ptr)
+#endif
+#if 1
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    ptr = (type*)DATA_PTR(obj); \
+} while (0)
+#else
+#define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct(obj, type, ptr)
+#endif
+
+/* Opaque types (for now at least) */
+typedef struct rb_iseq_struct rb_iseq_t;
+typedef struct rb_method_entry_struct rb_method_entry_t;
+typedef struct rb_proc_struct rb_proc_t;
+
+typedef struct {
+    VALUE *pc;			/* cfp[0] */
+    VALUE *sp;			/* cfp[1] */
+    VALUE *bp;			/* cfp[2] */
+    rb_iseq_t *iseq;		/* cfp[3] */
+    VALUE flag;			/* cfp[4] */
+    VALUE self;			/* cfp[5] / block[0] */
+    VALUE *lfp;			/* cfp[6] / block[1] */
+    VALUE *dfp;			/* cfp[7] / block[2] */
+    rb_iseq_t *block_iseq;	/* cfp[8] / block[3] */
+    VALUE proc;			/* cfp[9] / block[4] */
+    const rb_method_entry_t *me;/* cfp[10] */
+} rb_control_frame_t;
+
+enum ruby_special_exceptions {
+    ruby_error_reenter,
+    ruby_error_nomemory,
+    ruby_error_sysstack,
+    ruby_special_error_count
+};
+
+#define GetThreadPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_thread_t, ptr)
+
+#define GetProcPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_proc_t, ptr)
+
+#ifndef NSIG
+# define NSIG (_SIGMAX + 1)      /* For QNX */
+#endif
+
+#define RUBY_NSIG NSIG
+typedef struct rb_vm_struct {
+    VALUE self;
+
+    rb_thread_lock_t global_vm_lock;
+
+    struct rb_thread_struct *main_thread;
+    struct rb_thread_struct *running_thread;
+
+    st_table *living_threads;
+    VALUE thgroup_default;
+
+    int running;
+    int thread_abort_on_exception;
+    unsigned long trace_flag;
+    volatile int sleeper;
+
+    /* object management */
+    VALUE mark_object_ary;
+
+    VALUE special_exceptions[ruby_special_error_count];
+
+    /* load */
+    VALUE top_self;
+    VALUE load_path;
+    VALUE loaded_features;
+    struct st_table *loading_table;
+
+    /* signal */
+    struct {
+	VALUE cmd;
+	int safe;
+    } trap_list[RUBY_NSIG];
+
+    /* hook */
+    rb_event_hook_t *event_hooks;
+
+    int src_encoding_index;
+
+    VALUE verbose, debug, progname;
+    VALUE coverages;
+
+#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
+    struct rb_objspace *objspace;
+#endif
+} rb_vm_t;
+
+typedef struct rb_thread_struct
+{
+    VALUE self;
+    rb_vm_t *vm;
+
+    /* execution information */
+    VALUE *stack;		/* must free, must mark. rb: seems to be nil. */
+    unsigned long stack_size;   /* Number of stack (or rb_control_frame_t) entries */
+    rb_control_frame_t *cfp;
+
+    int safe_level;
+    int raised_flag;
+    VALUE last_status; /* $? */
+
+    /* passing state */
+    int state;
+
+    /* Lot's of other stuff ... */
+} rb_thread_t;
+
+extern rb_thread_t *ruby_current_thread;
+
+

data/lib/eventbuffer.rb

@@ -0,0 +1,172 @@
+module Trace
+
+  class EventBuffer
+    EventStruct = Struct.new(:event, :arg, :type, :thread, :method,
+                             :source_container, :source_location,
+                             :iseq, :pc_offset) unless defined?(EventStruct)
+    attr_reader   :buf
+    attr_accessor :marks    # User position mark into buffer. If buffer is limited,
+    attr_reader   :maxsize  # Maximum size of buffer or nil if unlimited.
+    attr_reader   :size     # size of buffer 
+    # then marks will drop out as they disappear from the buffer
+    def initialize(maxsize=nil)
+      @maxsize = maxsize
+      reset
+    end
+    
+    def reset
+      @buf   = []
+      @marks = []
+      @pos   = -1
+      @size  = 0 
+    end
+    
+    # Add a new event dropping off old events if that was declared
+    # marks are also dropped if buffer has a limit.
+    def append(event, frame, arg)
+      if 'c-return' == event 
+        arg = frame.sp(2)
+      elsif 'return' == event 
+        arg = frame.sp(1)
+      end
+        
+      iseq = frame.iseq
+      item = EventStruct.new(event, arg, frame.type, frame.thread, frame.method,
+                             frame.source_container, frame.source_location,
+                             iseq, iseq ? frame.pc_offset : nil)
+      @pos = self.succ_pos
+      @marks.shift if @marks[0] == @pos
+      @buf[@pos] = item
+      @size     += 1 unless @maxsize && @size == @maxsize
+    end
+
+    # Add mark for the current event buffer position.
+    def add_mark
+      @marks << @pos
+    end
+
+    # Like add mark, but do only if the last marked position has
+    # changed
+    def add_mark_nodup
+      @marks << @pos unless @marks[-1] == @pos
+    end
+    
+    def each(from=nil, to=nil)
+      from = self.succ_pos unless from
+      to   = @pos unless to
+      if from <= to
+        from.upto(to).each do |pos|
+          yield @buf[pos]
+        end
+      else
+        from.upto(@size-1).each do |pos|
+          yield @buf[pos]
+        end
+        0.upto(@pos).each do |pos|
+          yield @buf[pos]
+        end
+      end
+    end
+    
+    def each_with_index(from=nil, to=nil)
+      from = succ_pos unless from
+      to   = @pos     unless to
+      if from <= to
+        from.upto(to).each do |pos|
+          yield [@buf[pos], pos]
+        end
+      else
+        from.upto(@size-1).each do |pos|
+          yield [@buf[pos], pos]
+        end
+        0.upto(@pos).each do |pos|
+          yield [@buf[pos], pos]
+        end
+      end
+    end
+    
+    def format_entry(item, long_format=true)
+      # require 'rbdbgr'; Debugger.debug
+      container = 
+        if item.source_container[0] == 'file'
+          item.source_container[1].inspect
+        else
+          item.source_container.inspect
+        end
+      
+      location = 
+        if 1 == item.source_location.size 
+          item.source_location[0].inspect
+        else
+          item.source_location.inspect
+        end
+      
+      mess = "#{item.event} #{item.type} #{item.method} " + 
+        "#{container} #{location}"
+      if long_format && item.iseq
+        mess += "\n\t" + "VM offset #{item.pc_offset} of #{item.iseq.name}"
+      end
+      mess
+    end
+
+    # Return the next event buffer position taking into account
+    # that we may have a fixed-sized buffer ring.
+    def succ_pos(inc=1)
+      pos = @pos + inc 
+      @maxsize ? pos % @maxsize : pos 
+    end
+    
+    # Return the next event buffer position taking into account
+    # that we may have a fixed-sized buffer ring.
+    def pred_pos(dec=1)
+      pos = @pos - dec
+      @maxsize ? pos % @maxsize : pos 
+    end
+    
+    # Return the adjusted zeroth position in @buf.
+    def zero_pos
+      if !@maxsize || @buf.size < @maxsize
+        0
+      else 
+        self.succ_pos
+      end
+    end
+    
+  end # EventBuffer
+end # Trace 
+
+if __FILE__ == $0
+  def event_processor(event, frame, arg=nil)
+    begin 
+      @eventbuf.append(event, frame, arg)
+    rescue
+      p $!
+    end
+  end
+  def dump_all
+    puts '-' * 40
+    @eventbuf.each do |e| 
+      puts @eventbuf.format_entry(e) if e
+    end
+  end
+
+  require_relative 'trace'
+  @eventbuf = Trace::EventBuffer.new(5)
+  p @eventbuf.zero_pos
+  dump_all
+
+  trace_filter = Trace::Filter.new
+  trace_func   = method(:event_processor).to_proc
+  trace_filter << trace_func
+  trace_filter.set_trace_func(trace_func)
+  z=5
+  z.times do |i|
+    x = i
+    y = x+2
+  end
+  trace_filter.set_trace_func(nil)
+  p @eventbuf.buf[@eventbuf.zero_pos]
+  dump_all
+  @eventbuf.reset
+  dump_all
+end

data/lib/trace.rb

@@ -0,0 +1,3 @@
+require_relative 'trace_mod'
+require_relative 'tracefilter'
+require_relative 'eventbuffer'