rubinius-compiler 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a7ac1dad2806e3f305644c39c04c4ab7d0aa555
-  data.tar.gz: 9d0c78323f44d2dac51f8dde07f68a815c2a3acb
+  metadata.gz: 520dd233806924fc5d79d893d64d43bfc4179ffa
+  data.tar.gz: 1f6b7965fe802a7b8d0f16d58035f5734877f390
 SHA512:
-  metadata.gz: 758b02254a3a25084d3113442cec77c429029856d738970e0b30d61ef2a20c11345f8c177786c474da0e75e1524d16281c18ff76618395c383acddb270fd48fc
-  data.tar.gz: d62f54cb062a567d968761b23bd1bff4987276eaa698e8171406bcafb07cadc1b5ddb487376356ce4d86da18f228b12b2bc7fd4ef1676cea82633ebfb10fcb4e
+  metadata.gz: e6fa695fa6721b0b5f777493704fb2b591e862344b432a1e636e9a5383d940fe9261759d17e17fea6cccc7d21095799e6cc8c542c7403e5c73f18aa6cbae97e5
+  data.tar.gz: be746f644ce2a57d16f471c960e4b117f7bd855cd0bb6cb46b79800e2b0d69df1d7e92421a71819e52f72a915faa41291239511a1916f57340833a30cf65a32e

data/lib/rubinius/compiler/compiled_file.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module CodeTools
+module Rubinius::ToolSet.current::TS
   ##
   # A decode for the .rbc file format.
 
@@ -140,10 +140,8 @@ module CodeTools
           str.force_encoding enc if enc and defined?(Encoding)
           return str
         when 120 # ?x
-          enc = unmarshal_data
           count = next_string.to_i
           str = next_bytes count
-          str.force_encoding enc if enc and defined?(Encoding)
           return str.to_sym
         when 99  # ?c
           count = next_string.to_i
@@ -184,6 +182,7 @@ module CodeTools
           code.stack_size    = unmarshal_data
           code.local_count   = unmarshal_data
           code.required_args = unmarshal_data
+          code.post_args     = unmarshal_data
           code.total_args    = unmarshal_data
           code.splat         = unmarshal_data
           code.literals      = unmarshal_data
@@ -251,10 +250,21 @@ module CodeTools
         when Fixnum, Bignum
           "I\n#{val.to_s(16)}\n"
         when String
-          "s\n#{val.size}\n#{val}\n"
+          if defined?(Encoding)
+            # We manually construct the Encoding data to avoid recursion
+            # marshaling an Encoding name as a String.
+            name = val.encoding.name
+            enc_name = "E\n#{name.bytesize}\n#{name}\n"
+          else
+            # The kernel code is all US-ASCII. When building melbourne for 1.8
+            # Ruby, we fake a bunch of encoding stuff so force US-ASCII here.
+            enc_name = "E\n8\nUS-ASCII\n"
+          end
+
+          "s\n#{enc_name}#{val.bytesize}\n#{val}\n"
         when Symbol
           s = val.to_s
-          "x\n#{s.size}\n#{s}\n"
+          "x\n#{s.bytesize}\n#{s}\n"
         when Rubinius::Tuple
           str = "p\n#{val.size}\n"
           val.each do |ele|
@@ -292,9 +302,9 @@ module CodeTools
           str.append marshal(val.stack_size)
           str.append marshal(val.local_count)
           str.append marshal(val.required_args)
+          str.append marshal(val.post_args)
           str.append marshal(val.total_args)
           str.append marshal(val.splat)
-          str.append marshal(val.arity)
           str.append marshal(val.literals)
           str.append marshal(val.lines)
           str.append marshal(val.file)

data/lib/rubinius/compiler/compiler.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module CodeTools
+module Rubinius::ToolSet.current::TS
 
   class CompileError < RuntimeError
   end
@@ -27,7 +27,7 @@ module CodeTools
       end
     else
       def self.compiled_cache_writable?(db, dir)
-        File.writable?(db) or File.writable?(dir)
+        File.owned?(db) or File.owned?(dir)
       end
 
       def self.compiled_name(file)
@@ -51,6 +51,8 @@ module CodeTools
           dir = Rubinius::OS_STARTUP_DIR
           db = "#{dir}/.rbx"
           unless name.prefix?(dir) and compiled_cache_writable?(db, dir)
