@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-5

package/lib/ruby/3.4.11/ruby_vm/rjit/block.rb

@@ -1,11 +0,0 @@
-class RubyVM::RJIT::Block < Struct.new(
-  :iseq,        # @param ``
-  :pc,          # @param [Integer] Starting PC
-  :ctx,         # @param [RubyVM::RJIT::Context] **Starting** Context (TODO: freeze?)
-  :start_addr,  # @param [Integer] Starting address of this block's JIT code
-  :entry_exit,  # @param [Integer] Address of entry exit (optional)
-  :incoming,    # @param [Array<RubyVM::RJIT::BranchStub>] Incoming branches
-  :invalidated, # @param [TrueClass,FalseClass] true if already invalidated
-)
-  def initialize(incoming: [], invalidated: false, **) = super
-end

package/lib/ruby/3.4.11/ruby_vm/rjit/branch_stub.rb

@@ -1,24 +0,0 @@
-module RubyVM::RJIT
-  # Branch shapes
-  Next0   = :Next0   # target0 is a fallthrough
-  Next1   = :Next1   # target1 is a fallthrough
-  Default = :Default # neither targets is a fallthrough
-
-  class BranchStub < Struct.new(
-    :iseq,       # @param [RubyVM::RJIT::CPointer::Struct_rb_iseq_struct] Branch target ISEQ
-    :shape,      # @param [Symbol] Next0, Next1, or Default
-    :target0,    # @param [RubyVM::RJIT::BranchTarget] First branch target
-    :target1,    # @param [RubyVM::RJIT::BranchTarget,NilClass] Second branch target (optional)
-    :compile,    # @param [Proc] A callback to (re-)generate this branch stub
-    :start_addr, # @param [Integer] Stub source start address to be re-generated
-    :end_addr,   # @param [Integer] Stub source end address to be re-generated
-  )
-  end
-
-  class BranchTarget < Struct.new(
-    :pc,
-    :ctx,
-    :address,
-  )
-  end
-end

package/lib/ruby/3.4.11/ruby_vm/rjit/c_pointer.rb

