rubinius-compiler 3.9 → 3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cae6bb504ecb18d32cffe029f4289ea295e489b3
-  data.tar.gz: 58d59c9947a7575718524ff19540b98fbbc2d10d
+  metadata.gz: 43a70986619cb373730960efd90ca453c167d955
+  data.tar.gz: 491d005f82901b9b4892de820a6d5a3c914997c3
 SHA512:
-  metadata.gz: dad9a44d039237075e1be221038f929cde927b1f0deb72f12296ea1b3eb5461cd917ad56e9e7e7a95458f2e106bacd5e4dd097e27faafb7705a1f281ac442b86
-  data.tar.gz: 07369dc1d2f6a2ce1fb3e0bf869acd4dece223a8516a3e709db1ebc205b03d35fbe9f350a768b389563f58633e93e77da9759aeb70640f332173ecf2920f616c
+  metadata.gz: ee4b15f721f45fa9e9057c28aef06febccc47a7cc611a52e3ecf3bc8ae2edd76196d7d17cbb17d738a9d6dfe452fc3499e77d1c35eae8832742e474f83f43496
+  data.tar.gz: 5783d337b23a39cb4d1267854538cc620cade019e5cb22fb0d9a7365162d3d937dd119f0702248e0bbbd5515515d146e9c62940554918a416c76fd27629b968c

data/lib/rubinius/code/compiler/generator_methods.rb

@@ -2,92 +2,162 @@
 
 module CodeTools
   module GeneratorMethods
-      def noop
+      def add_scope
         @stream << 0
         @ip += 1
-        @current_block.add_stack(0, 0)
+        @current_block.add_stack(1, 0)
         @instruction = 0
       end
 
-      def push_nil
+      def allow_private
         @stream << 1
         @ip += 1
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(0, 0)
         @instruction = 1
       end
 
-      def push_true
-        @stream << 2
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def cast_array
+        unless @instruction == 2 or @instruction == 29
+          @stream << 2
+          @ip += 1
+        end
         @instruction = 2
       end
 
-      def push_false
+      def cast_for_multi_block_arg
         @stream << 3
         @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 3
       end
 
-      def push_int(arg1)
-        @stream << 4 << arg1
-        @ip += 2
+      def cast_for_single_block_arg
+        @stream << 4
+        @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 4
       end
 
-      def push_self
+      def cast_for_splat_block_arg
         @stream << 5
         @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 5
       end
 
-      def push_memo(arg1)
-        arg1 = find_literal(arg1)
-        @stream << 6 << arg1
-        @ip += 2
+      def cast_multi_value
+        @stream << 6
+        @ip += 1
         @current_block.add_stack(1, 1)
         @instruction = 6
       end
 
-      def emit_push_literal(arg1)
-        @stream << 7 << arg1
+      def check_frozen
+        @stream << 7
+        @ip += 1
+        @current_block.add_stack(1, 1)
+        @instruction = 7
+      end
+
+      def check_interrupts
+        @stream << 8
+        @ip += 1
+        @current_block.add_stack(0, 0)
+        @instruction = 8
+      end
+
+      def check_serial(arg1, arg2)
+        arg1 = find_literal(arg1)
+        @stream << 9 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(1, 1)
+        @instruction = 9
+      end
+
+      def check_serial_private(arg1, arg2)
+        arg1 = find_literal(arg1)
+        @stream << 10 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(1, 1)
+        @instruction = 10
+      end
+
+      def clear_exception
+        @stream << 11
+        @ip += 1
+        @current_block.add_stack(0, 0)
+        @instruction = 11
+      end
+
+      def create_block(arg1)
+        arg1 = add_generator(arg1)
+        @stream << 12 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 7
+        @instruction = 12
+      end
+
+      def dup
+        @stream << 13
+        @ip += 1
+        @current_block.add_stack(1, 2)
+        @instruction = 13
+      end
+
+      def dup_many(arg1)
+        arg1 = Integer(arg1)
+        @stream << 14 << arg1
+        @ip += 2
+        @current_block.add_stack(arg1, (arg1 * 2))
+        @instruction = 14
+      end
+
+      def ensure_return
+        @stream << 15
+        @ip += 1
+        @current_block.add_stack(1, 1)
+        @current_block.close true
+        @current_block = new_basic_block
+        @instruction = 15
+      end
+
+      def find_const(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 16 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
+        @instruction = 16
       end
 
       def goto(arg1)
         location = @ip + 1
-        @stream << 8 << arg1
+        @stream << 17 << arg1
         @ip += 2
         arg1.used_at location
         @current_block.add_stack(0, 0)
         @current_block.left = arg1.basic_block
         @current_block.close
         @current_block = new_basic_block
-        @instruction = 8
+        @instruction = 17
       end
 
-      def goto_if_false(arg1)
+      def goto_if_equal(arg1)
         location = @ip + 1
-        @stream << 9 << arg1
+        @stream << 18 << arg1
         @ip += 2
         arg1.used_at location
-        @current_block.add_stack(1, 0)
+        @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 = 9
+        @instruction = 18
       end
 
-      def goto_if_true(arg1)
+      def goto_if_false(arg1)
         location = @ip + 1
-        @stream << 10 << arg1
+        @stream << 19 << arg1
         @ip += 2
         arg1.used_at location
         @current_block.add_stack(1, 0)
@@ -96,12 +166,12 @@ module CodeTools
         block = new_basic_block
         @current_block.right = block
         @current_block = block
-        @instruction = 10
+        @instruction = 19
       end
 
       def goto_if_nil(arg1)
         location = @ip + 1
-        @stream << 11 << arg1
+        @stream << 20 << arg1
         @ip += 2
         arg1.used_at location
         @current_block.add_stack(1, 0)
@@ -110,26 +180,26 @@ module CodeTools
         block = new_basic_block
         @current_block.right = block
         @current_block = block
-        @instruction = 11
+        @instruction = 20
       end
 
-      def goto_if_not_nil(arg1)
+      def goto_if_not_equal(arg1)
         location = @ip + 1
-        @stream << 12 << arg1
+        @stream << 21 << arg1
         @ip += 2
         arg1.used_at location
-        @current_block.add_stack(1, 0)
+        @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 = 12
+        @instruction = 21
       end
 
-      def goto_if_undefined(arg1)
+      def goto_if_not_nil(arg1)
         location = @ip + 1
-        @stream << 13 << arg1
+        @stream << 22 << arg1
         @ip += 2
         arg1.used_at location
         @current_block.add_stack(1, 0)
@@ -138,12 +208,12 @@ module CodeTools
         block = new_basic_block
         @current_block.right = block
         @current_block = block
-        @instruction = 13
+        @instruction = 22
       end
 
       def goto_if_not_undefined(arg1)
         location = @ip + 1
-        @stream << 14 << arg1
+        @stream << 23 << arg1
         @ip += 2
         arg1.used_at location
         @current_block.add_stack(1, 0)
@@ -152,549 +222,471 @@ module CodeTools
         block = new_basic_block
         @current_block.right = block
         @current_block = block
-        @instruction = 14
+        @instruction = 23
       end
 
-      def goto_if_equal(arg1)
+      def goto_if_true(arg1)
         location = @ip + 1
-        @stream << 15 << arg1
+        @stream << 24 << arg1
         @ip += 2
         arg1.used_at location
-        @current_block.add_stack(2, 0)
+        @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 = 15
+        @instruction = 24
       end
 
-      def goto_if_not_equal(arg1)
+      def goto_if_undefined(arg1)
         location = @ip + 1
-        @stream << 16 << arg1
+        @stream << 25 << arg1
         @ip += 2
         arg1.used_at location
-        @current_block.add_stack(2, 0)
+        @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 = 16
-      end
-
-      def ret
-        @stream << 17
-        @ip += 1
-        @current_block.add_stack(1, 1)
-        @current_block.close true
-        @current_block = new_basic_block
-        @instruction = 17
-      end
-
-      def swap
-        @stream << 18
-        @ip += 1
-        @current_block.add_stack(2, 2)
-        @instruction = 18
+        @instruction = 25
       end
 
-      def dup
-        @stream << 19
+      def instance_of
+        @stream << 26
         @ip += 1
-        @current_block.add_stack(1, 2)
-        @instruction = 19
+        @current_block.add_stack(2, 1)
+        @instruction = 26
       end
 
-      def dup_many(arg1)
-        arg1 = Integer(arg1)
-        @stream << 20 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1, (arg1 * 2))
-        @instruction = 20
+      def invoke_primitive(arg1, arg2)
+        arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
+        @stream << 27 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(arg2, 1)
+        @instruction = 27
       end
 
-      def pop
-        @stream << 21
+      def kind_of
+        @stream << 28
         @ip += 1
-        @current_block.add_stack(1, 0)
-        @instruction = 21
+        @current_block.add_stack(2, 1)
+        @instruction = 28
       end
 
-      def pop_many(arg1)
+      def make_array(arg1)
         arg1 = Integer(arg1)
-        @stream << 22 << arg1
+        @stream << 29 << arg1
         @ip += 2
-        @current_block.add_stack(arg1, 0)
-        @instruction = 22
+        @current_block.add_stack(arg1, 1)
+        @instruction = 29
       end
 
-      def rotate(arg1)
-        arg1 = Integer(arg1)
-        @stream << 23 << arg1
+      def move_down(arg1)
+        @stream << 30 << arg1
         @ip += 2
         @current_block.add_stack(arg1, (arg1 * 1))
-        @instruction = 23
+        @instruction = 30
       end
 
-      def move_down(arg1)
-        @stream << 24 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1, (arg1 * 1))
-        @instruction = 24
+      def noop
+        @stream << 31
+        @ip += 1
+        @current_block.add_stack(0, 0)
+        @instruction = 31
       end
 
-      def set_local(arg1)
-        @stream << 25 << arg1
+      def object_to_s(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 32 << arg1
         @ip += 2
         @current_block.add_stack(1, 1)
-        @instruction = 25
+        @instruction = 32
       end
 
-      def push_local(arg1)
-        @stream << 26 << arg1
+      def passed_arg(arg1)
+        @stream << 33 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 26
+        @instruction = 33
       end
 
-      def push_local_depth(arg1, arg2)
-        @stream << 27 << arg1 << arg2
-        @ip += 3
+      def passed_blockarg(arg1)
+        arg1 = Integer(arg1)
+        @stream << 34 << arg1
+        @ip += 2
         @current_block.add_stack(0, 1)
-        @instruction = 27
+        @instruction = 34
       end
 
-      def set_local_depth(arg1, arg2)
-        @stream << 28 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(1, 1)
-        @instruction = 28
+      def pop
+        @stream << 35
+        @ip += 1
+        @current_block.add_stack(1, 0)
+        @instruction = 35
       end
 
-      def passed_arg(arg1)
-        @stream << 29 << arg1
+      def pop_many(arg1)
+        arg1 = Integer(arg1)
+        @stream << 36 << arg1
         @ip += 2
-        @current_block.add_stack(0, 1)
-        @instruction = 29
-      end
-
-      def push_current_exception
-        @stream << 30
-        @ip += 1
-        @current_block.add_stack(0, 1)
-        @instruction = 30
+        @current_block.add_stack(arg1, 0)
+        @instruction = 36
       end
 
-      def clear_exception
-        @stream << 31
+      def pop_unwind
+        @stream << 37
         @ip += 1
         @current_block.add_stack(0, 0)
-        @instruction = 31
+        @instruction = 37
       end
 
-      def push_exception_state
-        @stream << 32
+      def push_block
+        @stream << 38
         @ip += 1
         @current_block.add_stack(0, 1)
-        @instruction = 32
+        @instruction = 38
       end
 
-      def restore_exception_state
-        @stream << 33
-        @ip += 1
-        @current_block.add_stack(1, 0)
-        @instruction = 33
-      end
-
-      def raise_exc
-        @stream << 34
-        @ip += 1
-        @current_block.add_stack(1, 0)
-        @current_block.close false
-        @current_block = new_basic_block
-        @instruction = 34
-      end
-
-      def setup_unwind(arg1, arg2)
-        location = @ip + 1
-        @stream << 35 << arg1 << arg2
-        @ip += 3
-        arg1.used_at location
-        @current_block.add_stack(0, 0)
-        @current_block.left = arg1.basic_block
-        @current_block.close
-        block = new_basic_block
-        @current_block.right = block
-        @current_block = block
-        @instruction = 35
-      end
-
-      def pop_unwind
-        @stream << 36
-        @ip += 1
-        @current_block.add_stack(0, 0)
-        @instruction = 36
-      end
-
-      def raise_return
-        @stream << 37
-        @ip += 1
-        @current_block.add_stack(1, 1)
-        @current_block.close true
-        @current_block = new_basic_block
-        @instruction = 37
-      end
-
-      def ensure_return
-        @stream << 38
-        @ip += 1
-        @current_block.add_stack(1, 1)
-        @current_block.close true
-        @current_block = new_basic_block
-        @instruction = 38
-      end
-
-      def raise_break
+      def push_block_arg
         @stream << 39
         @ip += 1
-        @current_block.add_stack(1, 1)
-        @current_block.close false
-        @current_block = new_basic_block
+        @current_block.add_stack(0, 1)
         @instruction = 39
       end
 
-      def reraise
-        @stream << 40
-        @ip += 1
-        @current_block.add_stack(0, 0)
-        @current_block.close false
-        @current_block = new_basic_block
+      def push_const(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 40 << arg1
+        @ip += 2
+        @current_block.add_stack(0, 1)
         @instruction = 40
       end
 
-      def make_array(arg1)
-        arg1 = Integer(arg1)
-        @stream << 41 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1, 1)
+      def push_cpath_top
+        @stream << 41
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 41
       end
 
-      def cast_array
-        unless @instruction == 42 or @instruction == 41
-          @stream << 42
-          @ip += 1
-        end
+      def push_current_exception
+        @stream << 42
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 42
       end
 
-      def shift_array
+      def push_exception_state
         @stream << 43
         @ip += 1
-        @current_block.add_stack(1, 2)
+        @current_block.add_stack(0, 1)
         @instruction = 43
       end
 
-      def set_ivar(arg1)
-        arg1 = find_literal(arg1)
-        @stream << 44 << arg1
-        @ip += 2
-        @current_block.add_stack(1, 1)
+      def push_false
+        @stream << 44
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 44
       end
 
-      def push_ivar(arg1)
-        arg1 = find_literal(arg1)
-        @stream << 45 << arg1
-        @ip += 2
+      def push_has_block
+        @stream << 45
+        @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 45
       end
 
-      def set_const(arg1)
-        arg1 = find_literal(arg1)
+      def push_int(arg1)
         @stream << 46 << arg1
         @ip += 2
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(0, 1)
         @instruction = 46
       end
 
-      def set_const_at(arg1)
+      def push_ivar(arg1)
         arg1 = find_literal(arg1)
         @stream << 47 << arg1
         @ip += 2
-        @current_block.add_stack(2, 1)
+        @current_block.add_stack(0, 1)
         @instruction = 47
       end
 
-      def push_cpath_top
-        @stream << 48
-        @ip += 1
+      def emit_push_literal(arg1)
+        @stream << 48 << arg1
+        @ip += 2
         @current_block.add_stack(0, 1)
         @instruction = 48
       end
 
-      def push_const(arg1)
-        arg1 = find_literal(arg1)
+      def push_local(arg1)
         @stream << 49 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
         @instruction = 49
       end
 
-      def find_const(arg1)
-        arg1 = find_literal(arg1)
-        @stream << 50 << arg1
-        @ip += 2
-        @current_block.add_stack(1, 1)
+      def push_local_depth(arg1, arg2)
+        @stream << 50 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(0, 1)
         @instruction = 50
       end
 
-      def set_call_flags(arg1)
+      def push_memo(arg1)
+        arg1 = find_literal(arg1)
         @stream << 51 << arg1
         @ip += 2
-        @current_block.add_stack(0, 0)
+        @current_block.add_stack(1, 1)
         @instruction = 51
       end
 
-      def allow_private
+      def push_mirror
         @stream << 52
         @ip += 1
-        @current_block.add_stack(0, 0)
+        @current_block.add_stack(0, 1)
         @instruction = 52
       end
 
-      def send_vcall(arg1)
-        arg1 = find_literal(arg1)
+      def push_my_field(arg1)
         @stream << 53 << arg1
         @ip += 2
         @current_block.add_stack(0, 1)
         @instruction = 53
       end
 
-      def send_method(arg1)
-        arg1 = find_literal(arg1)
+      def push_my_offset(arg1)
         @stream << 54 << arg1
         @ip += 2
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(0, 1)
         @instruction = 54
       end
 
-      def send_stack(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 55 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2+1, 1)
+      def push_nil
+        @stream << 55
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 55
       end
 
-      def send_stack_with_block(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 56 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2+2, 1)
+      def push_proc
+        @stream << 56
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 56
       end
 
-      def send_stack_with_splat(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 57 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2+3, 1)
+      def push_rubinius
+        @stream << 57
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 57
       end
 
-      def send_super_stack_with_block(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 58 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2+1, 1)
+      def push_scope
+        @stream << 58
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 58
       end
 
-      def send_super_stack_with_splat(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 59 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2+2, 1)
+      def push_self
+        @stream << 59
+        @ip += 1
+        @current_block.add_stack(0, 1)
         @instruction = 59
       end
 
-      def push_block
-        @stream << 60
-        @ip += 1
+      def push_stack_local(arg1)
+        @stream << 60 << arg1
+        @ip += 2
         @current_block.add_stack(0, 1)
         @instruction = 60
       end
 
-      def passed_blockarg(arg1)
-        arg1 = Integer(arg1)
-        @stream << 61 << arg1
-        @ip += 2
+      def push_true
+        @stream << 61
+        @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 61
       end
 
-      def create_block(arg1)
-        arg1 = add_generator(arg1)
-        @stream << 62 << arg1
-        @ip += 2
+      def push_type
+        @stream << 62
+        @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 62
       end
 
-      def cast_for_single_block_arg
+      def push_undef
         @stream << 63
         @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 63
       end
 
-      def cast_for_multi_block_arg
+      def push_variables
         @stream << 64
         @ip += 1
         @current_block.add_stack(0, 1)
         @instruction = 64
       end
 
-      def cast_for_splat_block_arg
+      def raise_break
         @stream << 65
         @ip += 1
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(1, 1)
+        @current_block.close false
+        @current_block = new_basic_block
         @instruction = 65
       end
 
-      def yield_stack(arg1)
-        arg1 = Integer(arg1)
-        @stream << 66 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1, 1)
+      def raise_exc
+        @stream << 66
+        @ip += 1
+        @current_block.add_stack(1, 0)
+        @current_block.close false
+        @current_block = new_basic_block
         @instruction = 66
       end
 
