syntax_tree 5.0.0 → 5.1.0

data/lib/syntax_tree/yarv/instructions.rb

@@ -0,0 +1,5203 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This is an operand to various YARV instructions that represents the
+    # information about a specific call site.
+    class CallData
+      CALL_ARGS_SPLAT = 1 << 0
+      CALL_ARGS_BLOCKARG = 1 << 1
+      CALL_FCALL = 1 << 2
+      CALL_VCALL = 1 << 3
+      CALL_ARGS_SIMPLE = 1 << 4
+      CALL_BLOCKISEQ = 1 << 5
+      CALL_KWARG = 1 << 6
+      CALL_KW_SPLAT = 1 << 7
+      CALL_TAILCALL = 1 << 8
+      CALL_SUPER = 1 << 9
+      CALL_ZSUPER = 1 << 10
+      CALL_OPT_SEND = 1 << 11
+      CALL_KW_SPLAT_MUT = 1 << 12
+
+      attr_reader :method, :argc, :flags, :kw_arg
+
+      def initialize(
+        method,
+        argc = 0,
+        flags = CallData::CALL_ARGS_SIMPLE,
+        kw_arg = nil
+      )
+        @method = method
+        @argc = argc
+        @flags = flags
+        @kw_arg = kw_arg
+      end
+
+      def flag?(mask)
+        (flags & mask) > 0
+      end
+
+      def to_h
+        result = { mid: method, flag: flags, orig_argc: argc }
+        result[:kw_arg] = kw_arg if kw_arg
+        result
+      end
+
+      def self.from(serialized)
+        new(
+          serialized[:mid],
+          serialized[:orig_argc],
+          serialized[:flag],
+          serialized[:kw_arg]
+        )
+      end
+    end
+
+    # A convenience method for creating a CallData object.
+    def self.calldata(
+      method,
+      argc = 0,
+      flags = CallData::CALL_ARGS_SIMPLE,
+      kw_arg = nil
+    )
+      CallData.new(method, argc, flags, kw_arg)
+    end
+
+    # ### Summary
+    #
+    # `adjuststack` accepts a single integer argument and removes that many
+    # elements from the top of the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = [true]
+    # x[0] ||= nil
+    # x[0]
+    # ~~~
+    #
+    class AdjustStack
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("adjuststack", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:adjuststack, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.pop(number)
+      end
+    end
+
+    # ### Summary
+    #
+    # `anytostring` ensures that the value on top of the stack is a string.
+    #
+    # It pops two values off the stack. If the first value is a string it
+    # pushes it back on the stack. If the first value is not a string, it uses
+    # Ruby's built in string coercion to coerce the second value to a string
+    # and then pushes that back on the stack.
+    #
+    # This is used in conjunction with `objtostring` as a fallback for when an
+    # object's `to_s` method does not return a string.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "#{5}"
+    # ~~~
+    #
+    class AnyToString
+      def disasm(fmt)
+        fmt.instruction("anytostring")
+      end
+
+      def to_a(_iseq)
+        [:anytostring]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        original, value = vm.pop(2)
+
+        if value.is_a?(String)
+          vm.push(value)
+        else
+          vm.push("#<#{original.class.name}:0000>")
+        end
+      end
+    end
+
+    # ### Summary
+    #
+    # `branchif` has one argument: the jump index. It pops one value off the
+    # stack: the jump condition.
+    #
+    # If the value popped off the stack is true, `branchif` jumps to
+    # the jump index and continues executing there.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = true
+    # x ||= "foo"
+    # puts x
+    # ~~~
+    #
+    class BranchIf
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def disasm(fmt)
+        fmt.instruction("branchif", [fmt.label(label)])
+      end
+
+      def to_a(_iseq)
+        [:branchif, label.name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.jump(label) if vm.pop
+      end
+    end
+
+    # ### Summary
+    #
+    # `branchnil` has one argument: the jump index. It pops one value off the
+    # stack: the jump condition.
+    #
+    # If the value popped off the stack is nil, `branchnil` jumps to
+    # the jump index and continues executing there.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = nil
+    # if x&.to_s
+    #   puts "hi"
+    # end
+    # ~~~
+    #
+    class BranchNil
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def disasm(fmt)
+        fmt.instruction("branchnil", [fmt.label(label)])
+      end
+
+      def to_a(_iseq)
+        [:branchnil, label.name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.jump(label) if vm.pop.nil?
+      end
+    end
+
+    # ### Summary
+    #
+    # `branchunless` has one argument: the jump index. It pops one value off
+    # the stack: the jump condition.
+    #
+    # If the value popped off the stack is false or nil, `branchunless` jumps
+    # to the jump index and continues executing there.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # if 2 + 3
+    #   puts "foo"
+    # end
+    # ~~~
+    #
+    class BranchUnless
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def disasm(fmt)
+        fmt.instruction("branchunless", [fmt.label(label)])
+      end
+
+      def to_a(_iseq)
+        [:branchunless, label.name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.jump(label) unless vm.pop
+      end
+    end
+
+    # ### Summary
+    #
+    # `checkkeyword` checks if a keyword was passed at the callsite that
+    # called into the method represented by the instruction sequence. It has
+    # two arguments: the index of the local variable that stores the keywords
+    # metadata and the index of the keyword within that metadata. It pushes
+    # a boolean onto the stack indicating whether or not the keyword was
+    # given.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def evaluate(value: rand)
+    #   value
+    # end
+    #
+    # evaluate(value: 3)
+    # ~~~
+    #
+    class CheckKeyword
+      attr_reader :keyword_bits_index, :keyword_index
+
+      def initialize(keyword_bits_index, keyword_index)
+        @keyword_bits_index = keyword_bits_index
+        @keyword_index = keyword_index
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "checkkeyword",
+          [fmt.object(keyword_bits_index), fmt.object(keyword_index)]
+        )
+      end
+
+      def to_a(iseq)
+        [
+          :checkkeyword,
+          iseq.local_table.offset(keyword_bits_index),
+          keyword_index
+        ]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.local_get(keyword_bits_index, 0)[keyword_index])
+      end
+    end
+
+    # ### Summary
+    #
+    # `checkmatch` checks if the current pattern matches the current value. It
+    # pops the target and the pattern off the stack and pushes a boolean onto
+    # the stack if it matches or not.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # foo in Foo
+    # ~~~
+    #
+    class CheckMatch
+      TYPE_WHEN = 1
+      TYPE_CASE = 2
+      TYPE_RESCUE = 3
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def disasm(fmt)
+        fmt.instruction("checkmatch", [fmt.object(type)])
+      end
+
+      def to_a(_iseq)
+        [:checkmatch, type]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        raise NotImplementedError, "checkmatch"
+      end
+    end
+
+    # ### Summary
+    #
+    # `checktype` checks if the value on top of the stack is of a certain type.
+    # The type is the only argument. It pops the value off the stack and pushes
+    # a boolean onto the stack indicating whether or not the value is of the
+    # given type.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # foo in [bar]
+    # ~~~
+    #
+    class CheckType
+      TYPE_OBJECT = 0x01
+      TYPE_CLASS = 0x02
+      TYPE_MODULE = 0x03
+      TYPE_FLOAT = 0x04
+      TYPE_STRING = 0x05
+      TYPE_REGEXP = 0x06
+      TYPE_ARRAY = 0x07
+      TYPE_HASH = 0x08
+      TYPE_STRUCT = 0x09
+      TYPE_BIGNUM = 0x0a
+      TYPE_FILE = 0x0b
+      TYPE_DATA = 0x0c
+      TYPE_MATCH = 0x0d
+      TYPE_COMPLEX = 0x0e
+      TYPE_RATIONAL = 0x0f
+      TYPE_NIL = 0x11
+      TYPE_TRUE = 0x12
+      TYPE_FALSE = 0x13
+      TYPE_SYMBOL = 0x14
+      TYPE_FIXNUM = 0x15
+      TYPE_UNDEF = 0x16
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def disasm(fmt)
+        name =
+          case type
+          when TYPE_OBJECT
+            "T_OBJECT"
+          when TYPE_CLASS
+            "T_CLASS"
+          when TYPE_MODULE
+            "T_MODULE"
+          when TYPE_FLOAT
+            "T_FLOAT"
+          when TYPE_STRING
+            "T_STRING"
+          when TYPE_REGEXP
+            "T_REGEXP"
+          when TYPE_ARRAY
+            "T_ARRAY"
+          when TYPE_HASH
+            "T_HASH"
+          when TYPE_STRUCT
+            "T_STRUCT"
+          when TYPE_BIGNUM
+            "T_BIGNUM"
+          when TYPE_FILE
+            "T_FILE"
+          when TYPE_DATA
+            "T_DATA"
+          when TYPE_MATCH
+            "T_MATCH"
+          when TYPE_COMPLEX
+            "T_COMPLEX"
+          when TYPE_RATIONAL
+            "T_RATIONAL"
+          when TYPE_NIL
+            "T_NIL"
+          when TYPE_TRUE
+            "T_TRUE"
+          when TYPE_FALSE
+            "T_FALSE"
+          when TYPE_SYMBOL
+            "T_SYMBOL"
+          when TYPE_FIXNUM
+            "T_FIXNUM"
+          when TYPE_UNDEF
+            "T_UNDEF"
+          end
+
+        fmt.instruction("checktype", [name])
+      end
+
+      def to_a(_iseq)
+        [:checktype, type]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        # TODO: This is incorrect. The instruction only pushes a single value
+        # onto the stack. However, if this is set to 1, we no longer match the
+        # output of RubyVM::InstructionSequence. So leaving this here until we
+        # can investigate further.
+        2
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        object = vm.pop
+        result =
+          case type
+          when TYPE_OBJECT
+            raise NotImplementedError, "checktype TYPE_OBJECT"
+          when TYPE_CLASS
+            object.is_a?(Class)
+          when TYPE_MODULE
+            object.is_a?(Module)
+          when TYPE_FLOAT
+            object.is_a?(Float)
+          when TYPE_STRING
+            object.is_a?(String)
+          when TYPE_REGEXP
+            object.is_a?(Regexp)
+          when TYPE_ARRAY
+            object.is_a?(Array)
+          when TYPE_HASH
+            object.is_a?(Hash)
+          when TYPE_STRUCT
+            object.is_a?(Struct)
+          when TYPE_BIGNUM
+            raise NotImplementedError, "checktype TYPE_BIGNUM"
+          when TYPE_FILE
+            object.is_a?(File)
+          when TYPE_DATA
+            raise NotImplementedError, "checktype TYPE_DATA"
+          when TYPE_MATCH
+            raise NotImplementedError, "checktype TYPE_MATCH"
+          when TYPE_COMPLEX
+            object.is_a?(Complex)
+          when TYPE_RATIONAL
+            object.is_a?(Rational)
+          when TYPE_NIL
+            object.nil?
+          when TYPE_TRUE
+            object == true
+          when TYPE_FALSE
+            object == false
+          when TYPE_SYMBOL
+            object.is_a?(Symbol)
+          when TYPE_FIXNUM
+            object.is_a?(Integer)
+          when TYPE_UNDEF
+            raise NotImplementedError, "checktype TYPE_UNDEF"
+          end
+
+        vm.push(result)
+      end
+    end
+
+    # ### Summary
+    #
+    # `concatarray` concatenates the two Arrays on top of the stack.
+    #
+    # It coerces the two objects at the top of the stack into Arrays by
+    # calling `to_a` if necessary, and makes sure to `dup` the first Array if
+    # it was already an Array, to avoid mutating it when concatenating.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [1, *2]
+    # ~~~
+    #
+    class ConcatArray
+      def disasm(fmt)
+        fmt.instruction("concatarray")
+      end
+
+      def to_a(_iseq)
+        [:concatarray]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        left, right = vm.pop(2)
+        vm.push([*left, *right])
+      end
+    end
+
+    # ### Summary
+    #
+    # `concatstrings` pops a number of strings from the stack joins them
+    # together into a single string and pushes that string back on the stack.
+    #
+    # This does no coercion and so is always used in conjunction with
+    # `objtostring` and `anytostring` to ensure the stack contents are always
+    # strings.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "#{5}"
+    # ~~~
+    #
+    class ConcatStrings
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("concatstrings", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:concatstrings, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number).join)
+      end
+    end
+
+    # ### Summary
+    #
+    # `defineclass` defines a class. First it pops the superclass off the
+    # stack, then it pops the object off the stack that the class should be
+    # defined under. It has three arguments: the name of the constant, the
+    # instruction sequence associated with the class, and various flags that
+    # indicate if it is a singleton class, a module, or a regular class.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # class Foo
+    # end
+    # ~~~
+    #
+    class DefineClass
+      TYPE_CLASS = 0
+      TYPE_SINGLETON_CLASS = 1
+      TYPE_MODULE = 2
+      FLAG_SCOPED = 8
+      FLAG_HAS_SUPERCLASS = 16
+
+      attr_reader :name, :class_iseq, :flags
+
+      def initialize(name, class_iseq, flags)
+        @name = name
+        @class_iseq = class_iseq
+        @flags = flags
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(class_iseq)
+        fmt.instruction(
+          "defineclass",
+          [fmt.object(name), class_iseq.name, fmt.object(flags)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:defineclass, name, class_iseq.to_a, flags]
+      end
+
+      def length
+        4
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        object, superclass = vm.pop(2)
+        iseq = class_iseq
+
+        clazz = Class.new(superclass || Object)
+        vm.push(vm.run_class_frame(iseq, clazz))
+
+        object.const_set(name, clazz)
+      end
+    end
+
+    # ### Summary
+    #
+    # `defined` checks if the top value of the stack is defined. If it is, it
+    # pushes its value onto the stack. Otherwise it pushes `nil`.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # defined?(x)
+    # ~~~
+    #
+    class Defined
+      TYPE_NIL = 1
+      TYPE_IVAR = 2
+      TYPE_LVAR = 3
+      TYPE_GVAR = 4
+      TYPE_CVAR = 5
+      TYPE_CONST = 6
+      TYPE_METHOD = 7
+      TYPE_YIELD = 8
+      TYPE_ZSUPER = 9
+      TYPE_SELF = 10
+      TYPE_TRUE = 11
+      TYPE_FALSE = 12
+      TYPE_ASGN = 13
+      TYPE_EXPR = 14
+      TYPE_REF = 15
+      TYPE_FUNC = 16
+      TYPE_CONST_FROM = 17
+
+      attr_reader :type, :name, :message
+
+      def initialize(type, name, message)
+        @type = type
+        @name = name
+        @message = message
+      end
+
+      def disasm(fmt)
+        type_name =
+          case type
+          when TYPE_NIL
+            "nil"
+          when TYPE_IVAR
+            "ivar"
+          when TYPE_LVAR
+            "lvar"
+          when TYPE_GVAR
+            "gvar"
+          when TYPE_CVAR
+            "cvar"
+          when TYPE_CONST
+            "const"
+          when TYPE_METHOD
+            "method"
+          when TYPE_YIELD
+            "yield"
+          when TYPE_ZSUPER
+            "zsuper"
+          when TYPE_SELF
+            "self"
+          when TYPE_TRUE
+            "true"
+          when TYPE_FALSE
+            "false"
+          when TYPE_ASGN
+            "asgn"
+          when TYPE_EXPR
+            "expr"
+          when TYPE_REF
+            "ref"
+          when TYPE_FUNC
+            "func"
+          when TYPE_CONST_FROM
+            "constant-from"
+          end
+
+        fmt.instruction(
+          "defined",
+          [type_name, fmt.object(name), fmt.object(message)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:defined, type, name, message]
+      end
+
+      def length
+        4
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        object = vm.pop
+
+        result =
+          case type
+          when TYPE_NIL, TYPE_SELF, TYPE_TRUE, TYPE_FALSE, TYPE_ASGN, TYPE_EXPR
+            message
+          when TYPE_IVAR
+            message if vm._self.instance_variable_defined?(name)
+          when TYPE_LVAR
+            raise NotImplementedError, "defined TYPE_LVAR"
+          when TYPE_GVAR
+            message if global_variables.include?(name)
+          when TYPE_CVAR
+            clazz = vm._self
+            clazz = clazz.singleton_class unless clazz.is_a?(Module)
+            message if clazz.class_variable_defined?(name)
+          when TYPE_CONST
+            raise NotImplementedError, "defined TYPE_CONST"
+          when TYPE_METHOD
+            raise NotImplementedError, "defined TYPE_METHOD"
+          when TYPE_YIELD
+            raise NotImplementedError, "defined TYPE_YIELD"
+          when TYPE_ZSUPER
+            raise NotImplementedError, "defined TYPE_ZSUPER"
+          when TYPE_REF
+            raise NotImplementedError, "defined TYPE_REF"
+          when TYPE_FUNC
+            message if object.respond_to?(name, true)
+          when TYPE_CONST_FROM
+            raise NotImplementedError, "defined TYPE_CONST_FROM"
+          end
+
+        vm.push(result)
+      end
+    end
+
+    # ### Summary
+    #
+    # `definemethod` defines a method on the class of the current value of
+    # `self`. It accepts two arguments. The first is the name of the method
+    # being defined. The second is the instruction sequence representing the
+    # body of the method.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def value = "value"
+    # ~~~
+    #
+    class DefineMethod
+      attr_reader :method_name, :method_iseq
+
+      def initialize(method_name, method_iseq)
+        @method_name = method_name
+        @method_iseq = method_iseq
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(method_iseq)
+        fmt.instruction(
+          "definemethod",
+          [fmt.object(method_name), method_iseq.name]
+        )
+      end
+
+      def to_a(_iseq)
+        [:definemethod, method_name, method_iseq.to_a]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        name = method_name
+        iseq = method_iseq
+
+        vm
+          ._self
+          .__send__(:define_method, name) do |*args, **kwargs, &block|
+            vm.run_method_frame(name, iseq, self, *args, **kwargs, &block)
+          end
+      end
+    end
+
+    # ### Summary
+    #
+    # `definesmethod` defines a method on the singleton class of the current
+    # value of `self`. It accepts two arguments. The first is the name of the
+    # method being defined. The second is the instruction sequence representing
+    # the body of the method. It pops the object off the stack that the method
+    # should be defined on.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def self.value = "value"
+    # ~~~
+    #
+    class DefineSMethod
+      attr_reader :method_name, :method_iseq
+
+      def initialize(method_name, method_iseq)
+        @method_name = method_name
+        @method_iseq = method_iseq
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(method_iseq)
+        fmt.instruction(
+          "definesmethod",
+          [fmt.object(method_name), method_iseq.name]
+        )
+      end
+
+      def to_a(_iseq)
+        [:definesmethod, method_name, method_iseq.to_a]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        name = method_name
+        iseq = method_iseq
+
+        vm
+          ._self
+          .__send__(:define_singleton_method, name) do |*args, **kwargs, &block|
+            vm.run_method_frame(name, iseq, self, *args, **kwargs, &block)
+          end
+      end
+    end
+
+    # ### Summary
+    #
+    # `dup` copies the top value of the stack and pushes it onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # $global = 5
+    # ~~~
+    #
+    class Dup
+      def disasm(fmt)
+        fmt.instruction("dup")
+      end
+
+      def to_a(_iseq)
+        [:dup]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        2
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.stack.last.dup)
+      end
+    end
+
+    # ### Summary
+    #
+    # `duparray` dups an Array literal and pushes it onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [true]
+    # ~~~
+    #
+    class DupArray
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("duparray", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:duparray, object]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(object.dup)
+      end
+    end
+
+    # ### Summary
+    #
+    # `duphash` dups a Hash literal and pushes it onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # { a: 1 }
+    # ~~~
+    #
+    class DupHash
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("duphash", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:duphash, object]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(object.dup)
+      end
+    end
+
+    # ### Summary
+    #
+    # `dupn` duplicates the top `n` stack elements.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # Object::X ||= true
+    # ~~~
+    #
+    class DupN
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("dupn", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:dupn, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        number
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        values = vm.pop(number)
+        vm.push(*values)
+        vm.push(*values)
+      end
+    end
+
+    # ### Summary
+    #
+    # `expandarray` looks at the top of the stack, and if the value is an array
+    # it replaces it on the stack with `number` elements of the array, or `nil`
+    # if the elements are missing.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x, = [true, false, nil]
+    # ~~~
+    #
+    class ExpandArray
+      attr_reader :number, :flags
+
+      def initialize(number, flags)
+        @number = number
+        @flags = flags
+      end
+
+      def disasm(fmt)
+        fmt.instruction("expandarray", [fmt.object(number), fmt.object(flags)])
+      end
+
+      def to_a(_iseq)
+        [:expandarray, number, flags]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        number
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        raise NotImplementedError, "expandarray"
+      end
+    end
+
+    # ### Summary
+    #
+    # `getblockparam` is a similar instruction to `getlocal` in that it looks
+    # for a local variable in the current instruction sequence's local table and
+    # walks recursively up the parent instruction sequences until it finds it.
+    # The local it retrieves, however, is a special block local that was passed
+    # to the current method. It pushes the value of the block local onto the
+    # stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo(&block)
+    #   block
+    # end
+    # ~~~
+    #
+    class GetBlockParam
+      attr_reader :index, :level
+
+      def initialize(index, level)
+        @index = index
+        @level = level
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getblockparam", [fmt.local(index, explicit: level)])
+      end
+
+      def to_a(iseq)
+        current = iseq
+        level.times { current = iseq.parent_iseq }
+        [:getblockparam, current.local_table.offset(index), level]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.local_get(index, level))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getblockparamproxy` is almost the same as `getblockparam` except that it
+    # pushes a proxy object onto the stack instead of the actual value of the
+    # block local. This is used when a method is being called on the block
+    # local.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo(&block)
+    #   block.call
+    # end
+    # ~~~
+    #
+    class GetBlockParamProxy
+      attr_reader :index, :level
+
+      def initialize(index, level)
+        @index = index
+        @level = level
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "getblockparamproxy",
+          [fmt.local(index, explicit: level)]
+        )
+      end
+
+      def to_a(iseq)
+        current = iseq
+        level.times { current = iseq.parent_iseq }
+        [:getblockparamproxy, current.local_table.offset(index), level]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.local_get(index, level))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getclassvariable` looks for a class variable in the current class and
+    # pushes its value onto the stack. It uses an inline cache to reduce the
+    # need to lookup the class variable in the class hierarchy every time.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # @@class_variable
+    # ~~~
+    #
+    class GetClassVariable
+      attr_reader :name, :cache
+
+      def initialize(name, cache)
+        @name = name
+        @cache = cache
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "getclassvariable",
+          [fmt.object(name), fmt.inline_storage(cache)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:getclassvariable, name, cache]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        clazz = vm._self
+        clazz = clazz.class unless clazz.is_a?(Class)
+        vm.push(clazz.class_variable_get(name))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getconstant` performs a constant lookup and pushes the value of the
+    # constant onto the stack. It pops both the class it should look in and
+    # whether or not it should look globally as well.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # Constant
+    # ~~~
+    #
+    class GetConstant
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getconstant", [fmt.object(name)])
+      end
+
+      def to_a(_iseq)
+        [:getconstant, name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        # const_base, allow_nil =
+        vm.pop(2)
+
+        vm.frame.nesting.reverse_each do |clazz|
+          if clazz.const_defined?(name)
+            vm.push(clazz.const_get(name))
+            return
+          end
+        end
+
+        raise NameError, "uninitialized constant #{name}"
+      end
+    end
+
+    # ### Summary
+    #
+    # `getglobal` pushes the value of a global variables onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # $$
+    # ~~~
+    #
+    class GetGlobal
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getglobal", [fmt.object(name)])
+      end
+
+      def to_a(_iseq)
+        [:getglobal, name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        # Evaluating the name of the global variable because there isn't a
+        # reflection API for global variables.
+        vm.push(eval(name.to_s, binding, __FILE__, __LINE__))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getinstancevariable` pushes the value of an instance variable onto the
+    # stack. It uses an inline cache to avoid having to look up the instance
+    # variable in the class hierarchy every time.
+    #
+    # This instruction has two forms, but both have the same structure. Before
+    # Ruby 3.2, the inline cache corresponded to both the get and set
+    # instructions and could be shared. Since Ruby 3.2, it uses object shapes
+    # instead so the caches are unique per instruction.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # @instance_variable
+    # ~~~
+    #
+    class GetInstanceVariable
+      attr_reader :name, :cache
+
+      def initialize(name, cache)
+        @name = name
+        @cache = cache
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "getinstancevariable",
+          [fmt.object(name), fmt.inline_storage(cache)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:getinstancevariable, name, cache]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        method = Object.instance_method(:instance_variable_get)
+        vm.push(method.bind(vm._self).call(name))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getlocal` fetches the value of a local variable from a frame determined
+    # by the level and index arguments. The level is the number of frames back
+    # to look and the index is the index in the local table. It pushes the value
+    # it finds onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # tap { tap { value } }
+    # ~~~
+    #
+    class GetLocal
+      attr_reader :index, :level
+
+      def initialize(index, level)
+        @index = index
+        @level = level
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getlocal", [fmt.local(index, explicit: level)])
+      end
+
+      def to_a(iseq)
+        current = iseq
+        level.times { current = current.parent_iseq }
+        [:getlocal, current.local_table.offset(index), level]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.local_get(index, level))
+      end
+    end
+
+    # ### Summary
+    #
+    # `getlocal_WC_0` is a specialized version of the `getlocal` instruction. It
+    # fetches the value of a local variable from the current frame determined by
+    # the index given as its only argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # value
+    # ~~~
+    #
+    class GetLocalWC0
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getlocal_WC_0", [fmt.local(index, implicit: 0)])
+      end
+
+      def to_a(iseq)
+        [:getlocal_WC_0, iseq.local_table.offset(index)]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        GetLocal.new(index, 0)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `getlocal_WC_1` is a specialized version of the `getlocal` instruction. It
+    # fetches the value of a local variable from the parent frame determined by
+    # the index given as its only argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # self.then { value }
+    # ~~~
+    #
+    class GetLocalWC1
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getlocal_WC_1", [fmt.local(index, implicit: 1)])
+      end
+
+      def to_a(iseq)
+        [:getlocal_WC_1, iseq.parent_iseq.local_table.offset(index)]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        GetLocal.new(index, 1)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `getspecial` pushes the value of a special local variable onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 1 if (a == 1) .. (b == 2)
+    # ~~~
+    #
+    class GetSpecial
+      SVAR_LASTLINE = 0 # $_
+      SVAR_BACKREF = 1 # $~
+      SVAR_FLIPFLOP_START = 2 # flipflop
+
+      attr_reader :key, :type
+
+      def initialize(key, type)
+        @key = key
+        @type = type
+      end
+
+      def disasm(fmt)
+        fmt.instruction("getspecial", [fmt.object(key), fmt.object(type)])
+      end
+
+      def to_a(_iseq)
+        [:getspecial, key, type]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        case key
+        when SVAR_LASTLINE
+          raise NotImplementedError, "getspecial SVAR_LASTLINE"
+        when SVAR_BACKREF
+          raise NotImplementedError, "getspecial SVAR_BACKREF"
+        when SVAR_FLIPFLOP_START
+          vm.frame_svar.svars[SVAR_FLIPFLOP_START]
+        end
+      end
+    end
+
+    # ### Summary
+    #
+    # `intern` converts the top element of the stack to a symbol and pushes the
+    # symbol onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # :"#{"foo"}"
+    # ~~~
+    #
+    class Intern
+      def disasm(fmt)
+        fmt.instruction("intern")
+      end
+
+      def to_a(_iseq)
+        [:intern]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop.to_sym)
+      end
+    end
+
+    # ### Summary
+    #
+    # `invokeblock` invokes the block given to the current method. It pops the
+    # arguments for the block off the stack and pushes the result of running the
+    # block onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo
+    #   yield
+    # end
+    # ~~~
+    #
+    class InvokeBlock
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("invokeblock", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:invokeblock, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        calldata.argc
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.frame_yield.block.call(*vm.pop(calldata.argc)))
+      end
+    end
+
+    # ### Summary
+    #
+    # `invokesuper` is similar to the `send` instruction, except that it calls
+    # the super method. It pops the receiver and arguments off the stack and
+    # pushes the return value onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo
+    #   super
+    # end
+    # ~~~
+    #
+    class InvokeSuper
+      attr_reader :calldata, :block_iseq
+
+      def initialize(calldata, block_iseq)
+        @calldata = calldata
+        @block_iseq = block_iseq
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(block_iseq) if block_iseq
+        fmt.instruction(
+          "invokesuper",
+          [fmt.calldata(calldata), block_iseq&.name || "nil"]
+        )
+      end
+
+      def to_a(_iseq)
+        [:invokesuper, calldata.to_h, block_iseq&.to_a]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        argb = (calldata.flag?(CallData::CALL_ARGS_BLOCKARG) ? 1 : 0)
+        argb + calldata.argc + 1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        block =
+          if (iseq = block_iseq)
+            ->(*args, **kwargs, &blk) do
+              vm.run_block_frame(iseq, *args, **kwargs, &blk)
+            end
+          end
+
+        keywords =
+          if calldata.kw_arg
+            calldata.kw_arg.zip(vm.pop(calldata.kw_arg.length)).to_h
+          else
+            {}
+          end
+
+        arguments = vm.pop(calldata.argc)
+        receiver = vm.pop
+
+        method = receiver.method(vm.frame.name).super_method
+        vm.push(method.call(*arguments, **keywords, &block))
+      end
+    end
+
+    # ### Summary
+    #
+    # `jump` unconditionally jumps to the label given as its only argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = 0
+    # if x == 0
+    #   puts "0"
+    # else
+    #   puts "2"
+    # end
+    # ~~~
+    #
+    class Jump
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def disasm(fmt)
+        fmt.instruction("jump", [fmt.label(label)])
+      end
+
+      def to_a(_iseq)
+        [:jump, label.name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.jump(label)
+      end
+    end
+
+    # ### Summary
+    #
+    # `leave` exits the current frame.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # ;;
+    # ~~~
+    #
+    class Leave
+      def disasm(fmt)
+        fmt.instruction("leave")
+      end
+
+      def to_a(_iseq)
+        [:leave]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        # TODO: This is wrong. It should be 1. But it's 0 for now because
+        # otherwise the stack size is incorrectly calculated.
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.leave
+      end
+    end
+
+    # ### Summary
+    #
+    # `newarray` puts a new array initialized with `number` values from the
+    # stack. It pops `number` values off the stack and pushes the array onto the
+    # stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # ["string"]
+    # ~~~
+    #
+    class NewArray
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("newarray", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:newarray, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number))
+      end
+    end
+
+    # ### Summary
+    #
+    # `newarraykwsplat` is a specialized version of `newarray` that takes a **
+    # splat argument. It pops `number` values off the stack and pushes the array
+    # onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # ["string", **{ foo: "bar" }]
+    # ~~~
+    #
+    class NewArrayKwSplat
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("newarraykwsplat", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:newarraykwsplat, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number))
+      end
+    end
+
+    # ### Summary
+    #
+    # `newhash` puts a new hash onto the stack, using `number` elements from the
+    # stack. `number` needs to be even. It pops `number` elements off the stack
+    # and pushes a hash onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo(key, value)
+    #   { key => value }
+    # end
+    # ~~~
+    #
+    class NewHash
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("newhash", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:newhash, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number).each_slice(2).to_h)
+      end
+    end
+
+    # ### Summary
+    #
+    # `newrange` creates a new range object from the top two values on the
+    # stack. It pops both of them off, and then pushes on the new range. It
+    # takes one argument which is 0 if the end is included or 1 if the end value
+    # is excluded.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = 0
+    # y = 1
+    # p (x..y), (x...y)
+    # ~~~
+    #
+    class NewRange
+      attr_reader :exclude_end
+
+      def initialize(exclude_end)
+        @exclude_end = exclude_end
+      end
+
+      def disasm(fmt)
+        fmt.instruction("newrange", [fmt.object(exclude_end)])
+      end
+
+      def to_a(_iseq)
+        [:newrange, exclude_end]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(Range.new(*vm.pop(2), exclude_end == 1))
+      end
+    end
+
+    # ### Summary
+    #
+    # `nop` is a no-operation instruction. It is used to pad the instruction
+    # sequence so there is a place for other instructions to jump to.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # raise rescue true
+    # ~~~
+    #
+    class Nop
+      def disasm(fmt)
+        fmt.instruction("nop")
+      end
+
+      def to_a(_iseq)
+        [:nop]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `objtostring` pops a value from the stack, calls `to_s` on that value and
+    # then pushes the result back to the stack.
+    #
+    # It has various fast paths for classes like String, Symbol, Module, Class,
+    # etc. For everything else it calls `to_s`.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "#{5}"
+    # ~~~
+    #
+    class ObjToString
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("objtostring", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:objtostring, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop.to_s)
+      end
+    end
+
+    # ### Summary
+    #
+    # `once` is an instruction that wraps an instruction sequence and ensures
+    # that is it only ever executed once for the lifetime of the program. It
+    # uses a cache to ensure that it is only executed once. It pushes the result
+    # of running the instruction sequence onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # END { puts "END" }
+    # ~~~
+    #
+    class Once
+      attr_reader :iseq, :cache
+
+      def initialize(iseq, cache)
+        @iseq = iseq
+        @cache = cache
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(iseq)
+        fmt.instruction("once", [iseq.name, fmt.inline_storage(cache)])
+      end
+
+      def to_a(_iseq)
+        [:once, iseq.to_a, cache]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        return if @executed
+        vm.push(vm.run_block_frame(iseq))
+        @executed = true
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_and` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `&` operator is used. There is a fast path for if
+    # both operands are integers. It pops both the receiver and the argument off
+    # the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 & 3
+    # ~~~
+    #
+    class OptAnd
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_and", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_and, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_aref` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `[]` operator is used. There are fast paths if the
+    # receiver is an integer, array, or hash.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 7[2]
+    # ~~~
+    #
+    class OptAref
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_aref", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_aref, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_aref_with` is a specialization of the `opt_aref` instruction that
+    # occurs when the `[]` operator is used with a string argument known at
+    # compile time. There are fast paths if the receiver is a hash. It pops the
+    # receiver off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # { 'test' => true }['test']
+    # ~~~
+    #
+    class OptArefWith
+      attr_reader :object, :calldata
+
+      def initialize(object, calldata)
+        @object = object
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_aref_with",
+          [fmt.object(object), fmt.calldata(calldata)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:opt_aref_with, object, calldata.to_h]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop[object])
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_aset` is an instruction for setting the hash value by the key in
+    # the `recv[obj] = set` format. It is a specialization of the
+    # `opt_send_without_block` instruction. It pops the receiver, the key, and
+    # the value off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # {}[:key] = value
+    # ~~~
+    #
+    class OptAset
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_aset", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_aset, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        3
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_aset_with` is an instruction for setting the hash value by the known
+    # string key in the `recv[obj] = set` format. It pops the receiver and the
+    # value off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # {}["key"] = value
+    # ~~~
+    #
+    class OptAsetWith
+      attr_reader :object, :calldata
+
+      def initialize(object, calldata)
+        @object = object
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_aset_with",
+          [fmt.object(object), fmt.calldata(calldata)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:opt_aset_with, object, calldata.to_h]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        hash, value = vm.pop(2)
+        vm.push(hash[object] = value)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_case_dispatch` is a branch instruction that moves the control flow
+    # for case statements that have clauses where they can all be used as hash
+    # keys for an internal hash.
+    #
+    # It has two arguments: the `case_dispatch_hash` and an `else_label`. It
+    # pops one value off the stack: a hash key. `opt_case_dispatch` looks up the
+    # key in the `case_dispatch_hash` and jumps to the corresponding label if
+    # there is one. If there is no value in the `case_dispatch_hash`,
+    # `opt_case_dispatch` jumps to the `else_label` index.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # case 1
+    # when 1
+    #   puts "foo"
+    # else
+    #   puts "bar"
+    # end
+    # ~~~
+    #
+    class OptCaseDispatch
+      attr_reader :case_dispatch_hash, :else_label
+
+      def initialize(case_dispatch_hash, else_label)
+        @case_dispatch_hash = case_dispatch_hash
+        @else_label = else_label
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_case_dispatch",
+          ["<cdhash>", fmt.label(else_label)]
+        )
+      end
+
+      def to_a(_iseq)
+        [
+          :opt_case_dispatch,
+          case_dispatch_hash.flat_map { |key, value| [key, value.name] },
+          else_label.name
+        ]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.jump(case_dispatch_hash.fetch(vm.pop, else_label))
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_div` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `/` operator is used. There are fast paths for if
+    # both operands are integers, or if both operands are floats. It pops both
+    # the receiver and the argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 / 3
+    # ~~~
+    #
+    class OptDiv
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_div", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_div, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_empty_p` is an optimization applied when the method `empty?` is
+    # called. It pops the receiver off the stack and pushes on the result of the
+    # method call.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "".empty?
+    # ~~~
+    #
+    class OptEmptyP
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_empty_p", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_empty_p, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_eq` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the == operator is used. Fast paths exist when both
+    # operands are integers, floats, symbols or strings. It pops both the
+    # receiver and the argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 == 2
+    # ~~~
+    #
+    class OptEq
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_eq", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_eq, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_ge` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the >= operator is used. Fast paths exist when both
+    # operands are integers or floats. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 4 >= 3
+    # ~~~
+    #
+    class OptGE
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_ge", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_ge, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_getconstant_path` performs a constant lookup on a chain of constant
+    # names. It accepts as its argument an array of constant names, and pushes
+    # the value of the constant onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # ::Object
+    # ~~~
+    #
+    class OptGetConstantPath
+      attr_reader :names
+
+      def initialize(names)
+        @names = names
+      end
+
+      def disasm(fmt)
+        cache = "<ic:0 #{names.join("::")}>"
+        fmt.instruction("opt_getconstant_path", [cache])
+      end
+
+      def to_a(_iseq)
+        [:opt_getconstant_path, names]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        current = vm._self
+        current = current.class unless current.is_a?(Class)
+
+        names.each do |name|
+          current = name == :"" ? Object : current.const_get(name)
+        end
+
+        vm.push(current)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_gt` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the > operator is used. Fast paths exist when both
+    # operands are integers or floats. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 4 > 3
+    # ~~~
+    #
+    class OptGT
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_gt", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_gt, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_le` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the <= operator is used. Fast paths exist when both
+    # operands are integers or floats. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 3 <= 4
+    # ~~~
+    #
+    class OptLE
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_le", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_le, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_length` is a specialization of `opt_send_without_block`, when the
+    # `length` method is called. There are fast paths when the receiver is
+    # either a string, hash, or array. It pops the receiver off the stack and
+    # pushes on the result of the method call.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "".length
+    # ~~~
+    #
+    class OptLength
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_length", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_length, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_lt` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the < operator is used. Fast paths exist when both
+    # operands are integers or floats. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 3 < 4
+    # ~~~
+    #
+    class OptLT
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_lt", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_lt, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_ltlt` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `<<` operator is used. Fast paths exists when the
+    # receiver is either a String or an Array. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "" << 2
+    # ~~~
+    #
+    class OptLTLT
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_ltlt", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_ltlt, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_minus` is a specialization of the `opt_send_without_block`
+    # instruction that occurs when the `-` operator is used. There are fast
+    # paths for if both operands are integers or if both operands are floats. It
+    # pops both the receiver and the argument off the stack and pushes on the
+    # result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 3 - 2
+    # ~~~
+    #
+    class OptMinus
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_minus", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_minus, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_mod` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `%` operator is used. There are fast paths for if
+    # both operands are integers or if both operands are floats. It pops both
+    # the receiver and the argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 4 % 2
+    # ~~~
+    #
+    class OptMod
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_mod", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_mod, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_mult` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `*` operator is used. There are fast paths for if
+    # both operands are integers or floats. It pops both the receiver and the
+    # argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 3 * 2
+    # ~~~
+    #
+    class OptMult
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_mult", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_mult, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_neq` is an optimization that tests whether two values at the top of
+    # the stack are not equal by testing their equality and calling the `!` on
+    # the result. This allows `opt_neq` to use the fast paths optimized in
+    # `opt_eq` when both operands are Integers, Floats, Symbols, or Strings. It
+    # pops both the receiver and the argument off the stack and pushes on the
+    # result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 != 2
+    # ~~~
+    #
+    class OptNEq
+      attr_reader :eq_calldata, :neq_calldata
+
+      def initialize(eq_calldata, neq_calldata)
+        @eq_calldata = eq_calldata
+        @neq_calldata = neq_calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_neq",
+          [fmt.calldata(eq_calldata), fmt.calldata(neq_calldata)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:opt_neq, eq_calldata.to_h, neq_calldata.to_h]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        receiver, argument = vm.pop(2)
+        vm.push(receiver != argument)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_newarray_max` is a specialization that occurs when the `max` method
+    # is called on an array literal. It pops the values of the array off the
+    # stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [a, b, c].max
+    # ~~~
+    #
+    class OptNewArrayMax
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_newarray_max", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:opt_newarray_max, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number).max)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_newarray_min` is a specialization that occurs when the `min` method
+    # is called on an array literal. It pops the values of the array off the
+    # stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [a, b, c].min
+    # ~~~
+    #
+    class OptNewArrayMin
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_newarray_min", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:opt_newarray_min, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        number
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.pop(number).min)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_nil_p` is an optimization applied when the method `nil?` is called.
+    # It returns true immediately when the receiver is `nil` and defers to the
+    # `nil?` method in other cases. It pops the receiver off the stack and
+    # pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "".nil?
+    # ~~~
+    #
+    class OptNilP
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_nil_p", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_nil_p, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_not` negates the value on top of the stack by calling the `!` method
+    # on it. It pops the receiver off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # !true
+    # ~~~
+    #
+    class OptNot
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_not", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_not, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_or` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `|` operator is used. There is a fast path for if
+    # both operands are integers. It pops both the receiver and the argument off
+    # the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 | 3
+    # ~~~
+    #
+    class OptOr
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_or", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_or, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_plus` is a specialization of the `opt_send_without_block` instruction
+    # that occurs when the `+` operator is used. There are fast paths for if
+    # both operands are integers, floats, strings, or arrays. It pops both the
+    # receiver and the argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 2 + 3
+    # ~~~
+    #
+    class OptPlus
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_plus", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_plus, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_regexpmatch2` is a specialization of the `opt_send_without_block`
+    # instruction that occurs when the `=~` operator is used. It pops both the
+    # receiver and the argument off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # /a/ =~ "a"
+    # ~~~
+    #
+    class OptRegExpMatch2
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_regexpmatch2", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_regexpmatch2, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_send_without_block` is a specialization of the send instruction that
+    # occurs when a method is being called without a block. It pops the receiver
+    # and the arguments off the stack and pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # puts "Hello, world!"
+    # ~~~
+    #
+    class OptSendWithoutBlock
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_send_without_block", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_send_without_block, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1 + calldata.argc
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_size` is a specialization of `opt_send_without_block`, when the
+    # `size` method is called. There are fast paths when the receiver is either
+    # a string, hash, or array. It pops the receiver off the stack and pushes on
+    # the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "".size
+    # ~~~
+    #
+    class OptSize
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_size", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_size, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_str_freeze` pushes a frozen known string value with no interpolation
+    # onto the stack using the #freeze method. If the method gets overridden,
+    # this will fall back to a send.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "hello".freeze
+    # ~~~
+    #
+    class OptStrFreeze
+      attr_reader :object, :calldata
+
+      def initialize(object, calldata)
+        @object = object
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_str_freeze",
+          [fmt.object(object), fmt.calldata(calldata)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:opt_str_freeze, object, calldata.to_h]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(object.freeze)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_str_uminus` pushes a frozen known string value with no interpolation
+    # onto the stack. If the method gets overridden, this will fall back to a
+    # send.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # -"string"
+    # ~~~
+    #
+    class OptStrUMinus
+      attr_reader :object, :calldata
+
+      def initialize(object, calldata)
+        @object = object
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "opt_str_uminus",
+          [fmt.object(object), fmt.calldata(calldata)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:opt_str_uminus, object, calldata.to_h]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(-object)
+      end
+    end
+
+    # ### Summary
+    #
+    # `opt_succ` is a specialization of the `opt_send_without_block` instruction
+    # when the method being called is `succ`. Fast paths exist when the receiver
+    # is either a String or a Fixnum. It pops the receiver off the stack and
+    # pushes on the result.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "".succ
+    # ~~~
+    #
+    class OptSucc
+      attr_reader :calldata
+
+      def initialize(calldata)
+        @calldata = calldata
+      end
+
+      def disasm(fmt)
+        fmt.instruction("opt_succ", [fmt.calldata(calldata)])
+      end
+
+      def to_a(_iseq)
+        [:opt_succ, calldata.to_h]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        Send.new(calldata, nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `pop` pops the top value off the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # a ||= 2
+    # ~~~
+    #
+    class Pop
+      def disasm(fmt)
+        fmt.instruction("pop")
+      end
+
+      def to_a(_iseq)
+        [:pop]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.pop
+      end
+    end
+
+    # ### Summary
+    #
+    # `putnil` pushes a global nil object onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # nil
+    # ~~~
+    #
+    class PutNil
+      def disasm(fmt)
+        fmt.instruction("putnil")
+      end
+
+      def to_a(_iseq)
+        [:putnil]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        PutObject.new(nil)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `putobject` pushes a known value onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 5
+    # ~~~
+    #
+    class PutObject
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("putobject", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:putobject, object]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(object)
+      end
+    end
+
+    # ### Summary
+    #
+    # `putobject_INT2FIX_0_` pushes 0 on the stack. It is a specialized
+    # instruction resulting from the operand unification optimization. It is
+    # equivalent to `putobject 0`.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 0
+    # ~~~
+    #
+    class PutObjectInt2Fix0
+      def disasm(fmt)
+        fmt.instruction("putobject_INT2FIX_0_")
+      end
+
+      def to_a(_iseq)
+        [:putobject_INT2FIX_0_]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        PutObject.new(0)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `putobject_INT2FIX_1_` pushes 1 on the stack. It is a specialized
+    # instruction resulting from the operand unification optimization. It is
+    # equivalent to `putobject 1`.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # 1
+    # ~~~
+    #
+    class PutObjectInt2Fix1
+      def disasm(fmt)
+        fmt.instruction("putobject_INT2FIX_1_")
+      end
+
+      def to_a(_iseq)
+        [:putobject_INT2FIX_1_]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        PutObject.new(1)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `putself` pushes the current value of self onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # puts "Hello, world!"
+    # ~~~
+    #
+    class PutSelf
+      def disasm(fmt)
+        fmt.instruction("putself")
+      end
+
+      def to_a(_iseq)
+        [:putself]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm._self)
+      end
+    end
+
+    # ### Summary
+    #
+    # `putspecialobject` pushes one of three special objects onto the stack.
+    # These are either the VM core special object, the class base special
+    # object, or the constant base special object.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # alias foo bar
+    # ~~~
+    #
+    class PutSpecialObject
+      OBJECT_VMCORE = 1
+      OBJECT_CBASE = 2
+      OBJECT_CONST_BASE = 3
+
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("putspecialobject", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:putspecialobject, object]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        case object
+        when OBJECT_VMCORE
+          vm.push(vm.frozen_core)
+        when OBJECT_CBASE
+          value = vm._self
+          value = value.singleton_class unless value.is_a?(Class)
+          vm.push(value)
+        when OBJECT_CONST_BASE
+          vm.push(vm.const_base)
+        end
+      end
+    end
+
+    # ### Summary
+    #
+    # `putstring` pushes an unfrozen string literal onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "foo"
+    # ~~~
+    #
+    class PutString
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("putstring", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:putstring, object]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(object.dup)
+      end
+    end
+
+    # ### Summary
+    #
+    # `send` invokes a method with an optional block. It pops its receiver and
+    # the arguments for the method off the stack and pushes the return value
+    # onto the stack. It has two arguments: the calldata for the call site and
+    # the optional block instruction sequence.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "hello".tap { |i| p i }
+    # ~~~
+    #
+    class Send
+      attr_reader :calldata, :block_iseq
+
+      def initialize(calldata, block_iseq)
+        @calldata = calldata
+        @block_iseq = block_iseq
+      end
+
+      def disasm(fmt)
+        fmt.enqueue(block_iseq) if block_iseq
+        fmt.instruction(
+          "send",
+          [fmt.calldata(calldata), block_iseq&.name || "nil"]
+        )
+      end
+
+      def to_a(_iseq)
+        [:send, calldata.to_h, block_iseq&.to_a]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        argb = (calldata.flag?(CallData::CALL_ARGS_BLOCKARG) ? 1 : 0)
+        argb + calldata.argc + 1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        block =
+          if (iseq = block_iseq)
+            ->(*args, **kwargs, &blk) do
+              vm.run_block_frame(iseq, *args, **kwargs, &blk)
+            end
+          end
+
+        keywords =
+          if calldata.kw_arg
+            calldata.kw_arg.zip(vm.pop(calldata.kw_arg.length)).to_h
+          else
+            {}
+          end
+
+        arguments = vm.pop(calldata.argc)
+        receiver = vm.pop
+
+        vm.push(
+          receiver.__send__(calldata.method, *arguments, **keywords, &block)
+        )
+      end
+    end
+
+    # ### Summary
+    #
+    # `setblockparam` sets the value of a block local variable on a frame
+    # determined by the level and index arguments. The level is the number of
+    # frames back to look and the index is the index in the local table. It pops
+    # the value it is setting off the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # def foo(&bar)
+    #   bar = baz
+    # end
+    # ~~~
+    #
+    class SetBlockParam
+      attr_reader :index, :level
+
+      def initialize(index, level)
+        @index = index
+        @level = level
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setblockparam", [fmt.local(index, explicit: level)])
+      end
+
+      def to_a(iseq)
+        current = iseq
+        level.times { current = current.parent_iseq }
+        [:setblockparam, current.local_table.offset(index), level]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.local_set(index, level, vm.pop)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setclassvariable` looks for a class variable in the current class and
+    # sets its value to the value it pops off the top of the stack. It uses an
+    # inline cache to reduce the need to lookup the class variable in the class
+    # hierarchy every time.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # @@class_variable = 1
+    # ~~~
+    #
+    class SetClassVariable
+      attr_reader :name, :cache
+
+      def initialize(name, cache)
+        @name = name
+        @cache = cache
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "setclassvariable",
+          [fmt.object(name), fmt.inline_storage(cache)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:setclassvariable, name, cache]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        clazz = vm._self
+        clazz = clazz.class unless clazz.is_a?(Class)
+        clazz.class_variable_set(name, vm.pop)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setconstant` pops two values off the stack: the value to set the
+    # constant to and the constant base to set it in.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # Constant = 1
+    # ~~~
+    #
+    class SetConstant
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setconstant", [fmt.object(name)])
+      end
+
+      def to_a(_iseq)
+        [:setconstant, name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        value, parent = vm.pop(2)
+        parent.const_set(name, value)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setglobal` sets the value of a global variable to a value popped off the
+    # top of the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # $global = 5
+    # ~~~
+    #
+    class SetGlobal
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setglobal", [fmt.object(name)])
+      end
+
+      def to_a(_iseq)
+        [:setglobal, name]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        # Evaluating the name of the global variable because there isn't a
+        # reflection API for global variables.
+        eval("#{name} = vm.pop", binding, __FILE__, __LINE__)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setinstancevariable` pops a value off the top of the stack and then sets
+    # the instance variable associated with the instruction to that value.
+    #
+    # This instruction has two forms, but both have the same structure. Before
+    # Ruby 3.2, the inline cache corresponded to both the get and set
+    # instructions and could be shared. Since Ruby 3.2, it uses object shapes
+    # instead so the caches are unique per instruction.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # @instance_variable = 1
+    # ~~~
+    #
+    class SetInstanceVariable
+      attr_reader :name, :cache
+
+      def initialize(name, cache)
+        @name = name
+        @cache = cache
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "setinstancevariable",
+          [fmt.object(name), fmt.inline_storage(cache)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:setinstancevariable, name, cache]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        method = Object.instance_method(:instance_variable_set)
+        method.bind(vm._self).call(name, vm.pop)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setlocal` sets the value of a local variable on a frame determined by the
+    # level and index arguments. The level is the number of frames back to
+    # look and the index is the index in the local table. It pops the value it
+    # is setting off the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # tap { tap { value = 10 } }
+    # ~~~
+    #
+    class SetLocal
+      attr_reader :index, :level
+
+      def initialize(index, level)
+        @index = index
+        @level = level
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setlocal", [fmt.local(index, explicit: level)])
+      end
+
+      def to_a(iseq)
+        current = iseq
+        level.times { current = current.parent_iseq }
+        [:setlocal, current.local_table.offset(index), level]
+      end
+
+      def length
+        3
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.local_set(index, level, vm.pop)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setlocal_WC_0` is a specialized version of the `setlocal` instruction. It
+    # sets the value of a local variable on the current frame to the value at
+    # the top of the stack as determined by the index given as its only
+    # argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # ~~~
+    #
+    class SetLocalWC0
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setlocal_WC_0", [fmt.local(index, implicit: 0)])
+      end
+
+      def to_a(iseq)
+        [:setlocal_WC_0, iseq.local_table.offset(index)]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        SetLocal.new(index, 0)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setlocal_WC_1` is a specialized version of the `setlocal` instruction. It
+    # sets the value of a local variable on the parent frame to the value at the
+    # top of the stack as determined by the index given as its only argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # value = 5
+    # self.then { value = 10 }
+    # ~~~
+    #
+    class SetLocalWC1
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setlocal_WC_1", [fmt.local(index, implicit: 1)])
+      end
+
+      def to_a(iseq)
+        [:setlocal_WC_1, iseq.parent_iseq.local_table.offset(index)]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        SetLocal.new(index, 1)
+      end
+
+      def call(vm)
+        canonical.call(vm)
+      end
+    end
+
+    # ### Summary
+    #
+    # `setn` sets a value in the stack to a value popped off the top of the
+    # stack. It then pushes that value onto the top of the stack as well.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # {}[:key] = 'val'
+    # ~~~
+    #
+    class SetN
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setn", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:setn, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.stack[-number - 1] = vm.stack.last
+      end
+    end
+
+    # ### Summary
+    #
+    # `setspecial` pops a value off the top of the stack and sets a special
+    # local variable to that value. The special local variable is determined by
+    # the key given as its only argument.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # baz if (foo == 1) .. (bar == 1)
+    # ~~~
+    #
+    class SetSpecial
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def disasm(fmt)
+        fmt.instruction("setspecial", [fmt.object(key)])
+      end
+
+      def to_a(_iseq)
+        [:setspecial, key]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        0
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        case key
+        when GetSpecial::SVAR_LASTLINE
+          raise NotImplementedError, "svar SVAR_LASTLINE"
+        when GetSpecial::SVAR_BACKREF
+          raise NotImplementedError, "setspecial SVAR_BACKREF"
+        when GetSpecial::SVAR_FLIPFLOP_START
+          vm.frame_svar.svars[GetSpecial::SVAR_FLIPFLOP_START]
+        end
+      end
+    end
+
+    # ### Summary
+    #
+    # `splatarray` coerces the array object at the top of the stack into Array
+    # by calling `to_a`. It pushes a duplicate of the array if there is a flag,
+    # and the original array if there isn't one.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # x = *(5)
+    # ~~~
+    #
+    class SplatArray
+      attr_reader :flag
+
+      def initialize(flag)
+        @flag = flag
+      end
+
+      def disasm(fmt)
+        fmt.instruction("splatarray", [fmt.object(flag)])
+      end
+
+      def to_a(_iseq)
+        [:splatarray, flag]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(*vm.pop)
+      end
+    end
+
+    # ### Summary
+    #
+    # `swap` swaps the top two elements in the stack.
+    #
+    # ### TracePoint
+    #
+    # `swap` does not dispatch any events.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # !!defined?([[]])
+    # ~~~
+    #
+    class Swap
+      def disasm(fmt)
+        fmt.instruction("swap")
+      end
+
+      def to_a(_iseq)
+        [:swap]
+      end
+
+      def length
+        1
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        2
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        left, right = vm.pop(2)
+        vm.push(right, left)
+      end
+    end
+
+    # ### Summary
+    #
+    # `throw` pops a value off the top of the stack and throws it. It is caught
+    # using the instruction sequence's (or an ancestor's) catch table. It pushes
+    # on the result of throwing the value.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [1, 2, 3].map { break 2 }
+    # ~~~
+    #
+    class Throw
+      TAG_NONE = 0x0
+      TAG_RETURN = 0x1
+      TAG_BREAK = 0x2
+      TAG_NEXT = 0x3
+      TAG_RETRY = 0x4
+      TAG_REDO = 0x5
+      TAG_RAISE = 0x6
+      TAG_THROW = 0x7
+      TAG_FATAL = 0x8
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def disasm(fmt)
+        fmt.instruction("throw", [fmt.object(type)])
+      end
+
+      def to_a(_iseq)
+        [:throw, type]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        raise NotImplementedError, "throw"
+      end
+    end
+
+    # ### Summary
+    #
+    # `topn` pushes a single value onto the stack that is a copy of the value
+    # within the stack that is `number` of slots down from the top.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # case 3
+    # when 1..5
+    #   puts "foo"
+    # end
+    # ~~~
+    #
+    class TopN
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def disasm(fmt)
+        fmt.instruction("topn", [fmt.object(number)])
+      end
+
+      def to_a(_iseq)
+        [:topn, number]
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        0
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(vm.stack[-number - 1])
+      end
+    end
+
+    # ### Summary
+    #
+    # `toregexp` pops a number of values off the stack, combines them into a new
+    # regular expression, and pushes the new regular expression onto the stack.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # /foo #{bar}/
+    # ~~~
+    #
+    class ToRegExp
+      attr_reader :options, :length
+
+      def initialize(options, length)
+        @options = options
+        @length = length
+      end
+
+      def disasm(fmt)
+        fmt.instruction("toregexp", [fmt.object(options), fmt.object(length)])
+      end
+
+      def to_a(_iseq)
+        [:toregexp, options, length]
+      end
+
+      def pops
+        length
+      end
+
+      def pushes
+        1
+      end
+
+      def canonical
+        self
+      end
+
+      def call(vm)
+        vm.push(Regexp.new(vm.pop(length).join, options))
+      end
+    end
+  end
+end