@@ -1,394 +0,0 @@
-module RubyVM::RJIT
-  # Every class under this namespace is a pointer. Even if the type is
-  # immediate, it shouldn't be dereferenced until `*` is called.
-  module CPointer
-    # Note: We'd like to avoid alphabetic method names to avoid a conflict
-    # with member methods. to_i and to_s are considered an exception.
-    class Struct
-      # @param name [String]
-      # @param sizeof [Integer]
-      # @param members [Hash{ Symbol => [RubyVM::RJIT::CType::*, Integer, TrueClass] }]
-      def initialize(addr, sizeof, members)
-        @addr = addr
-        @sizeof = sizeof
-        @members = members
-      end
-
-      # Get a raw address
-      def to_i
-        @addr
-      end
-
-      # Serialized address for generated code
-      def to_s
-        "0x#{@addr.to_s(16)}"
-      end
-
-      # Pointer diff
-      def -(struct)
-        raise ArgumentError if self.class != struct.class
-        (@addr - struct.to_i) / @sizeof
-      end
-
-      # Primitive API that does no automatic dereference
-      # TODO: remove this?
-      # @param member [Symbol]
-      def [](member)
-        type, offset = @members.fetch(member)
-        type.new(@addr + offset / 8)
-      end
-
-      private
-
-      # @param member [Symbol]
-      # @param value [Object]
-      def []=(member, value)
-        type, offset = @members.fetch(member)
-        type[@addr + offset / 8] = value
-      end
-
-      # @param size [Integer]
-      # @param members [Hash{ Symbol => [Integer, RubyVM::RJIT::CType::*] }]
-      def self.define(size, members)
-        Class.new(self) do
-          # Return the size of this type
-          define_singleton_method(:size) { size }
-
-          # Return the offset to a field
-          define_singleton_method(:offsetof) do |field, *fields|
-            member, offset = members.fetch(field)
-            offset /= 8
-            unless fields.empty?
-              offset += member.offsetof(*fields)
-            end
-            offset
-          end
-
-          # Return member names
-          define_singleton_method(:members) { members.keys }
-
-          define_method(:initialize) do |addr = nil|
-            if addr.nil? # TODO: get rid of this feature later
-              addr = Fiddle.malloc(size)
-            end
-            super(addr, size, members)
-          end
-
-          members.each do |member, (type, offset, to_ruby)|
-            # Intelligent API that does automatic dereference
-            define_method(member) do
-              value = self[member]
-              if value.respond_to?(:*)
-                value = value.*
-              end
-              if to_ruby
-                value = C.to_ruby(value)
-              end
-              value
-            end
-
-            define_method("#{member}=") do |value|
-              if to_ruby
-                value = C.to_value(value)
-              end
-              self[member] = value
-            end
-          end
-        end
-      end
-    end
-
-    # Note: We'd like to avoid alphabetic method names to avoid a conflict
-    # with member methods. to_i is considered an exception.
-    class Union
-      # @param _name [String] To be used when it starts defining a union pointer class
-      # @param sizeof [Integer]
-      # @param members [Hash{ Symbol => RubyVM::RJIT::CType::* }]
-      def initialize(addr, sizeof, members)
-        @addr = addr
-        @sizeof = sizeof
-        @members = members
-      end
-
-      # Get a raw address
-      def to_i
-        @addr
-      end
-
-      # Move addr to access this pointer like an array
-      def +(index)
-        raise ArgumentError unless index.is_a?(Integer)
-        self.class.new(@addr + index * @sizeof)
-      end
-
-      # Pointer diff
-      def -(union)
-        raise ArgumentError if self.class != union.class
-        (@addr - union.instance_variable_get(:@addr)) / @sizeof
-      end
-
-      # @param sizeof [Integer]
-      # @param members [Hash{ Symbol => RubyVM::RJIT::CType::* }]
-      def self.define(sizeof, members)
-        Class.new(self) do
-          # Return the size of this type
-          define_singleton_method(:sizeof) { sizeof }
-
-          # Part of Struct's offsetof implementation
-          define_singleton_method(:offsetof) do |field, *fields|
-            member = members.fetch(field)
-            offset = 0
-            unless fields.empty?
-              offset += member.offsetof(*fields)
-            end
-            offset
-          end
-
-          define_method(:initialize) do |addr|
-            super(addr, sizeof, members)
-          end
-
-          members.each do |member, type|
-            # Intelligent API that does automatic dereference
-            define_method(member) do
-              value = type.new(@addr)
-              if value.respond_to?(:*)
-                value = value.*
-              end
-              value
-            end
-          end
-        end
-      end
-    end
-
-    class Immediate
-      # @param addr [Integer]
-      # @param size [Integer]
-      # @param pack [String]
-      def initialize(addr, size, pack)
-        @addr = addr
-        @size = size
-        @pack = pack
-      end
-
-      # Get a raw address
-      def to_i
-        @addr
-      end
-
-      # Move addr to addess this pointer like an array
-      def +(index)
-        Immediate.new(@addr + index * @size, @size, @pack)
-      end
-
-      # Dereference
-      def *
-        self[0]
-      end
-
-      # Array access
-      def [](index)
-        return nil if @addr == 0
-        Fiddle::Pointer.new(@addr + index * @size)[0, @size].unpack1(@pack)
-      end
-
-      # Array set
-      def []=(index, value)
-        Fiddle::Pointer.new(@addr + index * @size)[0, @size] = [value].pack(@pack)
-      end
-
-      # Serialized address for generated code. Used for embedding things like body->iseq_encoded.
-      def to_s
-        "0x#{Integer(@addr).to_s(16)}"
-      end
-
-      # @param fiddle_type [Integer] Fiddle::TYPE_*
-      def self.define(fiddle_type)
-        size = Fiddle::PackInfo::SIZE_MAP.fetch(fiddle_type)
-        pack = Fiddle::PackInfo::PACK_MAP.fetch(fiddle_type)
-
-        Class.new(self) do
-          define_method(:initialize) do |addr|
-            super(addr, size, pack)
-          end
-
-          define_singleton_method(:size) do
-            size
-          end
-
-          # Type-level []=: Used by struct fields
-          define_singleton_method(:[]=) do |addr, value|
-            Fiddle::Pointer.new(addr)[0, size] = [value].pack(pack)
-          end
-        end
-      end
-    end
-
-    # -Fiddle::TYPE_CHAR Immediate with special handling of true/false
-    class Bool < Immediate.define(-Fiddle::TYPE_CHAR)
-      # Dereference
-      def *
-        return nil if @addr == 0
-        super != 0
-      end
-
-      def self.[]=(addr, value)
-        super(addr, value ? 1 : 0)
-      end
-    end
-
-    # Basically Immediate but without #* to skip auto-dereference of structs.
-    class Array
-      attr_reader :type
-
-      # @param addr [Integer]
-      # @param type [Class] RubyVM::RJIT::CType::*
-      def initialize(addr, type)
-        @addr = addr
-        @type = type
-      end
-
-      # Array access
-      def [](index)
-        @type.new(@addr)[index]
-      end
-
-      # Array set
-      # @param index [Integer]
-      # @param value [Integer, RubyVM::RJIT::CPointer::Struct] an address itself or an object that return an address with to_i
-      def []=(index, value)
-        @type.new(@addr)[index] = value
-      end
-
-      private
-
-      def self.define(block)
-        Class.new(self) do
-          define_method(:initialize) do |addr|
-            super(addr, block.call)
-          end
-        end
-      end
-    end
-
-    class Pointer
-      attr_reader :type
-
-      # @param addr [Integer]
-      # @param type [Class] RubyVM::RJIT::CType::*
-      def initialize(addr, type)
-        @addr = addr
-        @type = type
-      end
-
-      # Move addr to addess this pointer like an array
-      def +(index)
-        raise ArgumentError unless index.is_a?(Integer)
-        Pointer.new(@addr + index * Fiddle::SIZEOF_VOIDP, @type)
-      end
-
-      # Dereference
-      def *
-        return nil if dest_addr == 0
-        @type.new(dest_addr)
-      end
-
-      # Array access
-      def [](index)
-        (self + index).*
-      end
-
-      # Array set
-      # @param index [Integer]
-      # @param value [Integer, RubyVM::RJIT::CPointer::Struct] an address itself or an object that return an address with to_i
-      def []=(index, value)
-        Fiddle::Pointer.new(@addr + index * Fiddle::SIZEOF_VOIDP)[0, Fiddle::SIZEOF_VOIDP] =
-          [value.to_i].pack(Fiddle::PackInfo::PACK_MAP[Fiddle::TYPE_VOIDP])
-      end
-
-      # Get a raw address
-      def to_i
-        @addr
-      end
-
-      private
-
-      def dest_addr
-        Fiddle::Pointer.new(@addr)[0, Fiddle::SIZEOF_VOIDP].unpack1(Fiddle::PackInfo::PACK_MAP[Fiddle::TYPE_VOIDP])
-      end
-
-      def self.define(block)
-        Class.new(self) do
-          define_method(:initialize) do |addr|
-            super(addr, block.call)
-          end
-
-          # Type-level []=: Used by struct fields
-          # @param addr [Integer]
-          # @param value [Integer, RubyVM::RJIT::CPointer::Struct] an address itself, or an object that return an address with to_i
-          define_singleton_method(:[]=) do |addr, value|
-            value = value.to_i
-            Fiddle::Pointer.new(addr)[0, Fiddle::SIZEOF_VOIDP] = [value].pack(Fiddle::PackInfo::PACK_MAP[Fiddle::TYPE_VOIDP])
-          end
-        end
-      end
-    end
-
-    class BitField
-      # @param addr [Integer]
-      # @param width [Integer]
-      # @param offset [Integer]
-      def initialize(addr, width, offset)
-        @addr = addr
-        @width = width
-        @offset = offset
-      end
-
-      # Dereference
-      def *
-        byte = Fiddle::Pointer.new(@addr)[0, Fiddle::SIZEOF_CHAR].unpack('c').first
-        if @width == 1
-          bit = (1 & (byte >> @offset))
-          bit == 1
-        elsif @width <= 8 && @offset == 0
-          bitmask = @width.times.map { |i| 1 << i }.sum
-          byte & bitmask
-        else
-          raise NotImplementedError.new("not-implemented bit field access: width=#{@width} offset=#{@offset}")
-        end
-      end
-
-      # @param width [Integer]
-      # @param offset [Integer]
-      def self.define(width, offset)
-        Class.new(self) do
-          define_method(:initialize) do |addr|
-            super(addr, width, offset)
-          end
-        end
-      end
-    end
-
-    # Give a name to a dynamic CPointer class to see it on inspect
-    def self.with_class_name(prefix, name, cache: false, &block)
-      return block.call if !name.nil? && name.empty?
-
-      # Use a cached result only if cache: true
-      class_name = "#{prefix}_#{name}"
-      klass =
-        if cache && self.const_defined?(class_name)
-          self.const_get(class_name)
-        else
-          block.call
-        end
-
-      # Give it a name unless it's already defined
-      unless self.const_defined?(class_name)
-        self.const_set(class_name, klass)
-      end
-
-      klass
-    end
-  end
-end

