This is an archive of the discontinued LLVM Phabricator instance.

Differential D45585

[DAGCombiner][X86] When promoting loads don't use ZEXTLOAD even its legal
ClosedPublic

Authored by craig.topper on Apr 12 2018, 12:36 PM.

Details

Reviewers
spatel
RKSimon
efriedma
craig.topper
Commits
rGf3cefad255e9: [DAGCombiner][X86] When promoting loads don't use ZEXTLOAD even its legal
rL330781: [DAGCombiner][X86] When promoting loads don't use ZEXTLOAD even its legal
Summary

We were previously prefering ZEXTLOAD over EXTLOAD if it is legal. This triggers during X86's promotion of i16->i32. Not sure about other targets.

Using ZEXTLOAD can prevent folding it to SEXTLOAD later if we were to promote a sign extended operand like we would need for SRA. However, X86 doesn't currently promote i16 SRA. I was looking into doing that which is how I found this issue.

This is also blocking our ability to fold 4 byte aligned EXTLOADs with "loadi32". This is what caused most of the test changes here.

There are couple tests where the instruction counts went up. I need to look closer at those.

Diff Detail

Repository
rL LLVM

Event Timeline

craig.topper created this revision.Apr 12 2018, 12:36 PM
craig.topper added inline comments.Apr 12 2018, 12:40 PM
test/CodeGen/X86/pr32420.ll
16 ↗(On Diff #142232)

There's some oddly repeated code in here. It looks like we managed to duplicate the load.

test/CodeGen/X86/pr34137.ll
14 ↗(On Diff #142232)

Somethig odd happened here. There are 2 identical ands.

craig.topper added inline comments.Apr 12 2018, 1:01 PM
test/CodeGen/X86/pr32420.ll
16 ↗(On Diff #142232)

Nevermind, we didn't replicate it we just failed to combine the two logic cones.

craig.topper added a comment.Apr 12 2018, 1:26 PM

It seems DAG combine doesn't know these properties which accounts for some of the redundancies seen in the test output. We can either improve DAG combine or just trust that InstCombine would have prevented this in the first place

(A&B)&A -> A & B
(A^B)^A -> B

craig.topper added a comment.Apr 20 2018, 10:32 PM

Ping

zvi added a subscriber: zvi.Apr 22 2018, 11:28 AM

LGTM

craig.topper accepted this revision.Apr 24 2018, 1:48 PM

approving based on Zvi's LGTM. Assuming he forgot to Accept.

This revision is now accepted and ready to land.Apr 24 2018, 1:48 PM
RKSimon added inline comments.Apr 24 2018, 3:12 PM
test/CodeGen/X86/mul-constant-i16.ll
75 ↗(On Diff #142232)

These are likely to be performance regressions on most targets - the special case x86 'MulConstantOptimization' patterns in combineMul should still be used where possible.

craig.topper added inline comments.Apr 24 2018, 3:20 PM
test/CodeGen/X86/mul-constant-i16.ll
75 ↗(On Diff #142232)

Agreed. But that issue wasn't caused by this patch. It's pretty easy to hit with 32-bit instructions too.

https://godbolt.org/g/9Pa83o

Closed by commit rL330781: [DAGCombiner][X86] When promoting loads don't use ZEXTLOAD even its legal (authored by ctopper). · Explain WhyApr 24 2018, 3:38 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
CodeGen/
SelectionDAG/
12 lines
test/
CodeGen/
X86/
10 lines
6 lines
2 lines
2 lines
15 lines
67 lines
2 lines
32 lines
18 lines
3 lines
8 lines
4 lines

Diff 143823

llvm/trunk/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,083 Lines • ▼ Show 20 Lines
} }
SDValue DAGCombiner::PromoteOperand(SDValue Op, EVT PVT, bool &Replace) { SDValue DAGCombiner::PromoteOperand(SDValue Op, EVT PVT, bool &Replace) {
Replace = false; Replace = false;
SDLoc DL(Op); SDLoc DL(Op);
if (ISD::isUNINDEXEDLoad(Op.getNode())) { if (ISD::isUNINDEXEDLoad(Op.getNode())) {
LoadSDNode *LD = cast<LoadSDNode>(Op); LoadSDNode *LD = cast<LoadSDNode>(Op);
EVT MemVT = LD->getMemoryVT(); EVT MemVT = LD->getMemoryVT();
ISD::LoadExtType ExtType = ISD::isNON_EXTLoad(LD) ISD::LoadExtType ExtType = ISD::isNON_EXTLoad(LD) ? ISD::EXTLOAD
? (TLI.isLoadExtLegal(ISD::ZEXTLOAD, PVT, MemVT) ? ISD::ZEXTLOAD
: ISD::EXTLOAD)
: LD->getExtensionType(); : LD->getExtensionType();
Replace = true; Replace = true;
return DAG.getExtLoad(ExtType, DL, PVT, return DAG.getExtLoad(ExtType, DL, PVT,
LD->getChain(), LD->getBasePtr(), LD->getChain(), LD->getBasePtr(),
MemVT, LD->getMemOperand()); MemVT, LD->getMemOperand());
} }
unsigned Opc = Op.getOpcode(); unsigned Opc = Op.getOpcode();
switch (Opc) { switch (Opc) {
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Linesbool DAGCombiner::PromoteLoad(SDValue Op) {
// what's the right type to promote it to. // what's the right type to promote it to.
if (TLI.IsDesirableToPromoteOp(Op, PVT)) { if (TLI.IsDesirableToPromoteOp(Op, PVT)) {
assert(PVT != VT && "Don't know what type to promote to!"); assert(PVT != VT && "Don't know what type to promote to!");
SDLoc DL(Op); SDLoc DL(Op);
SDNode *N = Op.getNode(); SDNode *N = Op.getNode();
LoadSDNode *LD = cast<LoadSDNode>(N); LoadSDNode *LD = cast<LoadSDNode>(N);
EVT MemVT = LD->getMemoryVT(); EVT MemVT = LD->getMemoryVT();
ISD::LoadExtType ExtType = ISD::isNON_EXTLoad(LD) ISD::LoadExtType ExtType = ISD::isNON_EXTLoad(LD) ? ISD::EXTLOAD
? (TLI.isLoadExtLegal(ISD::ZEXTLOAD, PVT, MemVT) ? ISD::ZEXTLOAD
: ISD::EXTLOAD)
: LD->getExtensionType(); : LD->getExtensionType();
SDValue NewLD = DAG.getExtLoad(ExtType, DL, PVT, SDValue NewLD = DAG.getExtLoad(ExtType, DL, PVT,
LD->getChain(), LD->getBasePtr(), LD->getChain(), LD->getBasePtr(),
MemVT, LD->getMemOperand()); MemVT, LD->getMemOperand());
SDValue Result = DAG.getNode(ISD::TRUNCATE, DL, VT, NewLD); SDValue Result = DAG.getNode(ISD::TRUNCATE, DL, VT, NewLD);
DEBUG(dbgs() << "\nPromoting "; DEBUG(dbgs() << "\nPromoting ";
N->dump(&DAG); N->dump(&DAG);
dbgs() << "\nTo: "; dbgs() << "\nTo: ";
▲ Show 20 Lines • Show All 16,639 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/3addr-16bit.ll

Show All 23 Lines
; X64-NEXT: LBB0_2: ## %bb1 ; X64-NEXT: LBB0_2: ## %bb1
; X64-NEXT: movzwl %ax, %eax ; X64-NEXT: movzwl %ax, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X32-LABEL: test1: ; X32-LABEL: test1:
; X32: ## %bb.0: ## %entry ; X32: ## %bb.0: ## %entry
; X32-NEXT: pushl %esi ; X32-NEXT: pushl %esi
; X32-NEXT: subl $8, %esp ; X32-NEXT: subl $8, %esp
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X32-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ecx, %eax
; X32-NEXT: incl %eax ; X32-NEXT: incl %eax
; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx ; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx
; X32-NEXT: jne LBB0_2 ; X32-NEXT: jne LBB0_2
; X32-NEXT: ## %bb.1: ## %bb ; X32-NEXT: ## %bb.1: ## %bb
; X32-NEXT: movzwl %ax, %esi ; X32-NEXT: movzwl %ax, %esi
; X32-NEXT: movl %esi, (%esp) ; X32-NEXT: movl %esi, (%esp)
; X32-NEXT: calll _foo ; X32-NEXT: calll _foo
Show All 36 Lines
; X64-NEXT: LBB1_2: ## %bb1 ; X64-NEXT: LBB1_2: ## %bb1
; X64-NEXT: movzwl %ax, %eax ; X64-NEXT: movzwl %ax, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X32-LABEL: test2: ; X32-LABEL: test2:
; X32: ## %bb.0: ## %entry ; X32: ## %bb.0: ## %entry
; X32-NEXT: pushl %esi ; X32-NEXT: pushl %esi
; X32-NEXT: subl $8, %esp ; X32-NEXT: subl $8, %esp
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X32-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ecx, %eax
; X32-NEXT: decl %eax ; X32-NEXT: decl %eax
; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx ; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx
; X32-NEXT: jne LBB1_2 ; X32-NEXT: jne LBB1_2
; X32-NEXT: ## %bb.1: ## %bb ; X32-NEXT: ## %bb.1: ## %bb
; X32-NEXT: movzwl %ax, %esi ; X32-NEXT: movzwl %ax, %esi
; X32-NEXT: movl %esi, (%esp) ; X32-NEXT: movl %esi, (%esp)
; X32-NEXT: calll _foo ; X32-NEXT: calll _foo
Show All 38 Lines
; X64-NEXT: LBB2_2: ## %bb1 ; X64-NEXT: LBB2_2: ## %bb1
; X64-NEXT: movzwl %ax, %eax ; X64-NEXT: movzwl %ax, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X32-LABEL: test3: ; X32-LABEL: test3:
; X32: ## %bb.0: ## %entry ; X32: ## %bb.0: ## %entry
; X32-NEXT: pushl %esi ; X32-NEXT: pushl %esi
; X32-NEXT: subl $8, %esp ; X32-NEXT: subl $8, %esp
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X32-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ecx, %eax
; X32-NEXT: addl $2, %eax ; X32-NEXT: addl $2, %eax
; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx ; X32-NEXT: cmpw {{[0-9]+}}(%esp), %cx
; X32-NEXT: jne LBB2_2 ; X32-NEXT: jne LBB2_2
; X32-NEXT: ## %bb.1: ## %bb ; X32-NEXT: ## %bb.1: ## %bb
; X32-NEXT: movzwl %ax, %esi ; X32-NEXT: movzwl %ax, %esi
; X32-NEXT: movl %esi, (%esp) ; X32-NEXT: movl %esi, (%esp)
; X32-NEXT: calll _foo ; X32-NEXT: calll _foo
Show All 36 Lines
; X64-NEXT: LBB3_2: ## %bb1 ; X64-NEXT: LBB3_2: ## %bb1
; X64-NEXT: movzwl %ax, %eax ; X64-NEXT: movzwl %ax, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X32-LABEL: test4: ; X32-LABEL: test4:
; X32: ## %bb.0: ## %entry ; X32: ## %bb.0: ## %entry
; X32-NEXT: pushl %esi ; X32-NEXT: pushl %esi
; X32-NEXT: subl $8, %esp ; X32-NEXT: subl $8, %esp
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X32-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %edx ; X32-NEXT: movl {{[0-9]+}}(%esp), %edx
; X32-NEXT: movl %edx, %eax ; X32-NEXT: movl %edx, %eax
; X32-NEXT: addl %ecx, %eax ; X32-NEXT: addl %ecx, %eax
; X32-NEXT: cmpw %cx, %dx ; X32-NEXT: cmpw %cx, %dx
; X32-NEXT: jne LBB3_2 ; X32-NEXT: jne LBB3_2
; X32-NEXT: ## %bb.1: ## %bb ; X32-NEXT: ## %bb.1: ## %bb
; X32-NEXT: movzwl %ax, %esi ; X32-NEXT: movzwl %ax, %esi
; X32-NEXT: movl %esi, (%esp) ; X32-NEXT: movl %esi, (%esp)
; X32-NEXT: calll _foo ; X32-NEXT: calll _foo
Show All 21 Lines

llvm/trunk/test/CodeGen/X86/avx512-mask-op.ll

Show All 9 Lines
; CHECK-LABEL: mask16: ; CHECK-LABEL: mask16:
; CHECK: ## %bb.0: ; CHECK: ## %bb.0:
; CHECK-NEXT: notl %edi ; CHECK-NEXT: notl %edi
; CHECK-NEXT: movl %edi, %eax ; CHECK-NEXT: movl %edi, %eax
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; ;
; X86-LABEL: mask16: ; X86-LABEL: mask16:
; X86: ## %bb.0: ; X86: ## %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: notl %eax ; X86-NEXT: notl %eax
; X86-NEXT: ## kill: def $ax killed $ax killed $eax ; X86-NEXT: ## kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%m0 = bitcast i16 %x to <16 x i1> %m0 = bitcast i16 %x to <16 x i1>
%m1 = xor <16 x i1> %m0, <i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1> %m1 = xor <16 x i1> %m0, <i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1, i1 -1>
%ret = bitcast <16 x i1> %m1 to i16 %ret = bitcast <16 x i1> %m1 to i16
ret i16 %ret ret i16 %ret
} }
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
; CHECK-NEXT: xorl %esi, %eax ; CHECK-NEXT: xorl %esi, %eax
; CHECK-NEXT: andl %esi, %edi ; CHECK-NEXT: andl %esi, %edi
; CHECK-NEXT: orl %eax, %edi ; CHECK-NEXT: orl %eax, %edi
; CHECK-NEXT: movl %edi, %eax ; CHECK-NEXT: movl %edi, %eax
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; ;
; X86-LABEL: mand16: ; X86-LABEL: mand16:
; X86: ## %bb.0: ; X86: ## %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: movl %eax, %edx ; X86-NEXT: movl %eax, %edx
; X86-NEXT: andl %ecx, %edx ; X86-NEXT: andl %ecx, %edx
; X86-NEXT: xorl %ecx, %eax ; X86-NEXT: xorl %ecx, %eax
; X86-NEXT: orl %edx, %eax ; X86-NEXT: orl %edx, %eax
; X86-NEXT: ## kill: def $ax killed $ax killed $eax ; X86-NEXT: ## kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%ma = bitcast i16 %x to <16 x i1> %ma = bitcast i16 %x to <16 x i1>
%mb = bitcast i16 %y to <16 x i1> %mb = bitcast i16 %y to <16 x i1>
▲ Show 20 Lines • Show All 3,279 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/fixup-bw-copy.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shrl $8, %eax ; X64-NEXT: shrl $8, %eax
; X64-NEXT: addb %dil, %al ; X64-NEXT: addb %dil, %al
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X32-LABEL: test_movb_hreg: ; X32-LABEL: test_movb_hreg:
; X32: # %bb.0: ; X32: # %bb.0:
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X32-NEXT: movl {{[0-9]+}}(%esp), %eax
; X32-NEXT: addb %al, %ah ; X32-NEXT: addb %al, %ah
; X32-NEXT: movb %ah, %al ; X32-NEXT: movb %ah, %al
; X32-NEXT: retl ; X32-NEXT: retl
%tmp0 = trunc i16 %a0 to i8 %tmp0 = trunc i16 %a0 to i8
%tmp1 = lshr i16 %a0, 8 %tmp1 = lshr i16 %a0, 8
%tmp2 = trunc i16 %tmp1 to i8 %tmp2 = trunc i16 %tmp1 to i8
%tmp3 = add i8 %tmp0, %tmp2 %tmp3 = add i8 %tmp0, %tmp2
ret i8 %tmp3 ret i8 %tmp3
} }

llvm/trunk/test/CodeGen/X86/iabs.ll

Show All 30 Lines; X64-NEXT: retq
%b = icmp sgt i8 %a, -1 %b = icmp sgt i8 %a, -1
%abs = select i1 %b, i8 %a, i8 %tmp1neg %abs = select i1 %b, i8 %a, i8 %tmp1neg
ret i8 %abs ret i8 %abs
} }
define i16 @test_i16(i16 %a) nounwind { define i16 @test_i16(i16 %a) nounwind {
; X86-NO-CMOV-LABEL: test_i16: ; X86-NO-CMOV-LABEL: test_i16:
; X86-NO-CMOV: # %bb.0: ; X86-NO-CMOV: # %bb.0:
; X86-NO-CMOV-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NO-CMOV-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NO-CMOV-NEXT: movl %eax, %ecx ; X86-NO-CMOV-NEXT: movl %eax, %ecx
; X86-NO-CMOV-NEXT: sarw $15, %cx ; X86-NO-CMOV-NEXT: sarw $15, %cx
; X86-NO-CMOV-NEXT: addl %ecx, %eax ; X86-NO-CMOV-NEXT: addl %ecx, %eax
; X86-NO-CMOV-NEXT: xorl %ecx, %eax ; X86-NO-CMOV-NEXT: xorl %ecx, %eax
; X86-NO-CMOV-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NO-CMOV-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NO-CMOV-NEXT: retl ; X86-NO-CMOV-NEXT: retl
; ;
; X86-CMOV-LABEL: test_i16: ; X86-CMOV-LABEL: test_i16:
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/ins_subreg_coalesce-1.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=i686-- -mattr=-bmi | FileCheck %s ; RUN: llc < %s -mtriple=i686-- -mattr=-bmi | FileCheck %s
define fastcc i32 @t() nounwind { define fastcc i32 @t() nounwind {
entry:
; CHECK-LABEL: t: ; CHECK-LABEL: t:
; CHECK: movzwl 0, %eax ; CHECK: # %bb.0: # %walkExprTree.exit
; CHECK: orl $2, %eax ; CHECK-NEXT: movl 0, %eax
; CHECK: movw %ax, 0 ; CHECK-NEXT: orl $2, %eax
; CHECK: shrl $3, %eax ; CHECK-NEXT: movw %ax, 0
; CHECK: andl $1, %eax ; CHECK-NEXT: shrl $3, %eax
; CHECK-NEXT: andl $1, %eax
; CHECK-NEXT: retl
entry:
br i1 false, label %UnifiedReturnBlock, label %bb4 br i1 false, label %UnifiedReturnBlock, label %bb4
bb4: ; preds = %entry bb4: ; preds = %entry
br i1 false, label %bb17, label %bb22 br i1 false, label %bb17, label %bb22
bb17: ; preds = %bb4 bb17: ; preds = %bb4
ret i32 1 ret i32 1
bb22: ; preds = %bb4 bb22: ; preds = %bb4
br i1 true, label %walkExprTree.exit, label %bb4.i br i1 true, label %walkExprTree.exit, label %bb4.i
bb4.i: ; preds = %bb22 bb4.i: ; preds = %bb22
Show All 12 Lines

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

Show All 13 Lines
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 1 %mul = mul nsw i16 %x, 1
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_2(i16 %x) { define i16 @test_mul_by_2(i16 %x) {
; X86-LABEL: test_mul_by_2: ; X86-LABEL: test_mul_by_2:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: addl %eax, %eax ; X86-NEXT: addl %eax, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_2: ; X64-LABEL: test_mul_by_2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi), %eax ; X64-NEXT: leal (%rdi,%rdi), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 2 %mul = mul nsw i16 %x, 2
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_3(i16 %x) { define i16 @test_mul_by_3(i16 %x) {
; X86-LABEL: test_mul_by_3: ; X86-LABEL: test_mul_by_3:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: imull $3, {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_3: ; X64-LABEL: test_mul_by_3:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 3 %mul = mul nsw i16 %x, 3
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_4(i16 %x) { define i16 @test_mul_by_4(i16 %x) {
; X86-LABEL: test_mul_by_4: ; X86-LABEL: test_mul_by_4:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $2, %eax ; X86-NEXT: shll $2, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_4: ; X64-LABEL: test_mul_by_4:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (,%rdi,4), %eax ; X64-NEXT: leal (,%rdi,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 4 %mul = mul nsw i16 %x, 4
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_5(i16 %x) { define i16 @test_mul_by_5(i16 %x) {
; X86-LABEL: test_mul_by_5: ; X86-LABEL: test_mul_by_5:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: imull $5, {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_5: ; X64-LABEL: test_mul_by_5:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 5 %mul = mul nsw i16 %x, 5
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_6(i16 %x) { define i16 @test_mul_by_6(i16 %x) {
; X86-LABEL: test_mul_by_6: ; X86-LABEL: test_mul_by_6:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: addl %eax, %eax ; X86-NEXT: addl %eax, %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_6: ; X64-LABEL: test_mul_by_6:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: addl %edi, %edi ; X64-NEXT: addl %edi, %edi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 6 %mul = mul nsw i16 %x, 6
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_7(i16 %x) { define i16 @test_mul_by_7(i16 %x) {
; X86-LABEL: test_mul_by_7: ; X86-LABEL: test_mul_by_7:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (,%ecx,8), %eax ; X86-NEXT: leal (,%ecx,8), %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_7: ; X64-LABEL: test_mul_by_7:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (,%rdi,8), %eax ; X64-NEXT: leal (,%rdi,8), %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 7 %mul = mul nsw i16 %x, 7
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_8(i16 %x) { define i16 @test_mul_by_8(i16 %x) {
; X86-LABEL: test_mul_by_8: ; X86-LABEL: test_mul_by_8:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $3, %eax ; X86-NEXT: shll $3, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_8: ; X64-LABEL: test_mul_by_8:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (,%rdi,8), %eax ; X64-NEXT: leal (,%rdi,8), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 8 %mul = mul nsw i16 %x, 8
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_9(i16 %x) { define i16 @test_mul_by_9(i16 %x) {
; X86-LABEL: test_mul_by_9: ; X86-LABEL: test_mul_by_9:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: imull $9, {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,8), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_9: ; X64-LABEL: test_mul_by_9:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 9 %mul = mul nsw i16 %x, 9
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_10(i16 %x) { define i16 @test_mul_by_10(i16 %x) {
; X86-LABEL: test_mul_by_10: ; X86-LABEL: test_mul_by_10:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: addl %eax, %eax ; X86-NEXT: addl %eax, %eax
; X86-NEXT: leal (%eax,%eax,4), %eax ; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_10: ; X64-LABEL: test_mul_by_10:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: addl %edi, %edi ; X64-NEXT: addl %edi, %edi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 10 %mul = mul nsw i16 %x, 10
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_11(i16 %x) { define i16 @test_mul_by_11(i16 %x) {
; X86-LABEL: test_mul_by_11: ; X86-LABEL: test_mul_by_11:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,4), %ecx ; X86-NEXT: leal (%eax,%eax,4), %ecx
; X86-NEXT: leal (%eax,%ecx,2), %eax ; X86-NEXT: leal (%eax,%ecx,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_11: ; X64-LABEL: test_mul_by_11:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: leal (%rdi,%rax,2), %eax ; X64-NEXT: leal (%rdi,%rax,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 11 %mul = mul nsw i16 %x, 11
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_12(i16 %x) { define i16 @test_mul_by_12(i16 %x) {
; X86-LABEL: test_mul_by_12: ; X86-LABEL: test_mul_by_12:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $2, %eax ; X86-NEXT: shll $2, %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_12: ; X64-LABEL: test_mul_by_12:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: shll $2, %edi ; X64-NEXT: shll $2, %edi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 12 %mul = mul nsw i16 %x, 12
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_13(i16 %x) { define i16 @test_mul_by_13(i16 %x) {
; X86-LABEL: test_mul_by_13: ; X86-LABEL: test_mul_by_13:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,2), %ecx ; X86-NEXT: leal (%eax,%eax,2), %ecx
; X86-NEXT: leal (%eax,%ecx,4), %eax ; X86-NEXT: leal (%eax,%ecx,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_13: ; X64-LABEL: test_mul_by_13:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: leal (%rdi,%rax,4), %eax ; X64-NEXT: leal (%rdi,%rax,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 13 %mul = mul nsw i16 %x, 13
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_14(i16 %x) { define i16 @test_mul_by_14(i16 %x) {
; X86-LABEL: test_mul_by_14: ; X86-LABEL: test_mul_by_14:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,2), %eax ; X86-NEXT: leal (%ecx,%ecx,2), %eax
; X86-NEXT: leal (%ecx,%eax,4), %eax ; X86-NEXT: leal (%ecx,%eax,4), %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_14: ; X64-LABEL: test_mul_by_14:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: leal (%rdi,%rax,4), %eax ; X64-NEXT: leal (%rdi,%rax,4), %eax
; X64-NEXT: addl %edi, %eax ; X64-NEXT: addl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 14 %mul = mul nsw i16 %x, 14
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_15(i16 %x) { define i16 @test_mul_by_15(i16 %x) {
; X86-LABEL: test_mul_by_15: ; X86-LABEL: test_mul_by_15:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,4), %eax ; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_15: ; X64-LABEL: test_mul_by_15:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: leal (%rax,%rax,2), %eax ; X64-NEXT: leal (%rax,%rax,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 15 %mul = mul nsw i16 %x, 15
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_16(i16 %x) { define i16 @test_mul_by_16(i16 %x) {
; X86-LABEL: test_mul_by_16: ; X86-LABEL: test_mul_by_16:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $4, %eax ; X86-NEXT: shll $4, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_16: ; X64-LABEL: test_mul_by_16:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: shll $4, %edi ; X64-NEXT: shll $4, %edi
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 16 %mul = mul nsw i16 %x, 16
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_17(i16 %x) { define i16 @test_mul_by_17(i16 %x) {
; X86-LABEL: test_mul_by_17: ; X86-LABEL: test_mul_by_17:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: shll $4, %eax ; X86-NEXT: shll $4, %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_17: ; X64-LABEL: test_mul_by_17:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shll $4, %eax ; X64-NEXT: shll $4, %eax
; X64-NEXT: leal (%rax,%rdi), %eax ; X64-NEXT: leal (%rax,%rdi), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 17 %mul = mul nsw i16 %x, 17
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_18(i16 %x) { define i16 @test_mul_by_18(i16 %x) {
; X86-LABEL: test_mul_by_18: ; X86-LABEL: test_mul_by_18:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: addl %eax, %eax ; X86-NEXT: addl %eax, %eax
; X86-NEXT: leal (%eax,%eax,8), %eax ; X86-NEXT: leal (%eax,%eax,8), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_18: ; X64-LABEL: test_mul_by_18:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: addl %edi, %edi ; X64-NEXT: addl %edi, %edi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 18 %mul = mul nsw i16 %x, 18
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_19(i16 %x) { define i16 @test_mul_by_19(i16 %x) {
; X86-LABEL: test_mul_by_19: ; X86-LABEL: test_mul_by_19:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,4), %eax ; X86-NEXT: leal (%ecx,%ecx,4), %eax
; X86-NEXT: shll $2, %eax ; X86-NEXT: shll $2, %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_19: ; X64-LABEL: test_mul_by_19:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: shll $2, %eax ; X64-NEXT: shll $2, %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 19 %mul = mul nsw i16 %x, 19
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_20(i16 %x) { define i16 @test_mul_by_20(i16 %x) {
; X86-LABEL: test_mul_by_20: ; X86-LABEL: test_mul_by_20:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $2, %eax ; X86-NEXT: shll $2, %eax
; X86-NEXT: leal (%eax,%eax,4), %eax ; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_20: ; X64-LABEL: test_mul_by_20:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: shll $2, %edi ; X64-NEXT: shll $2, %edi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 20 %mul = mul nsw i16 %x, 20
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_21(i16 %x) { define i16 @test_mul_by_21(i16 %x) {
; X86-LABEL: test_mul_by_21: ; X86-LABEL: test_mul_by_21:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,4), %ecx ; X86-NEXT: leal (%eax,%eax,4), %ecx
; X86-NEXT: leal (%eax,%ecx,4), %eax ; X86-NEXT: leal (%eax,%ecx,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_21: ; X64-LABEL: test_mul_by_21:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: leal (%rdi,%rax,4), %eax ; X64-NEXT: leal (%rdi,%rax,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 21 %mul = mul nsw i16 %x, 21
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_22(i16 %x) { define i16 @test_mul_by_22(i16 %x) {
; X86-LABEL: test_mul_by_22: ; X86-LABEL: test_mul_by_22:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,4), %eax ; X86-NEXT: leal (%ecx,%ecx,4), %eax
; X86-NEXT: leal (%ecx,%eax,4), %eax ; X86-NEXT: leal (%ecx,%eax,4), %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_22: ; X64-LABEL: test_mul_by_22:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: leal (%rdi,%rax,4), %eax ; X64-NEXT: leal (%rdi,%rax,4), %eax
; X64-NEXT: addl %edi, %eax ; X64-NEXT: addl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 22 %mul = mul nsw i16 %x, 22
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_23(i16 %x) { define i16 @test_mul_by_23(i16 %x) {
; X86-LABEL: test_mul_by_23: ; X86-LABEL: test_mul_by_23:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,2), %eax ; X86-NEXT: leal (%ecx,%ecx,2), %eax
; X86-NEXT: shll $3, %eax ; X86-NEXT: shll $3, %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_23: ; X64-LABEL: test_mul_by_23:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: shll $3, %eax ; X64-NEXT: shll $3, %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 23 %mul = mul nsw i16 %x, 23
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_24(i16 %x) { define i16 @test_mul_by_24(i16 %x) {
; X86-LABEL: test_mul_by_24: ; X86-LABEL: test_mul_by_24:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $3, %eax ; X86-NEXT: shll $3, %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_24: ; X64-LABEL: test_mul_by_24:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: shll $3, %edi ; X64-NEXT: shll $3, %edi
; X64-NEXT: leal (%rdi,%rdi,2), %eax ; X64-NEXT: leal (%rdi,%rdi,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 24 %mul = mul nsw i16 %x, 24
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_25(i16 %x) { define i16 @test_mul_by_25(i16 %x) {
; X86-LABEL: test_mul_by_25: ; X86-LABEL: test_mul_by_25:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,4), %eax ; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: leal (%eax,%eax,4), %eax ; X86-NEXT: leal (%eax,%eax,4), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_25: ; X64-LABEL: test_mul_by_25:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,4), %eax ; X64-NEXT: leal (%rdi,%rdi,4), %eax
; X64-NEXT: leal (%rax,%rax,4), %eax ; X64-NEXT: leal (%rax,%rax,4), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 25 %mul = mul nsw i16 %x, 25
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_26(i16 %x) { define i16 @test_mul_by_26(i16 %x) {
; X86-LABEL: test_mul_by_26: ; X86-LABEL: test_mul_by_26:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,8), %eax ; X86-NEXT: leal (%ecx,%ecx,8), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_26: ; X64-LABEL: test_mul_by_26:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: leal (%rax,%rax,2), %eax ; X64-NEXT: leal (%rax,%rax,2), %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 26 %mul = mul nsw i16 %x, 26
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_27(i16 %x) { define i16 @test_mul_by_27(i16 %x) {
; X86-LABEL: test_mul_by_27: ; X86-LABEL: test_mul_by_27:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal (%eax,%eax,8), %eax ; X86-NEXT: leal (%eax,%eax,8), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_27: ; X64-LABEL: test_mul_by_27:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: leal (%rax,%rax,2), %eax ; X64-NEXT: leal (%rax,%rax,2), %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 27 %mul = mul nsw i16 %x, 27
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_28(i16 %x) { define i16 @test_mul_by_28(i16 %x) {
; X86-LABEL: test_mul_by_28: ; X86-LABEL: test_mul_by_28:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,8), %eax ; X86-NEXT: leal (%ecx,%ecx,8), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_28: ; X64-LABEL: test_mul_by_28:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: leal (%rax,%rax,2), %eax ; X64-NEXT: leal (%rax,%rax,2), %eax
; X64-NEXT: addl %edi, %eax ; X64-NEXT: addl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 28 %mul = mul nsw i16 %x, 28
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_29(i16 %x) { define i16 @test_mul_by_29(i16 %x) {
; X86-LABEL: test_mul_by_29: ; X86-LABEL: test_mul_by_29:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: leal (%ecx,%ecx,8), %eax ; X86-NEXT: leal (%ecx,%ecx,8), %eax
; X86-NEXT: leal (%eax,%eax,2), %eax ; X86-NEXT: leal (%eax,%eax,2), %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: addl %ecx, %eax ; X86-NEXT: addl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_29: ; X64-LABEL: test_mul_by_29:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: # kill: def $edi killed $edi def $rdi ; X64-NEXT: # kill: def $edi killed $edi def $rdi
; X64-NEXT: leal (%rdi,%rdi,8), %eax ; X64-NEXT: leal (%rdi,%rdi,8), %eax
; X64-NEXT: leal (%rax,%rax,2), %eax ; X64-NEXT: leal (%rax,%rax,2), %eax
; X64-NEXT: addl %edi, %eax ; X64-NEXT: addl %edi, %eax
; X64-NEXT: addl %edi, %eax ; X64-NEXT: addl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 29 %mul = mul nsw i16 %x, 29
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_30(i16 %x) { define i16 @test_mul_by_30(i16 %x) {
; X86-LABEL: test_mul_by_30: ; X86-LABEL: test_mul_by_30:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: shll $5, %eax ; X86-NEXT: shll $5, %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: subl %ecx, %eax ; X86-NEXT: subl %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_30: ; X64-LABEL: test_mul_by_30:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shll $5, %eax ; X64-NEXT: shll $5, %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: subl %edi, %eax ; X64-NEXT: subl %edi, %eax
; X64-NEXT: # kill: def $ax killed $ax killed $eax ; X64-NEXT: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 30 %mul = mul nsw i16 %x, 30
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_31(i16 %x) { define i16 @test_mul_by_31(i16 %x) {
; X86-LABEL: test_mul_by_31: ; X86-LABEL: test_mul_by_31:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: shll $5, %eax ; 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: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_31: ; X64-LABEL: test_mul_by_31:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shll $5, %eax ; 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: # kill: def $ax killed $ax killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 31 %mul = mul nsw i16 %x, 31
ret i16 %mul ret i16 %mul
} }
define i16 @test_mul_by_32(i16 %x) { define i16 @test_mul_by_32(i16 %x) {
; X86-LABEL: test_mul_by_32: ; X86-LABEL: test_mul_by_32:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: shll $5, %eax ; X86-NEXT: shll $5, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_by_32: ; X64-LABEL: test_mul_by_32:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: shll $5, %edi ; X64-NEXT: shll $5, %edi
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
%mul = mul nsw i16 %x, 32 %mul = mul nsw i16 %x, 32
ret i16 %mul ret i16 %mul
} }
; (x*9+42)*(x*5+2) ; (x*9+42)*(x*5+2)
define i16 @test_mul_spec(i16 %x) nounwind { define i16 @test_mul_spec(i16 %x) nounwind {
; X86-LABEL: test_mul_spec: ; X86-LABEL: test_mul_spec:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: leal 42(%eax,%eax,8), %ecx ; X86-NEXT: leal 42(%eax,%eax,8), %ecx
; X86-NEXT: leal 2(%eax,%eax,4), %eax ; X86-NEXT: leal 2(%eax,%eax,4), %eax
; X86-NEXT: imull %ecx, %eax ; X86-NEXT: imull %ecx, %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: test_mul_spec: ; X64-LABEL: test_mul_spec:
; X64: # %bb.0: ; X64: # %bb.0:
Show All 13 Lines

llvm/trunk/test/CodeGen/X86/popcnt.ll

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
; X64-POPCNT-NEXT: retq ; X64-POPCNT-NEXT: retq
%cnt = tail call i8 @llvm.ctpop.i8(i8 %x) %cnt = tail call i8 @llvm.ctpop.i8(i8 %x)
ret i8 %cnt ret i8 %cnt
} }
define i16 @cnt16(i16 %x) nounwind readnone { define i16 @cnt16(i16 %x) nounwind readnone {
; X32-LABEL: cnt16: ; X32-LABEL: cnt16:
; X32: # %bb.0: ; X32: # %bb.0:
; X32-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X32-NEXT: movl {{[0-9]+}}(%esp), %eax
; X32-NEXT: movl %eax, %ecx ; X32-NEXT: movl %eax, %ecx
; X32-NEXT: shrl %ecx ; X32-NEXT: shrl %ecx
; X32-NEXT: andl $21845, %ecx # imm = 0x5555 ; X32-NEXT: andl $21845, %ecx # imm = 0x5555
; X32-NEXT: subl %ecx, %eax ; X32-NEXT: subl %ecx, %eax
; X32-NEXT: movl %eax, %ecx ; X32-NEXT: movl %eax, %ecx
; X32-NEXT: andl $13107, %ecx # imm = 0x3333 ; X32-NEXT: andl $13107, %ecx # imm = 0x3333
; X32-NEXT: shrl $2, %eax ; X32-NEXT: shrl $2, %eax
; X32-NEXT: andl $13107, %eax # imm = 0x3333 ; X32-NEXT: andl $13107, %eax # imm = 0x3333
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/pr32345.ll

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
; 6860-NEXT: # implicit-def: $esi ; 6860-NEXT: # implicit-def: $esi
; 6860-NEXT: movw %ax, %si ; 6860-NEXT: movw %ax, %si
; 6860-NEXT: xorl %ecx, %esi ; 6860-NEXT: xorl %ecx, %esi
; 6860-NEXT: movw %si, %ax ; 6860-NEXT: movw %si, %ax
; 6860-NEXT: movzwl %ax, %esi ; 6860-NEXT: movzwl %ax, %esi
; 6860-NEXT: addl $-16610, %ecx # imm = 0xBF1E ; 6860-NEXT: addl $-16610, %ecx # imm = 0xBF1E
; 6860-NEXT: movb %cl, %bl ; 6860-NEXT: movb %cl, %bl
; 6860-NEXT: xorl %ecx, %ecx ; 6860-NEXT: xorl %ecx, %ecx
; 6860-NEXT: movl %ecx, {{[0-9]+}}(%esp) # 4-byte Spill ; 6860-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; 6860-NEXT: movb %bl, %cl ; 6860-NEXT: movb %bl, %cl
; 6860-NEXT: movl {{[0-9]+}}(%esp), %edi # 4-byte Reload ; 6860-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %edi # 4-byte Reload
; 6860-NEXT: shrdl %cl, %edi, %esi ; 6860-NEXT: shrdl %cl, %edi, %esi
; 6860-NEXT: testb $32, %bl ; 6860-NEXT: testb $32, %bl
; 6860-NEXT: movl %edi, {{[0-9]+}}(%esp) # 4-byte Spill ; 6860-NEXT: movl %edi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; 6860-NEXT: movl %esi, {{[0-9]+}}(%esp) # 4-byte Spill ; 6860-NEXT: movl %esi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; 6860-NEXT: jne .LBB0_2 ; 6860-NEXT: jne .LBB0_2
; 6860-NEXT: # %bb.1: # %bb ; 6860-NEXT: # %bb.1: # %bb
; 6860-NEXT: movl {{[0-9]+}}(%esp), %eax # 4-byte Reload ; 6860-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; 6860-NEXT: movl %eax, {{[0-9]+}}(%esp) # 4-byte Spill ; 6860-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; 6860-NEXT: .LBB0_2: # %bb ; 6860-NEXT: .LBB0_2: # %bb
; 6860-NEXT: movl {{[0-9]+}}(%esp), %eax # 4-byte Reload ; 6860-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
; 6860-NEXT: movb %al, %cl ; 6860-NEXT: movb %al, %cl
; 6860-NEXT: # implicit-def: $eax ; 6860-NEXT: # implicit-def: $eax
; 6860-NEXT: movb %cl, (%eax) ; 6860-NEXT: movb %cl, (%eax)
; 6860-NEXT: leal -12(%ebp), %esp ; 6860-NEXT: leal -12(%ebp), %esp
; 6860-NEXT: popl %esi ; 6860-NEXT: popl %esi
; 6860-NEXT: popl %edi ; 6860-NEXT: popl %edi
; 6860-NEXT: popl %ebx ; 6860-NEXT: popl %ebx
; 6860-NEXT: popl %ebp ; 6860-NEXT: popl %ebp
; 6860-NEXT: .cfi_def_cfa %esp, 4 ; 6860-NEXT: .cfi_def_cfa %esp, 4
; 6860-NEXT: retl ; 6860-NEXT: retl
; ;
; X64-LABEL: foo: ; X64-LABEL: foo:
; X64: # %bb.0: # %bb ; X64: # %bb.0: # %bb
; X64-NEXT: movzwl {{.*}}(%rip), %ecx
; X64-NEXT: movzwl {{.*}}(%rip), %eax ; X64-NEXT: movzwl {{.*}}(%rip), %eax
; X64-NEXT: xorw %cx, %ax ; X64-NEXT: movzwl {{.*}}(%rip), %ecx
; X64-NEXT: xorl %ecx, %eax ; X64-NEXT: movl %ecx, %edx
; X64-NEXT: movzwl %ax, %eax ; X64-NEXT: xorl %edx, %edx
; X64-NEXT: xorl %eax, %edx
; X64-NEXT: movzwl %dx, %eax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp)
; X64-NEXT: addl $-16610, %ecx # imm = 0xBF1E ; X64-NEXT: addl $-16610, %ecx # imm = 0xBF1E
; X64-NEXT: # kill: def $cl killed $cl killed $ecx ; X64-NEXT: # kill: def $cl killed $cl killed $ecx
; X64-NEXT: shrq %cl, %rax ; X64-NEXT: shrq %cl, %rax
; X64-NEXT: movb %al, (%rax) ; X64-NEXT: movb %al, (%rax)
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; 686-LABEL: foo: ; 686-LABEL: foo:
; 686: # %bb.0: # %bb ; 686: # %bb.0: # %bb
; 686-NEXT: pushl %ebp ; 686-NEXT: pushl %ebp
; 686-NEXT: .cfi_def_cfa_offset 8 ; 686-NEXT: .cfi_def_cfa_offset 8
; 686-NEXT: .cfi_offset %ebp, -8 ; 686-NEXT: .cfi_offset %ebp, -8
; 686-NEXT: movl %esp, %ebp ; 686-NEXT: movl %esp, %ebp
; 686-NEXT: .cfi_def_cfa_register %ebp ; 686-NEXT: .cfi_def_cfa_register %ebp
; 686-NEXT: andl $-8, %esp ; 686-NEXT: andl $-8, %esp
; 686-NEXT: subl $8, %esp ; 686-NEXT: subl $8, %esp
; 686-NEXT: movzwl var_27, %ecx
; 686-NEXT: movzwl var_22, %eax ; 686-NEXT: movzwl var_22, %eax
; 686-NEXT: xorw %cx, %ax ; 686-NEXT: movzwl var_27, %ecx
; 686-NEXT: xorl %ecx, %eax ; 686-NEXT: movl %ecx, %edx
; 686-NEXT: movzwl %ax, %eax ; 686-NEXT: xorl %ecx, %edx
; 686-NEXT: xorl %eax, %edx
; 686-NEXT: movzwl %dx, %eax
; 686-NEXT: movl %eax, (%esp) ; 686-NEXT: movl %eax, (%esp)
; 686-NEXT: movl $0, {{[0-9]+}}(%esp) ; 686-NEXT: movl $0, {{[0-9]+}}(%esp)
; 686-NEXT: addl $-16610, %ecx # imm = 0xBF1E ; 686-NEXT: addl $-16610, %ecx # imm = 0xBF1E
; 686-NEXT: xorl %edx, %edx ; 686-NEXT: xorl %edx, %edx
; 686-NEXT: shrdl %cl, %edx, %eax ; 686-NEXT: shrdl %cl, %edx, %eax
; 686-NEXT: testb $32, %cl ; 686-NEXT: testb $32, %cl
; 686-NEXT: jne .LBB0_2 ; 686-NEXT: jne .LBB0_2
; 686-NEXT: # %bb.1: # %bb ; 686-NEXT: # %bb.1: # %bb
Show All 37 Lines

llvm/trunk/test/CodeGen/X86/pr32420.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s | FileCheck %s ; RUN: llc < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
@a = common local_unnamed_addr global i16 0, align 4 @a = common local_unnamed_addr global i16 0, align 4
@b = common local_unnamed_addr global i16 0, align 4 @b = common local_unnamed_addr global i16 0, align 4
define i32 @PR32420() { define i32 @PR32420() {
; CHECK-LABEL: PR32420: ; CHECK-LABEL: PR32420:
; CHECK: ## %bb.0: ; CHECK: ## %bb.0:
; CHECK-NEXT: movq _a@{{.*}}(%rip), %rax ; CHECK-NEXT: movq _a@{{.*}}(%rip), %rcx
; CHECK-NEXT: movzwl (%rax), %eax ; CHECK-NEXT: movzwl (%rcx), %eax
; CHECK-NEXT: movl %eax, %ecx ; CHECK-NEXT: movl %eax, %edx
; CHECK-NEXT: shll $12, %edx
; CHECK-NEXT: sarw $12, %dx
; CHECK-NEXT: movq _b@{{.*}}(%rip), %rsi
; CHECK-NEXT: orw (%rsi), %dx
; CHECK-NEXT: movl (%rcx), %ecx
; CHECK-NEXT: shll $12, %ecx ; CHECK-NEXT: shll $12, %ecx
; CHECK-NEXT: sarw $12, %cx ; CHECK-NEXT: sarw $12, %cx
; CHECK-NEXT: movq _b@{{.*}}(%rip), %rdx ; CHECK-NEXT: andl %edx, %ecx
; CHECK-NEXT: movl %ecx, %esi ; CHECK-NEXT: movw %cx, (%rsi)
; CHECK-NEXT: orw (%rdx), %si
; CHECK-NEXT: andl %ecx, %esi
; CHECK-NEXT: movw %si, (%rdx)
; CHECK-NEXT: retq ; CHECK-NEXT: retq
%load2 = load i16, i16* @a, align 4 %load2 = load i16, i16* @a, align 4
%shl3 = shl i16 %load2, 12 %shl3 = shl i16 %load2, 12
%ashr4 = ashr i16 %shl3, 12 %ashr4 = ashr i16 %shl3, 12
%t2 = load volatile i16, i16* @b, align 4 %t2 = load volatile i16, i16* @b, align 4
%conv8 = or i16 %t2, %ashr4 %conv8 = or i16 %t2, %ashr4
%load9 = load i16, i16* @a, align 4 %load9 = load i16, i16* @a, align 4
%shl10 = shl i16 %load9, 12 %shl10 = shl i16 %load9, 12
%ashr11 = ashr i16 %shl10, 12 %ashr11 = ashr i16 %shl10, 12
%and = and i16 %conv8, %ashr11 %and = and i16 %conv8, %ashr11
store i16 %and, i16* @b, align 4 store i16 %and, i16* @b, align 4
%cast1629 = zext i16 %load2 to i32 %cast1629 = zext i16 %load2 to i32
ret i32 %cast1629 ret i32 %cast1629
} }

llvm/trunk/test/CodeGen/X86/pr34137.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
@var_3 = external global i16, align 2 @var_3 = external global i16, align 2
@var_13 = external global i16, align 2 @var_13 = external global i16, align 2
@var_212 = external global i64, align 8 @var_212 = external global i64, align 8
define void @pr34127() { define void @pr34127() {
; CHECK-LABEL: pr34127: ; CHECK-LABEL: pr34127:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movzwl {{.*}}(%rip), %eax ; CHECK-NEXT: movzwl {{.*}}(%rip), %eax
; CHECK-NEXT: movzwl {{.*}}(%rip), %ecx ; CHECK-NEXT: movzwl {{.*}}(%rip), %ecx
; CHECK-NEXT: andw %ax, %cx
; CHECK-NEXT: andl %eax, %ecx ; CHECK-NEXT: andl %eax, %ecx
; CHECK-NEXT: andl %eax, %ecx
; CHECK-NEXT: movzwl %cx, %ecx
; CHECK-NEXT: movl %ecx, -{{[0-9]+}}(%rsp) ; CHECK-NEXT: movl %ecx, -{{[0-9]+}}(%rsp)
; CHECK-NEXT: xorl %edx, %edx ; CHECK-NEXT: xorl %edx, %edx
; CHECK-NEXT: testw %cx, %cx ; CHECK-NEXT: testw %cx, %cx
; CHECK-NEXT: sete %dl ; CHECK-NEXT: sete %dl
; CHECK-NEXT: andl %eax, %edx ; CHECK-NEXT: andl %eax, %edx
; CHECK-NEXT: movq %rdx, {{.*}}(%rip) ; CHECK-NEXT: movq %rdx, {{.*}}(%rip)
; CHECK-NEXT: movw $0, (%rax) ; CHECK-NEXT: movw $0, (%rax)
; CHECK-NEXT: retq ; CHECK-NEXT: retq
Show All 31 Lines

llvm/trunk/test/CodeGen/X86/promote-i16.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=i686-unknown-linux-gnu | FileCheck %s --check-prefix=X86 ; RUN: llc < %s -mtriple=i686-unknown-linux-gnu | FileCheck %s --check-prefix=X86
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefix=X64 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefix=X64
define signext i16 @foo(i16 signext %x) nounwind { define signext i16 @foo(i16 signext %x) nounwind {
; X86-LABEL: foo: ; X86-LABEL: foo:
; X86: # %bb.0: # %entry ; X86: # %bb.0: # %entry
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl $21998, %eax # imm = 0x55EE
; X86-NEXT: xorl $21998, %eax # imm = 0x55EE ; X86-NEXT: xorl {{[0-9]+}}(%esp), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: foo: ; X64-LABEL: foo:
; X64: # %bb.0: # %entry ; X64: # %bb.0: # %entry
; X64-NEXT: xorl $21998, %edi # imm = 0x55EE ; X64-NEXT: xorl $21998, %edi # imm = 0x55EE
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
entry: entry:
%0 = xor i16 %x, 21998 %0 = xor i16 %x, 21998
ret i16 %0 ret i16 %0
} }
define signext i16 @bar(i16 signext %x) nounwind { define signext i16 @bar(i16 signext %x) nounwind {
; X86-LABEL: bar: ; X86-LABEL: bar:
; X86: # %bb.0: # %entry ; X86: # %bb.0: # %entry
; X86-NEXT: movzwl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl $54766, %eax # imm = 0xD5EE
; X86-NEXT: xorl $54766, %eax # imm = 0xD5EE ; X86-NEXT: xorl {{[0-9]+}}(%esp), %eax
; X86-NEXT: # kill: def $ax killed $ax killed $eax ; X86-NEXT: # kill: def $ax killed $ax killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: bar: ; X64-LABEL: bar:
; X64: # %bb.0: # %entry ; X64: # %bb.0: # %entry
; X64-NEXT: xorl $54766, %edi # imm = 0xD5EE ; X64-NEXT: xorl $54766, %edi # imm = 0xD5EE
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/reduce-trunc-shl.ll

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines; AVX2-NEXT: retq
%trunc = trunc i64 %shl to i32 %trunc = trunc i64 %shl to i32
store i32 %trunc, i32* %out store i32 %trunc, i32* %out
ret void ret void
} }
define void @trunc_shl_15_i16_i64(i16* %out, i64* %in) { define void @trunc_shl_15_i16_i64(i16* %out, i64* %in) {
; SSE2-LABEL: trunc_shl_15_i16_i64: ; SSE2-LABEL: trunc_shl_15_i16_i64:
; SSE2: # %bb.0: ; SSE2: # %bb.0:
; SSE2-NEXT: movzwl (%rsi), %eax ; SSE2-NEXT: movl (%rsi), %eax
; SSE2-NEXT: shll $15, %eax ; SSE2-NEXT: shll $15, %eax
; SSE2-NEXT: movw %ax, (%rdi) ; SSE2-NEXT: movw %ax, (%rdi)
; SSE2-NEXT: retq ; SSE2-NEXT: retq
; ;
; AVX2-LABEL: trunc_shl_15_i16_i64: ; AVX2-LABEL: trunc_shl_15_i16_i64:
; AVX2: # %bb.0: ; AVX2: # %bb.0:
; AVX2-NEXT: movzwl (%rsi), %eax ; AVX2-NEXT: movl (%rsi), %eax
; AVX2-NEXT: shll $15, %eax ; AVX2-NEXT: shll $15, %eax
; AVX2-NEXT: movw %ax, (%rdi) ; AVX2-NEXT: movw %ax, (%rdi)
; AVX2-NEXT: retq ; AVX2-NEXT: retq
%val = load i64, i64* %in %val = load i64, i64* %in
%shl = shl i64 %val, 15 %shl = shl i64 %val, 15
%trunc = trunc i64 %shl to i16 %trunc = trunc i64 %shl to i16
store i16 %trunc, i16* %out store i16 %trunc, i16* %out
ret void ret void
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines