vm.c: answer str[0] from C in OP_GETIDX0 - #7040

The gap

vm_op_getidx0() answers ary[0] and hash[0] from C and has no String
branch, so str[0] is the one index form of the three that leaves the opcode
through getidx0_fallback and reaches String#[] as an ordinary send. Its
sibling vm_op_getidx() does have a String branch, so str[1] is already
answered in C. The two opcodes disagree about String for no reason other than
the branch never having been written.

What it costs

Best of seven runs each, alternating the two binaries, with
while i < n; s[0]; i += 1; end over a local. Both are linear, so this is a
constant factor rather than a complexity change.

The arena restore is not optional

mrb_str_aref() returns a freshly allocated String, and an inline opcode never
runs the cfunc epilogue that would shrink the arena. That is the bug #7022
fixed across the allocating inline opcodes, including the Hash branch of this
same vm_op_getidx0(). A String branch written without the save and restore
would re-open it one index form later: the loop above becomes quadratic, and
under MRB_GC_FIXED_ARENA, which build_config/ci/gcc-clang.rb and
build_config/ci/msvc.rb both define, it raises instead:

$ ./build/fixedarena/bin/mruby -e 's="hello"; i=0; while i < 20000; s[0]; i+=1; end'
-e:1: arena overflow error (NoMemoryError)

With the restore in place the same command prints nothing and exits 0.

Unlike the Hash branch above it, this one does not refresh ci afterwards:
mrb_str_aref() on a plain String with an Integer index cannot run Ruby code
and so cannot move the stack. The result needs no mrb_gc_protect() either,
since it is stored in regs[a] and the VM stack is a GC root, which is why the
cfunc epilogues can shrink unconditionally too.

It changes what a redefined String#[] sees

The class guard reads the receiver's class, not whether String#[] has been
redefined, so the branch bypasses a redefinition installed on String itself:

class String
  def [](i); "OVERRIDDEN"; end
end
s = "hello"
p s[0]              # => "OVERRIDDEN" before, "h" now
p s[1]              # => "e" before and now
p s.send(:[], 0)    # => "OVERRIDDEN" both ways

class Sub < String; end
p Sub.new("hello")[0]   # => "OVERRIDDEN" both ways

The change is to make s[0] agree with s[1], which has ignored such a
redefinition ever since vm_op_getidx() gained its String branch. A subclass
receiver keeps reaching the override, because the guard rejects it. Whether the
existing s[1] behaviour is right is a separate and much larger question,
since the Array and Hash branches of both opcodes work the same way; this
change does not widen it beyond one more index form.

Which shapes reach the opcode

OP_GETIDX0 is emitted for a literal zero index only when the receiver is
already in a register: a local, a method argument, a block-local. These are
OP_GETIDX0, and slow before this change:

s = "hello"; s[0]                          # GETIDX0
def m(u); u[0]; end                        # GETIDX0
[1].each { |x| t = "hi"; t[0] }            # GETIDX0

and these are not, because the receiver has to be materialized first, after
which the compiler emits the general OP_GETIDX with a LOADI_0 beside it and
the String branch of that opcode answers it in C:

s = "hello"; [1].each { s[0] }             # GETUPVAR + LOADI_0 + GETIDX
@iv[0]                                     # GETIV + LOADI_0 + GETIDX

A benchmark that puts the loop inside a block over an outer s therefore
measures the C path and shows no difference at all. The figures above all come
from a while loop over a local.

The tests

test/t/gc.rb already carries an OP_GETIDX0 arena assertion for the Hash
branch, added by #7022. The new one is a second assertion for the same opcode,
naming the branch it pins so the two do not read as one assertion moved. It
passes without this change, since there is nothing to leak without a String
branch, and is there to fail if the branch is ever added or rewritten without
the restore. Checked both ways: it passes with the branch as written, and fails
with the same branch minus the two arena calls.

test/t/string.rb gets an assertion for the redefinition case above, which
nothing in the suite covered, and it pins both index forms at once. It restores
String#[] in an ensure. The saved alias is removed only where
remove_method exists, since that comes from mruby-metaprog and the core test
build does not have it; for the same reason the assertion does not use send.

Checked configurations

All at mruby/mruby@9df343588, with the change applied.

Summary by CodeRabbit

• Performance

  • Improved string indexing at position 0 for faster execution with standard strings.

• Bug Fixes

  • Prevented temporary indexing results from being retained during garbage collection.
  • Ensured indexed access respects custom behavior for string subclasses while preserving optimized behavior for standard strings.

• Tests

  • Added coverage for garbage collection and string indexing overrides.