package/lib/ruby/3.4.11/ruby_vm/rjit/c_type.rb

@@ -1,99 +0,0 @@
-require 'fiddle'
-require 'fiddle/pack'
-require_relative 'c_pointer'
-
-module RubyVM::RJIT
-  module CType
-    module Struct
-      # @param name [String]
-      # @param members [Hash{ Symbol => [Integer, RubyVM::RJIT::CType::*] }]
-      def self.new(name, sizeof, **members)
-        name = members.keys.join('_') if name.empty?
-        CPointer.with_class_name('Struct', name) do
-          CPointer::Struct.define(sizeof, members)
-        end
-      end
-    end
-
-    module Union
-      # @param name [String]
-      # @param members [Hash{ Symbol => RubyVM::RJIT::CType::* }]
-      def self.new(name, sizeof, **members)
-        name = members.keys.join('_') if name.empty?
-        CPointer.with_class_name('Union', name) do
-          CPointer::Union.define(sizeof, members)
-        end
-      end
-    end
-
-    module Immediate
-      # @param fiddle_type [Integer]
-      def self.new(fiddle_type)
-        name = Fiddle.constants.find do |const|
-          const.start_with?('TYPE_') && Fiddle.const_get(const) == fiddle_type.abs
-        end&.name
-        name = name.delete_prefix('TYPE_')
-        if fiddle_type.negative?
-          name.prepend('U')
-        end
-        CPointer.with_class_name('Immediate', name, cache: true) do
-          CPointer::Immediate.define(fiddle_type)
-        end
-      end
-
-      # @param type [String]
-      def self.parse(ctype)
-        new(Fiddle::Importer.parse_ctype(ctype))
-      end
-
-      def self.find(size, signed)
-        fiddle_type = TYPE_MAP.fetch(size)
-        fiddle_type = -fiddle_type unless signed
-        new(fiddle_type)
-      end
-
-      TYPE_MAP = Fiddle::PackInfo::SIZE_MAP.map { |type, size| [size, type.abs] }.to_h
-      private_constant :TYPE_MAP
-    end
-
-    module Bool
-      def self.new
-        CPointer::Bool
-      end
-    end
-
-    class Array
-      def self.new(&block)
-        CPointer.with_class_name('Array', block.object_id.to_s) do
-          CPointer::Array.define(block)
-        end
-      end
-    end
-
-    class Pointer
-      # This takes a block to avoid "stack level too deep" on a cyclic reference
-      # @param block [Proc]
-      def self.new(&block)
-        CPointer.with_class_name('Pointer', block.object_id.to_s) do
-          CPointer::Pointer.define(block)
-        end
-      end
-    end
-
-    module BitField
-      # @param width [Integer]
-      # @param offset [Integer]
-      def self.new(width, offset)
-        CPointer.with_class_name('BitField', "#{offset}_#{width}") do
-          CPointer::BitField.define(width, offset)
-        end
-      end
-    end
-
-    # Types that are referenced but not part of code generation targets
-    Stub = ::Struct.new(:name)
-
-    # Types that it failed to figure out from the header
-    Unknown = Module.new
-  end
-end