+            # Yes, this retarded shit is necessary because people actually
+            # run under fucked environments with no HOME set.
             return unless ENV["HOME"]
 
             dir = File.expand_path "~/"
@@ -346,19 +348,6 @@ module CodeTools
       parser.input string
       transforms.each { |x| parser.enable_transform x }
 
-      compiler.generator.processor Rubinius::TestGenerator
-
-      compiler.run
-    end
-
-    def self.compile_test_bytecode_19(string, transforms)
-      compiler = new :string, :bytecode
-
-      parser = compiler.parser
-      parser.root AST::Snippet
-      parser.input string
-      transforms.each { |x| parser.enable_transform x }
-
       compiler.generator.processor TestGenerator
 
       compiler.run

data/lib/rubinius/compiler/evaluator.rb

@@ -3,7 +3,7 @@
 ##
 # Used for the Rubinius::asm Compiler hook.
 
-module CodeTools
+module Rubinius::ToolSet.current::TS
   module AST
     class Node
     end

data/lib/rubinius/compiler/generator.rb

@@ -1,6 +1,6 @@
 # -*- encoding: us-ascii -*-
 
-module CodeTools
+module Rubinius::ToolSet.current::TS
   class Generator
     include GeneratorMethods
 
@@ -134,7 +134,7 @@ module CodeTools
           stack = 0
 
           while i < n
-            insn = Rubinius::InstructionSet[stream[i]]
+            insn = InstructionSet[stream[i]]
             printf "[%3d] %04d  %-28s" % [stack, i, insn.opcode.inspect]
 
             args = stream[i+1, insn.size-1]
@@ -261,7 +261,6 @@ module CodeTools
       @required_args = 0
       @post_args = 0
       @total_args = 0
-      @arity = 0
 
       @detected_args = 0
       @detected_locals = 0
@@ -286,7 +285,7 @@ module CodeTools
                   :required_args, :post_args, :total_args, :splat_index,
                   :local_count, :local_names, :primitive, :for_block, :for_module_body,
                   :current_block, :detected_args, :detected_locals,
-                  :block_index, :arity
+                  :block_index
 
     def execute(node)
       node.bytecode self
@@ -325,7 +324,6 @@ module CodeTools
       code.total_args     = @total_args
       code.splat          = @splat_index
       code.block_index    = @block_index
-      code.arity          = @arity
       code.local_count    = @local_count
       code.local_names    = @local_names.to_tuple if @local_names
 
@@ -450,12 +448,6 @@ module CodeTools
     alias_method :dup,  :dup_top
     alias_method :git,  :goto_if_true
     alias_method :gif,  :goto_if_false
-    alias_method :gin,  :goto_if_nil
-    alias_method :ginn, :goto_if_not_nil
-    alias_method :giu,  :goto_if_undefined
-    alias_method :ginu, :goto_if_not_undefined
-    alias_method :gie,  :goto_if_equal
-    alias_method :gine, :goto_if_not_equal
     alias_method :swap, :swap_stack
 
     # Helpers
@@ -627,7 +619,7 @@ module CodeTools
 
     def send_with_splat(meth, args, priv=false, concat=false)
       val = 0
-      val |= Rubinius::InstructionSet::CALL_FLAG_CONCAT if concat
+      val |= InstructionSet::CALL_FLAG_CONCAT if concat
       set_call_flags val unless val == 0
 
       allow_private if priv

data/lib/rubinius/compiler/generator_methods.rb

@@ -1,6 +1,6 @@
 # *** This file is generated by InstructionParser ***
 
-module CodeTools
+module Rubinius::ToolSet.current::TS
   module GeneratorMethods
       def noop
         @stream << 0
@@ -113,223 +113,139 @@ module CodeTools
         @instruction = 10
       end
 
