RFR: 8282204: Use lea instructions for arithmetic operations on x86_64 [v9]

[Quan Anh Mai]

On Fri, 4 Mar 2022 06:29:43 GMT, Quan Anh Mai <duke at openjdk.java.net> wrote:

>> Hi,
>> 
>> This patch adds several matching rules for x86_64 backend to use `lea` instructions for several fused arithmetic operations. Also, `lea`s don't kill flags and allow different `dst` and `src`, so it is preferred over `sll` if possible, too. 
>> 
>> Thank you very much.
>
> Quan Anh Mai has updated the pull request incrementally with one additional commit since the last revision:
> 
>   remove 0x67 prefix

I would refrain from doing that, carelessly changing `add`s to `lea`s may bring negative results in real-world situations since the latter is a little larger in size and lower in throughput. IMO the best solution would be emitting `lea` after the coalescing of an `add` or `shl` and its input fails (e.g when the `dst` operand is needed for other operations), resulting in a sequence `mov r1, r2; add r1, r3/imm` become `lea r1, [r2 + r3/imm]`. This happens after the register allocation phase and well after the matching phase. I perceive the peephole rules are more appropriate for this transformation but I'm still exploring this idea.

The latest change removes the redundant 0x67 prefix from `leal` since it reduces the size of the instruction and without `REX.W` prefix the destination register is 32-bit and according to the manual, the result is:

> 64-bit effective address is calculated (default address size) and the lower 32 bits of the address are stored in the requested 32-bit register destination.

which will produce the same result as before. The `prefix(src, dst)` is brought out for uniformity with other instructions, the function itself does not do anything on x86_32 (see assembler_x86.inline.hpp) so it is not a concern.

Thank you very much.

-------------

PR: https://git.openjdk.java.net/jdk/pull/7560