[X86] Improve mul x, 2^N +/- 2 pattern by making the +/- 2x compute independently to x << N

[goldstein.w.n]

Summary

Previous pattern was omitting ops in sequence which just increases the
latency (to 3c, same as imul!) i.e:

(add/sub (add/sub (shl x, N), x), x)

Better is to compute 2x indepedently so x << N for better ULP i.e:
(add/sub (shl x, N), (add x, x))

[pengfei]

llvm/test/CodeGen/X86/mul-constant-result.ll

166–175

Regression?

[RKSimon]

LGTM - cheers

llvm/test/CodeGen/X86/mul-constant-result.ll

166–175

The increase in lines seems to be due to extra labels/cfi-directives - tbh I'd take the extra LEA if we reduce control flow instructions.

[craig.topper]

Can you describe the old vs new pattern in the description

[goldstein.w.n]

llvm/test/CodeGen/X86/mul-constant-result.ll

166–175

The increase in lines seems to be due to extra labels/cfi-directives - tbh I'd take the extra LEA if we reduce control flow instructions.

166–175

Regression?

I think that the tail of some cases fold when its sub; sub so lower LOC, more jumps.
Issue?

[goldstein.w.n]

Improved description / summary

[goldstein.w.n]

In D141113#4031804, @craig.topper wrote:

Can you describe the old vs new pattern in the description

Done I think.

[pengfei]

LGTM.

llvm/test/CodeGen/X86/mul-constant-result.ll

166–175

Look it again, although the new code have one more BB, it has one less jmp. So the new code it better.

llvm/lib/Target/X86/X86ISelLowering.cpp

if (isPowerOf2_64(AbsMulAmt - 1)) {
                            DAG.getConstant(Log2_64(AbsMulAmt + 1),
                                            DL, MVT::i8));
       // To negate, reverse the operands of the subtract.
       if (SignMulAmt < 0)
         NewMul = DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), NewMul);
       else
         NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
     } else if (SignMulAmt >= 0 && isPowerOf2_64(AbsMulAmt - 2)) {
-      // (mul x, 2^N + 2) => (add (add (shl x, N), x), x)
+      // (mul x, 2^N + 2) => (add (shl x, N), (add x, x))
       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
                            DAG.getConstant(Log2_64(AbsMulAmt - 2),
                                            DL, MVT::i8));
-      NewMul = DAG.getNode(ISD::ADD, DL, VT, NewMul, N->getOperand(0));
-      NewMul = DAG.getNode(ISD::ADD, DL, VT, NewMul, N->getOperand(0));
+      NewMul = DAG.getNode(
+          ISD::ADD, DL, VT, NewMul,
+          DAG.getNode(ISD::ADD, DL, VT, N->getOperand(0), N->getOperand(0)));
     } else if (SignMulAmt >= 0 && isPowerOf2_64(AbsMulAmt + 2)) {
-      // (mul x, 2^N - 2) => (sub (sub (shl x, N), x), x)
+      // (mul x, 2^N - 2) => (sub (shl x, N), (add x, x))
       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
                            DAG.getConstant(Log2_64(AbsMulAmt + 2),
                                            DL, MVT::i8));
-      NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
-      NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
+      NewMul = DAG.getNode(
+          ISD::SUB, DL, VT, NewMul,
+          DAG.getNode(ISD::ADD, DL, VT, N->getOperand(0), N->getOperand(0)));
     }
   }
 
   return NewMul;
 }
 
 // Try to form a MULHU or MULHS node by looking for
 // (srl (mul ext, ext), 16)

