wilson 1.0.1 → 1.1.0

data.tar.gz.sig

@@ -1,2 +1,4 @@
-c:�gfL���nr��U5�!
-�����7�-�g*�[����"���Wg���m�]�F�����/���v��]O6�%;�+���Σ=�HD��Dh`I��SA#�6�ҥBA�ѧ|R��_I6�sr��P�S���:�v�ϕi�K".�P2|2��xҪ���<�]��e�9�������P��n���SQw9�-S����w�~7�_�!R]sK.�#��ۭ��\��KK�$�3�X��7E:����%.B��`
+�@���s�C;�n(Oـ��5�|��n���SNB���NKD��"d��w�ϑ�r���9�*��a���}�+
+
+��ܟ<�wU
+KyԆ�P?oҖ�<��s-nE���j�[u��̝x�t-����QK4
1�-��M2O'd;�&d`�w=�z��x�,Y~��y��������>�� �}s �N!�v�ń�sy����NT$V�Q��[��Z��w��

data/History.txt

@@ -1,3 +1,24 @@
+=== 1.1.0 / 2009-05-08
+
+* 1 major enhancement:
+
+  * Added Object#asm for inline assembly. 100% ruby, no C.
+
+* 7 minor enhancements:
+
+  * Added arg(n) for cleanly accessing ruby arguments.
+  * Added debugging output if $DEBUG.
+  * Added defasm and asm test cases.
+  * Added from_ruby and sped up to_ruby a teeny amount.
+  * Improved benchmark code
+  * Refactored ASM DSL to Object#assemble.
+  * Sped up tests a fair amount by optimizing supportsProcessor.
+
+* 2 bug fixes:
+
+  * Found a bug in the nasm manual that wilson parses. Fixed SAR.
+  * Found a bug in the nasm manual that wilson parses. Fixed cmp.
+
 === 1.0.1 / 2009-04-22
 
 * 3 minor enhancements:

data/README.txt

@@ -13,18 +13,35 @@ is about as metal as you can get (and it is easier to spell than
 
 == FEATURES/PROBLEMS:
 
-* Generates x86 machine code directly, with no dependencies.
-* Still has problems with jumps, I need smart ppl to help me.
+* Generates x86 machine code directly. No dependencies. No system calls.
+* Registers ruby methods with #defasm, or run inline assembly with #asm.
+* Terrible, yet, awesome.
 
 == SYNOPSIS:
 
   class X
     defasm :superfast_meaning_of_life do
-      eax.mov 42.r                  # (42 << 1) + 1
+      eax.mov 42
+      to_ruby eax # ruby fixnums = (n << 1) + 1
+    end
+
+    def inline_asm_example
+      n = 1000
+  
+      asm :count_to_n do
+        eax.xor eax
+        count = self.label
+        eax.inc
+        eax.cmp n
+        jne count
+  
+        to_ruby eax
+      end
     end
   end
   
   p X.new.superfast_meaning_of_life # => 42
+  p X.new.inline_asm_example        # => 1000
 
 == REQUIREMENTS:
 
@@ -38,7 +55,7 @@ is about as metal as you can get (and it is easier to spell than
 
 (The MIT License)
 
-Copyright (c) 2008 Ryan Davis, Seattle.rb
+Copyright (c) 2008-2009 Ryan Davis, Seattle.rb
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems'
 require 'hoe'
 require './lib/wilson.rb'
 
-Hoe.new('wilson', Wilson::VERSION) do |p|
+h = Hoe.new('wilson', Wilson::VERSION) do |p|
   p.rubyforge_name = 'seattlerb'
   p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
 end
@@ -12,7 +12,7 @@ end
 namespace :test do
   desc "profiles your tests"
   task :prof do
-    send(*h.test_cmd(:zenprofile))
+    ruby "-S zenprofile #{h.make_test_cmd}"
   end
 end
 

data/bench.rb

@@ -2,14 +2,31 @@
 
 # % rm -r ~/.ruby_inline; ./bench.rb 1_000_000 1_000
 # # of iterations = 1000000
+# $n = 1000
+#
 #                           user     system      total        real
-# null_time             0.130000   0.000000   0.130000 (  0.123534)
-# c-nil                 0.280000   0.000000   0.280000 (  0.284030)
-# asm-nil               0.270000   0.000000   0.270000 (  0.278700)
-# c                     0.830000   0.010000   0.840000 (  0.841285)
-# asm2                  0.840000   0.000000   0.840000 (  0.842834)
-# asm                   3.510000   0.010000   3.520000 (  3.543986)
-# ruby                 89.790000   0.200000  89.990000 ( 90.653678)
+# null_time             0.120000   0.000000   0.120000 (  0.122507)
+# cee_nil               0.280000   0.000000   0.280000 (  0.279552)
+# asm_nil               0.280000   0.000000   0.280000 (  0.275498)
+# ruby_nil              0.370000   0.000000   0.370000 (  0.372142)
+# cee                   0.830000   0.010000   0.840000 (  0.837607)
+# asm2                  0.830000   0.000000   0.830000 (  0.839430)
+# asm                   3.520000   0.000000   3.520000 (  3.542521)
+# ruby                 98.970000   0.430000  99.400000 (101.903256)
+#
+# % rm -r ~/.ruby_inline; ./bench.rb 10_000_000 100
+# # of iterations = 10000000
+# $n = 100
+#
+#                           user     system      total        real
+# null_time             1.220000   0.000000   1.220000 (  1.243087)
+# cee_nil               2.780000   0.010000   2.790000 (  2.825447)
+# asm_nil               2.760000   0.010000   2.770000 (  2.770936)
+# ruby_nil              3.710000   0.000000   3.710000 (  3.735188)
+# cee                   3.560000   0.010000   3.570000 (  3.581262)
+# asm2                  3.450000   0.010000   3.460000 (  3.481769)
+# asm                   5.990000   0.010000   6.000000 (  6.042270)
+# ruby                 95.460000   0.300000  95.760000 ( 96.578792)
 
 $: << 'lib'
 require 'wilson'
@@ -18,96 +35,74 @@ require 'inline'
 require 'benchmark'
 
 max = (ARGV.shift || 10_000_000).to_i
-$n  = (ARGV.shift || 10).to_i
+n   = (ARGV.shift || 100).to_i
 
 class Counter
   inline do |builder|
     builder.c "VALUE cee_nil() { return Qnil;}"
-    builder.c "long cee() { long i; for (i = 0;i<#{$n};i++) {}; return i;}"
+    builder.c "long cee(int n) { long i; for (i = 0;i<n+1;i++) {}; return i;}"
   end
 
-  # 00000f7a  pushl %ebp
-  # 00000f7b  xorl  %eax,%eax
-  # 00000f7d  movl  %esp,%ebp
-  # 00000f7f  incl  %eax
-  # 00000f80  cmpl  $0x000003e8,%eax
-  # 00000f85  jne 0x00000f7f
-  # 00000f87  leave
-  # 00000f88  movw  $0x07d1,%ax
-  # 00000f8c  ret
-
   defasm :asm_nil do
     eax.mov 4
   end
 
-  defasm :asm do
-    eax.mov 0
-    ecx.mov $n
+  defasm :asm, :n do # naive version
+    eax.xor eax
+
+    ecx.mov arg(0)
+    from_ruby ecx
+    ecx.inc
+
     count = self.label
-    eax.add 1
+    eax.inc
     count.loop
 
-    eax.add eax # fixnum: n + n + 1
-    eax.inc
+    to_ruby eax
   end
 
-  # 00000000  55                push ebp
-  # 00000001  89E5              mov ebp,esp
-  # 00000003  56                push esi
-  # 00000004  57                push edi
-  # 00000005  B800000000        mov eax,0x0
-  # 0000000A  B910270000        mov ecx,0x2710
-  # 0000000F  83C001            add eax,byte +0x1
-  # 00000012  E2FB              loop 0xf
-  # 00000014  01C0              add eax,eax
-  # 00000016  40                inc eax
-  # 00000017  5F                pop edi
-  # 00000018  5E                pop esi
-  # 00000019  C9                leave
-  # 0000001A  C3                ret
-
-  defasm :asm2 do
-    eax.mov 0
+  defasm :asm2, :n do
+    eax.xor eax
+
+    edx.mov arg(0)
+    from_ruby edx
+    edx.inc
+
     count = self.label
     eax.inc
-    eax.cmp $n
-    jne count
+    eax.cmp edx
+    jnz count
 
-    eax.add eax # fixnum: n + n + 1
-    eax.inc
+    to_ruby eax
   end
 
-  # 00000000  55                push ebp
-  # 00000001  89E5              mov ebp,esp
-  # 00000003  B800000000        mov eax,0x0
-  # 00000008  40                inc eax
-  # 00000009  3DE8030000        cmp eax,0x3e8
-  # 0000000E  75F8              jnz 0x8
-  # 00000010  01C0              add eax,eax
-  # 00000012  40                inc eax
-  # 00000013  C9                leave
-  # 00000014  C3                ret
-
   def ruby_nil
     nil
   end
 
-  def ruby
-    $n.times do; end
+  def ruby n
+    (n+1).times do; end
   end
 end
 
 counter = Counter.new
 
-raise "bad c_nil"   unless counter.cee_nil.nil?
-raise "bad asm_nil" unless counter.asm_nil.nil?
-raise "bad c"       unless counter.cee  == $n
-raise "bad asm2"    unless counter.asm2 == $n
-raise "bad asm"     unless counter.asm  == $n
-raise "bad ruby"    unless counter.ruby == $n
+%w(cee_nil asm_nil ruby_nil).each do |name|
+  eval "abort 'bad #{name}' unless counter.#{name}.nil? "
+end
+
+%w(cee asm2 asm ruby).each do |name|
+  eval "
+    x = counter.#{name}(n)
+    warn \"%5s = %4d\" % [name, x] if $DEBUG
+    abort 'bad #{name}' unless x == n + 1
+  "
+end
+
+exit 0 if $DEBUG
 
 puts "# of iterations = #{max}"
-puts "$n = #{$n}"
+puts "n = #{n}"
 puts
 Benchmark::bm(20) do |x|
   x.report("null_time") do
@@ -116,7 +111,7 @@ Benchmark::bm(20) do |x|
     end
   end
 
-  %w(cee_nil asm_nil ruby_nil cee asm2 asm ruby).each do |name|
+  %w(cee_nil asm_nil ruby_nil).each do |name|
     eval "
       x.report(#{name.inspect}) do
         for i in 0..max do
@@ -125,4 +120,16 @@ Benchmark::bm(20) do |x|
       end
     "
   end
+
+  funcs = %w(cee asm2 asm)
+  funcs << 'ruby' if ENV['PAIN']
+  funcs.each do |name|
+    eval "
+      x.report(#{name.inspect}) do
+        for i in 0..max do
+          counter.#{name}(n)
+        end
+      end
+    "
+  end
 end

data/lib/wilson.rb

@@ -3,80 +3,6 @@
 require 'dl'
 require 'dl/import'
 
-module Ruby
-  extend DL::Importable
-
-  typealias "VALUE", "unsigned long", proc { |v| v.object_id << 1 }
-
-  dlload "libruby.dylib"
-
-  extern "void rb_define_method(VALUE, char*, void*, int)"
-end
-
-class Object
-  def r
-    self.object_id
-  end
-end
-
-class Integer
-  def r
-    (self.object_id << 1) + 1
-  end
-
-  def inspect
-    "0x#{to_s 16}"
-  end
-end
-
-ASM = []
-
-class Module
-  def defasm name, *args, &block
-    asm = Wilson::MachineCodeX86.new
-
-    asm.ebp.push
-    asm.ebp.mov asm.esp
-
-    asm.esi.push
-    asm.edi.push
-
-    size = asm.stream.size
-
-    asm.instance_eval(&block)
-
-    if asm.stream.size == size  # return nil
-      warn "returning nil for #{self}##{name}"
-      asm.eax.mov 4
-    end
-
-    asm.edi.pop
-    asm.esi.pop
-
-    asm.leave
-    asm.ret
-
-    code = asm.stream.pack("C*")
-
-    if $DEBUG then
-      path = "#{name}.obj"
-      File.open path, "wb" do |f|
-        f.write code
-      end
-
-      p name
-      puts code.unpack("C*").map { |n| "%02X" % n }.join(' ')
-      system "ndisasm -u #{path}"
-
-      File.unlink path
-    end
-
-    ptr  = code.to_ptr
-    ASM << ptr
-    Ruby.rb_define_method self, name.to_s, ptr, 0
-  end
-end
-
 class Object
   def subclass_responsibility; raise "subclass responsibility" end
   def no!; false end
@@ -92,38 +18,20 @@ class Object
   alias :special_register? :no!
 end
 
-class Integer
-  def m
-    address = Wilson::Address.new
-    address.offset = self
-    address
-  end
-
-  def immediate_value?
-    true
-  end
-end
-
-class Array
-  def second
-    self[1]
-  end
-
-  def push_D integer
-    self.push(*[integer].pack("V").unpack("C4"))
-  end
-
-  def push_B integer
-    self << (integer & 255)
-  end
-
-  def push_W integer
-    self.push((integer & 255), (integer >> 8 & 255))
-  end
-end
+##
+# Wilson is a pure ruby x86 assembler. No, really. Worst Idea Evar.
+#
+# Why "wilson"? I wanted to name it "metal", but there is an existing
+# project with that name... So I'm naming it after Wilson Bilkovich, who
+# is about as metal as you can get (and it is easier to spell than
+# "bilkovich", even tho that sounds more metal).
+#
+# Wilson is a port (and extension) of the smalltalk x86 assembler by
+# Michael Lucas-Smith. I came across it when he presented it at
+# Smalltalk SuperPowers at OOPSLA 2008.
 
 module Wilson
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 
   ##
   # Assembler parses the NASM documentation and creates Command
@@ -156,6 +64,11 @@ module Wilson
        FMULTO fpureg  ; DC C8+r              [8086,FPU]
        FSUBTO fpureg  ; DC E8+r              [8086,FPU]
        FSUBRTO fpureg ; DC E0+r              [8086,FPU]
+
+       CMP r/m16,imm8 ; o16 83 /7 ib         [8086]
+       CMP r/m32,imm8 ; o32 83 /7 ib         [386]
+       SAR r/m16,1    ; o16 D1 /7            [8086]
+       SAR r/m32,1    ; o32 D1 /7            [386]
       '
     end
 
@@ -263,6 +176,7 @@ module Wilson
       (self.class.nasm + self.class.nasm_fixes).each_line do |line|
         self.process_line line.strip.sub(/^# /, '')
       end
+
       self
     end
   end
@@ -622,13 +536,15 @@ module Wilson
     end
 
     def supportsProcessor instructionProcessors
-      processors.any? { |e| instructionProcessors.include? e }
+      # TODO: can still be improved. hashes, caching... something
+      ! (processors & instructionProcessors).empty?
     end
 
     def instructions
       self.cachedInstructions ||= @instructions.select { |e|
         self.supportsProcessor e.processors
       }
+      self.cachedInstructions
     end
 
     def method_missing msg, *args
@@ -863,10 +779,18 @@ module Wilson
       self.edi = Register.on_id_bits self, 7, 32
     end
 
+    def arg n
+      ebp + (n+3) * 4
+    end
+
     def to_ruby reg
-      reg.add reg
+      reg.shl 1
       reg.inc
     end
+
+    def from_ruby reg
+      reg.shr 1
+    end
   end
 
   ##
@@ -1201,6 +1125,114 @@ module Wilson
   end
 end # module Wilson
 
+module Ruby
+  extend DL::Importable
+
+  typealias "VALUE", "unsigned long", proc { |v| v.object_id << 1 }
+
+  dlload "libruby.dylib"
+
+  extern "void rb_define_method(VALUE, char*, void*, int)"
+end
+
+class Integer
+  def m
+    address = Wilson::Address.new
+    address.offset = self
+    address
+  end
+
+  def immediate_value?
+    true
+  end
+
+  def inspect
+    "0x#{to_s 16}"
+  end if $DEBUG
+end
+
+class Array
+  def second
+    self[1]
+  end
+
+  def push_D integer
+    self.push(*[integer].pack("V").unpack("C4"))
+  end
+
+  def push_B integer
+    self << (integer & 255)
+  end
+
+  def push_W integer
+    self.push((integer & 255), (integer >> 8 & 255))
+  end
+end
+
+ASM = []
+
+class Module
+  def defasm name, *args, &block
+    code = assemble(args.size, &block)
+    ptr  = code.to_ptr
+
+    ASM << ptr
+    Ruby.rb_define_method self, name.to_s, ptr, args.size
+  end
+end
+
+class Object
+  def assemble arg_count = 0, &block
+    asm = Wilson::MachineCodeX86.new
+
+    # TODO: enter?
+    asm.ebp.push
+    asm.ebp.mov asm.esp
+
+    size = asm.stream.size
+
+    asm.instance_eval(&block)
+
+    if asm.stream.size == size  # return nil
+      warn "returning nil for #{self}##{name}"
+      asm.eax.mov 4
+    end
+
+    asm.leave
+    asm.ret
+
+    code = asm.stream.pack("C*")
+
+    if $DEBUG then
+      path = "#{$$}.obj"
+      File.open path, "wb" do |f|
+        f.write code
+      end
+
+      puts code.unpack("C*").map { |n| "%02X" % n }.join(' ')
+      system "ndisasm -u #{path}"
+
+      File.unlink path
+    end
+
+    code
+  end
+
+  @@asm = {}
+  def asm(name, *args, &block)
+    code = @@asm[name] ||= assemble(&block).to_ptr
+
+    return execute_asm(code) # code is the function pointer, wrapped
+  end
+
+  defasm :execute_asm, :code do
+    eax.mov ebp + 0x0c # grab code
+    eax.mov eax + 0x10 # unwrap function pointer field
+    eax.mov eax.m      # dereference the pointer
+    eax.call           # call the function pointer
+  end
+end
+
 __END__
 
 #   The Netwide Assembler: NASM
@@ -1861,8 +1893,8 @@ __END__
 # CMP r/m16,imm16               ; o16 81 /0 iw         [8086]
 # CMP r/m32,imm32               ; o32 81 /0 id         [386]
 
-# CMP r/m16,imm8                ; o16 83 /0 ib         [8086]
-# CMP r/m32,imm8                ; o32 83 /0 ib         [386]
+# DEADCMP r/m16,imm8                ; o16 83 /0 ib         [8086]
+# DEADCMP r/m32,imm8                ; o32 83 /0 ib         [386]
 
 # CMP AL,imm8                   ; 3C ib                [8086]
 # CMP AX,imm16                  ; o16 3D iw            [8086]
@@ -4222,10 +4254,10 @@ __END__
 # SAR r/m8,1                    ; D0 /0                [8086]
 # SAR r/m8,CL                   ; D2 /0                [8086]
 # SAR r/m8,imm8                 ; C0 /0 ib             [286]
-# SAR r/m16,1                   ; o16 D1 /0            [8086]
+# xxSAR r/m16,1                   ; o16 D1 /0            [8086]
 # SAR r/m16,CL                  ; o16 D3 /0            [8086]
 # SAR r/m16,imm8                ; o16 C1 /0 ib         [286]
-# SAR r/m32,1                   ; o32 D1 /0            [386]
+# xxSAR r/m32,1                   ; o32 D1 /0            [386]
 # SAR r/m32,CL                  ; o32 D3 /0            [386]
 # SAR r/m32,imm8                ; o32 C1 /0 ib         [386]
 

data/test/test_wilson.rb

@@ -2,6 +2,22 @@
 require 'test/unit'
 require 'wilson'
 
+class X
+  def counter
+    n = 1000
+
+    asm :count_to_n do
+      eax.mov 0
+      count = self.label
+      eax.inc
+      eax.cmp n
+      jne count
+
+      to_ruby eax
+    end
+  end
+end
+
 class TestWilson < Test::Unit::TestCase
   # MachineCodeX86Test initialize-release
 
@@ -12,6 +28,27 @@ class TestWilson < Test::Unit::TestCase
 
   attr_reader :asm, :stream
 
+  defasm :passthrough, :n do
+    eax.mov arg(0) # add n as-is
+  end
+
+  defasm :add_to_n, :n do
+    eax.mov arg(0) # set eax to n
+    eax.add 2      # increment ruby fixnum directly
+  end
+
+  def test_wtf_inline!
+    assert_equal 1000, X.new.counter
+  end
+
+  def test_wtf1?
+    assert_equal 42, add_to_n(41)
+  end
+
+  def test_wtf2?
+    assert_equal 42, passthrough(42)
+  end
+
   # MachineCodeX86Test testing ow/od
 
   def test_mov_offset_eax

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wilson
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -30,7 +30,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2009-04-22 00:00:00 -07:00
+date: 2009-05-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency