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

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

@@ -1,155 +0,0 @@
-require 'set'
-
-module RubyVM::RJIT
-  class Invariants
-    class << self
-      # Called by RubyVM::RJIT::Compiler to lazily initialize this
-      # @param cb [CodeBlock]
-      # @param ocb [CodeBlock]
-      # @param compiler [RubyVM::RJIT::Compiler]
-      # @param exit_compiler [RubyVM::RJIT::ExitCompiler]
-      def initialize(cb, ocb, compiler, exit_compiler)
-        @cb = cb
-        @ocb = ocb
-        @compiler = compiler
-        @exit_compiler = exit_compiler
-        @bop_blocks = Set.new # TODO: actually invalidate this
-        @cme_blocks = Hash.new { |h, k| h[k] = Set.new }
-        @const_blocks = Hash.new { |h, k| h[k] = Set.new }
-        @patches = {}
-
-        # freeze # workaround a binding.irb issue. TODO: resurrect this
-      end
-
-      # @param jit [RubyVM::RJIT::JITState]
-      # @param klass [Integer]
-      # @param op [Integer]
-      def assume_bop_not_redefined(jit, klass, op)
-        return false unless C.BASIC_OP_UNREDEFINED_P(klass, op)
-
-        ensure_block_entry_exit(jit, cause: 'assume_bop_not_redefined')
-        @bop_blocks << jit.block
-        true
-      end
-
-      # @param jit [RubyVM::RJIT::JITState]
-      def assume_method_lookup_stable(jit, cme)
-        ensure_block_entry_exit(jit, cause: 'assume_method_lookup_stable')
-        @cme_blocks[cme.to_i] << jit.block
-      end
-
-      # @param jit [RubyVM::RJIT::JITState]
-      def assume_method_basic_definition(jit, klass, mid)
-        if C.rb_method_basic_definition_p(klass, mid)
-          cme = C.rb_callable_method_entry(klass, mid)
-          assume_method_lookup_stable(jit, cme)
-          true
-        else
-          false
-        end
-      end
-
-      def assume_stable_constant_names(jit, idlist)
-        (0..).each do |i|
-          break if (id = idlist[i]) == 0
-          @const_blocks[id] << jit.block
-        end
-      end
-
-      # @param asm [RubyVM::RJIT::Assembler]
-      def record_global_inval_patch(asm, target)
-        asm.pos_marker do |address|
-          if @patches.key?(address)
-            raise 'multiple patches in the same address'
-          end
-          @patches[address] = target
-        end
-      end
-
-      def on_cme_invalidate(cme)
-        @cme_blocks.fetch(cme.to_i, []).each do |block|
-          @cb.with_write_addr(block.start_addr) do
-            asm = Assembler.new
-            asm.comment('on_cme_invalidate')
-            asm.jmp(block.entry_exit)
-            @cb.write(asm)
-          end
-          # TODO: re-generate branches that refer to this block
-        end
-        @cme_blocks.delete(cme.to_i)
-      end
-
-      def on_constant_ic_update(iseq, ic, insn_idx)
-        # TODO: check multi ractor as well
-        if ic.entry.ic_cref
-          # No need to recompile the slowpath
-          return
-        end
-
-        pc = iseq.body.iseq_encoded + insn_idx
-        insn_name = Compiler.decode_insn(pc.*).name
-        if insn_name != :opt_getconstant_path && insn_name != :trace_opt_getconstant_path
-          raise 'insn_idx was not at opt_getconstant_path'
-        end
-        if ic.to_i != pc[1]
-          raise 'insn_idx + 1 was not at the updated IC'
-        end
-        @compiler.invalidate_blocks(iseq, pc.to_i)
-      end
-
-      def on_constant_state_changed(id)
-        @const_blocks.fetch(id, []).each do |block|
-          @compiler.invalidate_block(block)
-        end
-      end
-
-      def on_tracing_invalidate_all
-        invalidate_all
-      end
-
-      def on_update_references
-        # Give up. In order to support GC.compact, you'd have to update ISEQ
-        # addresses in BranchStub, etc. Ideally, we'd need to update moved
-        # pointers in JITed code here, but we just invalidate all for now.
-        invalidate_all
-      end
-
-      # @param jit [RubyVM::RJIT::JITState]
-      # @param block [RubyVM::RJIT::Block]
-      def ensure_block_entry_exit(jit, cause:)
-        block = jit.block
-        if block.entry_exit.nil?
-          block.entry_exit = Assembler.new.then do |asm|
-            @exit_compiler.compile_entry_exit(block.pc, block.ctx, asm, cause:)
-            @ocb.write(asm)
-          end
-        end
-      end
-
-      private
-
-      def invalidate_all
-        # On-Stack Replacement
-        @patches.each do |address, target|
-          # TODO: assert patches don't overlap each other
-          @cb.with_write_addr(address) do
-            asm = Assembler.new
-            asm.comment('on_tracing_invalidate_all')
-            asm.jmp(target)
-            @cb.write(asm)
-          end
-        end
-        @patches.clear
-
-        C.rjit_for_each_iseq do |iseq|
-          # Avoid entering past code
-          iseq.body.jit_entry = 0
-          # Avoid reusing past code
-          iseq.body.rjit_blocks.clear if iseq.body.rjit_blocks
-          # Compile this again if not converted to trace_* insns
-          iseq.body.jit_entry_calls = 0
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module RubyVM::RJIT
-  class JITState < Struct.new(
-    :iseq,                        # @param `RubyVM::RJIT::CPointer::Struct_rb_iseq_t`
-    :pc,                          # @param [Integer] The JIT target PC
-    :cfp,                         # @param `RubyVM::RJIT::CPointer::Struct_rb_control_frame_t` The JIT source CFP (before RJIT is called)
-    :block,                       # @param [RubyVM::RJIT::Block]
-    :stack_size_for_pc,           # @param [Integer]
-    :side_exit_for_pc,            # @param [Hash{ Integer => Integer }] { sp_offset => address }
-    :record_boundary_patch_point, # @param [TrueClass,FalseClass]
-  )
-    def initialize(side_exit_for_pc: {}, record_boundary_patch_point: false, **) = super
-
-    def insn
-      Compiler.decode_insn(C.VALUE.new(pc).*)
-    end
-
-    def operand(index, signed: false, ruby: false)
-      addr = pc + (index + 1) * Fiddle::SIZEOF_VOIDP
-      value = Fiddle::Pointer.new(addr)[0, Fiddle::SIZEOF_VOIDP].unpack(signed ? 'q' : 'Q')[0]
-      if ruby
-        value = C.to_ruby(value)
-      end
-      value
-    end
-
-    def at_current_insn?
-      pc == cfp.pc.to_i
-    end
-
-    def peek_at_local(n)
-      local_table_size = iseq.body.local_table_size
-      offset = -C::VM_ENV_DATA_SIZE - local_table_size + n + 1
-      value = (cfp.ep + offset).*
-      C.to_ruby(value)
-    end
-
-    def peek_at_stack(depth_from_top)
-      raise 'not at current insn' unless at_current_insn?
-      offset = -(1 + depth_from_top)
-      # rb_rjit_branch_stub_hit updates SP, so you don't need to worry about sp_offset
-      value = (cfp.sp + offset).*
-      C.to_ruby(value)
-    end
-
-    def peek_at_self
-      C.to_ruby(cfp.self)
-    end
-
-    def peek_at_block_handler(level)
-      ep = ep_at_level(cfp, level:)
-      ep[C::VM_ENV_DATA_INDEX_SPECVAL]
-    end
-
-    private
-
-    def ep_at_level(cfp, level:)
-      ep = cfp.ep
-      level.times do
-        # VM_ENV_PREV_EP
-        ep = C.VALUE.new(ep[C::VM_ENV_DATA_INDEX_SPECVAL] & ~0x03)
-      end
-      ep
-    end
-  end
-end

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

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-module RubyVM::RJIT
-  # Return a Hash for \RJIT statistics. \--rjit-stats makes more information available.
-  def self.runtime_stats
-    stats = {}
-
-    # Insn exits
-    INSNS.each_value do |insn|
-      exits = C.rjit_insn_exits[insn.bin]
-      if exits > 0
-        stats[:"exit_#{insn.name}"] = exits
-      end
-    end
-
-    # Runtime stats
-    C.rb_rjit_runtime_counters.members.each do |member|
-      stats[member] = C.rb_rjit_counters.public_send(member)
-    end
-    stats[:vm_insns_count] = C.rb_vm_insns_count
-
-    # Other stats are calculated here
-    stats[:side_exit_count] = stats.select { |name, _count| name.start_with?('exit_') }.sum(&:last)
-    if stats[:vm_insns_count] > 0
-      retired_in_rjit = stats[:rjit_insns_count] - stats[:side_exit_count]
-      stats[:total_insns_count] = retired_in_rjit + stats[:vm_insns_count]
-      stats[:ratio_in_rjit] = 100.0 * retired_in_rjit / stats[:total_insns_count]
-    else
-      stats.delete(:vm_insns_count)
-    end
-
-    stats
-  end
-
-  # :nodoc: all
-  class << self
-    private
-
-    # --yjit-stats at_exit
-    def print_stats
-      stats = runtime_stats
-      $stderr.puts("***RJIT: Printing RJIT statistics on exit***")
-
-      print_counters(stats, prefix: 'send_', prompt: 'method call exit reasons')
-      print_counters(stats, prefix: 'invokeblock_', prompt: 'invokeblock exit reasons')
-      print_counters(stats, prefix: 'invokesuper_', prompt: 'invokesuper exit reasons')
-      print_counters(stats, prefix: 'getblockpp_', prompt: 'getblockparamproxy exit reasons')
-      print_counters(stats, prefix: 'getivar_', prompt: 'getinstancevariable exit reasons')
-      print_counters(stats, prefix: 'setivar_', prompt: 'setinstancevariable exit reasons')
-      print_counters(stats, prefix: 'optaref_', prompt: 'opt_aref exit reasons')
-      print_counters(stats, prefix: 'optgetconst_', prompt: 'opt_getconstant_path exit reasons')
-      print_counters(stats, prefix: 'expandarray_', prompt: 'expandarray exit reasons')
-
-      $stderr.puts "compiled_block_count:  #{format_number(13, stats[:compiled_block_count])}"
-      $stderr.puts "side_exit_count:       #{format_number(13, stats[:side_exit_count])}"
-      $stderr.puts "total_insns_count:     #{format_number(13, stats[:total_insns_count])}" if stats.key?(:total_insns_count)
-      $stderr.puts "vm_insns_count:        #{format_number(13, stats[:vm_insns_count])}" if stats.key?(:vm_insns_count)
-      $stderr.puts "rjit_insns_count:      #{format_number(13, stats[:rjit_insns_count])}"
-      $stderr.puts "ratio_in_rjit:         #{format('%12.1f', stats[:ratio_in_rjit])}%" if stats.key?(:ratio_in_rjit)
-
-      print_exit_counts(stats)
-    end
-
-    def print_counters(stats, prefix:, prompt:)
-      $stderr.puts("#{prompt}: ")
-      counters = stats.filter { |key, _| key.start_with?(prefix) }
-      counters.filter! { |_, value| value != 0 }
-      counters.transform_keys! { |key| key.to_s.delete_prefix(prefix) }
-
-      if counters.empty?
-        $stderr.puts("    (all relevant counters are zero)")
-        return
-      end
-
-      counters = counters.to_a
-      counters.sort_by! { |(_, counter_value)| counter_value }
-      longest_name_length = counters.max_by { |(name, _)| name.length }.first.length
-      total = counters.sum { |(_, counter_value)| counter_value }
-
-      counters.reverse_each do |(name, value)|
-        percentage = value.fdiv(total) * 100
-        $stderr.printf("    %*s %s (%4.1f%%)\n", longest_name_length, name, format_number(10, value), percentage)
-      end
-    end
-
-    def print_exit_counts(stats, how_many: 20, padding: 2)
-      exits = stats.filter_map { |name, count| [name.to_s.delete_prefix('exit_'), count] if name.start_with?('exit_') }.to_h
-      return if exits.empty?
-
-      top_exits = exits.sort_by { |_name, count| -count }.first(how_many).to_h
-      total_exits = exits.values.sum
-      $stderr.puts "Top-#{top_exits.size} most frequent exit ops (#{format("%.1f", 100.0 * top_exits.values.sum / total_exits)}% of exits):"
-
-      name_width  = top_exits.map { |name, _count| name.length }.max + padding
-      count_width = top_exits.map { |_name, count| format_number(10, count).length }.max + padding
-      top_exits.each do |name, count|
-        ratio = 100.0 * count / total_exits
-        $stderr.puts "#{format("%#{name_width}s", name)}: #{format_number(count_width, count)} (#{format('%4.1f', ratio)}%)"
-      end
-    end
-
-    # Format large numbers with comma separators for readability
-    def format_number(pad, number)
-      integer, decimal = number.to_s.split('.')
-      d_groups = integer.chars.reverse.each_slice(3)
-      with_commas = d_groups.map(&:join).join(',').reverse
-      [with_commas, decimal].compact.join('.').rjust(pad, ' ')
-    end
-
-    # --yjit-trace-exits at_exit
-    def dump_trace_exits
-      filename = "#{Dir.pwd}/rjit_exit_locations.dump"
-      File.binwrite(filename, Marshal.dump(exit_traces))
-      $stderr.puts("RJIT exit locations dumped to:\n#{filename}")
-    end
-
-    # Convert rb_rjit_raw_samples and rb_rjit_line_samples into a StackProf format.
-    def exit_traces
-      results = C.rjit_exit_traces
-      raw_samples = results[:raw].dup
-      line_samples = results[:lines].dup
-      frames = results[:frames].dup
-      samples_count = 0
-
-      # Loop through the instructions and set the frame hash with the data.
-      # We use nonexistent.def for the file name, otherwise insns.def will be displayed
-      # and that information isn't useful in this context.
-      RubyVM::INSTRUCTION_NAMES.each_with_index do |name, frame_id|
-        frame_hash = { samples: 0, total_samples: 0, edges: {}, name: name, file: "nonexistent.def", line: nil, lines: {} }
-        results[:frames][frame_id] = frame_hash
-        frames[frame_id] = frame_hash
-      end
-
-      # Loop through the raw_samples and build the hashes for StackProf.
-      # The loop is based off an example in the StackProf documentation and therefore
-      # this functionality can only work with that library.
-      #
-      # Raw Samples:
-      # [ length, frame1, frame2, frameN, ..., instruction, count
-      #
-      # Line Samples
-      # [ length, line_1, line_2, line_n, ..., dummy value, count
-      i = 0
-      while i < raw_samples.length
-        stack_length = raw_samples[i] + 1
-        i += 1 # consume the stack length
-
-        prev_frame_id = nil
-        stack_length.times do |idx|
-          idx += i
-          frame_id = raw_samples[idx]
-
-          if prev_frame_id
-            prev_frame = frames[prev_frame_id]
-            prev_frame[:edges][frame_id] ||= 0
-            prev_frame[:edges][frame_id] += 1
-          end
-
-          frame_info = frames[frame_id]
-          frame_info[:total_samples] += 1
-
-          frame_info[:lines][line_samples[idx]] ||= [0, 0]
-          frame_info[:lines][line_samples[idx]][0] += 1
-
-          prev_frame_id = frame_id
-        end
-
-        i += stack_length # consume the stack
-
-        top_frame_id = prev_frame_id
-        top_frame_line = 1
-
-        sample_count = raw_samples[i]
-
-        frames[top_frame_id][:samples] += sample_count
-        frames[top_frame_id][:lines] ||= {}
-        frames[top_frame_id][:lines][top_frame_line] ||= [0, 0]
-        frames[top_frame_id][:lines][top_frame_line][1] += sample_count
-
-        samples_count += sample_count
-        i += 1
-      end
-
-      results[:samples] = samples_count
-      # Set missed_samples and gc_samples to 0 as their values
-      # don't matter to us in this context.
-      results[:missed_samples] = 0
-      results[:gc_samples] = 0
-      results
-    end
-  end
-end

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