llvm/test/CodeGen/X86/mul-constant-i16.ll

 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 13
   ret i16 %mul
 }
 
 define i16 @test_mul_by_14(i16 %x) {
 ; X86-LABEL: test_mul_by_14:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_14:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $4, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $ax killed $ax killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $ax killed $ax killed $rax
 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 14
   ret i16 %mul
 }
 
 define i16 @test_mul_by_15(i16 %x) {
 ; X86-LABEL: test_mul_by_15:
 ; X86:       # %bb.0:

 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 29
   ret i16 %mul
 }
 
 define i16 @test_mul_by_30(i16 %x) {
 ; X86-LABEL: test_mul_by_30:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_30:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $5, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $ax killed $ax killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $ax killed $ax killed $rax
 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 30
   ret i16 %mul
 }
 
 define i16 @test_mul_by_31(i16 %x) {
 ; X86-LABEL: test_mul_by_31:
 ; X86:       # %bb.0:

 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 41
   ret i16 %mul
 }
 
 define i16 @test_mul_by_62(i16 %x) {
 ; X86-LABEL: test_mul_by_62:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $6, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_62:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $6, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $ax killed $ax killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $ax killed $ax killed $rax
 ; X64-NEXT:    retq
   %mul = mul nsw i16 %x, 62
   ret i16 %mul
 }
 
 define i16 @test_mul_by_66(i16 %x) {
 ; X86-LABEL: test_mul_by_66:
 ; X86:       # %bb.0:

llvm/test/CodeGen/X86/mul-constant-i32.ll

 ; X64-SLM-NEXT:    retq
   %mul = mul nsw i32 %x, 13
   ret i32 %mul
 }
 
 define i32 @test_mul_by_14(i32 %x) {
 ; X86-LABEL: test_mul_by_14:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_14:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $4, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_14:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $14, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; X64-NOOPT-LABEL: test_mul_by_14:

 ; X64-SLM-NEXT:    retq
   %mul = mul nsw i32 %x, 29
   ret i32 %mul
 }
 
 define i32 @test_mul_by_30(i32 %x) {
 ; X86-LABEL: test_mul_by_30:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_30:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $5, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_30:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $30, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; X64-NOOPT-LABEL: test_mul_by_30:

 ; X64-SLM-NEXT:    retq
   %mul = mul nsw i32 %x, 41
   ret i32 %mul
 }
 
 define i32 @test_mul_by_62(i32 %x) {
 ; X86-LABEL: test_mul_by_62:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT:    movl %ecx, %eax
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    leal (%eax,%eax), %ecx
 ; X86-NEXT:    shll $6, %eax
 ; X86-NEXT:    subl %ecx, %eax
-; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: test_mul_by_62:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $6, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_62:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $62, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; X64-NOOPT-LABEL: test_mul_by_62:

 ; X64-NOOPT-LABEL: test_mul_by_66:
 ; X64-NOOPT:       # %bb.0:
 ; X64-NOOPT-NEXT:    imull $66, %edi, %eax
 ; X64-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_66:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    movl %edi, %eax
-; X64-SLM-NEXT:    shll $6, %eax
-; X64-SLM-NEXT:    addl %edi, %eax
+; X64-SLM-NEXT:    leal (%rdi,%rdi), %eax
+; X64-SLM-NEXT:    shll $6, %edi
 ; X64-SLM-NEXT:    addl %edi, %eax
 ; X64-SLM-NEXT:    retq
   %mul = mul nsw i32 %x, 66
   ret i32 %mul
 }
 
 define i32 @test_mul_by_73(i32 %x) {
 ; X86-LABEL: test_mul_by_73:

llvm/test/CodeGen/X86/mul-constant-i64.ll

 ; X64-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 13
   ret i64 %mul
 }
 
 define i64 @test_mul_by_14(i64 %x) {
 ; X86-LABEL: test_mul_by_14:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    movl %eax, %ecx
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT:    leal (%ecx,%ecx), %eax
 ; X86-NEXT:    shll $4, %ecx
 ; X86-NEXT:    subl %eax, %ecx
-; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $14, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X86-NOOPT-LABEL: test_mul_by_14:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $14, %eax

 ; X64-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 29
   ret i64 %mul
 }
 
 define i64 @test_mul_by_30(i64 %x) {
 ; X86-LABEL: test_mul_by_30:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    movl %eax, %ecx
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT:    leal (%ecx,%ecx), %eax
 ; X86-NEXT:    shll $5, %ecx
 ; X86-NEXT:    subl %eax, %ecx
-; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $30, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X86-NOOPT-LABEL: test_mul_by_30:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $30, %eax

 ; X64-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 41
   ret i64 %mul
 }
 
 define i64 @test_mul_by_62(i64 %x) {
 ; X86-LABEL: test_mul_by_62:
 ; X86:       # %bb.0:
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    movl %eax, %ecx
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT:    leal (%ecx,%ecx), %eax
 ; X86-NEXT:    shll $6, %ecx
 ; X86-NEXT:    subl %eax, %ecx
-; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $62, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X86-NOOPT-LABEL: test_mul_by_62:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $62, %eax

 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    movq %rdi, %rax
 ; X64-JAG-NEXT:    shlq $6, %rax
 ; X64-JAG-NEXT:    leaq (%rax,%rdi,2), %rax
 ; X64-JAG-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_66:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax
-; X64-SLM-NEXT:    shlq $6, %rax
-; X64-SLM-NEXT:    addq %rdi, %rax
+; X64-SLM-NEXT:    leaq (%rdi,%rdi), %rax
+; X64-SLM-NEXT:    shlq $6, %rdi
 ; X64-SLM-NEXT:    addq %rdi, %rax
 ; X64-SLM-NEXT:    retq
 ;
 ; X64-NOOPT-LABEL: test_mul_by_66:
 ; X64-NOOPT:       # %bb.0:
 ; X64-NOOPT-NEXT:    imulq $66, %rdi, %rax
 ; X64-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 66

llvm/test/CodeGen/X86/mul-constant-i8.ll

; X64-NEXT:    retq
   %m = mul i8 %x, 13
   ret i8 %m
 }
 
 define i8 @test_mul_by_14(i8 %x) {
 ; X64-LABEL: test_mul_by_14:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $4, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $al killed $al killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $al killed $al killed $rax
 ; X64-NEXT:    retq
   %m = mul i8 %x, 14
   ret i8 %m
 }
 
 define i8 @test_mul_by_15(i8 %x) {
 ; X64-LABEL: test_mul_by_15:
 ; X64:       # %bb.0:
; X64-NEXT:    retq
   %m = mul i8 %x, 29
   ret i8 %m
 }
 
 define i8 @test_mul_by_30(i8 %x) {
 ; X64-LABEL: test_mul_by_30:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $5, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $al killed $al killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $al killed $al killed $rax
 ; X64-NEXT:    retq
   %m = mul i8 %x, 30
   ret i8 %m
 }
 
 define i8 @test_mul_by_31(i8 %x) {
 ; X64-LABEL: test_mul_by_31:
 ; X64:       # %bb.0:
; X64-NEXT:    retq
   %m = mul i8 %x, 41
   ret i8 %m
 }
 
 define i8 @test_mul_by_62(i8 %x) {
 ; X64-LABEL: test_mul_by_62:
 ; X64:       # %bb.0:
 ; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    leal (%rax,%rax), %ecx
 ; X64-NEXT:    shll $6, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    subl %edi, %eax
-; X64-NEXT:    # kill: def $al killed $al killed $eax
+; X64-NEXT:    subl %ecx, %eax
+; X64-NEXT:    # kill: def $al killed $al killed $rax
 ; X64-NEXT:    retq
   %m = mul i8 %x, 62
   ret i8 %m
 }
 
 define i8 @test_mul_by_66(i8 %x) {
 ; X64-LABEL: test_mul_by_66:
 ; X64:       # %bb.0:

llvm/test/CodeGen/X86/mul-constant-result.ll

 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
 ; X86-NEXT:  .LBB0_12:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    jmp .LBB0_9
 ; X86-NEXT:  .LBB0_13:
 ; X86-NEXT:    leal (,%eax,8), %ecx
-; X86-NEXT:    jmp .LBB0_41
+; X86-NEXT:    jmp .LBB0_42
 ; X86-NEXT:  .LBB0_14:
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
 ; X86-NEXT:  .LBB0_16:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    jmp .LBB0_11
 ; X86-NEXT:  .LBB0_17:
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    jmp .LBB0_18
 ; X86-NEXT:  .LBB0_19:
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    jmp .LBB0_9
 ; X86-NEXT:  .LBB0_20:
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    jmp .LBB0_21
 ; X86-NEXT:  .LBB0_22:
-; X86-NEXT:    movl %eax, %ecx
-; X86-NEXT:    shll $4, %ecx
-; X86-NEXT:    subl %eax, %ecx
-; X86-NEXT:    jmp .LBB0_41
-; X86-NEXT:  .LBB0_23:
+; X86-NEXT:    leal (%eax,%eax), %ecx
+; X86-NEXT:    shll $4, %eax
+; X86-NEXT:    jmp .LBB0_23
+; X86-NEXT:  .LBB0_24:
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    jmp .LBB0_9
-; X86-NEXT:  .LBB0_24:
+; X86-NEXT:  .LBB0_25:
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_25:
+; X86-NEXT:  .LBB0_26:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $4, %ecx
-; X86-NEXT:    jmp .LBB0_26
-; X86-NEXT:  .LBB0_27:
+; X86-NEXT:    jmp .LBB0_27
+; X86-NEXT:  .LBB0_28:
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:  .LBB0_15:
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_28:
+; X86-NEXT:  .LBB0_29:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:  .LBB0_18:
 ; X86-NEXT:    leal (%eax,%ecx,2), %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_29:
+; X86-NEXT:  .LBB0_30:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    jmp .LBB0_11
-; X86-NEXT:  .LBB0_30:
+; X86-NEXT:  .LBB0_31:
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:  .LBB0_21:
 ; X86-NEXT:    leal (%eax,%ecx,4), %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_31:
+; X86-NEXT:  .LBB0_32:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %ecx
-; X86-NEXT:    jmp .LBB0_26
-; X86-NEXT:  .LBB0_32:
+; X86-NEXT:    jmp .LBB0_27
+; X86-NEXT:  .LBB0_33:
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    shll $3, %ecx
-; X86-NEXT:    jmp .LBB0_41
-; X86-NEXT:  .LBB0_33:
+; X86-NEXT:    jmp .LBB0_42
+; X86-NEXT:  .LBB0_34:
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    jmp .LBB0_9
-; X86-NEXT:  .LBB0_34:
+; X86-NEXT:  .LBB0_35:
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:  .LBB0_11:
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_35:
+; X86-NEXT:  .LBB0_36:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,4), %ecx
-; X86-NEXT:    jmp .LBB0_26
-; X86-NEXT:  .LBB0_36:
+; X86-NEXT:    jmp .LBB0_27
+; X86-NEXT:  .LBB0_37:
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:  .LBB0_9:
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_37:
+; X86-NEXT:  .LBB0_38:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
-; X86-NEXT:    jmp .LBB0_26
-; X86-NEXT:  .LBB0_38:
+; X86-NEXT:    jmp .LBB0_27
+; X86-NEXT:  .LBB0_39:
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
 ; X86-NEXT:    addl %eax, %ecx
-; X86-NEXT:  .LBB0_26:
+; X86-NEXT:  .LBB0_27:
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_39:
-; X86-NEXT:    .cfi_def_cfa_offset 8
-; X86-NEXT:    movl %eax, %ecx
-; X86-NEXT:    shll $5, %ecx
-; X86-NEXT:    subl %eax, %ecx
-; X86-NEXT:    jmp .LBB0_41
 ; X86-NEXT:  .LBB0_40:
+; X86-NEXT:    .cfi_def_cfa_offset 8
+; X86-NEXT:    leal (%eax,%eax), %ecx
+; X86-NEXT:    shll $5, %eax
+; X86-NEXT:  .LBB0_23:
+; X86-NEXT:    subl %ecx, %eax
+; X86-NEXT:    popl %esi
+; X86-NEXT:    .cfi_def_cfa_offset 4
+; X86-NEXT:    retl
+; X86-NEXT:  .LBB0_41:
+; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $5, %ecx
-; X86-NEXT:  .LBB0_41:
+; X86-NEXT:  .LBB0_42:
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
-; X86-NEXT:  .LBB0_42:
+; X86-NEXT:  .LBB0_43:
 ; X86-NEXT:    .cfi_def_cfa_offset 8
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: mult:
 ; X64-HSW:       # %bb.0:

 ; X64-HSW-NEXT:  .LBB0_8:
 ; X64-HSW-NEXT:    addl %eax, %eax
 ; X64-HSW-NEXT:  .LBB0_5:
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
 ; X64-HSW-NEXT:  .LBB0_9:
 ; X64-HSW-NEXT:    leal (,%rax,8), %ecx
