[llvm] [SelectOptimize] Enable by default; add no-PGO density heuristic; fix… (PR #200691)
Eitan Frachtenberg via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 1 07:34:18 PDT 2026
https://github.com/eitanf updated https://github.com/llvm/llvm-project/pull/200691
>From 062e4ec7ad16df94f1516dc1e90f8256b9b5a796 Mon Sep 17 00:00:00 2001
From: Eitan Frachtenberg <eitan at specexec.com>
Date: Sun, 31 May 2026 13:17:58 -0700
Subject: [PATCH 1/2] [SelectOptimize] Enable by default; add no-PGO density
heuristic; fix !unpredictable in loop path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Since clang 10, SimplifyCFG speculatively converts conditional branches to
select instructions (cmovs) even when those branches are highly predictable.
SelectOptimize — the IR pass designed to revert this when unprofitable — was
left disabled by default, so the cmov chains were never rolled back.
This patch fixes the regression through four coordinated changes:
## Change 1: Enable SelectOptimize by default
TargetPassConfig.cpp: change `DisableSelectOptimize` from `cl::init(true)`
to `cl::init(false)`.
SelectOptimize was added in D85085 precisely to handle the case where
SimplifyCFG converts predictable branches to selects; leaving it disabled by
default defeats its purpose.
## Change 2: Add a no-PGO density heuristic to SelectOptimize
When no profile summary is available and the target considers predictable
selects expensive (i.e., `isPredictableSelectExpensive()` is true, which holds
for out-of-order x86), use the number of scalar select instructions in a basic
block as a proxy for over-speculation by SimplifyCFG.
SimplifyCFG's `isProfitableToSpeculate()` returns true for every branch when
no branch-weight metadata exists, so deeply unrolled loop bodies frequently
accumulate large clusters of selects from originally-predictable branches.
Reverting such BBs to branches recovers the predictable-branch IPC advantage.
The threshold is controlled by `-select-opti-nopgo-density-threshold`
(default: 4). Vector selects are excluded — they must stay as selects.
The motivating reproducer (calc<N> template-recursive digit parser) goes from
81 cmov instructions on clang 18 to 6 with this fix, recovering ~49% in
cycles on an AMD Ryzen 9 5950X.
## Change 3: Fix missing !unpredictable guard in findProfitableSIGroupsInnerLoops
`isConvertToBranchProfitableBase()` (the non-loop path) correctly skips
selects annotated with `!unpredictable` metadata. The loop-analysis path
`findProfitableSIGroupsInnerLoops()` did not have this guard, causing it to
convert selects that the programmer explicitly marked as unpredictable.
Add the same guard to the per-group loop in the loop path.
## Change 4: Remove bail-outs from CodeGenPrepare and X86CmovConversion
Both passes contain:
if (!getCGPassBuilderOption().DisableSelectOptimize) return false;
making them mutually exclusive with SelectOptimize. This is unnecessary:
the passes operate at different levels (IR vs machine) and are naturally
complementary. A select converted to a branch by SelectOptimize simply
disappears before ISel; the later passes see nothing to do for it.
Replace the bail-outs with explanatory comments.
Fixes: https://github.com/llvm/llvm-project/issues/XXXXX
Reviewers: RKSimon, arsenm, topperc
---
llvm/lib/CodeGen/CodeGenPrepare.cpp | 9 +-
llvm/lib/CodeGen/SelectOptimize.cpp | 45 +
llvm/lib/CodeGen/TargetPassConfig.cpp | 2 +-
llvm/lib/Target/X86/X86CmovConversion.cpp | 10 +-
llvm/test/CodeGen/X86/freeze.ll | 42 +-
llvm/test/CodeGen/X86/llc-pipeline-npm.ll | 2 +
llvm/test/CodeGen/X86/pseudo_cmov_lower.ll | 1734 ++++++++++++++++-
llvm/test/CodeGen/X86/pseudo_cmov_lower2.ll | 25 +-
llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll | 318 +--
.../test/CodeGen/X86/shl-crash-on-legalize.ll | 34 +-
llvm/test/CodeGen/X86/x86-cmov-converter.ll | 94 +-
11 files changed, 2073 insertions(+), 242 deletions(-)
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index aa14d2586a534..214caab182c10 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -7730,9 +7730,12 @@ bool CodeGenPrepare::optimizeSelectInst(SelectInst *SI) {
if (DisableSelectToBranch)
return false;
- // If the SelectOptimize pass is enabled, selects have already been optimized.
- if (!getCGPassBuilderOption().DisableSelectOptimize)
- return false;
+ // SelectOptimize (IR-level) and CodeGenPrepare use complementary heuristics:
+ // SelectOptimize focuses on density-based and loop-level analysis, while
+ // CodeGenPrepare focuses on expensive-cold-operand sinking. Both can safely
+ // coexist: if SelectOptimize already converted a select to a branch, that
+ // select is gone from the IR and CodeGenPrepare simply has nothing to do for
+ // it. Do NOT skip based on SelectOptimize being enabled.
// Find all consecutive select instructions that share the same condition.
SmallVector<SelectInst *, 2> ASI;
diff --git a/llvm/lib/CodeGen/SelectOptimize.cpp b/llvm/lib/CodeGen/SelectOptimize.cpp
index 9d1e113cd2fb9..0c4694ea6eeff 100644
--- a/llvm/lib/CodeGen/SelectOptimize.cpp
+++ b/llvm/lib/CodeGen/SelectOptimize.cpp
@@ -58,6 +58,9 @@ STATISTIC(NumSelectColdBB,
"Number of select groups not converted due to cold basic block");
STATISTIC(NumSelectConvertedLoop,
"Number of select groups converted due to loop-level analysis");
+STATISTIC(NumSelectConvertedNoPGO,
+ "Number of select groups converted due to high select density "
+ "without profile data");
STATISTIC(NumSelectsConverted, "Number of selects converted");
static cl::opt<unsigned> ColdOperandThreshold(
@@ -96,6 +99,16 @@ static cl::opt<bool>
cl::init(false),
cl::desc("Disable loop-level heuristics."));
+// When no profile data is available, use the count of select instructions in a
+// basic block as a proxy for over-speculation by SimplifyCFG. A BB containing
+// at least this many selects is assumed to have had predictable branches
+// speculatively converted, and will be reverted to branch form.
+static cl::opt<unsigned> SelectDensityNoPGOThreshold(
+ "select-opti-nopgo-density-threshold",
+ cl::desc("Min scalar selects per non-loop basic block to trigger branch "
+ "conversion without profile data (default: 4)"),
+ cl::init(4), cl::Hidden);
+
namespace {
class SelectOptimizeImpl {
@@ -976,6 +989,17 @@ void SelectOptimizeImpl::findProfitableSIGroupsInnerLoops(
}
for (SelectGroup &ASI : SIGroups) {
+ // Skip groups that contain an unpredictable select: forming a branch around
+ // an unpredictable condition is never profitable.
+ if (llvm::any_of(ASI.Selects, [](const SelectLike &SI) {
+ return SI.getI()->getMetadata(LLVMContext::MD_unpredictable);
+ })) {
+ OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti",
+ ASI.Selects.front().getI());
+ ORmiss << "Not converted to branch because of unpredictable branch. ";
+ EmitAndPrintRemark(ORE, ORmiss);
+ continue;
+ }
// Assuming infinite resources, the cost of a group of instructions is the
// cost of the most expensive instruction of the group.
Scaled64 SelectCost = Scaled64::getZero(), BranchCost = Scaled64::getZero();
@@ -1058,6 +1082,27 @@ bool SelectOptimizeImpl::isConvertToBranchProfitableBase(
return true;
}
+ // When no profile data is available on a target where predictable selects
+ // are expensive (e.g., modern out-of-order x86), use the total number of
+ // select instructions in the basic block as a proxy for over-speculation
+ // by SimplifyCFG. SimplifyCFG's isProfitableToSpeculate() returns true
+ // for every branch when no branch-weight metadata exists, which can convert
+ // large groups of predictable branches into select chains. Revert to
+ // branches when the select density exceeds the configured threshold.
+ if (!PSI->hasProfileSummary() && TLI->isPredictableSelectExpensive()) {
+ unsigned SelectCount = llvm::count_if(*BB, [](const Instruction &I) {
+ // Count only scalar selects; vector selects must not revert to branches.
+ auto *S = dyn_cast<SelectInst>(&I);
+ return S && !S->getType()->isVectorTy();
+ });
+ if (SelectCount >= SelectDensityNoPGOThreshold) {
+ ++NumSelectConvertedNoPGO;
+ OR << "Converted to branch: high select density without profile data. ";
+ EmitAndPrintRemark(ORE, OR);
+ return true;
+ }
+ }
+
ORmiss << "Not profitable to convert to branch (base heuristic).";
EmitAndPrintRemark(ORE, ORmiss);
return false;
diff --git a/llvm/lib/CodeGen/TargetPassConfig.cpp b/llvm/lib/CodeGen/TargetPassConfig.cpp
index 096e9a6f2b1dc..a568b50479dfa 100644
--- a/llvm/lib/CodeGen/TargetPassConfig.cpp
+++ b/llvm/lib/CodeGen/TargetPassConfig.cpp
@@ -259,7 +259,7 @@ static cl::opt<bool> DisableExpandReductions(
/// Disable the select optimization pass.
static cl::opt<bool> DisableSelectOptimize(
- "disable-select-optimize", cl::init(true), cl::Hidden,
+ "disable-select-optimize", cl::init(false), cl::Hidden,
cl::desc("Disable the select-optimization pass from running"));
/// Enable garbage-collecting empty basic blocks.
diff --git a/llvm/lib/Target/X86/X86CmovConversion.cpp b/llvm/lib/Target/X86/X86CmovConversion.cpp
index d2f0a9f72f6e3..b663375caec6e 100644
--- a/llvm/lib/Target/X86/X86CmovConversion.cpp
+++ b/llvm/lib/Target/X86/X86CmovConversion.cpp
@@ -173,9 +173,13 @@ bool X86CmovConversionImpl::runOnMachineFunction(MachineFunction &MF) {
if (!EnableCmovConverter)
return false;
- // If the SelectOptimize pass is enabled, cmovs have already been optimized.
- if (!getCGPassBuilderOption().DisableSelectOptimize)
- return false;
+ // SelectOptimize and X86CmovConversion operate at different levels (IR vs
+ // machine) and are complementary: SelectOptimize converts IR selects to
+ // branches before ISel, while X86CmovConversion converts machine-level cmovs
+ // (including memory-operand cmovs and loop cmovs) to branches after ISel.
+ // Both can safely coexist — if SelectOptimize already converted a select to a
+ // branch, ISel will not emit a cmov for it and X86CmovConversion sees nothing
+ // to do. Do NOT skip based on SelectOptimize being enabled.
LLVM_DEBUG(dbgs() << "********** " << DEBUG_TYPE << " : " << MF.getName()
<< "**********\n");
diff --git a/llvm/test/CodeGen/X86/freeze.ll b/llvm/test/CodeGen/X86/freeze.ll
index 38e3e23f7caac..31d90542921f9 100644
--- a/llvm/test/CodeGen/X86/freeze.ll
+++ b/llvm/test/CodeGen/X86/freeze.ll
@@ -147,23 +147,43 @@ entry:
define i64 @pr155345(ptr %p1, i1 %cond, ptr %p2, ptr %p3) {
; X86ASM-LABEL: pr155345:
; X86ASM: # %bb.0: # %entry
+; X86ASM-NEXT: movq %rcx, %rax
; X86ASM-NEXT: movzbl (%rdi), %edi
-; X86ASM-NEXT: xorl %eax, %eax
-; X86ASM-NEXT: orb $1, %dil
+; X86ASM-NEXT: orq $1, %rdi
; X86ASM-NEXT: movb %dil, (%rdx)
-; X86ASM-NEXT: movzbl %dil, %edx
-; X86ASM-NEXT: cmovel %edx, %eax
-; X86ASM-NEXT: sete %dil
; X86ASM-NEXT: testb $1, %sil
-; X86ASM-NEXT: cmovnel %edx, %eax
-; X86ASM-NEXT: movb %dl, (%rcx)
+; X86ASM-NEXT: je .LBB11_2
+; X86ASM-NEXT: # %bb.1:
+; X86ASM-NEXT: xorl %ecx, %ecx
+; X86ASM-NEXT: testb %cl, %cl
+; X86ASM-NEXT: jne .LBB11_4
+; X86ASM-NEXT: .LBB11_5: # %select.false.sink2
+; X86ASM-NEXT: movq %rdi, %rcx
+; X86ASM-NEXT: jmp .LBB11_6
+; X86ASM-NEXT: .LBB11_2: # %select.false.sink
+; X86ASM-NEXT: cmpb $0, (%rdx)
+; X86ASM-NEXT: setne %cl
+; X86ASM-NEXT: testb %cl, %cl
+; X86ASM-NEXT: je .LBB11_5
+; X86ASM-NEXT: .LBB11_4:
+; X86ASM-NEXT: xorl %ecx, %ecx
+; X86ASM-NEXT: .LBB11_6: # %select.end1
; X86ASM-NEXT: movl $1, %edx
-; X86ASM-NEXT: movl %eax, %ecx
+; X86ASM-NEXT: # kill: def $cl killed $cl killed $rcx
; X86ASM-NEXT: shlq %cl, %rdx
-; X86ASM-NEXT: orb %sil, %dil
-; X86ASM-NEXT: movzbl %dil, %eax
+; X86ASM-NEXT: movb %dil, (%rax)
+; X86ASM-NEXT: testb $1, %sil
+; X86ASM-NEXT: je .LBB11_8
+; X86ASM-NEXT: # %bb.7:
+; X86ASM-NEXT: xorl %eax, %eax
+; X86ASM-NEXT: jmp .LBB11_9
+; X86ASM-NEXT: .LBB11_8: # %select.false.sink4
+; X86ASM-NEXT: cmpb $0, (%rax)
+; X86ASM-NEXT: setne %al
+; X86ASM-NEXT: .LBB11_9: # %select.end3
+; X86ASM-NEXT: xorb $1, %al
+; X86ASM-NEXT: movzbl %al, %eax
; X86ASM-NEXT: andl %edx, %eax
-; X86ASM-NEXT: andl $1, %eax
; X86ASM-NEXT: retq
entry:
%load1 = load i8, ptr %p1, align 1
diff --git a/llvm/test/CodeGen/X86/llc-pipeline-npm.ll b/llvm/test/CodeGen/X86/llc-pipeline-npm.ll
index 9f5414b793554..e0891790dc7b4 100644
--- a/llvm/test/CodeGen/X86/llc-pipeline-npm.ll
+++ b/llvm/test/CodeGen/X86/llc-pipeline-npm.ll
@@ -99,6 +99,7 @@
; O2-NEXT: ee-instrument<post-inline>
; O2-NEXT: scalarize-masked-mem-intrin
; O2-NEXT: expand-reductions
+; O2-NEXT: select-optimize
; O2-NEXT: interleaved-access
; O2-NEXT: x86-partial-reduction
; O2-NEXT: indirectbr-expand
@@ -289,6 +290,7 @@
; O3-WINDOWS-NEXT: ee-instrument<post-inline>
; O3-WINDOWS-NEXT: scalarize-masked-mem-intrin
; O3-WINDOWS-NEXT: expand-reductions
+; O3-WINDOWS-NEXT: select-optimize
; O3-WINDOWS-NEXT: interleaved-access
; O3-WINDOWS-NEXT: x86-partial-reduction
; O3-WINDOWS-NEXT: indirectbr-expand
diff --git a/llvm/test/CodeGen/X86/pseudo_cmov_lower.ll b/llvm/test/CodeGen/X86/pseudo_cmov_lower.ll
index 7d7d72e4c89f6..aafb12afe2f46 100644
--- a/llvm/test/CodeGen/X86/pseudo_cmov_lower.ll
+++ b/llvm/test/CodeGen/X86/pseudo_cmov_lower.ll
@@ -1,11 +1,24 @@
-; RUN: llc < %s -mtriple=i386-linux-gnu -o - | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6
+; RUN: llc < %s -mtriple=i386-linux-gnu -o - | FileCheck %s
; This test checks that only a single js gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo1:
-; CHECK: js
-; CHECK-NOT: js
define i32 @foo1(i32 %v1, i32 %v2, i32 %v3) nounwind {
+; CHECK-LABEL: foo1:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %edx
+; CHECK-NEXT: testl %edx, %edx
+; CHECK-NEXT: js .LBB0_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
+; CHECK-NEXT: .LBB0_1:
+; CHECK-NEXT: movl %eax, %ecx
+; CHECK-NEXT: movl %edx, %eax
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
entry:
%cmp = icmp slt i32 %v1, 0
%v2.v3 = select i1 %cmp, i32 %v2, i32 %v3
@@ -17,11 +30,21 @@ entry:
; This test checks that only a single js gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR. This makes
; sure the code for the lowering for opposite conditions gets tested.
-; CHECK-LABEL: foo11:
-; CHECK: js
-; CHECK-NOT: js
-; CHECK-NOT: jns
define i32 @foo11(i32 %v1, i32 %v2, i32 %v3) nounwind {
+; CHECK-LABEL: foo11:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: testl %eax, %eax
+; CHECK-NEXT: js .LBB1_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
+; CHECK-NEXT: .LBB1_1:
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: movl %ecx, %eax
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
entry:
%cmp1 = icmp slt i32 %v1, 0
%v2.v3 = select i1 %cmp1, i32 %v2, i32 %v3
@@ -33,10 +56,24 @@ entry:
; This test checks that only a single js gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo2:
-; CHECK: js
-; CHECK-NOT: js
define i32 @foo2(i8 %v1, i8 %v2, i8 %v3) nounwind {
+; CHECK-LABEL: foo2:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %edx
+; CHECK-NEXT: testb %dl, %dl
+; CHECK-NEXT: js .LBB2_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: jmp .LBB2_3
+; CHECK-NEXT: .LBB2_1:
+; CHECK-NEXT: movl %ecx, %eax
+; CHECK-NEXT: movl %edx, %ecx
+; CHECK-NEXT: .LBB2_3: # %entry
+; CHECK-NEXT: movsbl %al, %eax
+; CHECK-NEXT: movsbl %cl, %ecx
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
entry:
%cmp = icmp slt i8 %v1, 0
%v2.v3 = select i1 %cmp, i8 %v2, i8 %v3
@@ -49,10 +86,22 @@ entry:
; This test checks that only a single js gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo3:
-; CHECK: js
-; CHECK-NOT: js
define i32 @foo3(i16 %v1, i16 %v2, i16 %v3) nounwind {
+; CHECK-LABEL: foo3:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: testw %cx, %cx
+; CHECK-NEXT: movl %eax, %edx
+; CHECK-NEXT: js .LBB3_2
+; CHECK-NEXT: # %bb.1: # %entry
+; CHECK-NEXT: movzwl {{[0-9]+}}(%esp), %edx
+; CHECK-NEXT: movl %eax, %ecx
+; CHECK-NEXT: .LBB3_2: # %entry
+; CHECK-NEXT: movswl %dx, %eax
+; CHECK-NEXT: movswl %cx, %ecx
+; CHECK-NEXT: subl %ecx, %eax
+; CHECK-NEXT: retl
entry:
%cmp = icmp slt i16 %v1, 0
%v2.v3 = select i1 %cmp, i16 %v2, i16 %v3
@@ -65,10 +114,22 @@ entry:
; This test checks that only a single js gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo4:
-; CHECK: js
-; CHECK-NOT: js
define float @foo4(i32 %v1, float %v2, float %v3, float %v4) nounwind {
+; CHECK-LABEL: foo4:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: cmpl $0, {{[0-9]+}}(%esp)
+; CHECK-NEXT: js .LBB4_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: fstp %st(1)
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: retl
+; CHECK-NEXT: .LBB4_1:
+; CHECK-NEXT: fstp %st(2)
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: retl
entry:
%cmp = icmp slt i32 %v1, 0
%t1 = select i1 %cmp, float %v2, float %v3
@@ -79,10 +140,22 @@ entry:
; This test checks that only a single je gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo5:
-; CHECK: je
-; CHECK-NOT: je
define double @foo5(i32 %v1, double %v2, double %v3, double %v4) nounwind {
+; CHECK-LABEL: foo5:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: cmpl $0, {{[0-9]+}}(%esp)
+; CHECK-NEXT: je .LBB5_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: fstp %st(1)
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: retl
+; CHECK-NEXT: .LBB5_1:
+; CHECK-NEXT: fstp %st(2)
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: retl
entry:
%cmp = icmp eq i32 %v1, 0
%t1 = select i1 %cmp, double %v2, double %v3
@@ -93,10 +166,67 @@ entry:
; This test checks that only a single je gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo6:
-; CHECK: je
-; CHECK-NOT: je
define <4 x float> @foo6(i32 %v1, <4 x float> %v2, <4 x float> %v3, <4 x float> %v4) nounwind {
+; CHECK-LABEL: foo6:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: subl $28, %esp
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: cmpl $0, {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: je .LBB6_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: fstp %st(4)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: fxch %st(1)
+; CHECK-NEXT: fstps (%esp) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: jmp .LBB6_3
+; CHECK-NEXT: .LBB6_1:
+; CHECK-NEXT: fxch %st(3)
+; CHECK-NEXT: fstps (%esp) # 4-byte Folded Spill
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fxch %st(5)
+; CHECK-NEXT: fxch %st(3)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: .LBB6_3: # %entry
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: flds (%esp) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(2)
+; CHECK-NEXT: fxch %st(4)
+; CHECK-NEXT: fsubp %st, %st(2)
+; CHECK-NEXT: fxch %st(4)
+; CHECK-NEXT: fsubp %st, %st(2)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: fstps 12(%eax)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: fstps 8(%eax)
+; CHECK-NEXT: fstps 4(%eax)
+; CHECK-NEXT: fstps (%eax)
+; CHECK-NEXT: addl $28, %esp
+; CHECK-NEXT: retl $4
entry:
%cmp = icmp eq i32 %v1, 0
%t1 = select i1 %cmp, <4 x float> %v2, <4 x float> %v3
@@ -107,10 +237,32 @@ entry:
; This test checks that only a single je gets generated in the final code
; for lowering the CMOV pseudos that get created for this IR.
-; CHECK-LABEL: foo7:
-; CHECK: je
-; CHECK-NOT: je
define <2 x double> @foo7(i32 %v1, <2 x double> %v2, <2 x double> %v3, <2 x double> %v4) nounwind {
+; CHECK-LABEL: foo7:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: cmpl $0, {{[0-9]+}}(%esp)
+; CHECK-NEXT: je .LBB7_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: jmp .LBB7_3
+; CHECK-NEXT: .LBB7_1:
+; CHECK-NEXT: fstp %st(5)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: fxch %st(3)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: fxch %st(1)
+; CHECK-NEXT: .LBB7_3: # %entry
+; CHECK-NEXT: fxch %st(1)
+; CHECK-NEXT: fsubp %st, %st(2)
+; CHECK-NEXT: fsubp %st, %st(2)
+; CHECK-NEXT: retl
entry:
%cmp = icmp eq i32 %v1, 0
%t1 = select i1 %cmp, <2 x double> %v2, <2 x double> %v3
@@ -123,10 +275,439 @@ entry:
; for lowering the CMOV pseudos that get created for this IR. This combines
; all the supported types together into one long string of selects based
; on the same condition.
-; CHECK-LABEL: foo8:
-; CHECK: ja
-; CHECK-NOT: ja
define void @foo8(i32 %v1,
+; CHECK-LABEL: foo8:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: subl $444, %esp # imm = 0x1BC
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: cmpl $31, {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fldl {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: flds {{[0-9]+}}(%esp)
+; CHECK-NEXT: fstps (%esp) # 4-byte Folded Spill
+; CHECK-NEXT: jbe .LBB8_2
+; CHECK-NEXT: # %bb.1:
+; CHECK-NEXT: fstp %st(1)
+; CHECK-NEXT: fstp %st(2)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: fstp %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: movzwl {{[0-9]+}}(%esp), %edx
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: jmp .LBB8_3
+; CHECK-NEXT: .LBB8_2: # %select.false.sink
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(4)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(4)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(4)
+; CHECK-NEXT: fstp %st(3)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstp %st(0)
+; CHECK-NEXT: flds (%esp) # 4-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstps (%esp) # 4-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: faddp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fsubrp %st, %st(1)
+; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; CHECK-NEXT: movzwl {{[0-9]+}}(%esp), %edx
+; CHECK-NEXT: xorl $11, %edx
+; CHECK-NEXT: xorl $1234, %ecx # imm = 0x4D2
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fxch %st(1)
+; CHECK-NEXT: fxch %st(5)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: fxch %st(4)
+; CHECK-NEXT: fxch %st(2)
+; CHECK-NEXT: fxch %st(1)
+; CHECK-NEXT: .LBB8_3: # %select.end
+; CHECK-NEXT: movw %dx, 2(%eax)
+; CHECK-NEXT: movl %ecx, 4(%eax)
+; CHECK-NEXT: flds (%esp) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 8(%eax)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fstpl 16(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 32(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 36(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 40(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 44(%eax)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fstpl 48(%eax)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fstpl 56(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 64(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 68(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 72(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 76(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 80(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 84(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 88(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 92(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 96(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 100(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 104(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 108(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 112(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 116(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 120(%eax)
+; CHECK-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; CHECK-NEXT: fstps 124(%eax)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fstpl 128(%eax)
+; CHECK-NEXT: fstpl 136(%eax)
+; CHECK-NEXT: fstpl 144(%eax)
+; CHECK-NEXT: fstpl 152(%eax)
+; CHECK-NEXT: fstpl 160(%eax)
+; CHECK-NEXT: fstpl 168(%eax)
+; CHECK-NEXT: fstpl 176(%eax)
+; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; CHECK-NEXT: fstpl 184(%eax)
+; CHECK-NEXT: addl $444, %esp # imm = 0x1BC
+; CHECK-NEXT: retl
i8 %v2, i8 %v3,
i16 %v12, i16 %v13,
i32 %v22, i32 %v23,
@@ -212,10 +793,1099 @@ entry:
; pseudo-opcodes to be generated, this test should be replaced with one that
; tests those opcodes.
;
-; CHECK-LABEL: foo9:
-; CHECK: ja
-; CHECK-NOT: ja
define void @foo9(i32 %v1,
+; CHECK-LABEL: foo9:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: pushl %ebp
+; CHECK-NEXT: pushl %ebx
+; CHECK-NEXT: pushl %edi
+; CHECK-NEXT: pushl %esi
+; CHECK-NEXT: subl $144, %esp
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: cmpl $32, {{[0-9]+}}(%esp)
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %ah
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %ch
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %dh
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movzbl {{[0-9]+}}(%esp), %ebx
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %dl
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %bh
+; CHECK-NEXT: jae .LBB9_1
+; CHECK-NEXT: # %bb.2: # %entry
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb %bh, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %bh
+; CHECK-NEXT: movb %bh, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %bh
+; CHECK-NEXT: movb %bh, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb %al, %bh
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %bl
+; CHECK-NEXT: movb %bl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %dh
+; CHECK-NEXT: movb %dh, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: xorb {{[0-9]+}}(%esp), %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %dh # 1-byte Reload
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bl # 1-byte Reload
+; CHECK-NEXT: jmp .LBB9_3
+; CHECK-NEXT: .LBB9_1:
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[0-9]+}}(%esp), %al
+; CHECK-NEXT: movb %al, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: .LBB9_3: # %entry
+; CHECK-NEXT: shlb $3, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %bh, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: addb %bh, %bh
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: orb %bh, %dl
+; CHECK-NEXT: andb $3, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: addb %al, %al
+; CHECK-NEXT: movb %cl, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %bh, %cl
+; CHECK-NEXT: shlb $4, %dl
+; CHECK-NEXT: andb $15, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: movb %cl, {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: andb $1, %bl
+; CHECK-NEXT: orb %dl, %bl
+; CHECK-NEXT: andb $3, %bl
+; CHECK-NEXT: orb %cl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: andb $1, %dh
+; CHECK-NEXT: orb %dl, %dh
+; CHECK-NEXT: andb $3, %dh
+; CHECK-NEXT: orb %cl, %dh
+; CHECK-NEXT: shlb $4, %bl
+; CHECK-NEXT: andb $15, %dh
+; CHECK-NEXT: orb %bl, %dh
+; CHECK-NEXT: movzbl %dh, %edx
+; CHECK-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: addb %cl, %cl
+; CHECK-NEXT: andb $1, %ch
+; CHECK-NEXT: orb %cl, %ch
+; CHECK-NEXT: andb $3, %ch
+; CHECK-NEXT: orb %al, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: addb %cl, %cl
+; CHECK-NEXT: andb $1, %ah
+; CHECK-NEXT: orb %cl, %ah
+; CHECK-NEXT: andb $3, %ah
+; CHECK-NEXT: orb %al, %ah
+; CHECK-NEXT: shlb $4, %ch
+; CHECK-NEXT: andb $15, %ah
+; CHECK-NEXT: orb %ch, %ah
+; CHECK-NEXT: movzbl %ah, %eax
+; CHECK-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: andb $1, %ah
+; CHECK-NEXT: orb %dl, %ah
+; CHECK-NEXT: andb $3, %ah
+; CHECK-NEXT: orb %cl, %ah
+; CHECK-NEXT: shlb $4, %al
+; CHECK-NEXT: andb $15, %ah
+; CHECK-NEXT: orb %al, %ah
+; CHECK-NEXT: movzbl %ah, %eax
+; CHECK-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: andb $1, %ah
+; CHECK-NEXT: orb %dl, %ah
+; CHECK-NEXT: andb $3, %ah
+; CHECK-NEXT: orb %cl, %ah
+; CHECK-NEXT: shlb $4, %al
+; CHECK-NEXT: andb $15, %ah
+; CHECK-NEXT: orb %al, %ah
+; CHECK-NEXT: movzbl %ah, %esi
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %eax
+; CHECK-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %ebp
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %eax
+; CHECK-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: addb %dl, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %dl, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %edx
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %ah, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: andb $1, %ah
+; CHECK-NEXT: shlb $2, %ah
+; CHECK-NEXT: orb %al, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: addb %ch, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ch, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %eax
+; CHECK-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: shlb $2, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %ah, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %al, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: andb $1, %ah
+; CHECK-NEXT: shlb $2, %ah
+; CHECK-NEXT: orb %al, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: addb %ch, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ch, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: shlb $4, %cl
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %cl, %al
+; CHECK-NEXT: movzbl %al, %eax
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: shlb $3, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %ch, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 1-byte Folded Reload
+; CHECK-NEXT: addb %bl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: andb $1, %ch
+; CHECK-NEXT: orb %bl, %ch
+; CHECK-NEXT: andb $3, %ch
+; CHECK-NEXT: orb %cl, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %bl
+; CHECK-NEXT: shlb $2, %bl
+; CHECK-NEXT: orb %cl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: addb %bh, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %bh, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %bl, %cl
+; CHECK-NEXT: shlb $4, %ch
+; CHECK-NEXT: andb $15, %cl
+; CHECK-NEXT: orb %ch, %cl
+; CHECK-NEXT: movzbl %cl, %ecx
+; CHECK-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: shlb $3, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: shlb $2, %cl
+; CHECK-NEXT: orb %ch, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 1-byte Folded Reload
+; CHECK-NEXT: addb %bl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: andb $1, %ch
+; CHECK-NEXT: orb %bl, %ch
+; CHECK-NEXT: andb $3, %ch
+; CHECK-NEXT: orb %cl, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %bl
+; CHECK-NEXT: shlb $2, %bl
+; CHECK-NEXT: orb %cl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: addb %bh, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %bh, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %bl, %cl
+; CHECK-NEXT: shlb $4, %ch
+; CHECK-NEXT: andb $15, %cl
+; CHECK-NEXT: orb %ch, %cl
+; CHECK-NEXT: movzbl %cl, %edi
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: shlb $3, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bl # 1-byte Reload
+; CHECK-NEXT: andb $1, %bl
+; CHECK-NEXT: shlb $2, %bl
+; CHECK-NEXT: orb %bh, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: addb %bh, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: andb $1, %ch
+; CHECK-NEXT: orb %bh, %ch
+; CHECK-NEXT: andb $3, %ch
+; CHECK-NEXT: orb %bl, %ch
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: shlb $3, %cl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bh # 1-byte Reload
+; CHECK-NEXT: andb $1, %bh
+; CHECK-NEXT: shlb $2, %bh
+; CHECK-NEXT: orb %cl, %bh
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %bl # 1-byte Reload
+; CHECK-NEXT: addb %bl, %bl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %cl # 1-byte Reload
+; CHECK-NEXT: andb $1, %cl
+; CHECK-NEXT: orb %bl, %cl
+; CHECK-NEXT: andb $3, %cl
+; CHECK-NEXT: orb %bh, %cl
+; CHECK-NEXT: shlb $4, %ch
+; CHECK-NEXT: andb $15, %cl
+; CHECK-NEXT: orb %ch, %cl
+; CHECK-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 4-byte Reload
+; CHECK-NEXT: shll $8, %ebx
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %ebx # 4-byte Folded Reload
+; CHECK-NEXT: movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: shll $8, %esi
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Folded Reload
+; CHECK-NEXT: shll $8, %ebp
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %ebp # 4-byte Folded Reload
+; CHECK-NEXT: shll $16, %esi
+; CHECK-NEXT: movzwl %bp, %ebx
+; CHECK-NEXT: orl %esi, %ebx
+; CHECK-NEXT: movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; CHECK-NEXT: shll $8, %edx
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 4-byte Folded Reload
+; CHECK-NEXT: shll $8, %eax
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Folded Reload
+; CHECK-NEXT: shll $16, %edx
+; CHECK-NEXT: movzwl %ax, %ebp
+; CHECK-NEXT: orl %edx, %ebp
+; CHECK-NEXT: shll $8, %edi
+; CHECK-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %edi # 4-byte Folded Reload
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: addb %al, %al
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ch # 1-byte Reload
+; CHECK-NEXT: andb $1, %ch
+; CHECK-NEXT: orb %al, %ch
+; CHECK-NEXT: andb $3, %ch
+; CHECK-NEXT: orb %dl, %ch
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 1-byte Folded Reload
+; CHECK-NEXT: shlb $3, %al
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 1-byte Folded Reload
+; CHECK-NEXT: andb $1, %dl
+; CHECK-NEXT: shlb $2, %dl
+; CHECK-NEXT: orb %al, %dl
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %ah # 1-byte Reload
+; CHECK-NEXT: addb %ah, %ah
+; CHECK-NEXT: movb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Reload
+; CHECK-NEXT: andb $1, %al
+; CHECK-NEXT: orb %ah, %al
+; CHECK-NEXT: andb $3, %al
+; CHECK-NEXT: orb %dl, %al
+; CHECK-NEXT: shlb $4, %ch
+; CHECK-NEXT: andb $15, %al
+; CHECK-NEXT: orb %ch, %al
+; CHECK-NEXT: movzbl %cl, %edx
+; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; CHECK-NEXT: movzbl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 1-byte Folded Reload
+; CHECK-NEXT: movb %cl, (%ebx)
+; CHECK-NEXT: movzbl %al, %esi
+; CHECK-NEXT: shll $8, %esi
+; CHECK-NEXT: orl %edx, %esi
+; CHECK-NEXT: shll $16, %edi
+; CHECK-NEXT: movzwl %si, %edx
+; CHECK-NEXT: orl %edi, %edx
+; CHECK-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; CHECK-NEXT: movw %ax, 4(%ebx)
+; CHECK-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; CHECK-NEXT: movl %eax, 8(%ebx)
+; CHECK-NEXT: movl %edx, 20(%ebx)
+; CHECK-NEXT: movl %ebp, 16(%ebx)
+; CHECK-NEXT: addl $144, %esp
+; CHECK-NEXT: popl %esi
+; CHECK-NEXT: popl %edi
+; CHECK-NEXT: popl %ebx
+; CHECK-NEXT: popl %ebp
+; CHECK-NEXT: retl
<8 x i1> %v12, <8 x i1> %v13,
<16 x i1> %v22, <16 x i1> %v23,
<32 x i1> %v32, <32 x i1> %v33,
diff --git a/llvm/test/CodeGen/X86/pseudo_cmov_lower2.ll b/llvm/test/CodeGen/X86/pseudo_cmov_lower2.ll
index 6091e2bf5bc56..c20b9b3476ba5 100644
--- a/llvm/test/CodeGen/X86/pseudo_cmov_lower2.ll
+++ b/llvm/test/CodeGen/X86/pseudo_cmov_lower2.ll
@@ -122,16 +122,16 @@ define double @foo5(float %p1, double %p2, double %p3) nounwind {
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: xorps %xmm3, %xmm3
; CHECK-NEXT: ucomiss %xmm3, %xmm0
-; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
; CHECK-NEXT: jae .LBB4_1
-; CHECK-NEXT: # %bb.2: # %select.false
+; CHECK-NEXT: # %bb.2: # %select.false.sink
+; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
; CHECK-NEXT: addsd %xmm2, %xmm0
; CHECK-NEXT: .LBB4_3: # %select.end
; CHECK-NEXT: subsd %xmm1, %xmm0
; CHECK-NEXT: addsd %xmm2, %xmm0
; CHECK-NEXT: retq
-; CHECK-NEXT: .LBB4_1:
-; CHECK-NEXT: addsd %xmm0, %xmm1
+; CHECK-NEXT: .LBB4_1: # %select.true.sink
+; CHECK-NEXT: addsd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm1
; CHECK-NEXT: movapd %xmm1, %xmm0
; CHECK-NEXT: movapd %xmm1, %xmm2
; CHECK-NEXT: jmp .LBB4_3
@@ -156,27 +156,28 @@ define double @foo6(float %p1, double %p2, double %p3) nounwind {
; CHECK-NEXT: movaps %xmm0, %xmm3
; CHECK-NEXT: xorps %xmm0, %xmm0
; CHECK-NEXT: ucomiss %xmm0, %xmm3
-; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
; CHECK-NEXT: jae .LBB5_1
-; CHECK-NEXT: # %bb.2: # %select.false
+; CHECK-NEXT: # %bb.2: # %select.false.sink
+; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
; CHECK-NEXT: addsd %xmm2, %xmm0
; CHECK-NEXT: .LBB5_3: # %select.end
; CHECK-NEXT: ucomiss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm3
; CHECK-NEXT: movapd %xmm0, %xmm4
; CHECK-NEXT: jae .LBB5_5
-; CHECK-NEXT: # %bb.4: # %select.false2
+; CHECK-NEXT: # %bb.4: # %select.false
; CHECK-NEXT: movapd %xmm1, %xmm4
; CHECK-NEXT: .LBB5_5: # %select.end1
; CHECK-NEXT: ucomiss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm3
; CHECK-NEXT: movapd %xmm4, %xmm1
; CHECK-NEXT: jae .LBB5_7
-; CHECK-NEXT: # %bb.6: # %select.false4
+; CHECK-NEXT: # %bb.6: # %select.false3
; CHECK-NEXT: movapd %xmm2, %xmm1
-; CHECK-NEXT: .LBB5_7: # %select.end3
+; CHECK-NEXT: .LBB5_7: # %select.end2
; CHECK-NEXT: subsd %xmm4, %xmm0
; CHECK-NEXT: addsd %xmm1, %xmm0
; CHECK-NEXT: retq
-; CHECK-NEXT: .LBB5_1:
+; CHECK-NEXT: .LBB5_1: # %select.true.sink
+; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
; CHECK-NEXT: addsd %xmm1, %xmm0
; CHECK-NEXT: jmp .LBB5_3
entry:
@@ -201,8 +202,8 @@ declare void @llvm.dbg.value(metadata, metadata, metadata)
define double @foo1_g(float %p1, double %p2, double %p3) nounwind !dbg !4 {
; CHECK-LABEL: foo1_g:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: .file 1 "." "test.c"
-; CHECK-NEXT: .loc 1 3 0 prologue_end
+; CHECK-NEXT: .file 1 "." "test.c"
+; CHECK-NEXT: .loc 1 3 0 prologue_end # test.c:3:0
; CHECK-NEXT: xorps %xmm3, %xmm3
; CHECK-NEXT: ucomiss %xmm3, %xmm0
; CHECK-NEXT: movsd {{.*#+}} xmm0 = [1.25E+0,0.0E+0]
diff --git a/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll b/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
index 69a6cdb7081eb..c22dec5b3b2cf 100644
--- a/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
+++ b/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
@@ -45,10 +45,10 @@ define ptr @SyFgets(ptr %line, i64 %length, i64 %fid) {
; CHECK-NEXT: jne LBB0_5
; CHECK-NEXT: ## %bb.2: ## %if.then4
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: je LBB0_54
+; CHECK-NEXT: je LBB0_64
; CHECK-NEXT: ## %bb.3: ## %SyTime.exit
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: je LBB0_54
+; CHECK-NEXT: je LBB0_64
; CHECK-NEXT: LBB0_4: ## %cleanup
; CHECK-NEXT: addq $552, %rsp ## imm = 0x228
; CHECK-NEXT: popq %rbx
@@ -60,206 +60,260 @@ define ptr @SyFgets(ptr %line, i64 %length, i64 %fid) {
; CHECK-NEXT: retq
; CHECK-NEXT: LBB0_5: ## %if.end25
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: je LBB0_54
+; CHECK-NEXT: je LBB0_64
; CHECK-NEXT: ## %bb.6: ## %SyTime.exit2720
+; CHECK-NEXT: movq %rdi, %r14
; CHECK-NEXT: leaq {{[0-9]+}}(%rsp), %rax
; CHECK-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; CHECK-NEXT: cmpq %rax, %rcx
; CHECK-NEXT: jae LBB0_8
; CHECK-NEXT: ## %bb.7: ## %for.body.lr.ph
-; CHECK-NEXT: movq %rdi, %r14
; CHECK-NEXT: ## implicit-def: $rdi
; CHECK-NEXT: movq %rdx, %rbx
; CHECK-NEXT: movl $512, %edx ## imm = 0x200
; CHECK-NEXT: movl $32, %esi
; CHECK-NEXT: callq _memset
-; CHECK-NEXT: movq %r14, %rdi
; CHECK-NEXT: movq %rbx, %rdx
; CHECK-NEXT: LBB0_8: ## %while.body.preheader
; CHECK-NEXT: imulq $1040, %rdx, %rax ## imm = 0x410
; CHECK-NEXT: movq _syBuf at GOTPCREL(%rip), %rcx
-; CHECK-NEXT: leaq 8(%rcx,%rax), %rdx
-; CHECK-NEXT: movq _syCTRO at GOTPCREL(%rip), %rax
-; CHECK-NEXT: movl $1, %r13d
-; CHECK-NEXT: movb $1, %cl
+; CHECK-NEXT: leaq 8(%rcx,%rax), %rax
+; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-NEXT: movl $1, %esi
+; CHECK-NEXT: xorl %eax, %eax
+; CHECK-NEXT: movq _syCTRO at GOTPCREL(%rip), %rcx
+; CHECK-NEXT: movb $1, %dl
+; CHECK-NEXT: xorl %r8d, %r8d
+; CHECK-NEXT: jmp LBB0_9
; CHECK-NEXT: .p2align 4
+; CHECK-NEXT: LBB0_19: ## %select.end20
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: testb %dl, %dl
+; CHECK-NEXT: je LBB0_20
; CHECK-NEXT: LBB0_9: ## %do.body
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: movl $0, (%rax)
-; CHECK-NEXT: testb %cl, %cl
-; CHECK-NEXT: jne LBB0_9
-; CHECK-NEXT: ## %bb.10: ## %do.end
-; CHECK-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-NEXT: xorl %ebp, %ebp
+; CHECK-NEXT: movl $0, (%rcx)
; CHECK-NEXT: testb %al, %al
+; CHECK-NEXT: movl $0, %r9d
; CHECK-NEXT: jne LBB0_11
-; CHECK-NEXT: ## %bb.12: ## %while.body200.preheader
+; CHECK-NEXT: ## %bb.10: ## %select.false
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: movl %r8d, %r9d
+; CHECK-NEXT: LBB0_11: ## %select.end
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: xorl %edi, %edi
+; CHECK-NEXT: testb %dil, %dil
+; CHECK-NEXT: movl $0, %r8d
+; CHECK-NEXT: jne LBB0_13
+; CHECK-NEXT: ## %bb.12: ## %select.false7
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: movl %r9d, %edi
+; CHECK-NEXT: movl %esi, %r8d
+; CHECK-NEXT: LBB0_13: ## %select.end6
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: testb %al, %al
+; CHECK-NEXT: testb %al, %al
+; CHECK-NEXT: ## implicit-def: $esi
+; CHECK-NEXT: jne LBB0_15
+; CHECK-NEXT: ## %bb.14: ## %select.false13
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: movl %r8d, %esi
+; CHECK-NEXT: LBB0_15: ## %select.end12
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: testb %al, %al
+; CHECK-NEXT: xorl %r8d, %r8d
+; CHECK-NEXT: testb %r8b, %r8b
+; CHECK-NEXT: movl $0, %r9d
+; CHECK-NEXT: je LBB0_16
+; CHECK-NEXT: ## %bb.17: ## %select.end17
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: testb %r8b, %r8b
+; CHECK-NEXT: jne LBB0_19
+; CHECK-NEXT: jmp LBB0_18
+; CHECK-NEXT: .p2align 4
+; CHECK-NEXT: LBB0_16: ## %select.false18
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: movl %edi, %r9d
+; CHECK-NEXT: testb %r8b, %r8b
+; CHECK-NEXT: jne LBB0_19
+; CHECK-NEXT: LBB0_18: ## %select.false21
+; CHECK-NEXT: ## in Loop: Header=BB0_9 Depth=1
+; CHECK-NEXT: movl %r9d, %r8d
+; CHECK-NEXT: jmp LBB0_19
+; CHECK-NEXT: LBB0_20: ## %do.end
+; CHECK-NEXT: movq %r14, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-NEXT: leal (,%rsi,4), %r15d
+; CHECK-NEXT: cmpl $21, %r8d
+; CHECK-NEXT: cmovnel %esi, %r15d
+; CHECK-NEXT: xorl %ebp, %ebp
+; CHECK-NEXT: testb %al, %al
+; CHECK-NEXT: jne LBB0_21
+; CHECK-NEXT: ## %bb.22: ## %while.body200.preheader
; CHECK-NEXT: xorl %r12d, %r12d
; CHECK-NEXT: leaq LJTI0_0(%rip), %rdx
; CHECK-NEXT: leaq LJTI0_1(%rip), %r14
; CHECK-NEXT: movb $1, %sil
; CHECK-NEXT: movl $0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Folded Spill
-; CHECK-NEXT: xorl %r15d, %r15d
-; CHECK-NEXT: jmp LBB0_13
-; CHECK-NEXT: LBB0_43: ## %while.cond1037.preheader
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: xorl %r13d, %r13d
+; CHECK-NEXT: jmp LBB0_23
+; CHECK-NEXT: LBB0_53: ## %while.cond1037.preheader
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: testb %r12b, %r12b
-; CHECK-NEXT: je LBB0_54
+; CHECK-NEXT: je LBB0_64
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_20: ## %while.cond197.backedge
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
-; CHECK-NEXT: decl %r13d
-; CHECK-NEXT: testl %r13d, %r13d
-; CHECK-NEXT: movl %ebp, %r15d
-; CHECK-NEXT: jle LBB0_21
-; CHECK-NEXT: LBB0_13: ## %while.body200
+; CHECK-NEXT: LBB0_30: ## %while.cond197.backedge
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
+; CHECK-NEXT: decl %r15d
+; CHECK-NEXT: testl %r15d, %r15d
+; CHECK-NEXT: movl %ebp, %r13d
+; CHECK-NEXT: jle LBB0_31
+; CHECK-NEXT: LBB0_23: ## %while.body200
; CHECK-NEXT: ## =>This Loop Header: Depth=1
-; CHECK-NEXT: ## Child Loop BB0_28 Depth 2
-; CHECK-NEXT: ## Child Loop BB0_37 Depth 2
+; CHECK-NEXT: ## Child Loop BB0_38 Depth 2
+; CHECK-NEXT: ## Child Loop BB0_47 Depth 2
; CHECK-NEXT: leal -268(%rbp), %eax
; CHECK-NEXT: cmpl $105, %eax
-; CHECK-NEXT: ja LBB0_14
-; CHECK-NEXT: ## %bb.55: ## %while.body200
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: ja LBB0_24
+; CHECK-NEXT: ## %bb.65: ## %while.body200
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movslq (%r14,%rax,4), %rax
; CHECK-NEXT: addq %r14, %rax
; CHECK-NEXT: jmpq *%rax
-; CHECK-NEXT: LBB0_25: ## %sw.bb474
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: LBB0_35: ## %sw.bb474
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: testb %r12b, %r12b
; CHECK-NEXT: ## implicit-def: $rbx
-; CHECK-NEXT: jne LBB0_33
-; CHECK-NEXT: ## %bb.26: ## %do.body479.preheader
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jne LBB0_43
+; CHECK-NEXT: ## %bb.36: ## %do.body479.preheader
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: testb %r12b, %r12b
; CHECK-NEXT: ## implicit-def: $rbx
-; CHECK-NEXT: jne LBB0_33
-; CHECK-NEXT: ## %bb.27: ## %land.rhs485.preheader
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jne LBB0_43
+; CHECK-NEXT: ## %bb.37: ## %land.rhs485.preheader
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: ## implicit-def: $rax
-; CHECK-NEXT: jmp LBB0_28
+; CHECK-NEXT: jmp LBB0_38
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_31: ## %do.body479.backedge
-; CHECK-NEXT: ## in Loop: Header=BB0_28 Depth=2
+; CHECK-NEXT: LBB0_41: ## %do.body479.backedge
+; CHECK-NEXT: ## in Loop: Header=BB0_38 Depth=2
; CHECK-NEXT: leaq 1(%rbx), %rax
; CHECK-NEXT: testb %r12b, %r12b
-; CHECK-NEXT: je LBB0_32
-; CHECK-NEXT: LBB0_28: ## %land.rhs485
-; CHECK-NEXT: ## Parent Loop BB0_13 Depth=1
+; CHECK-NEXT: je LBB0_42
+; CHECK-NEXT: LBB0_38: ## %land.rhs485
+; CHECK-NEXT: ## Parent Loop BB0_23 Depth=1
; CHECK-NEXT: ## => This Inner Loop Header: Depth=2
; CHECK-NEXT: testb %sil, %sil
-; CHECK-NEXT: jne LBB0_54
-; CHECK-NEXT: ## %bb.29: ## %cond.true.i.i2780
-; CHECK-NEXT: ## in Loop: Header=BB0_28 Depth=2
+; CHECK-NEXT: jne LBB0_64
+; CHECK-NEXT: ## %bb.39: ## %cond.true.i.i2780
+; CHECK-NEXT: ## in Loop: Header=BB0_38 Depth=2
; CHECK-NEXT: movq %rax, %rbx
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: jne LBB0_31
-; CHECK-NEXT: ## %bb.30: ## %lor.rhs500
-; CHECK-NEXT: ## in Loop: Header=BB0_28 Depth=2
+; CHECK-NEXT: jne LBB0_41
+; CHECK-NEXT: ## %bb.40: ## %lor.rhs500
+; CHECK-NEXT: ## in Loop: Header=BB0_38 Depth=2
; CHECK-NEXT: ## implicit-def: $edi
; CHECK-NEXT: movl $256, %esi ## imm = 0x100
; CHECK-NEXT: callq ___maskrune
; CHECK-NEXT: movb $1, %sil
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: jne LBB0_31
-; CHECK-NEXT: jmp LBB0_33
+; CHECK-NEXT: jne LBB0_41
+; CHECK-NEXT: jmp LBB0_43
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_14: ## %while.body200
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: LBB0_24: ## %while.body200
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: leal 1(%rbp), %eax
; CHECK-NEXT: cmpl $21, %eax
-; CHECK-NEXT: ja LBB0_20
-; CHECK-NEXT: ## %bb.15: ## %while.body200
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: ja LBB0_30
+; CHECK-NEXT: ## %bb.25: ## %while.body200
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movslq (%rdx,%rax,4), %rax
; CHECK-NEXT: addq %rdx, %rax
; CHECK-NEXT: jmpq *%rax
-; CHECK-NEXT: LBB0_18: ## %while.cond201.preheader
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: LBB0_28: ## %while.cond201.preheader
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movl $1, %ebp
-; CHECK-NEXT: jmp LBB0_20
-; CHECK-NEXT: LBB0_44: ## %sw.bb1134
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jmp LBB0_30
+; CHECK-NEXT: LBB0_54: ## %sw.bb1134
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: leaq {{[0-9]+}}(%rsp), %rax
; CHECK-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; CHECK-NEXT: cmpq %rax, %rcx
-; CHECK-NEXT: jb LBB0_54
-; CHECK-NEXT: ## %bb.45: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jb LBB0_64
+; CHECK-NEXT: ## %bb.55: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movl $0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Folded Spill
; CHECK-NEXT: movl $268, %ebp ## imm = 0x10C
-; CHECK-NEXT: jmp LBB0_20
-; CHECK-NEXT: LBB0_39: ## %sw.bb566
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jmp LBB0_30
+; CHECK-NEXT: LBB0_49: ## %sw.bb566
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movl $20, %ebp
-; CHECK-NEXT: jmp LBB0_20
-; CHECK-NEXT: LBB0_19: ## %sw.bb243
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jmp LBB0_30
+; CHECK-NEXT: LBB0_29: ## %sw.bb243
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movl $2, %ebp
-; CHECK-NEXT: jmp LBB0_20
-; CHECK-NEXT: LBB0_32: ## %if.end517.loopexitsplit
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jmp LBB0_30
+; CHECK-NEXT: LBB0_42: ## %if.end517.loopexitsplit
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: incq %rbx
-; CHECK-NEXT: LBB0_33: ## %if.end517
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
-; CHECK-NEXT: leal -324(%r15), %eax
+; CHECK-NEXT: LBB0_43: ## %if.end517
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
+; CHECK-NEXT: leal -324(%r13), %eax
; CHECK-NEXT: cmpl $59, %eax
-; CHECK-NEXT: ja LBB0_34
-; CHECK-NEXT: ## %bb.56: ## %if.end517
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: ja LBB0_44
+; CHECK-NEXT: ## %bb.66: ## %if.end517
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movabsq $576460756598390785, %rcx ## imm = 0x800000100000001
; CHECK-NEXT: btq %rax, %rcx
-; CHECK-NEXT: jb LBB0_37
-; CHECK-NEXT: LBB0_34: ## %if.end517
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
-; CHECK-NEXT: cmpl $11, %r15d
-; CHECK-NEXT: je LBB0_37
-; CHECK-NEXT: ## %bb.35: ## %if.end517
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
-; CHECK-NEXT: cmpl $24, %r15d
-; CHECK-NEXT: je LBB0_37
-; CHECK-NEXT: ## %bb.36: ## %if.then532
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jb LBB0_47
+; CHECK-NEXT: LBB0_44: ## %if.end517
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
+; CHECK-NEXT: cmpl $11, %r13d
+; CHECK-NEXT: je LBB0_47
+; CHECK-NEXT: ## %bb.45: ## %if.end517
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
+; CHECK-NEXT: cmpl $24, %r13d
+; CHECK-NEXT: je LBB0_47
+; CHECK-NEXT: ## %bb.46: ## %if.then532
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: movq _SyFgets.yank at GOTPCREL(%rip), %rax
; CHECK-NEXT: movb $0, (%rax)
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_37: ## %for.cond534
-; CHECK-NEXT: ## Parent Loop BB0_13 Depth=1
+; CHECK-NEXT: LBB0_47: ## %for.cond534
+; CHECK-NEXT: ## Parent Loop BB0_23 Depth=1
; CHECK-NEXT: ## => This Inner Loop Header: Depth=2
; CHECK-NEXT: testb %r12b, %r12b
-; CHECK-NEXT: jne LBB0_37
-; CHECK-NEXT: ## %bb.38: ## %for.cond542.preheader
-; CHECK-NEXT: ## in Loop: Header=BB0_13 Depth=1
+; CHECK-NEXT: jne LBB0_47
+; CHECK-NEXT: ## %bb.48: ## %for.cond542.preheader
+; CHECK-NEXT: ## in Loop: Header=BB0_23 Depth=1
; CHECK-NEXT: testb %al, %al
; CHECK-NEXT: movb $0, (%rbx)
; CHECK-NEXT: leaq LJTI0_0(%rip), %rdx
-; CHECK-NEXT: jmp LBB0_20
+; CHECK-NEXT: jmp LBB0_30
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_41: ## %while.cond864
+; CHECK-NEXT: LBB0_51: ## %while.cond864
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: jmp LBB0_41
+; CHECK-NEXT: jmp LBB0_51
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_42: ## %while.cond962
+; CHECK-NEXT: LBB0_52: ## %while.cond962
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: jmp LBB0_42
+; CHECK-NEXT: jmp LBB0_52
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_24: ## %for.cond357
+; CHECK-NEXT: LBB0_34: ## %for.cond357
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: jmp LBB0_24
-; CHECK-NEXT: LBB0_11:
+; CHECK-NEXT: jmp LBB0_34
+; CHECK-NEXT: LBB0_21:
; CHECK-NEXT: movl $0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Folded Spill
-; CHECK-NEXT: LBB0_21: ## %while.end1465
+; CHECK-NEXT: LBB0_31: ## %while.end1465
; CHECK-NEXT: incl %ebp
; CHECK-NEXT: cmpl $16, %ebp
-; CHECK-NEXT: ja LBB0_49
-; CHECK-NEXT: ## %bb.22: ## %while.end1465
+; CHECK-NEXT: ja LBB0_59
+; CHECK-NEXT: ## %bb.32: ## %while.end1465
; CHECK-NEXT: movl $83969, %eax ## imm = 0x14801
; CHECK-NEXT: btl %ebp, %eax
-; CHECK-NEXT: jae LBB0_49
-; CHECK-NEXT: ## %bb.23:
+; CHECK-NEXT: jae LBB0_59
+; CHECK-NEXT: ## %bb.33:
; CHECK-NEXT: xorl %ebx, %ebx
; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r14 ## 8-byte Reload
-; CHECK-NEXT: LBB0_47: ## %if.then1477
+; CHECK-NEXT: LBB0_57: ## %if.then1477
; CHECK-NEXT: ## implicit-def: $edi
; CHECK-NEXT: ## implicit-def: $rsi
; CHECK-NEXT: movl $1, %edx
@@ -268,49 +322,49 @@ define ptr @SyFgets(ptr %line, i64 %length, i64 %fid) {
; CHECK-NEXT: movq _syHistory at GOTPCREL(%rip), %rax
; CHECK-NEXT: leaq 8189(%r14,%rax), %rax
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_48: ## %for.body1723
+; CHECK-NEXT: LBB0_58: ## %for.body1723
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
; CHECK-NEXT: decq %rax
-; CHECK-NEXT: jmp LBB0_48
-; CHECK-NEXT: LBB0_46: ## %if.then1477.loopexit
+; CHECK-NEXT: jmp LBB0_58
+; CHECK-NEXT: LBB0_56: ## %if.then1477.loopexit
; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r14 ## 8-byte Reload
; CHECK-NEXT: movq %r14, %rbx
-; CHECK-NEXT: jmp LBB0_47
-; CHECK-NEXT: LBB0_16: ## %while.cond635.preheader
+; CHECK-NEXT: jmp LBB0_57
+; CHECK-NEXT: LBB0_26: ## %while.cond635.preheader
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: je LBB0_40
+; CHECK-NEXT: je LBB0_50
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_17: ## %for.body643.us
+; CHECK-NEXT: LBB0_27: ## %for.body643.us
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: jmp LBB0_17
+; CHECK-NEXT: jmp LBB0_27
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_40: ## %while.cond661
+; CHECK-NEXT: LBB0_50: ## %while.cond661
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: jmp LBB0_40
-; CHECK-NEXT: LBB0_49: ## %for.cond1480.preheader
+; CHECK-NEXT: jmp LBB0_50
+; CHECK-NEXT: LBB0_59: ## %for.cond1480.preheader
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: je LBB0_54
-; CHECK-NEXT: ## %bb.50: ## %for.body1664.lr.ph
+; CHECK-NEXT: je LBB0_64
+; CHECK-NEXT: ## %bb.60: ## %for.body1664.lr.ph
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: testb %al, %al
; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r14 ## 8-byte Reload
; CHECK-NEXT: movl {{[-0-9]+}}(%r{{[sb]}}p), %ebp ## 4-byte Reload
-; CHECK-NEXT: jne LBB0_53
-; CHECK-NEXT: ## %bb.51: ## %while.body1679.preheader
+; CHECK-NEXT: jne LBB0_63
+; CHECK-NEXT: ## %bb.61: ## %while.body1679.preheader
; CHECK-NEXT: incl %ebp
; CHECK-NEXT: xorl %ebx, %ebx
; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: LBB0_52: ## %while.body1679
+; CHECK-NEXT: LBB0_62: ## %while.body1679
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1
; CHECK-NEXT: movq (%r14), %rdi
; CHECK-NEXT: callq _fileno
; CHECK-NEXT: incl %ebp
; CHECK-NEXT: testb %bl, %bl
-; CHECK-NEXT: jne LBB0_52
-; CHECK-NEXT: LBB0_53: ## %while.cond1683.preheader
+; CHECK-NEXT: jne LBB0_62
+; CHECK-NEXT: LBB0_63: ## %while.cond1683.preheader
; CHECK-NEXT: testb %al, %al
-; CHECK-NEXT: LBB0_54: ## %if.then.i
+; CHECK-NEXT: LBB0_64: ## %if.then.i
; CHECK-NEXT: ud2
entry:
%sub.ptr.rhs.cast646 = ptrtoint ptr %line to i64
diff --git a/llvm/test/CodeGen/X86/shl-crash-on-legalize.ll b/llvm/test/CodeGen/X86/shl-crash-on-legalize.ll
index 5f21a23f257a8..62ff45accdcae 100644
--- a/llvm/test/CodeGen/X86/shl-crash-on-legalize.ll
+++ b/llvm/test/CodeGen/X86/shl-crash-on-legalize.ll
@@ -12,17 +12,39 @@ define i32 @PR29058(i8 %x, i32 %y) {
; CHECK-LABEL: PR29058:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: testb %dil, %dil
+; CHECK-NEXT: je .LBB0_1
+; CHECK-NEXT: # %bb.2: # %select.false
+; CHECK-NEXT: movl %esi, %eax
+; CHECK-NEXT: jmp .LBB0_3
+; CHECK-NEXT: .LBB0_1:
; CHECK-NEXT: movl $2147483646, %eax # imm = 0x7FFFFFFE
-; CHECK-NEXT: cmovnel %esi, %eax
-; CHECK-NEXT: xorl %ecx, %ecx
-; CHECK-NEXT: cmpb $1, %dil
-; CHECK-NEXT: sbbl %ecx, %ecx
-; CHECK-NEXT: orb %sil, %cl
+; CHECK-NEXT: .LBB0_3: # %select.end
+; CHECK-NEXT: testb %dil, %dil
+; CHECK-NEXT: movl %esi, %ecx
+; CHECK-NEXT: jne .LBB0_5
+; CHECK-NEXT: # %bb.4: # %select.false2
+; CHECK-NEXT: movl $-1, %ecx
+; CHECK-NEXT: .LBB0_5: # %select.end1
; CHECK-NEXT: # kill: def $cl killed $cl killed $ecx
; CHECK-NEXT: shll %cl, %eax
+; CHECK-NEXT: testb %dil, %dil
; CHECK-NEXT: movq %rax, structMember(%rip)
-; CHECK-NEXT: # kill: def $eax killed $eax killed $rax
+; CHECK-NEXT: je .LBB0_6
+; CHECK-NEXT: # %bb.7: # %select.false4
+; CHECK-NEXT: movl %esi, %eax
+; CHECK-NEXT: testb %dil, %dil
+; CHECK-NEXT: jne .LBB0_10
+; CHECK-NEXT: .LBB0_9:
+; CHECK-NEXT: movl $-1, %esi
+; CHECK-NEXT: .LBB0_10: # %select.end6
+; CHECK-NEXT: movl %esi, %ecx
+; CHECK-NEXT: shll %cl, %eax
; CHECK-NEXT: retq
+; CHECK-NEXT: .LBB0_6:
+; CHECK-NEXT: movl $2147483646, %eax # imm = 0x7FFFFFFE
+; CHECK-NEXT: testb %dil, %dil
+; CHECK-NEXT: jne .LBB0_10
+; CHECK-NEXT: jmp .LBB0_9
entry:
%bool_1 = icmp ne i8 %x, 0
%bool_2 = icmp eq i8 %x, 0
diff --git a/llvm/test/CodeGen/X86/x86-cmov-converter.ll b/llvm/test/CodeGen/X86/x86-cmov-converter.ll
index b02da217e76b2..bc68114d7d5fc 100644
--- a/llvm/test/CodeGen/X86/x86-cmov-converter.ll
+++ b/llvm/test/CodeGen/X86/x86-cmov-converter.ll
@@ -280,22 +280,20 @@ define i32 @MaxIndex(i32 %n, ptr nocapture readonly %a) #0 {
; CHECK-NEXT: jl .LBB2_5
; CHECK-NEXT: # %bb.1: # %for.body.preheader
; CHECK-NEXT: movl %edi, %ecx
-; CHECK-NEXT: xorl %edi, %edi
+; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: movl $1, %edx
; CHECK-NEXT: .LBB2_2: # %for.body
; CHECK-NEXT: # =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: movl (%rsi,%rdx,4), %r8d
-; CHECK-NEXT: movslq %edi, %r9
-; CHECK-NEXT: movl %edx, %eax
-; CHECK-NEXT: cmpl (%rsi,%r9,4), %r8d
-; CHECK-NEXT: jg .LBB2_4
-; CHECK-NEXT: # %bb.3: # %for.body
+; CHECK-NEXT: movl (%rsi,%rdx,4), %edi
+; CHECK-NEXT: movslq %eax, %r8
+; CHECK-NEXT: cmpl (%rsi,%r8,4), %edi
+; CHECK-NEXT: jle .LBB2_4
+; CHECK-NEXT: # %bb.3: # %select.true.sink
; CHECK-NEXT: # in Loop: Header=BB2_2 Depth=1
-; CHECK-NEXT: movl %edi, %eax
-; CHECK-NEXT: .LBB2_4: # %for.body
+; CHECK-NEXT: movl %edx, %eax
+; CHECK-NEXT: .LBB2_4: # %select.end
; CHECK-NEXT: # in Loop: Header=BB2_2 Depth=1
; CHECK-NEXT: addq $1, %rdx
-; CHECK-NEXT: movl %eax, %edi
; CHECK-NEXT: cmpq %rdx, %rcx
; CHECK-NEXT: jne .LBB2_2
; CHECK-NEXT: .LBB2_5: # %for.cond.cleanup
@@ -308,22 +306,20 @@ define i32 @MaxIndex(i32 %n, ptr nocapture readonly %a) #0 {
; CHECK-FORCEALL-NEXT: jl .LBB2_5
; CHECK-FORCEALL-NEXT: # %bb.1: # %for.body.preheader
; CHECK-FORCEALL-NEXT: movl %edi, %ecx
-; CHECK-FORCEALL-NEXT: xorl %edi, %edi
+; CHECK-FORCEALL-NEXT: xorl %eax, %eax
; CHECK-FORCEALL-NEXT: movl $1, %edx
; CHECK-FORCEALL-NEXT: .LBB2_2: # %for.body
; CHECK-FORCEALL-NEXT: # =>This Inner Loop Header: Depth=1
-; CHECK-FORCEALL-NEXT: movl (%rsi,%rdx,4), %r8d
-; CHECK-FORCEALL-NEXT: movslq %edi, %r9
-; CHECK-FORCEALL-NEXT: movl %edx, %eax
-; CHECK-FORCEALL-NEXT: cmpl (%rsi,%r9,4), %r8d
-; CHECK-FORCEALL-NEXT: jg .LBB2_4
-; CHECK-FORCEALL-NEXT: # %bb.3: # %for.body
+; CHECK-FORCEALL-NEXT: movl (%rsi,%rdx,4), %edi
+; CHECK-FORCEALL-NEXT: movslq %eax, %r8
+; CHECK-FORCEALL-NEXT: cmpl (%rsi,%r8,4), %edi
+; CHECK-FORCEALL-NEXT: jle .LBB2_4
+; CHECK-FORCEALL-NEXT: # %bb.3: # %select.true.sink
; CHECK-FORCEALL-NEXT: # in Loop: Header=BB2_2 Depth=1
-; CHECK-FORCEALL-NEXT: movl %edi, %eax
-; CHECK-FORCEALL-NEXT: .LBB2_4: # %for.body
+; CHECK-FORCEALL-NEXT: movl %edx, %eax
+; CHECK-FORCEALL-NEXT: .LBB2_4: # %select.end
; CHECK-FORCEALL-NEXT: # in Loop: Header=BB2_2 Depth=1
; CHECK-FORCEALL-NEXT: addq $1, %rdx
-; CHECK-FORCEALL-NEXT: movl %eax, %edi
; CHECK-FORCEALL-NEXT: cmpq %rdx, %rcx
; CHECK-FORCEALL-NEXT: jne .LBB2_2
; CHECK-FORCEALL-NEXT: .LBB2_5: # %for.cond.cleanup
@@ -505,39 +501,53 @@ define i32 @BinarySearch(i32 %Mask, ptr nocapture readonly %Curr, ptr nocapture
; CHECK-LABEL: BinarySearch:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movl (%rsi), %eax
-; CHECK-NEXT: jmp .LBB5_2
-; CHECK-NEXT: .LBB5_1: # %while.body
-; CHECK-NEXT: # in Loop: Header=BB5_2 Depth=1
-; CHECK-NEXT: movl %ecx, %eax
-; CHECK-NEXT: xorl %ecx, %ecx
-; CHECK-NEXT: btl %eax, %edi
-; CHECK-NEXT: setae %cl
-; CHECK-NEXT: movq 8(%rdx,%rcx,8), %rdx
-; CHECK-NEXT: .LBB5_2: # %while.body
+; CHECK-NEXT: .LBB5_1: # %entry
; CHECK-NEXT: # =>This Inner Loop Header: Depth=1
; CHECK-NEXT: movl (%rdx), %ecx
; CHECK-NEXT: cmpl %ecx, %eax
-; CHECK-NEXT: ja .LBB5_1
-; CHECK-NEXT: # %bb.3: # %while.end
+; CHECK-NEXT: jbe .LBB5_6
+; CHECK-NEXT: # %bb.2: # %while.body
+; CHECK-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-NEXT: movl %ecx, %eax
+; CHECK-NEXT: btl %ecx, %edi
+; CHECK-NEXT: jb .LBB5_4
+; CHECK-NEXT: # %bb.3: # %select.true.sink
+; CHECK-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-NEXT: addq $16, %rdx
+; CHECK-NEXT: movq (%rdx), %rdx
+; CHECK-NEXT: jmp .LBB5_1
+; CHECK-NEXT: .LBB5_4: # %select.false.sink
+; CHECK-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-NEXT: addq $8, %rdx
+; CHECK-NEXT: movq (%rdx), %rdx
+; CHECK-NEXT: jmp .LBB5_1
+; CHECK-NEXT: .LBB5_6: # %while.end
; CHECK-NEXT: retq
;
; CHECK-FORCEALL-LABEL: BinarySearch:
; CHECK-FORCEALL: # %bb.0: # %entry
; CHECK-FORCEALL-NEXT: movl (%rsi), %eax
-; CHECK-FORCEALL-NEXT: jmp .LBB5_2
-; CHECK-FORCEALL-NEXT: .LBB5_1: # %while.body
-; CHECK-FORCEALL-NEXT: # in Loop: Header=BB5_2 Depth=1
-; CHECK-FORCEALL-NEXT: movl %ecx, %eax
-; CHECK-FORCEALL-NEXT: xorl %ecx, %ecx
-; CHECK-FORCEALL-NEXT: btl %eax, %edi
-; CHECK-FORCEALL-NEXT: setae %cl
-; CHECK-FORCEALL-NEXT: movq 8(%rdx,%rcx,8), %rdx
-; CHECK-FORCEALL-NEXT: .LBB5_2: # %while.body
+; CHECK-FORCEALL-NEXT: .LBB5_1: # %entry
; CHECK-FORCEALL-NEXT: # =>This Inner Loop Header: Depth=1
; CHECK-FORCEALL-NEXT: movl (%rdx), %ecx
; CHECK-FORCEALL-NEXT: cmpl %ecx, %eax
-; CHECK-FORCEALL-NEXT: ja .LBB5_1
-; CHECK-FORCEALL-NEXT: # %bb.3: # %while.end
+; CHECK-FORCEALL-NEXT: jbe .LBB5_6
+; CHECK-FORCEALL-NEXT: # %bb.2: # %while.body
+; CHECK-FORCEALL-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-FORCEALL-NEXT: movl %ecx, %eax
+; CHECK-FORCEALL-NEXT: btl %ecx, %edi
+; CHECK-FORCEALL-NEXT: jb .LBB5_4
+; CHECK-FORCEALL-NEXT: # %bb.3: # %select.true.sink
+; CHECK-FORCEALL-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-FORCEALL-NEXT: addq $16, %rdx
+; CHECK-FORCEALL-NEXT: movq (%rdx), %rdx
+; CHECK-FORCEALL-NEXT: jmp .LBB5_1
+; CHECK-FORCEALL-NEXT: .LBB5_4: # %select.false.sink
+; CHECK-FORCEALL-NEXT: # in Loop: Header=BB5_1 Depth=1
+; CHECK-FORCEALL-NEXT: addq $8, %rdx
+; CHECK-FORCEALL-NEXT: movq (%rdx), %rdx
+; CHECK-FORCEALL-NEXT: jmp .LBB5_1
+; CHECK-FORCEALL-NEXT: .LBB5_6: # %while.end
; CHECK-FORCEALL-NEXT: retq
entry:
%0 = load i32, ptr %Curr, align 8
>From f053f5088741f8446ab50dc91c951af0eb1d9f1f Mon Sep 17 00:00:00 2001
From: Eitan Frachtenberg <eitan at specexec.com>
Date: Mon, 1 Jun 2026 07:33:56 -0700
Subject: [PATCH 2/2] [SelectOptimize] Address review feedback and scope pass
insertion to X86
---
llvm/lib/CodeGen/CodeGenPrepare.cpp | 7 -------
llvm/lib/CodeGen/TargetPassConfig.cpp | 3 ++-
llvm/lib/Target/X86/X86CmovConversion.cpp | 8 --------
3 files changed, 2 insertions(+), 16 deletions(-)
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index 214caab182c10..55ded95d83f0f 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -7730,13 +7730,6 @@ bool CodeGenPrepare::optimizeSelectInst(SelectInst *SI) {
if (DisableSelectToBranch)
return false;
- // SelectOptimize (IR-level) and CodeGenPrepare use complementary heuristics:
- // SelectOptimize focuses on density-based and loop-level analysis, while
- // CodeGenPrepare focuses on expensive-cold-operand sinking. Both can safely
- // coexist: if SelectOptimize already converted a select to a branch, that
- // select is gone from the IR and CodeGenPrepare simply has nothing to do for
- // it. Do NOT skip based on SelectOptimize being enabled.
-
// Find all consecutive select instructions that share the same condition.
SmallVector<SelectInst *, 2> ASI;
ASI.push_back(SI);
diff --git a/llvm/lib/CodeGen/TargetPassConfig.cpp b/llvm/lib/CodeGen/TargetPassConfig.cpp
index a568b50479dfa..1a88303060e90 100644
--- a/llvm/lib/CodeGen/TargetPassConfig.cpp
+++ b/llvm/lib/CodeGen/TargetPassConfig.cpp
@@ -899,7 +899,8 @@ void TargetPassConfig::addIRPasses() {
addPass(createExpandReductionsPass());
// Convert conditional moves to conditional jumps when profitable.
- if (getOptLevel() != CodeGenOptLevel::None && !DisableSelectOptimize)
+ if (getOptLevel() != CodeGenOptLevel::None && !DisableSelectOptimize &&
+ TM->getTargetTriple().isX86())
addPass(createSelectOptimizePass());
if (EnableGlobalMergeFunc)
diff --git a/llvm/lib/Target/X86/X86CmovConversion.cpp b/llvm/lib/Target/X86/X86CmovConversion.cpp
index b663375caec6e..46e38c9917fe5 100644
--- a/llvm/lib/Target/X86/X86CmovConversion.cpp
+++ b/llvm/lib/Target/X86/X86CmovConversion.cpp
@@ -173,14 +173,6 @@ bool X86CmovConversionImpl::runOnMachineFunction(MachineFunction &MF) {
if (!EnableCmovConverter)
return false;
- // SelectOptimize and X86CmovConversion operate at different levels (IR vs
- // machine) and are complementary: SelectOptimize converts IR selects to
- // branches before ISel, while X86CmovConversion converts machine-level cmovs
- // (including memory-operand cmovs and loop cmovs) to branches after ISel.
- // Both can safely coexist — if SelectOptimize already converted a select to a
- // branch, ISel will not emit a cmov for it and X86CmovConversion sees nothing
- // to do. Do NOT skip based on SelectOptimize being enabled.
-
LLVM_DEBUG(dbgs() << "********** " << DEBUG_TYPE << " : " << MF.getName()
<< "**********\n");
More information about the llvm-commits
mailing list