class RubyVM::RJIT::Compiler

Attributes

write_pos[RW]

Public Class Methods

decode_insn(encoded) click to toggle source
# File ruby_vm/rjit/compiler.rb, line 44
def self.decode_insn(encoded)
  INSNS.fetch(C.rb_vm_insn_decode(encoded))
end
new() click to toggle source
# File ruby_vm/rjit/compiler.rb, line 48
def initialize
  mem_size = C.rjit_opts.exec_mem_size * 1024 * 1024
  mem_block = C.mmap(mem_size)
  @cb = CodeBlock.new(mem_block: mem_block, mem_size: mem_size / 2)
  @ocb = CodeBlock.new(mem_block: mem_block + mem_size / 2, mem_size: mem_size / 2, outlined: true)
  @exit_compiler = ExitCompiler.new
  @insn_compiler = InsnCompiler.new(@cb, @ocb, @exit_compiler)
  Invariants.initialize(@cb, @ocb, self, @exit_compiler)
end

Public Instance Methods

branch_stub_hit(branch_stub, cfp, target0_p) click to toggle source

Compile a branch stub. @param branch_stub [RubyVM::RJIT::BranchStub] @param cfp ‘RubyVM::RJIT::CPointer::Struct_rb_control_frame_t` @param target0_p [TrueClass,FalseClass] @return [Integer] The starting address of the compiled branch stub

# File ruby_vm/rjit/compiler.rb, line 120
def branch_stub_hit(branch_stub, cfp, target0_p)
  # Update cfp->pc for `jit.at_current_insn?`
  target = target0_p ? branch_stub.target0 : branch_stub.target1
  cfp.pc = target.pc

  # Reuse an existing block if it already exists
  block = find_block(branch_stub.iseq, target.pc, target.ctx)

  # If the branch stub's jump is the last code, allow overwriting part of
  # the old branch code with the new block code.
  fallthrough = block.nil? && @cb.write_addr == branch_stub.end_addr
  if fallthrough
    # If the branch stub's jump is the last code, allow overwriting part of
    # the old branch code with the new block code.
    @cb.set_write_addr(branch_stub.start_addr)
    branch_stub.shape = target0_p ? Next0 : Next1
    Assembler.new.tap do |branch_asm|
      branch_stub.compile.call(branch_asm)
      @cb.write(branch_asm)
    end
  end

  # Reuse or generate a block
  if block
    target.address = block.start_addr
  else
    jit = JITState.new(iseq: branch_stub.iseq, cfp:)
    target.address = Assembler.new.then do |asm|
      compile_block(asm, jit:, pc: target.pc, ctx: target.ctx.dup)
      @cb.write(asm)
    end
    block = jit.block
  end
  block.incoming << branch_stub # prepare for invalidate_block

  # Re-generate the branch code for non-fallthrough cases
  unless fallthrough
    @cb.with_write_addr(branch_stub.start_addr) do
      branch_asm = Assembler.new
      branch_stub.compile.call(branch_asm)
      @cb.write(branch_asm)
    end
  end

  return target.address
rescue Exception => e
  $stderr.puts e.full_message
  exit 1
end
compile(iseq, cfp) click to toggle source

Compile an ISEQ from its entry point. @param iseq ‘RubyVM::RJIT::CPointer::Struct_rb_iseq_t` @param cfp `RubyVM::RJIT::CPointer::Struct_rb_control_frame_t`

# File ruby_vm/rjit/compiler.rb, line 61
def compile(iseq, cfp)
  pc = cfp.pc.to_i
  jit = JITState.new(iseq:, cfp:)
  asm = Assembler.new
  compile_prologue(asm, iseq, pc)
  compile_block(asm, jit:, pc:)
  iseq.body.jit_func = @cb.write(asm)
rescue Exception => e
  $stderr.puts e.full_message
  exit 1
end
entry_stub_hit(entry_stub, cfp) click to toggle source

Compile an entry. @param entry [RubyVM::RJIT::EntryStub]

# File ruby_vm/rjit/compiler.rb, line 75
def entry_stub_hit(entry_stub, cfp)
  # Compile a new entry guard as a next entry
  pc = cfp.pc.to_i
  next_entry = Assembler.new.then do |asm|
    compile_entry_chain_guard(asm, cfp.iseq, pc)
    @cb.write(asm)
  end

  # Try to find an existing compiled version of this block
  ctx = Context.new
  block = find_block(cfp.iseq, pc, ctx)
  if block
    # If an existing block is found, generate a jump to the block.
    asm = Assembler.new
    asm.jmp(block.start_addr)
    @cb.write(asm)
  else
    # If this block hasn't yet been compiled, generate blocks after the entry guard.
    asm = Assembler.new
    jit = JITState.new(iseq: cfp.iseq, cfp:)
    compile_block(asm, jit:, pc:, ctx:)
    @cb.write(asm)

    block = jit.block
  end

  # Regenerate the previous entry
  @cb.with_write_addr(entry_stub.start_addr) do
    # The last instruction of compile_entry_chain_guard is jne
    asm = Assembler.new
    asm.jne(next_entry)
    @cb.write(asm)
  end

  return block.start_addr
rescue Exception => e
  $stderr.puts e.full_message
  exit 1
end
invalidate_block(block) click to toggle source
# File ruby_vm/rjit/compiler.rb, line 184
def invalidate_block(block)
  iseq = block.iseq
  # Avoid touching GCed ISEQs. We assume it won't be re-entered.
  return unless C.imemo_type_p(iseq, C.imemo_iseq)

  # Remove this block from the version array
  remove_block(iseq, block)

  # Invalidate the block with entry exit
  unless block.invalidated
    @cb.with_write_addr(block.start_addr) do
      asm = Assembler.new
      asm.comment('invalidate_block')
      asm.jmp(block.entry_exit)
      @cb.write(asm)
    end
    block.invalidated = true
  end

  # Re-stub incoming branches
  block.incoming.each do |branch_stub|
    target = [branch_stub.target0, branch_stub.target1].compact.find do |target|
      target.pc == block.pc && target.ctx == block.ctx
    end
    next if target.nil?
    # TODO: Could target.address be a stub address? Is invalidation not needed in that case?

    # If the target being re-generated is currently a fallthrough block,
    # the fallthrough code must be rewritten with a jump to the stub.
    if target.address == branch_stub.end_addr
      branch_stub.shape = Default
    end

    target.address = Assembler.new.then do |ocb_asm|
      @exit_compiler.compile_branch_stub(block.ctx, ocb_asm, branch_stub, target == branch_stub.target0)
      @ocb.write(ocb_asm)
    end
    @cb.with_write_addr(branch_stub.start_addr) do
      branch_asm = Assembler.new
      branch_stub.compile.call(branch_asm)
      @cb.write(branch_asm)
    end
  end
end
invalidate_blocks(iseq, pc) click to toggle source

@param iseq ‘RubyVM::RJIT::CPointer::Struct_rb_iseq_t` @param pc [Integer]

# File ruby_vm/rjit/compiler.rb, line 172
def invalidate_blocks(iseq, pc)
  list_blocks(iseq, pc).each do |block|
    invalidate_block(block)
  end

  # If they were the ISEQ's first blocks, re-compile RJIT entry as well
  if iseq.body.iseq_encoded.to_i == pc
    iseq.body.jit_func = 0
    iseq.body.total_calls = 0
  end
end