-; X64-HSW-NEXT:    jmp .LBB0_37
+; X64-HSW-NEXT:    jmp .LBB0_38
 ; X64-HSW-NEXT:  .LBB0_10:
 ; X64-HSW-NEXT:    shll $3, %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
 ; X64-HSW-NEXT:  .LBB0_12:
 ; X64-HSW-NEXT:    addl %eax, %eax
 ; X64-HSW-NEXT:  .LBB0_7:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax

 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
 ; X64-HSW-NEXT:  .LBB0_16:
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %ecx
 ; X64-HSW-NEXT:    leal (%rax,%rcx,4), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
 ; X64-HSW-NEXT:  .LBB0_18:
-; X64-HSW-NEXT:    movl %eax, %ecx
-; X64-HSW-NEXT:    shll $4, %ecx
-; X64-HSW-NEXT:    subl %eax, %ecx
-; X64-HSW-NEXT:    jmp .LBB0_37
-; X64-HSW-NEXT:  .LBB0_19:
+; X64-HSW-NEXT:    leal (%rax,%rax), %ecx
+; X64-HSW-NEXT:    shll $4, %eax
+; X64-HSW-NEXT:    subl %ecx, %eax
+; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
+; X64-HSW-NEXT:    retq
+; X64-HSW-NEXT:  .LBB0_20:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_20:
+; X64-HSW-NEXT:  .LBB0_21:
 ; X64-HSW-NEXT:    shll $4, %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_21:
+; X64-HSW-NEXT:  .LBB0_22:
 ; X64-HSW-NEXT:    movl %eax, %ecx
 ; X64-HSW-NEXT:    shll $4, %ecx
-; X64-HSW-NEXT:    jmp .LBB0_34
-; X64-HSW-NEXT:  .LBB0_22:
+; X64-HSW-NEXT:    jmp .LBB0_35
+; X64-HSW-NEXT:  .LBB0_23:
 ; X64-HSW-NEXT:    addl %eax, %eax
 ; X64-HSW-NEXT:  .LBB0_11:
 ; X64-HSW-NEXT:    leal (%rax,%rax,8), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_23:
+; X64-HSW-NEXT:  .LBB0_24:
 ; X64-HSW-NEXT:    leal (%rax,%rax,8), %ecx
 ; X64-HSW-NEXT:    leal (%rax,%rcx,2), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_24:
+; X64-HSW-NEXT:  .LBB0_25:
 ; X64-HSW-NEXT:    shll $2, %eax
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_25:
+; X64-HSW-NEXT:  .LBB0_26:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %ecx
 ; X64-HSW-NEXT:    leal (%rax,%rcx,4), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_26:
+; X64-HSW-NEXT:  .LBB0_27:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %ecx
 ; X64-HSW-NEXT:    leal (%rax,%rcx,4), %ecx
