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