-      def yield_splat(arg1)
-        arg1 = Integer(arg1)
-        @stream << 67 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1+1, 1)
+      def raise_return
+        @stream << 67
+        @ip += 1
+        @current_block.add_stack(1, 1)
+        @current_block.close true
+        @current_block = new_basic_block
         @instruction = 67
       end
 
-      def string_append
+      def reraise
         @stream << 68
         @ip += 1
-        @current_block.add_stack(2, 1)
+        @current_block.add_stack(0, 0)
+        @current_block.close false
+        @current_block = new_basic_block
         @instruction = 68
       end
 
-      def string_build(arg1)
-        arg1 = Integer(arg1)
-        @stream << 69 << arg1
-        @ip += 2
-        @current_block.add_stack(arg1, 1)
+      def restore_exception_state
+        @stream << 69
+        @ip += 1
+        @current_block.add_stack(1, 0)
         @instruction = 69
       end
 
-      def string_dup
+      def ret
         @stream << 70
         @ip += 1
         @current_block.add_stack(1, 1)
+        @current_block.close true
+        @current_block = new_basic_block
         @instruction = 70
       end
 
-      def push_scope
-        @stream << 71
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def rotate(arg1)
+        arg1 = Integer(arg1)
+        @stream << 71 << arg1
+        @ip += 2
+        @current_block.add_stack(arg1, (arg1 * 1))
         @instruction = 71
       end
 