-; X64-HSW-NEXT:    jmp .LBB0_34
-; X64-HSW-NEXT:  .LBB0_27:
+; X64-HSW-NEXT:    jmp .LBB0_35
+; X64-HSW-NEXT:  .LBB0_28:
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %ecx
 ; X64-HSW-NEXT:    shll $3, %ecx
-; X64-HSW-NEXT:    jmp .LBB0_37
-; X64-HSW-NEXT:  .LBB0_28:
+; X64-HSW-NEXT:    jmp .LBB0_38
+; X64-HSW-NEXT:  .LBB0_29:
 ; X64-HSW-NEXT:    shll $3, %eax
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_29:
+; X64-HSW-NEXT:  .LBB0_30:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_30:
+; X64-HSW-NEXT:  .LBB0_31:
 ; X64-HSW-NEXT:    leal (%rax,%rax,4), %ecx
 ; X64-HSW-NEXT:    leal (%rcx,%rcx,4), %ecx
-; X64-HSW-NEXT:    jmp .LBB0_34
-; X64-HSW-NEXT:  .LBB0_31:
+; X64-HSW-NEXT:    jmp .LBB0_35
+; X64-HSW-NEXT:  .LBB0_32:
 ; X64-HSW-NEXT:    leal (%rax,%rax,8), %eax
 ; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_32:
+; X64-HSW-NEXT:  .LBB0_33:
 ; X64-HSW-NEXT:    leal (%rax,%rax,8), %ecx
 ; X64-HSW-NEXT:    leal (%rcx,%rcx,2), %ecx
-; X64-HSW-NEXT:    jmp .LBB0_34
-; X64-HSW-NEXT:  .LBB0_33:
+; X64-HSW-NEXT:    jmp .LBB0_35
+; X64-HSW-NEXT:  .LBB0_34:
 ; X64-HSW-NEXT:    leal (%rax,%rax,8), %ecx
 ; X64-HSW-NEXT:    leal (%rcx,%rcx,2), %ecx
 ; X64-HSW-NEXT:    addl %eax, %ecx
-; X64-HSW-NEXT:  .LBB0_34:
+; X64-HSW-NEXT:  .LBB0_35:
 ; X64-HSW-NEXT:    addl %eax, %ecx
 ; X64-HSW-NEXT:    movl %ecx, %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_35:
-; X64-HSW-NEXT:    movl %eax, %ecx
-; X64-HSW-NEXT:    shll $5, %ecx
-; X64-HSW-NEXT:    subl %eax, %ecx
-; X64-HSW-NEXT:    jmp .LBB0_37
 ; X64-HSW-NEXT:  .LBB0_36:
+; X64-HSW-NEXT:    leal (%rax,%rax), %ecx
+; X64-HSW-NEXT:    shll $5, %eax
+; X64-HSW-NEXT:    subl %ecx, %eax
+; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
+; X64-HSW-NEXT:    retq
+; X64-HSW-NEXT:  .LBB0_37:
 ; X64-HSW-NEXT:    movl %eax, %ecx
 ; X64-HSW-NEXT:    shll $5, %ecx
-; X64-HSW-NEXT:  .LBB0_37:
+; X64-HSW-NEXT:  .LBB0_38:
 ; X64-HSW-NEXT:    subl %eax, %ecx
 ; X64-HSW-NEXT:    movl %ecx, %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
-; X64-HSW-NEXT:  .LBB0_39:
+; X64-HSW-NEXT:  .LBB0_40:
 ; X64-HSW-NEXT:    shll $5, %eax
 ; X64-HSW-NEXT:    # kill: def $eax killed $eax killed $rax
 ; X64-HSW-NEXT:    retq
   %3 = icmp eq i32 %1, 0
   %4 = icmp sgt i32 %1, 1
   %5 = or i1 %3, %4
   %6 = select i1 %5, i32 1, i32 %1
   switch i32 %0, label %69 [