I don't quite understand how this PR works. Please bear with me. The code for send is so complex that I find it hard to follow sometimes.

You say it's duplicating the ISEQ for each block. Conceptually, I understand what that means. However, I don't understand why this has an impact on the maximum number of versions in the JIT.

Are multiple entry blocks being generated for the ISEQs based on the block given in the call?

I guess I'm wondering: would it be possible to somehow duplicate the ISEQ directly at the interpreter level? That might be slightly less complex on the JIT side, and it would avoid having to add extra state to the context?

You say it's duplicating the ISEQ for each block. Conceptually, I understand what that means. However, I don't understand why this has an impact on the maximum number of versions in the JIT.

Whenever it duplicates each basic block of Array#each, it adds a version to that basic block that is called from a specific callsite and is going to call a particular block ISEQ.

Say, we have:

module Kernel
  def tap
    yield(self) # basic block 1: putself + invokeblock (version a, version b)
    self        # basic block 2: putself + leave (version a, version b)
  end
end

1.tap { :a }
2.tap { :b }

1.tap directly jumps to version a of basic block 1, which should only jump to { :a }, then jumps to version a of basic block 2, and returns to the caller.

They would be located linearly in the generated code. It's basically inlining except the frame push/pop for Array#each is still there.

Are multiple entry blocks being generated for the ISEQs based on the block given in the call?

If "entry blocks" means jit_entry, no. If it means the first block of the ISEQ, yes.

This PR duplicates blocks of Array#each for each blockiseq given to send. One blockiseq in the above example is { :a }, and another one is { :b }. An ISEQ literal is usually unique to each callsite. It could be extracted from &block and then shared by multiple callsites, but that doesn't make yield megamorphic as long as it's the same ISEQ. This is why we want to duplicate Array#each for each blockiseq.

I guess I'm wondering: would it be possible to somehow duplicate the ISEQ directly at the interpreter level? That might be slightly less complex on the JIT side, and it would avoid having to add extra state to the context?

Technically, it's possible if you rewrite how the interpreter does method lookup. The lookup is currently based on klass and mid. The lookup should include blockiseq, or it needs an extra check for annotated ISEQs after the main lookup. However, the former would be hard to implement, and the latter would make every non-cached ISEQ lookup slower.

It would also mean to add extra memory overhead to allocate more ISEQs and add more GC pressure because of them.

So, yes, it's possible, but harder to implement, uses more memory, and makes things slower in unrelated places.