-      def add_scope
+      def run_exception
         @stream << 72
         @ip += 1
-        @current_block.add_stack(1, 0)
+        @current_block.add_stack(0, 0)
         @instruction = 72
       end
 
-      def push_variables
-        @stream << 73
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def send_method(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 73 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
         @instruction = 73
       end
 
-      def check_interrupts
-        @stream << 74
-        @ip += 1
-        @current_block.add_stack(0, 0)
+      def send_stack(arg1, arg2)
+        arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
+        @stream << 74 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(arg2+1, 1)
         @instruction = 74
       end
 
-      def yield_debugger
-        @stream << 75
-        @ip += 1
-        @current_block.add_stack(0, 0)
+      def send_stack_with_block(arg1, arg2)
+        arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
+        @stream << 75 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(arg2+2, 1)
         @instruction = 75
       end
 
-      def check_serial(arg1, arg2)
+      def send_stack_with_splat(arg1, arg2)
         arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
         @stream << 76 << arg1 << arg2
         @ip += 3
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(arg2+3, 1)
         @instruction = 76
       end
 
-      def check_serial_private(arg1, arg2)
+      def send_super_stack_with_block(arg1, arg2)
         arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
         @stream << 77 << arg1 << arg2
         @ip += 3
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(arg2+1, 1)
         @instruction = 77
       end
 
-      def push_my_field(arg1)
-        @stream << 78 << arg1
-        @ip += 2
-        @current_block.add_stack(0, 1)
+      def send_super_stack_with_splat(arg1, arg2)
+        arg1 = find_literal(arg1)
+        arg2 = Integer(arg2)
+        @stream << 78 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(arg2+2, 1)
         @instruction = 78
       end
 
-      def store_my_field(arg1)
+      def send_vcall(arg1)
+        arg1 = find_literal(arg1)
         @stream << 79 << arg1
         @ip += 2
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(0, 1)
         @instruction = 79
       end
 
-      def kind_of
-        @stream << 80
-        @ip += 1
-        @current_block.add_stack(2, 1)
+      def set_call_flags(arg1)
+        @stream << 80 << arg1
+        @ip += 2
+        @current_block.add_stack(0, 0)
         @instruction = 80
       end
 
-      def instance_of
-        @stream << 81
-        @ip += 1
-        @current_block.add_stack(2, 1)
+      def set_const(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 81 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
         @instruction = 81
       end
 
-      def push_my_offset(arg1)
+      def set_const_at(arg1)
+        arg1 = find_literal(arg1)
         @stream << 82 << arg1
         @ip += 2
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(2, 1)
         @instruction = 82
       end
 
-      def zsuper(arg1)
+      def set_ivar(arg1)
         arg1 = find_literal(arg1)
         @stream << 83 << arg1
         @ip += 2
@@ -702,99 +694,114 @@ module CodeTools
         @instruction = 83
       end
 
-      def push_block_arg
-        @stream << 84
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def set_local(arg1)
+        @stream << 84 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
         @instruction = 84
       end
 
-      def push_undef
-        @stream << 85
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def set_local_depth(arg1, arg2)
+        @stream << 85 << arg1 << arg2
+        @ip += 3
+        @current_block.add_stack(1, 1)
         @instruction = 85
       end
 
-      def push_stack_local(arg1)
+      def set_stack_local(arg1)
         @stream << 86 << arg1
         @ip += 2
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(1, 1)
         @instruction = 86
       end
 
-      def set_stack_local(arg1)
-        @stream << 87 << arg1
-        @ip += 2
-        @current_block.add_stack(1, 1)
+      def setup_unwind(arg1, arg2)
+        location = @ip + 1
+        @stream << 87 << arg1 << arg2
+        @ip += 3
+        arg1.used_at location
+        @current_block.add_stack(0, 0)
+        @current_block.left = arg1.basic_block
+        @current_block.close
+        block = new_basic_block
+        @current_block.right = block
+        @current_block = block
         @instruction = 87
       end
 
-      def push_has_block
+      def shift_array
         @stream << 88
         @ip += 1
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(1, 2)
         @instruction = 88
       end
 
-      def push_proc
-        @stream << 89
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def store_my_field(arg1)
+        @stream << 89 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
         @instruction = 89
       end
 
-      def check_frozen
+      def string_append
         @stream << 90
         @ip += 1
-        @current_block.add_stack(1, 1)
+        @current_block.add_stack(2, 1)
         @instruction = 90
       end
 
-      def cast_multi_value
-        @stream << 91
-        @ip += 1
-        @current_block.add_stack(1, 1)
+      def string_build(arg1)
+        arg1 = Integer(arg1)
+        @stream << 91 << arg1
+        @ip += 2
+        @current_block.add_stack(arg1, 1)
         @instruction = 91
       end
 
-      def invoke_primitive(arg1, arg2)
-        arg1 = find_literal(arg1)
-        arg2 = Integer(arg2)
-        @stream << 92 << arg1 << arg2
-        @ip += 3
-        @current_block.add_stack(arg2, 1)
+      def string_dup
+        @stream << 92
+        @ip += 1
+        @current_block.add_stack(1, 1)
         @instruction = 92
       end
 
-      def push_rubinius
+      def swap
         @stream << 93
         @ip += 1
-        @current_block.add_stack(0, 1)
+        @current_block.add_stack(2, 2)
         @instruction = 93
       end
 
-      def object_to_s(arg1)
-        arg1 = find_literal(arg1)
-        @stream << 94 << arg1
-        @ip += 2
-        @current_block.add_stack(1, 1)
+      def yield_debugger
+        @stream << 94
+        @ip += 1
+        @current_block.add_stack(0, 0)
         @instruction = 94
       end
 
-      def push_type
-        @stream << 95
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def yield_splat(arg1)
+        arg1 = Integer(arg1)
+        @stream << 95 << arg1
+        @ip += 2
+        @current_block.add_stack(arg1+1, 1)
         @instruction = 95
       end
 
-      def push_mirror
-        @stream << 96
-        @ip += 1
-        @current_block.add_stack(0, 1)
+      def yield_stack(arg1)
+        arg1 = Integer(arg1)
+        @stream << 96 << arg1
+        @ip += 2
+        @current_block.add_stack(arg1, 1)
         @instruction = 96
       end
 
+      def zsuper(arg1)
+        arg1 = find_literal(arg1)
+        @stream << 97 << arg1
+        @ip += 2
+        @current_block.add_stack(1, 1)
+        @instruction = 97
+      end
+
   end
 end

data/lib/rubinius/code/compiler/version.rb

@@ -1,5 +1,5 @@
 module CodeTools
   class Compiler
-    VERSION = "3.9"
+    VERSION = "3.10"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubinius-compiler
 version: !ruby/object:Gem::Version
-  version: '3.9'
+  version: '3.10'
 platform: ruby
 authors:
 - Brian Shirai