JIT doesn't fold constant multiplication to single instruction

[ayende]

Description

Consider the following code:

int A(int i)
{
    return i * 4 * 8;
}

int B(int i)
{
    return i * (4 * 8);
}

These two functions should result in identical results.

But the JIT output slightly different code for each:

Program.<<Main>$>g__A|0_0(Int32)
    L0000: mov eax, ecx
    L0002: shl eax, 2
    L0005: shl eax, 3
    L0008: ret

Program.<<Main>$>g__B|0_1(Int32)
    L0000: mov eax, ecx
    L0002: shl eax, 5
    L0005: ret

This is on: ; Core CLR 7.0.823.31807 on x64

Analysis

Given that multiplication is communicative, and that this is a power of two operation, I would expect the JIT to fold them to the 2nd version, without the parenthesis.

The first version takes two instructions instead of 1.

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Description

Consider the following code:

int A(int i)
{
    return i * 4 * 8;
}

int B(int i)
{
    return i * (4 * 8);
}

These two functions should result in identical results.

But the JIT output slightly different code for each:

Program.<<Main>$>g__A|0_0(Int32)
    L0000: mov eax, ecx
    L0002: shl eax, 2
    L0005: shl eax, 3
    L0008: ret

Program.<<Main>$>g__B|0_1(Int32)
    L0000: mov eax, ecx
    L0002: shl eax, 5
    L0005: ret

This is on: ; Core CLR 7.0.823.31807 on x64

Analysis

Given that multiplication is communicative, and that this is a power of two operation, I would expect the JIT to fold them to the 2nd version, without the parenthesis.

The first version takes two instructions instead of 1.

Author:	ayende
Assignees:	-
Labels:	tenet-performance, area-CodeGen-coreclr
Milestone:	-

[EgorBo]

We do optimize this in JIT but it doesn't work well when constants are small powers of two - those are transformed into shift operation and then confuse the opt.

[MichalPetryka]

Note that the 2nd version is folded by Roslyn:

    .method private hidebysig static 
        int32 A (
            int32 i
        ) cil managed 
    {
        // Method begins at RVA 0x2067
        // Code size 6 (0x6)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldc.i4.4
        IL_0002: mul
        IL_0003: ldc.i4.8
        IL_0004: mul
        IL_0005: ret
    } // end of method Test::A

    .method private hidebysig static 
        int32 B (
            int32 i
        ) cil managed 
    {
        // Method begins at RVA 0x206e
        // Code size 5 (0x5)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldc.i4.s 32
        IL_0003: mul
        IL_0004: ret
    } // end of method Test::B

[huoyaoyuan]

those are transformed into shift operation and then confuse the opt.

Aren't shift operations mergable too?

The complex case would be that one number is transformed into shift.

[TIHan]

Currently the codegen for A is:

; Method Program.Program:A(int):int:this (FullOpts)
G_M29096_IG01:  ;; offset=0x0000
						;; size=0 bbWeight=1 PerfScore 0.00

G_M29096_IG02:  ;; offset=0x0000
       lea      eax, [4*rdx]
       shl      eax, 3
						;; size=10 bbWeight=1 PerfScore 1.00

G_M29096_IG03:  ;; offset=0x000A
       ret      
						;; size=1 bbWeight=1 PerfScore 1.00
; Total bytes of code: 11

Avoiding the LEA would be preferable if we can.