package/lib/ruby/3.4.11/ruby_vm/rjit/code_block.rb

@@ -1,91 +0,0 @@
-module RubyVM::RJIT
-  class CodeBlock
-    # @param mem_block [Integer] JIT buffer address
-    # @param mem_size  [Integer] JIT buffer size
-    # @param outliend  [TrueClass,FalseClass] true for outlined CodeBlock
-    def initialize(mem_block:, mem_size:, outlined: false)
-      @comments  = Hash.new { |h, k| h[k] = [] } if dump_disasm?
-      @mem_block = mem_block
-      @mem_size  = mem_size
-      @write_pos = 0
-      @outlined  = outlined
-    end
-
-    # @param asm [RubyVM::RJIT::Assembler]
-    def write(asm)
-      return 0 if @write_pos + asm.size >= @mem_size
-
-      start_addr = write_addr
-
-      # Write machine code
-      C.mprotect_write(@mem_block, @mem_size)
-      @write_pos += asm.assemble(start_addr)
-      C.mprotect_exec(@mem_block, @mem_size)
-
-      end_addr = write_addr
-
-      # Convert comment indexes to addresses
-      asm.comments.each do |index, comments|
-        @comments[start_addr + index] += comments if dump_disasm?
-      end
-      asm.comments.clear
-
-      # Dump disasm if --rjit-dump-disasm
-      if C.rjit_opts.dump_disasm && start_addr < end_addr
-        dump_disasm(start_addr, end_addr)
-      end
-      start_addr
-    end
-
-    def set_write_addr(addr)
-      @write_pos = addr - @mem_block
-      @comments.delete(addr) if dump_disasm?
-    end
-
-    def with_write_addr(addr)
-      old_write_pos = @write_pos
-      set_write_addr(addr)
-      yield
-    ensure
-      @write_pos = old_write_pos
-    end
-
-    def write_addr
-      @mem_block + @write_pos
-    end
-
-    def include?(addr)
-      (@mem_block...(@mem_block + @mem_size)).include?(addr)
-    end
-
-    def dump_disasm(from, to, io: STDOUT, color: true, test: false)
-      C.dump_disasm(from, to, test:).each do |address, mnemonic, op_str|
-        @comments.fetch(address, []).each do |comment|
-          io.puts colorize("  # #{comment}", bold: true, color:)
-        end
-        io.puts colorize("  0x#{format("%x", address)}: #{mnemonic} #{op_str}", color:)
-      end
-      io.puts
-    end
-
-    private
-
-    def colorize(text, bold: false, color:)
-      return text unless color
-      buf = +''
-      buf << "\e[1m" if bold
-      buf << "\e[34m" if @outlined
-      buf << text
-      buf << "\e[0m"
-      buf
-    end
-
-    def bold(text)
-      "\e[1m#{text}\e[0m"
-    end
-
-    def dump_disasm?
-      C.rjit_opts.dump_disasm
-    end
-  end
-end