@@ -1,221 +0,0 @@
-module RubyVM::RJIT
-  # Represent the type of a value (local/stack/self) in RJIT
-  Type = Data.define(:type) do
-    # Check if the type is an immediate
-    def imm?
-      case self
-      in Type::UnknownImm then true
-      in Type::Nil then true
-      in Type::True then true
-      in Type::False then true
-      in Type::Fixnum then true
-      in Type::Flonum then true
-      in Type::ImmSymbol then true
-      else false
-      end
-    end
-
-    # Returns true when the type is not specific.
-    def unknown?
-      case self
-      in Type::Unknown | Type::UnknownImm | Type::UnknownHeap then true
-      else false
-      end
-    end
-
-    # Returns true when we know the VALUE is a specific handle type,
-    # such as a static symbol ([Type::ImmSymbol], i.e. true from RB_STATIC_SYM_P()).
-    # Opposite of [Self::is_unknown].
-    def specific?
-      !self.unknown?
-    end
-
-    # Check if the type is a heap object
-    def heap?
-      case self
-      in Type::UnknownHeap then true
-      in Type::TArray then true
-      in Type::Hash then true
-      in Type::HeapSymbol then true
-      in Type::TString then true
-      in Type::CString then true
-      in Type::BlockParamProxy then true
-      else false
-      end
-    end
-
-    # Check if it's a T_ARRAY object
-    def array?
-      case self
-      in Type::TArray then true
-      else false
-      end
-    end
-
-    # Check if it's a T_STRING object (both TString and CString are T_STRING)
-    def string?
-      case self
-      in Type::TString then true
-      in Type::CString then true
-      else false
-      end
-    end
-
-    # Returns the class if it is known, otherwise nil
-    def known_class
-      case self
-      in Type::Nil then C.rb_cNilClass
-      in Type::True then C.rb_cTrueClass
-      in Type::False then C.rb_cFalseClass
-      in Type::Fixnum then C.rb_cInteger
-      in Type::Flonum then C.rb_cFloat
-      in Type::ImmSymbol | Type::HeapSymbol then C.rb_cSymbol
-      in Type::CString then C.rb_cString
-      else nil
-      end
-    end
-
-    # Returns a boolean representing whether the value is truthy if known, otherwise nil
-    def known_truthy
-      case self
-      in Type::Nil then false
-      in Type::False then false
-      in Type::UnknownHeap then false
-      in Type::Unknown | Type::UnknownImm then nil
-      else true
-      end
-    end
-
-    # Returns a boolean representing whether the value is equal to nil if known, otherwise nil
-    def known_nil
-      case [self, self.known_truthy]
-      in Type::Nil, _ then true
-      in Type::False, _ then false # Qfalse is not nil
-      in _, true then false # if truthy, can't be nil
-      in _, _ then nil # otherwise unknown
-      end
-    end
-
-    def diff(dst)
-      # Perfect match, difference is zero
-      if self == dst
-        return TypeDiff::Compatible[0]
-      end
-
-      # Any type can flow into an unknown type
-      if dst == Type::Unknown
-        return TypeDiff::Compatible[1]
-      end
-
-      # A CString is also a TString.
-      if self == Type::CString && dst == Type::TString
-        return TypeDiff::Compatible[1]
-      end
-
-      # Specific heap type into unknown heap type is imperfect but valid
-      if self.heap? && dst == Type::UnknownHeap
-        return TypeDiff::Compatible[1]
-      end
-
-      # Specific immediate type into unknown immediate type is imperfect but valid
-      if self.imm? && dst == Type::UnknownImm
-        return TypeDiff::Compatible[1]
-      end
-
-      # Incompatible types
-      return TypeDiff::Incompatible
-    end
-
-    def upgrade(new_type)
-      assert(new_type.diff(self) != TypeDiff::Incompatible)
-      new_type
-    end
-
-    private
-
-    def assert(cond)
-      unless cond
-        raise "'#{cond.inspect}' was not true"
-      end
-    end
-  end
-
-  # This returns an appropriate Type based on a known value
-  class << Type
-    def from(val)
-      if C::SPECIAL_CONST_P(val)
-        if fixnum?(val)
-          Type::Fixnum
-        elsif val.nil?
-          Type::Nil
-        elsif val == true
-          Type::True
-        elsif val == false
-          Type::False
-        elsif static_symbol?(val)
-          Type::ImmSymbol
-        elsif flonum?(val)
-          Type::Flonum
-        else
-          raise "Illegal value: #{val.inspect}"
-        end
-      else
-        val_class = C.to_value(C.rb_class_of(val))
-        if val_class == C.rb_cString && C.rb_obj_frozen_p(val)
-          return Type::CString
-        end
-        if C.to_value(val) == C.rb_block_param_proxy
-          return Type::BlockParamProxy
-        end
-        case C::BUILTIN_TYPE(val)
-        in C::RUBY_T_ARRAY
-          Type::TArray
-        in C::RUBY_T_HASH
-          Type::Hash
-        in C::RUBY_T_STRING
-          Type::TString
-        else
-          Type::UnknownHeap
-        end
-      end
-    end
-
-    private
-
-    def fixnum?(obj)
-      (C.to_value(obj) & C::RUBY_FIXNUM_FLAG) == C::RUBY_FIXNUM_FLAG
-    end
-
-    def flonum?(obj)
-      (C.to_value(obj) & C::RUBY_FLONUM_MASK) == C::RUBY_FLONUM_FLAG
-    end
-
-    def static_symbol?(obj)
-      (C.to_value(obj) & 0xff) == C::RUBY_SYMBOL_FLAG
-    end
-  end
-
-  # List of types
-  Type::Unknown     = Type[:Unknown]
-  Type::UnknownImm  = Type[:UnknownImm]
-  Type::UnknownHeap = Type[:UnknownHeap]
-  Type::Nil         = Type[:Nil]
-  Type::True        = Type[:True]
-  Type::False       = Type[:False]
-  Type::Fixnum      = Type[:Fixnum]
-  Type::Flonum      = Type[:Flonum]
-  Type::Hash        = Type[:Hash]
-  Type::ImmSymbol   = Type[:ImmSymbol]
-  Type::HeapSymbol  = Type[:HeapSymbol]
-
-  Type::TString = Type[:TString] # An object with the T_STRING flag set, possibly an rb_cString
-  Type::CString = Type[:CString] # An un-subclassed string of type rb_cString (can have instance vars in some cases)
-  Type::TArray  = Type[:TArray]  # An object with the T_ARRAY flag set, possibly an rb_cArray
-
-  Type::BlockParamProxy = Type[:BlockParamProxy] # A special sentinel value indicating the block parameter should be read from
-
-  module TypeDiff
-    Compatible = Data.define(:diversion) # The smaller, the more compatible.
-    Incompatible = :Incompatible
-  end
-end