-      def goto_if_nil(arg1)
-        location = @ip + 1
-        @stream << 11 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(1, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 11
-      end
-
-      def goto_if_not_nil(arg1)
-        location = @ip + 1
-        @stream << 12 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(1, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 12
-      end
-
-      def goto_if_undefined(arg1)
-        location = @ip + 1
-        @stream << 13 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(1, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 13
-      end
-
-      def goto_if_not_undefined(arg1)
-        location = @ip + 1
-        @stream << 14 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(1, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 14
-      end
-
-      def goto_if_equal(arg1)
-        location = @ip + 1
-        @stream << 15 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(2, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 15
-      end
-
-      def goto_if_not_equal(arg1)
-        location = @ip + 1
-        @stream << 16 << arg1
-        @ip += 2
-        arg1.used_at location
-        @current_block.add_stack(2, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 16
-      end
-
       def ret
-        @stream << 17
+        @stream << 11
         @ip += 1
         @current_block.add_stack(1, 1)
         @current_block.close true
         @current_block = new_basic_block
-        @instruction = 17
+        @instruction = 11
       end
 
       def swap_stack
-        @stream << 18
+        @stream << 12
         @ip += 1
         @current_block.add_stack(2, 2)
-        @instruction = 18
+        @instruction = 12
       end
 
       def dup_top
-        @stream << 19
+        @stream << 13
         @ip += 1
         @current_block.add_stack(1, 2)
-        @instruction = 19
+        @instruction = 13
       end
 
       def dup_many(arg1)
-        @stream << 20 << arg1
+        @stream << 14 << arg1
         @ip += 2
         @current_block.add_stack(arg1, (arg1 * 2))
-        @instruction = 20
+        @instruction = 14
       end
 
       def pop
-        @stream << 21
+        @stream << 15
         @ip += 1
         @current_block.add_stack(1, 0)
-        @instruction = 21
+        @instruction = 15
       end
 
       def pop_many(arg1)
-        @stream << 22 << arg1
+        @stream << 16 << arg1
         @ip += 2
         @current_block.add_stack(arg1, 0)
-        @instruction = 22
+        @instruction = 16
       end
 
       def rotate(arg1)
-        @stream << 23 << arg1
+        @stream << 17 << arg1
         @ip += 2
         @current_block.add_stack(arg1, (arg1 * 1))
-        @instruction = 23
+        @instruction = 17
       end
 
       def move_down(arg1)
-        @stream << 24 << arg1
+        @stream << 18 << arg1
         @ip += 2
         @current_block.add_stack(arg1, (arg1 * 1))
-        @instruction = 24
+        @instruction = 18
       end
 
       def set_local(arg1)
-        @stream << 25 << arg1
+        @stream << 19 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 25
+        @instruction = 19
       end
 
       def push_local(arg1)
-        @stream << 26 << arg1
+        @stream << 20 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 26
+        @instruction = 20
       end
 
       def push_local_depth(arg1, arg2)
-        @stream << 27 << arg1 << arg2
+        @stream << 21 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(0, 1)
-        @instruction = 27
+        @instruction = 21
       end
 
       def set_local_depth(arg1, arg2)
-        @stream << 28 << arg1 << arg2
+        @stream << 22 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(1, 1)
-        @instruction = 28
+        @instruction = 22
       end
 
       def passed_arg(arg1)
-        @stream << 29 << arg1
+        @stream << 23 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 29
+        @instruction = 23
       end
 
       def push_current_exception
-        @stream << 30
+        @stream << 24
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 30
+        @instruction = 24
       end
 
       def clear_exception
-        @stream << 31
+        @stream << 25
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 31
+        @instruction = 25
       end
 
       def push_exception_state
-        @stream << 32
+        @stream << 26
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 32
+        @instruction = 26
       end
 
       def restore_exception_state
-        @stream << 33
+        @stream << 27
         @ip += 1
         @current_block.add_stack(1, 0)
-        @instruction = 33
+        @instruction = 27
       end
 
       def raise_exc
-        @stream << 34
+        @stream << 28
         @ip += 1
         @current_block.add_stack(1, 0)
         @current_block.close false
         @current_block = new_basic_block
-        @instruction = 34
+        @instruction = 28
       end
 
       def setup_unwind(arg1, arg2)
         location = @ip + 1
-        @stream << 35 << arg1 << arg2
+        @stream << 29 << arg1 << arg2
         @ip += 3
         arg1.used_at location
         @current_block.add_stack(0, 0)
@@ -338,548 +254,548 @@ module CodeTools
         block = new_basic_block
         @current_block.right = block
         @current_block = block
-        @instruction = 35
+        @instruction = 29
       end
 
       def pop_unwind
-        @stream << 36
+        @stream << 30
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 36
+        @instruction = 30
       end
 
       def raise_return
-        @stream << 37
+        @stream << 31
         @ip += 1
         @current_block.add_stack(1, 1)
         @current_block.close true
         @current_block = new_basic_block
-        @instruction = 37
+        @instruction = 31
       end
 
       def ensure_return
-        @stream << 38
+        @stream << 32
         @ip += 1
         @current_block.add_stack(1, 1)
         @current_block.close true
         @current_block = new_basic_block
-        @instruction = 38
+        @instruction = 32
       end
 
       def raise_break
-        @stream << 39
+        @stream << 33
         @ip += 1
         @current_block.add_stack(1, 1)
         @current_block.close false
         @current_block = new_basic_block
-        @instruction = 39
+        @instruction = 33
       end
 
       def reraise
-        @stream << 40
+        @stream << 34
         @ip += 1
         @current_block.add_stack(0, 0)
         @current_block.close false
         @current_block = new_basic_block
-        @instruction = 40
+        @instruction = 34
       end
 
       def make_array(arg1)
-        @stream << 41 << arg1
+        @stream << 35 << arg1
         @ip += 2
         @current_block.add_stack(arg1, 1)
-        @instruction = 41
+        @instruction = 35
       end
 
       def cast_array
-        unless @instruction == 42 or @instruction == 41
-          @stream << 42
+        unless @instruction == 36 or @instruction == 35
+          @stream << 36
           @ip += 1
         end
-        @instruction = 42
+        @instruction = 36
       end
 
       def shift_array
-        @stream << 43
+        @stream << 37
         @ip += 1
         @current_block.add_stack(1, 2)
-        @instruction = 43
+        @instruction = 37
       end
 
       def set_ivar(arg1)
         arg1 = find_literal arg1
-        @stream << 44 << arg1
+        @stream << 38 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 44
+        @instruction = 38
       end
 
       def push_ivar(arg1)
         arg1 = find_literal arg1
-        @stream << 45 << arg1
+        @stream << 39 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 45
+        @instruction = 39
       end
 
       def set_const(arg1)
-        @stream << 47 << arg1
+        @stream << 41 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 47
+        @instruction = 41
       end
 
       def set_const_at(arg1)
-        @stream << 48 << arg1
+        @stream << 42 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 48
+        @instruction = 42
       end
 
       def find_const(arg1)
         arg1 = find_literal arg1
-        @stream << 49 << arg1
+        @stream << 43 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 49
+        @instruction = 43
       end
 
       def push_cpath_top
-        @stream << 50
+        @stream << 44
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 50
+        @instruction = 44
       end
 
       def push_const_fast(arg1)
-        @stream << 51 << arg1
+        @stream << 45 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 51
+        @instruction = 45
       end
 
       def find_const_fast(arg1)
-        @stream << 52 << arg1
+        @stream << 46 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 52
+        @instruction = 46
       end
 
       def set_call_flags(arg1)
-        @stream << 53 << arg1
+        @stream << 47 << arg1
         @ip += 2
         @current_block.add_stack(0, 0)
-        @instruction = 53
+        @instruction = 47
       end
 
       def allow_private
-        @stream << 54
+        @stream << 48
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 54
+        @instruction = 48
       end
 
       def send_method(arg1)
-        @stream << 55 << arg1
+        @stream << 49 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 55
+        @instruction = 49
       end
 
       def send_stack(arg1, arg2)
-        @stream << 56 << arg1 << arg2
+        @stream << 50 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+1, 1)
-        @instruction = 56
+        @instruction = 50
       end
 
       def send_stack_with_block(arg1, arg2)
-        @stream << 57 << arg1 << arg2
+        @stream << 51 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+2, 1)
-        @instruction = 57
+        @instruction = 51
       end
 
       def send_stack_with_splat(arg1, arg2)
-        @stream << 58 << arg1 << arg2
+        @stream << 52 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+3, 1)
-        @instruction = 58
+        @instruction = 52
       end
 
       def send_super_stack_with_block(arg1, arg2)
-        @stream << 59 << arg1 << arg2
+        @stream << 53 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+1, 1)
-        @instruction = 59
+        @instruction = 53
       end
 
       def send_super_stack_with_splat(arg1, arg2)
-        @stream << 60 << arg1 << arg2
+        @stream << 54 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+2, 1)
-        @instruction = 60
+        @instruction = 54
       end
 
       def push_block
-        @stream << 61
+        @stream << 55
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 61
+        @instruction = 55
       end
 
       def passed_blockarg(arg1)
-        @stream << 62 << arg1
+        @stream << 56 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 62
+        @instruction = 56
       end
 
       def create_block(arg1)
         arg1 = add_literal arg1
         @generators << arg1
-        @stream << 63 << arg1
+        @stream << 57 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 63
+        @instruction = 57
       end
 
       def cast_for_single_block_arg
-        @stream << 64
+        @stream << 58
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 64
+        @instruction = 58
       end
 
       def cast_for_multi_block_arg
-        @stream << 65
+        @stream << 59
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 65
+        @instruction = 59
       end
 
       def cast_for_splat_block_arg
-        @stream << 66
+        @stream << 60
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 66
+        @instruction = 60
       end
 
       def yield_stack(arg1)
-        @stream << 67 << arg1
+        @stream << 61 << arg1
         @ip += 2
         @current_block.add_stack(arg1, 1)
-        @instruction = 67
+        @instruction = 61
       end
 
       def yield_splat(arg1)
-        @stream << 68 << arg1
+        @stream << 62 << arg1
         @ip += 2
         @current_block.add_stack(arg1+1, 1)
-        @instruction = 68
+        @instruction = 62
       end
 
       def string_append
-        @stream << 69
+        @stream << 63
         @ip += 1
         @current_block.add_stack(2, 1)
-        @instruction = 69
+        @instruction = 63
       end
 
       def string_build(arg1)
-        @stream << 70 << arg1
+        @stream << 64 << arg1
         @ip += 2
         @current_block.add_stack(arg1, 1)
-        @instruction = 70
+        @instruction = 64
       end
 
       def string_dup
-        @stream << 71
+        @stream << 65
         @ip += 1
         @current_block.add_stack(1, 1)
-        @instruction = 71
+        @instruction = 65
       end
 
       def push_scope
-        @stream << 72
+        @stream << 66
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 72
+        @instruction = 66
       end
 
       def add_scope
-        @stream << 73
+        @stream << 67
         @ip += 1
         @current_block.add_stack(1, 0)
-        @instruction = 73
+        @instruction = 67
       end
 
       def push_variables
-        @stream << 74
+        @stream << 68
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 74
+        @instruction = 68
       end
 
       def check_interrupts
-        @stream << 75
+        @stream << 69
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 75
+        @instruction = 69
       end
 
       def yield_debugger
-        @stream << 76
+        @stream << 70
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 76
+        @instruction = 70
       end
 
       def is_nil
-        @stream << 77
+        @stream << 71
         @ip += 1
         @current_block.add_stack(1, 1)
-        @instruction = 77
+        @instruction = 71
       end
 
       def check_serial(arg1, arg2)
         arg1 = find_literal arg1
         arg2 = Integer(arg2)
-        @stream << 78 << arg1 << arg2
+        @stream << 72 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(1, 1)
-        @instruction = 78
+        @instruction = 72
       end
 
       def check_serial_private(arg1, arg2)
         arg1 = find_literal arg1
         arg2 = Integer(arg2)
-        @stream << 79 << arg1 << arg2
+        @stream << 73 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(1, 1)
-        @instruction = 79
+        @instruction = 73
       end
 
       def push_my_field(arg1)
-        @stream << 80 << arg1
+        @stream << 74 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 80
+        @instruction = 74
       end
 
       def store_my_field(arg1)
-        @stream << 81 << arg1
+        @stream << 75 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 81
+        @instruction = 75
       end
 
       def kind_of
-        @stream << 82
+        @stream << 76
         @ip += 1
         @current_block.add_stack(2, 1)
-        @instruction = 82
+        @instruction = 76
       end
 
       def instance_of
-        @stream << 83
+        @stream << 77
         @ip += 1
         @current_block.add_stack(2, 1)
-        @instruction = 83
+        @instruction = 77
       end
 
       def meta_push_neg_1
-        @stream << 84
+        @stream << 78
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 84
+        @instruction = 78
       end
 
       def meta_push_0
-        @stream << 85
+        @stream << 79
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 85
+        @instruction = 79
       end
 
       def meta_push_1
-        @stream << 86
+        @stream << 80
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 86
+        @instruction = 80
       end
 
       def meta_push_2
-        @stream << 87
+        @stream << 81
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 87
+        @instruction = 81
       end
 
       def meta_send_op_plus(arg1)
-        @stream << 88 << arg1
+        @stream << 82 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 88
+        @instruction = 82
       end
 
       def meta_send_op_minus(arg1)
-        @stream << 89 << arg1
+        @stream << 83 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 89
+        @instruction = 83
       end
 
       def meta_send_op_equal(arg1)
-        @stream << 90 << arg1
+        @stream << 84 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 90
+        @instruction = 84
       end
 
       def meta_send_op_lt(arg1)
-        @stream << 91 << arg1
+        @stream << 85 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 91
+        @instruction = 85
       end
 
       def meta_send_op_gt(arg1)
-        @stream << 92 << arg1
+        @stream << 86 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 92
+        @instruction = 86
       end
 
       def meta_send_op_tequal(arg1)
-        @stream << 93 << arg1
+        @stream << 87 << arg1
         @ip += 2
         @current_block.add_stack(2, 1)
-        @instruction = 93
+        @instruction = 87
       end
 
       def meta_send_call(arg1, arg2)
-        @stream << 94 << arg1 << arg2
+        @stream << 88 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+1, 1)
-        @instruction = 94
+        @instruction = 88
       end
 
       def push_my_offset(arg1)
