summaryrefslogtreecommitdiff
AgeCommit message (Collapse)Author
2021-10-20Return if fixnums impossibleJohn Hawthorn
2021-10-20Save PC and SP before accessing globalsAlan Wu
These instructions are marked as not leaf in insns.def, which indicate that they could raise exceptions and/or call Ruby methods.
2021-10-20Add setglobal to yjiteileencodes
Adds yjit support for setting global variables. Co-authored-by: Aaron Patterson <tenderlove@ruby-lang.org> Co-authored-by: John Hawthorn <john@hawthorn.email>
2021-10-20If codeblock is NULL because YJIT is disabled, YJIT.runtime_stats should ↵Noah Gibbs
return Qnil
2021-10-20Add getglobal to yjiteileencodes
Adds getglobal to yjit and a test for it. Co-authored-by: Aaron Patterson <tenderlove@ruby-lang.org>
2021-10-20Fix and uncomment getlocal testJohn Hawthorn
Previously, under the scraper, this would side-exit because it was returning to a C method. Now that we use the jit_func entrypoint, this test no longer side-exits.
2021-10-20Add flag so we can easily tell if all stats avail. Comment out broken test.Maxime Chevalier-Boisvert
2021-10-20Fix use-after-free on USE_EMBED_CI=0Alan Wu
The old code didn't keep old_operands[0] reachable while allocating. You can crash it by requiring erb under GC stress mode.
2021-10-20Add some YJIT runtime testsKevin Newton
This is just for helping my own understanding, but could be useful for others as well.
2021-10-20Clear JIT code when tracepoints get enabledAaron Patterson
Clear out any JIT code on iseqs when tracepoints get enabled. We can't handle tracepoints right now, so we'll just try to recompile later.
2021-10-20Make sure we can still compile with the JIT disabledAaron Patterson
If `--disable-jit-support` is passed to configure, then `jit_func` is removed from the iseq body and we can't compile YJIT. This commit detects when the JIT function pointer is gone and disables YJIT in that case.
2021-10-20Remove the scraperAaron Patterson
Now that we're using the jit function entry point, we don't need the scraper. Thank you for your service, scraper. ❤️
2021-10-20Change register definitions to match the entry point calling conventionAaron Patterson
The JIT entry point passes the CFP as RSI and the EC as RDI. Lets match that so we don't have to shuffle registers around.
2021-10-20Disable YJIT in MJIT testsAaron Patterson
2021-10-20make compiler happyAaron Patterson
2021-10-20Fix BOP invalidationAaron Patterson
Instead of mutating the iseqs, just clear the JIT function.
2021-10-20Add a guard that we start executing on the first PCAaron Patterson
Methods with optional parameters don't always start executing at the first PC, but we compile all methods assuming that they do. This commit adds a guard to ensure that we're actually starting at the first PC for methods with optional params
2021-10-20fix alignmentAaron Patterson
2021-10-20Always use `ret` to return to the interpreterAaron Patterson
Always using `ret` to return to the interpreter means that we never have to check the VM_FRAME_FLAG_FINISH flag. In the case that we return `Qundef`, the interpreter will execute the cfp. We can take advantage of this by setting the PC to the instruction we can't handle, and let the interpreter pick up the ball from there. If we return a value other than Qundef, the interpreter will take that value as the "return value" from the JIT and push that to the SP of the caller The leave instruction puts the return value on the top of the calling frame's stack. YJIT does the same thing for leave instructions. However, when we're returning back to the interpreter, the leave instruction _should not_ put the return value on the top of the stack, but put it in RAX and use RET. This commit pops the last value from the stack pointer and puts it in RAX so that the interpreter is happy with SP.
2021-10-20YJIT stats should always include the inlined and outlined sizes, regardless ↵Noah Gibbs
of RUBY_DEBUG and --yjit-stats/YJIT_STATS settings
2021-10-20Allow asserts on results, rather than stdoutJohn Hawthorn
2021-10-20Add assert_no_exits aliasJohn Hawthorn
2021-10-20more testingJohn Hawthorn
2021-10-20Add test for recursionJohn Hawthorn
2021-10-20Add test of yjit compilationJohn Hawthorn
2021-10-20Add YJIT.enabled?John Hawthorn
2021-10-20Ensure we guard the value before we returnKevin Newton
Otherwise you can end up not implicitly calling `to_ary`, which if it has side-effects will result in different behavior.
2021-10-20Update yjit.rbMaxime Chevalier-Boisvert
2021-10-20Update yjit.rbMaxime Chevalier-Boisvert
Co-authored-by: Rafael França <rafael.franca@shopify.com>
2021-10-20Dup strings so we can mutate themAaron Patterson
I guess the strings are frozen, so we need to dup before mutating
2021-10-20It's RUN_OPTS, not RUNOPTS!!! via @tenderloveMaxime Chevalier-Boisvert
2021-10-20Code review for expandarray and testsKevin Newton
2021-10-20Convert jumps to cmovKevin Newton
2021-10-20Implement expandarrayKevin Deisz
2021-10-20Implement splatarrayKevin Newton
2021-10-20Flatten mappings when clearing localsJohn Hawthorn
We clear locals when we know their values might change (ex. when performing a method call). However previously values on the stack which were originally pushed from a local would still point back to that local. With this commit, when clearing locals, we'll now iterate over the mappings of the stack and copy the known type from the local to the stack mapping, removing the association to the local. This should mean both that we'll retain any information we already know about the local type, and that if a local is modified we won't incorrectly infer it's new type from the existing value on the stack.
2021-10-20Add (void) for no arg functionsMaxime Chevalier-Boisvert
2021-10-20First pass at code page GC object.Maxime Chevalier-Boisvert
2021-10-20rb_struct_define_under needs a trailing NULLAaron Patterson
The last parameter to rb_struct_define_under needs to be NULL otherwise we can get a SEGV.
2021-10-20Use push and pop in jit_rb_obj_not to avoid corrupting typesJohn Hawthorn
2021-10-20Add assertions of types in jit_guard_known_klassJohn Hawthorn
2021-10-20Code page allocation codeMaxime Chevalier-Boisvert
2021-10-20Add an lldb script to print YJIT commentsAaron Patterson
This script is an lldb helper that just loops through all the comments stored and prints out the comment along with the address corresponding to the comment. For example, I'm crashing in JIT code at address 0x0000000110000168. Using the `lc` helper I can see that it's probably crashing inside the exit back to the interpreter ``` (lldb) bt 5 * thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x22220021) frame #0: 0x0000000110000168 * frame #1: 0x00000001002b5ff5 miniruby`invoke_block_from_c_bh [inlined] invoke_block(ec=0x0000000100e05350, iseq=0x0000000100c1ff10, self=0x0000000100c76cc0, captured=<unavailable>, cref=0x0000000000000000, type=<unavailable>, opt_pc=<unavailable>) at vm.c:1268:12 frame #2: 0x00000001002b5f7d miniruby`invoke_block_from_c_bh [inlined] invoke_iseq_block_from_c(ec=<unavailable>, captured=<unavailable>, self=0x0000000100c76cc0, argc=2, argv=<unavailable>, kw_splat=0, passed_block_handler=0x0000000000000000, cref=0x0000000000000000, is_lambda=<unavailable>, me=0x0000000000000000) at vm.c:1340 frame #3: 0x00000001002b5e14 miniruby`invoke_block_from_c_bh(ec=<unavailable>, block_handler=<unavailable>, argc=<unavailable>, argv=<unavailable>, kw_splat=0, passed_block_handler=0x0000000000000000, cref=0x0000000000000000, is_lambda=<unavailable>, force_blockarg=0) at vm.c:1358 frame #4: 0x000000010029860b miniruby`rb_yield_values(n=<unavailable>) at vm_eval.c:0 (lldb) lc 0x11000006d "putobject_INT2FIX_1_" 0x110000083 "leave" 0x110000087 "check for interrupts" 0x110000087 "RUBY_VM_CHECK_INTS(ec)" 0x110000098 "check for finish frame" 0x1100000ed "getlocal_WC_0" 0x110000107 "getlocal_WC_1" 0x11000012a "opt_send_without_block" 0x110000139 "opt_send_without_block" 0x11000013c "exit to interpreter" ```
2021-10-20Implement opt_divKevin Deisz
2021-10-20Implement opt_multKevin Deisz
Basically the same thing as opt_mod, but for multiplying.
2021-10-20Update depsMaxime Chevalier-Boisvert
2021-10-20Implement swap instructionMaxime Chevalier-Boisvert
2021-10-20Add FLONUM detectionJohn Hawthorn
2021-10-20Support guards against symbols and integersJohn Hawthorn
This adds guards
2021-10-20Allow chaining on immediate guardJohn Hawthorn
In jit_guard_known_klass whenever we encounter a new class should recompile the current instruction. However, previously once jit_guard_known_klass had guarded for a heap object it would not recompile for any immediate (special const) objects arriving afterwards and would take a plain side-exit instead of a chain guard. This commit uses jit_chain_guard inside jit_guard_known_klass instead of the plain side exit, so that we can recompile for any special constants arriving afterwards.
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-30 17:26:33 +0000