JIT: Minor optimizations

[bjorng]

This PR improves the code generation of the JIT in several ways.

The most important is eliminating reading from a BEAM register written by the previous BEAM instructions if the contents is already available in a CPU register.

For example, consider:

foo(<<X:16>>) ->
    (X band 7) bor 1.

The BEAM code for the expression body looks like this:

    {gc_bif,'band',
            {f,0},
            3,
            [{tr,{x,2},{t_integer,{0,65535}}},{integer,7}],
            {x,0}}.
    {gc_bif,'bor',{f,0},1,[{tr,{x,0},{t_integer,{0,7}}},{integer,1}],{x,0}}.

The result of the band operand is written X-register 0 ({x,0}). The bor operation then reads X-register 0.

The JIT in Erlang/OTP 25 generates the following code:

# i_band_ssjd
    mov rsi, qword ptr [rbx+16]
    mov eax, 127
    and rax, rsi
    mov qword ptr [rbx], rax
# i_bor_jssd
    mov rsi, qword ptr [rbx]
    mov eax, 31
    or rax, rsi
    mov qword ptr [rbx], rax

Here we can see that the last instruction of band stores the result to memory (mov qword ptr [rbx], rax). The very first thing bor does is to read back the value (albeit to another CPU register).

The new optimization will rewrite the first instruction of bor to get the value from the rax register:

# i_bor_jssd
    mov rsi, rax
    mov eax, 31
    or rax, rsi
    mov qword ptr [rbx], rax

But that is not actually the code that will be emitted because there is another optimization in this pull request that avoids loading a small integer operand into a register for logical operations. Here is the actual code for the two BEAM instructions:

# i_band_ssjd
    and eax, 127
    mov qword ptr [rbx], rax
# i_bor_jssd
    or rax, 31
    mov qword ptr [rbx], rax

As it happened, the result of the instruction before band (not shown) was available in the rax register. Since one operand for band is the integer 127, it can be used as an immediate operand for the and instruction. Similarly, the bor can also be reduced to two instructions because the result from band happened to be available in exactly the register it needed to be.

[github-actions]

CT Test Results

       3 files     132 suites   47m 27s ⏱️
1 496 tests 1 445 ✔️ 51 💤 0 ❌
1 887 runs  1 818 ✔️ 69 💤 0 ❌

Results for commit a4e80bd.

♻️ This comment has been updated with latest results.

To speed up review, make sure that you have read Contributing to Erlang/OTP and that all checks pass.

See the TESTING and DEVELOPMENT HowTo guides for details about how to run test locally.

Artifacts

• Complete CT logs (Download Logs)
• HTML Documentation (Download HTML Docs)
• Windows Installer

// Erlang/OTP Github Action Bot

[garazdawi]

lgtm.

I wonder what the overhead of the comment function and its arguments are for when we actually don't emit any log... maybe the compiler is smart enough to optimize it away.

[bjorng]

The compiler will not optimize away the call to ubif2mfa() because it is in another compilation unit and it can't know whether the call has any side effects.

I have updated the annotation code to test whether logging is enabled before doing anything potentially expensive. I sneaked in a few other improvements and simplifications.