-        @stream << 95 << arg1
+        @stream << 89 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 95
+        @instruction = 89
       end
 
       def zsuper(arg1)
         arg1 = find_literal arg1
-        @stream << 96 << arg1
+        @stream << 90 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 96
+        @instruction = 90
       end
 
       def push_block_arg
-        @stream << 97
+        @stream << 91
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 97
+        @instruction = 91
       end
 
       def push_undef
-        @stream << 98
+        @stream << 92
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 98
+        @instruction = 92
       end
 
       def push_stack_local(arg1)
-        @stream << 99 << arg1
+        @stream << 93 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 99
+        @instruction = 93
       end
 
       def set_stack_local(arg1)
-        @stream << 100 << arg1
+        @stream << 94 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 100
+        @instruction = 94
       end
 
       def push_has_block
-        @stream << 101
+        @stream << 95
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 101
+        @instruction = 95
       end
 
       def push_proc
-        @stream << 102
+        @stream << 96
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 102
+        @instruction = 96
       end
 
       def check_frozen
-        @stream << 103
+        @stream << 97
         @ip += 1
         @current_block.add_stack(1, 1)
-        @instruction = 103
+        @instruction = 97
       end
 
       def cast_multi_value
-        @stream << 104
+        @stream << 98
         @ip += 1
         @current_block.add_stack(1, 1)
-        @instruction = 104
+        @instruction = 98
       end
 
       def invoke_primitive(arg1, arg2)
         arg1 = find_literal arg1
         arg2 = Integer(arg2)
-        @stream << 105 << arg1 << arg2
+        @stream << 99 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2, 1)
-        @instruction = 105
+        @instruction = 99
       end
 
       def push_rubinius
-        @stream << 106
+        @stream << 100
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 106
+        @instruction = 100
       end
 
       def call_custom(arg1, arg2)
         arg1 = find_literal arg1
         arg2 = Integer(arg2)
-        @stream << 107 << arg1 << arg2
+        @stream << 101 << arg1 << arg2
         @ip += 3
         @current_block.add_stack(arg2+1, 1)
-        @instruction = 107
+        @instruction = 101
       end
 
       def meta_to_s(arg1)
-        @stream << 108 << arg1
+        @stream << 102 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 108
+        @instruction = 102
       end
 
       def push_type
-        @stream << 109
+        @stream << 103
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 109
+        @instruction = 103
       end
 
       def push_mirror
-        @stream << 110
+        @stream << 104
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 110
+        @instruction = 104
       end
 
   end