[NFCI] Regenerate instsimplify test checks

diff --git a/llvm/test/Transforms/InstSimplify/2011-01-14-Thread.ll b/llvm/test/Transforms/InstSimplify/2011-01-14-Thread.ll
index b05ec34..124f77a 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/2011-01-14-Thread.ll
+++ b/llvm/test/Transforms/InstSimplify/2011-01-14-Thread.ll
@@ -1,9 +1,11 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 define i32 @shift_select(i1 %cond) {
 ; CHECK-LABEL: @shift_select(
+; CHECK-NEXT:    ret i32 0
+;
   %s = select i1 %cond, i32 0, i32 1
   %r = lshr i32 %s, 1
   ret i32 %r
-; CHECK: ret i32 0
 }

diff --git a/llvm/test/Transforms/InstSimplify/2011-02-01-Vector.ll b/llvm/test/Transforms/InstSimplify/2011-02-01-Vector.ll
index e4c41ec..91f3442 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/2011-02-01-Vector.ll
+++ b/llvm/test/Transforms/InstSimplify/2011-02-01-Vector.ll
@@ -1,8 +1,10 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 define <2 x i32> @sdiv(<2 x i32> %x) {
 ; CHECK-LABEL: @sdiv(
+; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
+;
   %div = sdiv <2 x i32> %x, <i32 1, i32 1>
   ret <2 x i32> %div
-; CHECK: ret <2 x i32> %x
 }

diff --git a/llvm/test/Transforms/InstSimplify/2011-10-27-BinOpCrash.ll b/llvm/test/Transforms/InstSimplify/2011-10-27-BinOpCrash.ll
index 5380a7b..8d391cd 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/2011-10-27-BinOpCrash.ll
+++ b/llvm/test/Transforms/InstSimplify/2011-10-27-BinOpCrash.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine
 
 @_ZN11xercesc_2_5L11gDigitCharsE = external constant [32 x i16], align 2

diff --git a/llvm/test/Transforms/InstSimplify/2011-11-23-MaskedBitsCrash.ll b/llvm/test/Transforms/InstSimplify/2011-11-23-MaskedBitsCrash.ll
index 7d7eaeb..956fbb3 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/2011-11-23-MaskedBitsCrash.ll
+++ b/llvm/test/Transforms/InstSimplify/2011-11-23-MaskedBitsCrash.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify
 
 ; The mul can be proved to always overflow (turning a negative value

diff --git a/llvm/test/Transforms/InstSimplify/2013-04-19-ConstantFoldingCrash.ll b/llvm/test/Transforms/InstSimplify/2013-04-19-ConstantFoldingCrash.ll
index b382d2e..c1af4fb 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/2013-04-19-ConstantFoldingCrash.ll
+++ b/llvm/test/Transforms/InstSimplify/2013-04-19-ConstantFoldingCrash.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"

diff --git a/llvm/test/Transforms/InstSimplify/add-mask.ll b/llvm/test/Transforms/InstSimplify/add-mask.ll
index f26c8e6..0669a08 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/add-mask.ll
+++ b/llvm/test/Transforms/InstSimplify/add-mask.ll
@@ -70,7 +70,7 @@ declare void @llvm.assume(i1)
 ; Known bits without a constant
 define i1 @test4(i32 %a) {
 ; CHECK-LABEL: @test4(
-; CHECK-NEXT:    [[B:%.*]] = load i32, i32* @B
+; CHECK-NEXT:    [[B:%.*]] = load i32, i32* @B, align 4
 ; CHECK-NEXT:    [[B_AND:%.*]] = and i32 [[B]], 1
 ; CHECK-NEXT:    [[B_CND:%.*]] = icmp eq i32 [[B_AND]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[B_CND]])

diff --git a/llvm/test/Transforms/InstSimplify/and-icmps-same-ops.ll b/llvm/test/Transforms/InstSimplify/and-icmps-same-ops.ll
index 4215543..860732f 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/and-icmps-same-ops.ll
+++ b/llvm/test/Transforms/InstSimplify/and-icmps-same-ops.ll
@@ -6,7 +6,7 @@
 
 define i1 @eq_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -27,7 +27,7 @@ define i1 @eq_ne(i8 %a, i8 %b) {
 
 define i1 @eq_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -48,7 +48,7 @@ define i1 @eq_sgt(i8 %a, i8 %b) {
 
 define i1 @eq_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -69,7 +69,7 @@ define i1 @eq_slt(i8 %a, i8 %b) {
 
 define i1 @eq_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -90,7 +90,7 @@ define i1 @eq_ugt(i8 %a, i8 %b) {
 
 define i1 @eq_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -123,7 +123,7 @@ define i1 @ne_eq(i8 %a, i8 %b) {
 
 define i1 @ne_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -134,8 +134,8 @@ define i1 @ne_ne(i8 %a, i8 %b) {
 
 define i1 @ne_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -147,7 +147,7 @@ define i1 @ne_sge(i8 %a, i8 %b) {
 
 define i1 @ne_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_sgt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -158,8 +158,8 @@ define i1 @ne_sgt(i8 %a, i8 %b) {
 
 define i1 @ne_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -171,7 +171,7 @@ define i1 @ne_sle(i8 %a, i8 %b) {
 
 define i1 @ne_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_slt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -182,8 +182,8 @@ define i1 @ne_slt(i8 %a, i8 %b) {
 
 define i1 @ne_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -195,7 +195,7 @@ define i1 @ne_uge(i8 %a, i8 %b) {
 
 define i1 @ne_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ugt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -206,8 +206,8 @@ define i1 @ne_ugt(i8 %a, i8 %b) {
 
 define i1 @ne_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -219,7 +219,7 @@ define i1 @ne_ule(i8 %a, i8 %b) {
 
 define i1 @ne_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ult(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -232,7 +232,7 @@ define i1 @ne_ult(i8 %a, i8 %b) {
 
 define i1 @sge_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_eq(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -243,8 +243,8 @@ define i1 @sge_eq(i8 %a, i8 %b) {
 
 define i1 @sge_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -256,7 +256,7 @@ define i1 @sge_ne(i8 %a, i8 %b) {
 
 define i1 @sge_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -267,7 +267,7 @@ define i1 @sge_sge(i8 %a, i8 %b) {
 
 define i1 @sge_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_sgt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -278,8 +278,8 @@ define i1 @sge_sgt(i8 %a, i8 %b) {
 
 define i1 @sge_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -301,8 +301,8 @@ define i1 @sge_slt(i8 %a, i8 %b) {
 
 define i1 @sge_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -314,8 +314,8 @@ define i1 @sge_uge(i8 %a, i8 %b) {
 
 define i1 @sge_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -327,8 +327,8 @@ define i1 @sge_ugt(i8 %a, i8 %b) {
 
 define i1 @sge_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -340,8 +340,8 @@ define i1 @sge_ule(i8 %a, i8 %b) {
 
 define i1 @sge_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -365,7 +365,7 @@ define i1 @sgt_eq(i8 %a, i8 %b) {
 
 define i1 @sgt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -376,7 +376,7 @@ define i1 @sgt_ne(i8 %a, i8 %b) {
 
 define i1 @sgt_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -387,7 +387,7 @@ define i1 @sgt_sge(i8 %a, i8 %b) {
 
 define i1 @sgt_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -418,8 +418,8 @@ define i1 @sgt_slt(i8 %a, i8 %b) {
 
 define i1 @sgt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -431,8 +431,8 @@ define i1 @sgt_uge(i8 %a, i8 %b) {
 
 define i1 @sgt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -444,8 +444,8 @@ define i1 @sgt_ugt(i8 %a, i8 %b) {
 
 define i1 @sgt_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -457,8 +457,8 @@ define i1 @sgt_ule(i8 %a, i8 %b) {
 
 define i1 @sgt_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -472,7 +472,7 @@ define i1 @sgt_ult(i8 %a, i8 %b) {
 
 define i1 @sle_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_eq(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -483,8 +483,8 @@ define i1 @sle_eq(i8 %a, i8 %b) {
 
 define i1 @sle_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -496,8 +496,8 @@ define i1 @sle_ne(i8 %a, i8 %b) {
 
 define i1 @sle_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -519,7 +519,7 @@ define i1 @sle_sgt(i8 %a, i8 %b) {
 
 define i1 @sle_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -530,7 +530,7 @@ define i1 @sle_sle(i8 %a, i8 %b) {
 
 define i1 @sle_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_slt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -541,8 +541,8 @@ define i1 @sle_slt(i8 %a, i8 %b) {
 
 define i1 @sle_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -554,8 +554,8 @@ define i1 @sle_uge(i8 %a, i8 %b) {
 
 define i1 @sle_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -567,8 +567,8 @@ define i1 @sle_ugt(i8 %a, i8 %b) {
 
 define i1 @sle_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -580,8 +580,8 @@ define i1 @sle_ule(i8 %a, i8 %b) {
 
 define i1 @sle_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -605,7 +605,7 @@ define i1 @slt_eq(i8 %a, i8 %b) {
 
 define i1 @slt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -636,7 +636,7 @@ define i1 @slt_sgt(i8 %a, i8 %b) {
 
 define i1 @slt_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -647,7 +647,7 @@ define i1 @slt_sle(i8 %a, i8 %b) {
 
 define i1 @slt_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -658,8 +658,8 @@ define i1 @slt_slt(i8 %a, i8 %b) {
 
 define i1 @slt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -671,8 +671,8 @@ define i1 @slt_uge(i8 %a, i8 %b) {
 
 define i1 @slt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -684,8 +684,8 @@ define i1 @slt_ugt(i8 %a, i8 %b) {
 
 define i1 @slt_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -697,8 +697,8 @@ define i1 @slt_ule(i8 %a, i8 %b) {
 
 define i1 @slt_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -712,7 +712,7 @@ define i1 @slt_ult(i8 %a, i8 %b) {
 
 define i1 @uge_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_eq(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -723,8 +723,8 @@ define i1 @uge_eq(i8 %a, i8 %b) {
 
 define i1 @uge_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -736,8 +736,8 @@ define i1 @uge_ne(i8 %a, i8 %b) {
 
 define i1 @uge_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -749,8 +749,8 @@ define i1 @uge_sge(i8 %a, i8 %b) {
 
 define i1 @uge_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -762,8 +762,8 @@ define i1 @uge_sgt(i8 %a, i8 %b) {
 
 define i1 @uge_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -775,8 +775,8 @@ define i1 @uge_sle(i8 %a, i8 %b) {
 
 define i1 @uge_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -788,7 +788,7 @@ define i1 @uge_slt(i8 %a, i8 %b) {
 
 define i1 @uge_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -799,7 +799,7 @@ define i1 @uge_uge(i8 %a, i8 %b) {
 
 define i1 @uge_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_ugt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -810,8 +810,8 @@ define i1 @uge_ugt(i8 %a, i8 %b) {
 
 define i1 @uge_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -845,7 +845,7 @@ define i1 @ugt_eq(i8 %a, i8 %b) {
 
 define i1 @ugt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -856,8 +856,8 @@ define i1 @ugt_ne(i8 %a, i8 %b) {
 
 define i1 @ugt_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -869,8 +869,8 @@ define i1 @ugt_sge(i8 %a, i8 %b) {
 
 define i1 @ugt_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -882,8 +882,8 @@ define i1 @ugt_sgt(i8 %a, i8 %b) {
 
 define i1 @ugt_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -895,8 +895,8 @@ define i1 @ugt_sle(i8 %a, i8 %b) {
 
 define i1 @ugt_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -908,7 +908,7 @@ define i1 @ugt_slt(i8 %a, i8 %b) {
 
 define i1 @ugt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -919,7 +919,7 @@ define i1 @ugt_uge(i8 %a, i8 %b) {
 
 define i1 @ugt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -952,7 +952,7 @@ define i1 @ugt_ult(i8 %a, i8 %b) {
 
 define i1 @ule_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_eq(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -963,8 +963,8 @@ define i1 @ule_eq(i8 %a, i8 %b) {
 
 define i1 @ule_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -976,8 +976,8 @@ define i1 @ule_ne(i8 %a, i8 %b) {
 
 define i1 @ule_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -989,8 +989,8 @@ define i1 @ule_sge(i8 %a, i8 %b) {
 
 define i1 @ule_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1002,8 +1002,8 @@ define i1 @ule_sgt(i8 %a, i8 %b) {
 
 define i1 @ule_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1015,8 +1015,8 @@ define i1 @ule_sle(i8 %a, i8 %b) {
 
 define i1 @ule_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1028,8 +1028,8 @@ define i1 @ule_slt(i8 %a, i8 %b) {
 
 define i1 @ule_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1051,7 +1051,7 @@ define i1 @ule_ugt(i8 %a, i8 %b) {
 
 define i1 @ule_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -1062,7 +1062,7 @@ define i1 @ule_ule(i8 %a, i8 %b) {
 
 define i1 @ule_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_ult(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -1085,7 +1085,7 @@ define i1 @ult_eq(i8 %a, i8 %b) {
 
 define i1 @ult_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ne(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1096,8 +1096,8 @@ define i1 @ult_ne(i8 %a, i8 %b) {
 
 define i1 @ult_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1109,8 +1109,8 @@ define i1 @ult_sge(i8 %a, i8 %b) {
 
 define i1 @ult_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1122,8 +1122,8 @@ define i1 @ult_sgt(i8 %a, i8 %b) {
 
 define i1 @ult_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1135,8 +1135,8 @@ define i1 @ult_sle(i8 %a, i8 %b) {
 
 define i1 @ult_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1168,7 +1168,7 @@ define i1 @ult_ugt(i8 %a, i8 %b) {
 
 define i1 @ult_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1179,7 +1179,7 @@ define i1 @ult_ule(i8 %a, i8 %b) {
 
 define i1 @ult_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1202,7 +1202,7 @@ define <2 x i1> @ult_uge_vec(<2 x i8> %a, <2 x i8> %b) {
 
 define <2 x i1> @ult_ule_vec(<2 x i8> %a, <2 x i8> %b) {
 ; CHECK-LABEL: @ult_ule_vec(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult <2 x i8> %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult <2 x i8> [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = icmp ult <2 x i8> %a, %b
@@ -1213,8 +1213,8 @@ define <2 x i1> @ult_ule_vec(<2 x i8> %a, <2 x i8> %b) {
 
 define i1 @ult_uge_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_uge_swap(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %b, %a
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
@@ -1226,8 +1226,8 @@ define i1 @ult_uge_swap(i8 %a, i8 %b) {
 
 define i1 @ult_ult_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ult_swap(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %b, %a
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/and-or-icmp-zero.ll b/llvm/test/Transforms/InstSimplify/and-or-icmp-zero.ll
index b251bbf..15cfea4 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/and-or-icmp-zero.ll
+++ b/llvm/test/Transforms/InstSimplify/and-or-icmp-zero.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 ; In the next 16 tests (4 commutes * 2 (and/or) * 2 optional ptrtoint casts),
@@ -9,7 +10,7 @@
 
 define i1 @or_cmps_eq_zero_with_mask_commute1(i64 %x, i64 %y) {
 ; CHECK-LABEL: @or_cmps_eq_zero_with_mask_commute1(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 %x, %y
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq i64 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_ZERO]]
 ;
@@ -24,7 +25,7 @@ define i1 @or_cmps_eq_zero_with_mask_commute1(i64 %x, i64 %y) {
 
 define <2 x i1> @or_cmps_eq_zero_with_mask_commute2(<2 x i64> %x, <2 x i64> %y) {
 ; CHECK-LABEL: @or_cmps_eq_zero_with_mask_commute2(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i64> %x, %y
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i64> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq <2 x i64> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[SOMEBITS_ARE_ZERO]]
 ;
@@ -39,7 +40,7 @@ define <2 x i1> @or_cmps_eq_zero_with_mask_commute2(<2 x i64> %x, <2 x i64> %y)
 
 define i1 @or_cmps_eq_zero_with_mask_commute3(i4 %x, i4 %y) {
 ; CHECK-LABEL: @or_cmps_eq_zero_with_mask_commute3(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 %y, %x
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq i4 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_ZERO]]
 ;
@@ -54,7 +55,7 @@ define i1 @or_cmps_eq_zero_with_mask_commute3(i4 %x, i4 %y) {
 
 define <2 x i1> @or_cmps_eq_zero_with_mask_commute4(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @or_cmps_eq_zero_with_mask_commute4(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i4> %y, %x
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i4> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq <2 x i4> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[SOMEBITS_ARE_ZERO]]
 ;
@@ -69,7 +70,7 @@ define <2 x i1> @or_cmps_eq_zero_with_mask_commute4(<2 x i4> %x, <2 x i4> %y) {
 
 define <3 x i1> @and_cmps_eq_zero_with_mask_commute1(<3 x i4> %x, <3 x i4> %y) {
 ; CHECK-LABEL: @and_cmps_eq_zero_with_mask_commute1(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i4> %x, %y
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i4> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne <3 x i4> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <3 x i1> [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -84,7 +85,7 @@ define <3 x i1> @and_cmps_eq_zero_with_mask_commute1(<3 x i4> %x, <3 x i4> %y) {
 
 define i1 @and_cmps_eq_zero_with_mask_commute2(i4 %x, i4 %y) {
 ; CHECK-LABEL: @and_cmps_eq_zero_with_mask_commute2(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 %x, %y
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne i4 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -99,7 +100,7 @@ define i1 @and_cmps_eq_zero_with_mask_commute2(i4 %x, i4 %y) {
 
 define <3 x i1> @and_cmps_eq_zero_with_mask_commute3(<3 x i64> %x, <3 x i64> %y) {
 ; CHECK-LABEL: @and_cmps_eq_zero_with_mask_commute3(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i64> %y, %x
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i64> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne <3 x i64> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <3 x i1> [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -114,7 +115,7 @@ define <3 x i1> @and_cmps_eq_zero_with_mask_commute3(<3 x i64> %x, <3 x i64> %y)
 
 define i1 @and_cmps_eq_zero_with_mask_commute4(i64 %x, i64 %y) {
 ; CHECK-LABEL: @and_cmps_eq_zero_with_mask_commute4(
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 %y, %x
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne i64 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -129,8 +130,8 @@ define i1 @and_cmps_eq_zero_with_mask_commute4(i64 %x, i64 %y) {
 
 define i1 @or_cmps_ptr_eq_zero_with_mask_commute1(i64* %p, i64 %y) {
 ; CHECK-LABEL: @or_cmps_ptr_eq_zero_with_mask_commute1(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint i64* %p to i64
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 [[X]], %y
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint i64* [[P:%.*]] to i64
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 [[X]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq i64 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_ZERO]]
 ;
@@ -146,8 +147,8 @@ define i1 @or_cmps_ptr_eq_zero_with_mask_commute1(i64* %p, i64 %y) {
 
 define <2 x i1> @or_cmps_ptr_eq_zero_with_mask_commute2(<2 x i64*> %p, <2 x i64> %y) {
 ; CHECK-LABEL: @or_cmps_ptr_eq_zero_with_mask_commute2(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint <2 x i64*> %p to <2 x i64>
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i64> [[X]], %y
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint <2 x i64*> [[P:%.*]] to <2 x i64>
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i64> [[X]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq <2 x i64> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[SOMEBITS_ARE_ZERO]]
 ;
@@ -163,8 +164,8 @@ define <2 x i1> @or_cmps_ptr_eq_zero_with_mask_commute2(<2 x i64*> %p, <2 x i64>
 
 define i1 @or_cmps_ptr_eq_zero_with_mask_commute3(i4* %p, i4 %y) {
 ; CHECK-LABEL: @or_cmps_ptr_eq_zero_with_mask_commute3(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint i4* %p to i4
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 %y, [[X]]
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint i4* [[P:%.*]] to i4
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 [[Y:%.*]], [[X]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq i4 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_ZERO]]
 ;
@@ -180,8 +181,8 @@ define i1 @or_cmps_ptr_eq_zero_with_mask_commute3(i4* %p, i4 %y) {
 
 define <2 x i1> @or_cmps_ptr_eq_zero_with_mask_commute4(<2 x i4*> %p, <2 x i4> %y) {
 ; CHECK-LABEL: @or_cmps_ptr_eq_zero_with_mask_commute4(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint <2 x i4*> %p to <2 x i4>
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i4> %y, [[X]]
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint <2 x i4*> [[P:%.*]] to <2 x i4>
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <2 x i4> [[Y:%.*]], [[X]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_ZERO:%.*]] = icmp eq <2 x i4> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[SOMEBITS_ARE_ZERO]]
 ;
@@ -197,8 +198,8 @@ define <2 x i1> @or_cmps_ptr_eq_zero_with_mask_commute4(<2 x i4*> %p, <2 x i4> %
 
 define <3 x i1> @and_cmps_ptr_eq_zero_with_mask_commute1(<3 x i4*> %p, <3 x i4> %y) {
 ; CHECK-LABEL: @and_cmps_ptr_eq_zero_with_mask_commute1(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint <3 x i4*> %p to <3 x i4>
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i4> [[X]], %y
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint <3 x i4*> [[P:%.*]] to <3 x i4>
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i4> [[X]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne <3 x i4> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <3 x i1> [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -214,8 +215,8 @@ define <3 x i1> @and_cmps_ptr_eq_zero_with_mask_commute1(<3 x i4*> %p, <3 x i4>
 
 define i1 @and_cmps_ptr_eq_zero_with_mask_commute2(i4* %p, i4 %y) {
 ; CHECK-LABEL: @and_cmps_ptr_eq_zero_with_mask_commute2(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint i4* %p to i4
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 [[X]], %y
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint i4* [[P:%.*]] to i4
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i4 [[X]], [[Y:%.*]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne i4 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -231,8 +232,8 @@ define i1 @and_cmps_ptr_eq_zero_with_mask_commute2(i4* %p, i4 %y) {
 
 define <3 x i1> @and_cmps_ptr_eq_zero_with_mask_commute3(<3 x i64*> %p, <3 x i64> %y) {
 ; CHECK-LABEL: @and_cmps_ptr_eq_zero_with_mask_commute3(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint <3 x i64*> %p to <3 x i64>
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i64> %y, [[X]]
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint <3 x i64*> [[P:%.*]] to <3 x i64>
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and <3 x i64> [[Y:%.*]], [[X]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne <3 x i64> [[SOMEBITS]], zeroinitializer
 ; CHECK-NEXT:    ret <3 x i1> [[SOMEBITS_ARE_NOT_ZERO]]
 ;
@@ -248,8 +249,8 @@ define <3 x i1> @and_cmps_ptr_eq_zero_with_mask_commute3(<3 x i64*> %p, <3 x i64
 
 define i1 @and_cmps_ptr_eq_zero_with_mask_commute4(i64* %p, i64 %y) {
 ; CHECK-LABEL: @and_cmps_ptr_eq_zero_with_mask_commute4(
-; CHECK-NEXT:    [[X:%.*]] = ptrtoint i64* %p to i64
-; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 %y, [[X]]
+; CHECK-NEXT:    [[X:%.*]] = ptrtoint i64* [[P:%.*]] to i64
+; CHECK-NEXT:    [[SOMEBITS:%.*]] = and i64 [[Y:%.*]], [[X]]
 ; CHECK-NEXT:    [[SOMEBITS_ARE_NOT_ZERO:%.*]] = icmp ne i64 [[SOMEBITS]], 0
 ; CHECK-NEXT:    ret i1 [[SOMEBITS_ARE_NOT_ZERO]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/cast.ll b/llvm/test/Transforms/InstSimplify/cast.ll
index e5440c0..3e37c7f 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/cast.ll
+++ b/llvm/test/Transforms/InstSimplify/cast.ll
@@ -1,34 +1,43 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
 target datalayout = "p:32:32"
 
 define i1 @test1(i1 %V) {
+; CHECK-LABEL: @test1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 [[V:%.*]]
+;
 entry:
   %Z = zext i1 %V to i32
   %T = trunc i32 %Z to i1
   ret i1 %T
-; CHECK-LABEL: define i1 @test1(
-; CHECK: ret i1 %V
 }
 
 define i8* @test2(i8* %V) {
+; CHECK-LABEL: @test2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i8* [[V:%.*]]
+;
 entry:
   %BC1 = bitcast i8* %V to i32*
   %BC2 = bitcast i32* %BC1 to i8*
   ret i8* %BC2
-; CHECK-LABEL: define i8* @test2(
-; CHECK: ret i8* %V
 }
 
 define i8* @test3(i8* %V) {
+; CHECK-LABEL: @test3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i8* [[V:%.*]]
+;
 entry:
   %BC = bitcast i8* %V to i8*
   ret i8* %BC
-; CHECK-LABEL: define i8* @test3(
-; CHECK: ret i8* %V
 }
 
 define i32 @test4() {
 ; CHECK-LABEL: @test4(
+; CHECK-NEXT:    ret i32 4
+;
   %alloca = alloca i32, align 4                                     ; alloca + 0
   %gep = getelementptr inbounds i32, i32* %alloca, i32 1            ; alloca + 4
   %bc = bitcast i32* %gep to [4 x i8]*                              ; alloca + 4
@@ -37,11 +46,12 @@ define i32 @test4() {
   %add = getelementptr [4 x i8], [4 x i8]* %bc, i32 0, i32 %sub     ; alloca + 4 - alloca == 4
   %add_to_int = ptrtoint i8* %add to i32                            ; 4
   ret i32 %add_to_int                                               ; 4
-; CHECK-NEXT: ret i32 4
 }
 
 define i32 @test5() {
 ; CHECK-LABEL: @test5(
+; CHECK-NEXT:    ret i32 3
+;
   %alloca = alloca i32, align 4                                     ; alloca + 0
   %gep = getelementptr inbounds i32, i32* %alloca, i32 1            ; alloca + 4
   %bc = bitcast i32* %gep to [4 x i8]*                              ; alloca + 4
@@ -50,5 +60,4 @@ define i32 @test5() {
   %add = getelementptr [4 x i8], [4 x i8]* %bc, i32 0, i32 %sub     ; alloca + 4 - alloca - 1 == 3
   %add_to_int = ptrtoint i8* %add to i32                            ; 4
   ret i32 %add_to_int                                               ; 4
-; CHECK-NEXT: ret i32 3
 }

diff --git a/llvm/test/Transforms/InstSimplify/dead-code-removal.ll b/llvm/test/Transforms/InstSimplify/dead-code-removal.ll
index f383021..6358ddf 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/dead-code-removal.ll
+++ b/llvm/test/Transforms/InstSimplify/dead-code-removal.ll
@@ -1,11 +1,17 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
 
 define void @foo() nounwind {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:    br i1 undef, label [[TMP1:%.*]], label [[TMP2:%.*]]
+; CHECK:       1:
+; CHECK-NEXT:    br label [[TMP1]]
+; CHECK:       2:
+; CHECK-NEXT:    ret void
+;
   br i1 undef, label %1, label %4
 
 ; <label>:1                                       ; preds = %1, %0
-; CHECK-NOT: phi
-; CHECK-NOT: sub
   %2 = phi i32 [ %3, %1 ], [ undef, %0 ]
   %3 = sub i32 0, undef
   br label %1

diff --git a/llvm/test/Transforms/InstSimplify/exact-nsw-nuw.ll b/llvm/test/Transforms/InstSimplify/exact-nsw-nuw.ll
index dc8bd53..92f85ad 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/exact-nsw-nuw.ll
+++ b/llvm/test/Transforms/InstSimplify/exact-nsw-nuw.ll
@@ -1,10 +1,11 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 ; PR8862
 
 define i32 @shift1(i32 %A, i32 %B) {
 ; CHECK-LABEL: @shift1(
-; CHECK-NEXT:    ret i32 %A
+; CHECK-NEXT:    ret i32 [[A:%.*]]
 ;
   %C = lshr exact i32 %A, %B
   %D = shl nuw i32 %C, %B
@@ -13,8 +14,8 @@ define i32 @shift1(i32 %A, i32 %B) {
 
 define i32 @shift2(i32 %A, i32 %B) {
 ; CHECK-LABEL: @shift2(
-; CHECK-NEXT:    [[C:%.*]] = lshr i32 %A, %B
-; CHECK-NEXT:    [[D:%.*]] = shl nuw i32 [[C]], %B
+; CHECK-NEXT:    [[C:%.*]] = lshr i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[D:%.*]] = shl nuw i32 [[C]], [[B]]
 ; CHECK-NEXT:    ret i32 [[D]]
 ;
   %C = lshr i32 %A, %B
@@ -24,7 +25,7 @@ define i32 @shift2(i32 %A, i32 %B) {
 
 define i32 @shift3(i32 %A, i32 %B) {
 ; CHECK-LABEL: @shift3(
-; CHECK-NEXT:    ret i32 %A
+; CHECK-NEXT:    ret i32 [[A:%.*]]
 ;
   %C = ashr exact i32 %A, %B
   %D = shl nuw i32 %C, %B
@@ -33,7 +34,7 @@ define i32 @shift3(i32 %A, i32 %B) {
 
 define i32 @shift4(i32 %A, i32 %B) {
 ; CHECK-LABEL: @shift4(
-; CHECK-NEXT:    ret i32 %A
+; CHECK-NEXT:    ret i32 [[A:%.*]]
 ;
   %C = shl nuw i32 %A, %B
   %D = lshr i32 %C, %B
@@ -42,7 +43,7 @@ define i32 @shift4(i32 %A, i32 %B) {
 
 define i32 @shift5(i32 %A, i32 %B) {
 ; CHECK-LABEL: @shift5(
-; CHECK-NEXT:    ret i32 %A
+; CHECK-NEXT:    ret i32 [[A:%.*]]
 ;
   %C = shl nsw i32 %A, %B
   %D = ashr i32 %C, %B

diff --git a/llvm/test/Transforms/InstSimplify/fdiv.ll b/llvm/test/Transforms/InstSimplify/fdiv.ll
index 2905fe0..046a07c 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/fdiv.ll
+++ b/llvm/test/Transforms/InstSimplify/fdiv.ll
@@ -19,7 +19,7 @@ define float @frem_constant_fold() {
 
 define double @fmul_fdiv_common_operand(double %x, double %y) {
 ; CHECK-LABEL: @fmul_fdiv_common_operand(
-; CHECK-NEXT:    ret double %x
+; CHECK-NEXT:    ret double [[X:%.*]]
 ;
   %m = fmul double %x, %y
   %d = fdiv reassoc nnan double %m, %y
@@ -30,8 +30,8 @@ define double @fmul_fdiv_common_operand(double %x, double %y) {
 
 define double @fmul_fdiv_common_operand_too_strict(double %x, double %y) {
 ; CHECK-LABEL: @fmul_fdiv_common_operand_too_strict(
-; CHECK-NEXT:    [[M:%.*]] = fmul fast double %x, %y
-; CHECK-NEXT:    [[D:%.*]] = fdiv reassoc double [[M]], %y
+; CHECK-NEXT:    [[M:%.*]] = fmul fast double [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[D:%.*]] = fdiv reassoc double [[M]], [[Y]]
 ; CHECK-NEXT:    ret double [[D]]
 ;
   %m = fmul fast double %x, %y
@@ -43,7 +43,7 @@ define double @fmul_fdiv_common_operand_too_strict(double %x, double %y) {
 
 define <2 x float> @fmul_fdiv_common_operand_commute_vec(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @fmul_fdiv_common_operand_commute_vec(
-; CHECK-NEXT:    ret <2 x float> %x
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %m = fmul <2 x float> %y, %x
   %d = fdiv fast <2 x float> %m, %y

diff --git a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
index 7e7df8e..0e56be8 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
+++ b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 declare float @llvm.powi.f32.i16(float, i16) nounwind readonly
@@ -7,7 +8,7 @@ declare i32 @llvm.bswap.i32(i32)
 ; A
 define i32 @test_bswap(i32 %a) nounwind {
 ; CHECK-LABEL: @test_bswap(
-; CHECK-NEXT:    ret i32 %a
+; CHECK-NEXT:    ret i32 [[A:%.*]]
 ;
   %tmp2 = tail call i32 @llvm.bswap.i32( i32 %a )
   %tmp4 = tail call i32 @llvm.bswap.i32( i32 %tmp2 )
@@ -15,6 +16,11 @@ define i32 @test_bswap(i32 %a) nounwind {
 }
 
 define void @powi(double %V, double *%P) {
+; CHECK-LABEL: @powi(
+; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P:%.*]], align 8
+; CHECK-NEXT:    store volatile double [[V:%.*]], double* [[P]], align 8
+; CHECK-NEXT:    ret void
+;
   %B = tail call double @llvm.powi.f64.i32(double %V, i32 0) nounwind
   store volatile double %B, double* %P
 
@@ -22,12 +28,14 @@ define void @powi(double %V, double *%P) {
   store volatile double %C, double* %P
 
   ret void
-; CHECK-LABEL: @powi(
-; CHECK: store volatile double 1.0
-; CHECK: store volatile double %V
 }
 
 define void @powi_i16(float %V, float *%P) {
+; CHECK-LABEL: @powi_i16(
+; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P:%.*]], align 4
+; CHECK-NEXT:    store volatile float [[V:%.*]], float* [[P]], align 4
+; CHECK-NEXT:    ret void
+;
   %B = tail call float @llvm.powi.f32.i16(float %V, i16 0) nounwind
   store volatile float %B, float* %P
 
@@ -35,7 +43,4 @@ define void @powi_i16(float %V, float *%P) {
   store volatile float %C, float* %P
 
   ret void
-; CHECK-LABEL: @powi_i16(
-; CHECK: store volatile float 1.0
-; CHECK: store volatile float %V
 }

diff --git a/llvm/test/Transforms/InstSimplify/icmp-bool-constant.ll b/llvm/test/Transforms/InstSimplify/icmp-bool-constant.ll
index fd7e487..6205225 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/icmp-bool-constant.ll
+++ b/llvm/test/Transforms/InstSimplify/icmp-bool-constant.ll
@@ -6,7 +6,7 @@
 
 define <2 x i1> @eq_t(<2 x i1> %a) {
 ; CHECK-LABEL: @eq_t(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp eq <2 x i1> %a, <i1 true, i1 true>
   ret <2 x i1> %r
@@ -22,7 +22,7 @@ define <2 x i1> @eq_t_undef_elt(<2 x i1> %a) {
 
 define <2 x i1> @eq_f(<2 x i1> %a) {
 ; CHECK-LABEL: @eq_f(
-; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i1> %a, zeroinitializer
+; CHECK-NEXT:    [[R:%.*]] = icmp eq <2 x i1> [[A:%.*]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp eq <2 x i1> %a, <i1 false, i1 false>
@@ -31,7 +31,7 @@ define <2 x i1> @eq_f(<2 x i1> %a) {
 
 define <2 x i1> @ne_t(<2 x i1> %a) {
 ; CHECK-LABEL: @ne_t(
-; CHECK-NEXT:    [[R:%.*]] = icmp ne <2 x i1> %a, <i1 true, i1 true>
+; CHECK-NEXT:    [[R:%.*]] = icmp ne <2 x i1> [[A:%.*]], <i1 true, i1 true>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp ne <2 x i1> %a, <i1 true, i1 true>
@@ -40,7 +40,7 @@ define <2 x i1> @ne_t(<2 x i1> %a) {
 
 define <2 x i1> @ne_f(<2 x i1> %a) {
 ; CHECK-LABEL: @ne_f(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp ne <2 x i1> %a, <i1 false, i1 false>
   ret <2 x i1> %r
@@ -64,7 +64,7 @@ define <2 x i1> @ugt_t_undef_elt(<2 x i1> %a) {
 
 define <2 x i1> @ugt_f(<2 x i1> %a) {
 ; CHECK-LABEL: @ugt_f(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp ugt <2 x i1> %a, <i1 false, i1 false>
   ret <2 x i1> %r
@@ -72,7 +72,7 @@ define <2 x i1> @ugt_f(<2 x i1> %a) {
 
 define <2 x i1> @ult_t(<2 x i1> %a) {
 ; CHECK-LABEL: @ult_t(
-; CHECK-NEXT:    [[R:%.*]] = icmp ult <2 x i1> %a, <i1 true, i1 true>
+; CHECK-NEXT:    [[R:%.*]] = icmp ult <2 x i1> [[A:%.*]], <i1 true, i1 true>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp ult <2 x i1> %a, <i1 true, i1 true>
@@ -89,7 +89,7 @@ define <2 x i1> @ult_f(<2 x i1> %a) {
 
 define <2 x i1> @sgt_t(<2 x i1> %a) {
 ; CHECK-LABEL: @sgt_t(
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt <2 x i1> %a, <i1 true, i1 true>
+; CHECK-NEXT:    [[R:%.*]] = icmp sgt <2 x i1> [[A:%.*]], <i1 true, i1 true>
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp sgt <2 x i1> %a, <i1 true, i1 true>
@@ -114,7 +114,7 @@ define <2 x i1> @slt_t(<2 x i1> %a) {
 
 define <2 x i1> @slt_f(<2 x i1> %a) {
 ; CHECK-LABEL: @slt_f(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp slt <2 x i1> %a, <i1 false, i1 false>
   ret <2 x i1> %r
@@ -122,7 +122,7 @@ define <2 x i1> @slt_f(<2 x i1> %a) {
 
 define <2 x i1> @uge_t(<2 x i1> %a) {
 ; CHECK-LABEL: @uge_t(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp uge <2 x i1> %a, <i1 true, i1 true>
   ret <2 x i1> %r
@@ -146,7 +146,7 @@ define <2 x i1> @ule_t(<2 x i1> %a) {
 
 define <2 x i1> @ule_f(<2 x i1> %a) {
 ; CHECK-LABEL: @ule_f(
-; CHECK-NEXT:    [[R:%.*]] = icmp ule <2 x i1> %a, zeroinitializer
+; CHECK-NEXT:    [[R:%.*]] = icmp ule <2 x i1> [[A:%.*]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp ule <2 x i1> %a, <i1 false, i1 false>
@@ -171,7 +171,7 @@ define <2 x i1> @sge_t_undef_elt(<2 x i1> %a) {
 
 define <2 x i1> @sge_f(<2 x i1> %a) {
 ; CHECK-LABEL: @sge_f(
-; CHECK-NEXT:    [[R:%.*]] = icmp sge <2 x i1> %a, zeroinitializer
+; CHECK-NEXT:    [[R:%.*]] = icmp sge <2 x i1> [[A:%.*]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %r = icmp sge <2 x i1> %a, <i1 false, i1 false>
@@ -180,7 +180,7 @@ define <2 x i1> @sge_f(<2 x i1> %a) {
 
 define <2 x i1> @sle_t(<2 x i1> %a) {
 ; CHECK-LABEL: @sle_t(
-; CHECK-NEXT:    ret <2 x i1> %a
+; CHECK-NEXT:    ret <2 x i1> [[A:%.*]]
 ;
   %r = icmp sle <2 x i1> %a, <i1 true, i1 true>
   ret <2 x i1> %r

diff --git a/llvm/test/Transforms/InstSimplify/icmp-ranges.ll b/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
index 3c1b364..7063728 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
+++ b/llvm/test/Transforms/InstSimplify/icmp-ranges.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 ; Cycle through all pairs of predicates to test
@@ -20,7 +21,7 @@ define i1 @and_eq_eq(i8 %x) {
 
 define i1 @and_eq_ne(i8 %x) {
 ; CHECK-LABEL: @and_eq_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
@@ -57,7 +58,7 @@ define i1 @and_eq_sgt(i8 %x) {
 
 define i1 @and_eq_sle(i8 %x) {
 ; CHECK-LABEL: @and_eq_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
@@ -70,7 +71,7 @@ define i1 @and_eq_sle(i8 %x) {
 
 define i1 @and_eq_slt(i8 %x) {
 ; CHECK-LABEL: @and_eq_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
@@ -107,7 +108,7 @@ define i1 @and_eq_ugt(i8 %x) {
 
 define i1 @and_eq_ule(i8 %x) {
 ; CHECK-LABEL: @and_eq_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
@@ -120,7 +121,7 @@ define i1 @and_eq_ule(i8 %x) {
 
 define i1 @and_eq_ult(i8 %x) {
 ; CHECK-LABEL: @and_eq_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 13
@@ -134,7 +135,7 @@ define i1 @and_eq_ult(i8 %x) {
 
 define i1 @and_ne_eq(i8 %x) {
 ; CHECK-LABEL: @and_ne_eq(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
@@ -147,8 +148,8 @@ define i1 @and_ne_eq(i8 %x) {
 
 define i1 @and_ne_ne(i8 %x) {
 ; CHECK-LABEL: @and_ne_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -162,7 +163,7 @@ define i1 @and_ne_ne(i8 %x) {
 
 define i1 @and_ne_sge(i8 %x) {
 ; CHECK-LABEL: @and_ne_sge(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
@@ -175,7 +176,7 @@ define i1 @and_ne_sge(i8 %x) {
 
 define i1 @and_ne_sgt(i8 %x) {
 ; CHECK-LABEL: @and_ne_sgt(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
@@ -188,8 +189,8 @@ define i1 @and_ne_sgt(i8 %x) {
 
 define i1 @and_ne_sle(i8 %x) {
 ; CHECK-LABEL: @and_ne_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -203,8 +204,8 @@ define i1 @and_ne_sle(i8 %x) {
 
 define i1 @and_ne_slt(i8 %x) {
 ; CHECK-LABEL: @and_ne_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -218,7 +219,7 @@ define i1 @and_ne_slt(i8 %x) {
 
 define i1 @and_ne_uge(i8 %x) {
 ; CHECK-LABEL: @and_ne_uge(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
@@ -231,7 +232,7 @@ define i1 @and_ne_uge(i8 %x) {
 
 define i1 @and_ne_ugt(i8 %x) {
 ; CHECK-LABEL: @and_ne_ugt(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 13
@@ -244,8 +245,8 @@ define i1 @and_ne_ugt(i8 %x) {
 
 define i1 @and_ne_ule(i8 %x) {
 ; CHECK-LABEL: @and_ne_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -259,8 +260,8 @@ define i1 @and_ne_ule(i8 %x) {
 
 define i1 @and_ne_ult(i8 %x) {
 ; CHECK-LABEL: @and_ne_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -275,7 +276,7 @@ define i1 @and_ne_ult(i8 %x) {
 
 define i1 @and_sge_eq(i8 %x) {
 ; CHECK-LABEL: @and_sge_eq(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
@@ -288,8 +289,8 @@ define i1 @and_sge_eq(i8 %x) {
 
 define i1 @and_sge_ne(i8 %x) {
 ; CHECK-LABEL: @and_sge_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -303,7 +304,7 @@ define i1 @and_sge_ne(i8 %x) {
 
 define i1 @and_sge_sge(i8 %x) {
 ; CHECK-LABEL: @and_sge_sge(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
@@ -316,7 +317,7 @@ define i1 @and_sge_sge(i8 %x) {
 
 define i1 @and_sge_sgt(i8 %x) {
 ; CHECK-LABEL: @and_sge_sgt(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 13
@@ -329,8 +330,8 @@ define i1 @and_sge_sgt(i8 %x) {
 
 define i1 @and_sge_sle(i8 %x) {
 ; CHECK-LABEL: @and_sge_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -344,8 +345,8 @@ define i1 @and_sge_sle(i8 %x) {
 
 define i1 @and_sge_slt(i8 %x) {
 ; CHECK-LABEL: @and_sge_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -359,8 +360,8 @@ define i1 @and_sge_slt(i8 %x) {
 
 define i1 @and_sge_uge(i8 %x) {
 ; CHECK-LABEL: @and_sge_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -374,8 +375,8 @@ define i1 @and_sge_uge(i8 %x) {
 
 define i1 @and_sge_ugt(i8 %x) {
 ; CHECK-LABEL: @and_sge_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -389,8 +390,8 @@ define i1 @and_sge_ugt(i8 %x) {
 
 define i1 @and_sge_ule(i8 %x) {
 ; CHECK-LABEL: @and_sge_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -404,8 +405,8 @@ define i1 @and_sge_ule(i8 %x) {
 
 define i1 @and_sge_ult(i8 %x) {
 ; CHECK-LABEL: @and_sge_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -420,7 +421,7 @@ define i1 @and_sge_ult(i8 %x) {
 
 define i1 @and_sgt_eq(i8 %x) {
 ; CHECK-LABEL: @and_sgt_eq(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -433,8 +434,8 @@ define i1 @and_sgt_eq(i8 %x) {
 
 define i1 @and_sgt_ne(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -448,7 +449,7 @@ define i1 @and_sgt_ne(i8 %x) {
 
 define i1 @and_sgt_sge(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sge(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -461,7 +462,7 @@ define i1 @and_sgt_sge(i8 %x) {
 
 define i1 @and_sgt_sgt(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sgt(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -474,8 +475,8 @@ define i1 @and_sgt_sgt(i8 %x) {
 
 define i1 @and_sgt_sle(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -489,8 +490,8 @@ define i1 @and_sgt_sle(i8 %x) {
 
 define i1 @and_sgt_slt(i8 %x) {
 ; CHECK-LABEL: @and_sgt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -504,8 +505,8 @@ define i1 @and_sgt_slt(i8 %x) {
 
 define i1 @and_sgt_uge(i8 %x) {
 ; CHECK-LABEL: @and_sgt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -519,8 +520,8 @@ define i1 @and_sgt_uge(i8 %x) {
 
 define i1 @and_sgt_ugt(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -534,8 +535,8 @@ define i1 @and_sgt_ugt(i8 %x) {
 
 define i1 @and_sgt_ule(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -549,8 +550,8 @@ define i1 @and_sgt_ule(i8 %x) {
 
 define i1 @and_sgt_ult(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -577,7 +578,7 @@ define i1 @and_sle_eq(i8 %x) {
 
 define i1 @and_sle_ne(i8 %x) {
 ; CHECK-LABEL: @and_sle_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
@@ -614,7 +615,7 @@ define i1 @and_sle_sgt(i8 %x) {
 
 define i1 @and_sle_sle(i8 %x) {
 ; CHECK-LABEL: @and_sle_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
@@ -627,7 +628,7 @@ define i1 @and_sle_sle(i8 %x) {
 
 define i1 @and_sle_slt(i8 %x) {
 ; CHECK-LABEL: @and_sle_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 13
@@ -640,8 +641,8 @@ define i1 @and_sle_slt(i8 %x) {
 
 define i1 @and_sle_uge(i8 %x) {
 ; CHECK-LABEL: @and_sle_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -655,8 +656,8 @@ define i1 @and_sle_uge(i8 %x) {
 
 define i1 @and_sle_ugt(i8 %x) {
 ; CHECK-LABEL: @and_sle_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -670,8 +671,8 @@ define i1 @and_sle_ugt(i8 %x) {
 
 define i1 @and_sle_ule(i8 %x) {
 ; CHECK-LABEL: @and_sle_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -685,8 +686,8 @@ define i1 @and_sle_ule(i8 %x) {
 
 define i1 @and_sle_ult(i8 %x) {
 ; CHECK-LABEL: @and_sle_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -713,7 +714,7 @@ define i1 @and_slt_eq(i8 %x) {
 
 define i1 @and_slt_ne(i8 %x) {
 ; CHECK-LABEL: @and_slt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
@@ -750,7 +751,7 @@ define i1 @and_slt_sgt(i8 %x) {
 
 define i1 @and_slt_sle(i8 %x) {
 ; CHECK-LABEL: @and_slt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
@@ -763,7 +764,7 @@ define i1 @and_slt_sle(i8 %x) {
 
 define i1 @and_slt_slt(i8 %x) {
 ; CHECK-LABEL: @and_slt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 13
@@ -776,8 +777,8 @@ define i1 @and_slt_slt(i8 %x) {
 
 define i1 @and_slt_uge(i8 %x) {
 ; CHECK-LABEL: @and_slt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -791,8 +792,8 @@ define i1 @and_slt_uge(i8 %x) {
 
 define i1 @and_slt_ugt(i8 %x) {
 ; CHECK-LABEL: @and_slt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -806,8 +807,8 @@ define i1 @and_slt_ugt(i8 %x) {
 
 define i1 @and_slt_ule(i8 %x) {
 ; CHECK-LABEL: @and_slt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -821,8 +822,8 @@ define i1 @and_slt_ule(i8 %x) {
 
 define i1 @and_slt_ult(i8 %x) {
 ; CHECK-LABEL: @and_slt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -837,7 +838,7 @@ define i1 @and_slt_ult(i8 %x) {
 
 define i1 @and_uge_eq(i8 %x) {
 ; CHECK-LABEL: @and_uge_eq(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
@@ -850,8 +851,8 @@ define i1 @and_uge_eq(i8 %x) {
 
 define i1 @and_uge_ne(i8 %x) {
 ; CHECK-LABEL: @and_uge_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -865,7 +866,7 @@ define i1 @and_uge_ne(i8 %x) {
 
 define i1 @and_uge_sge(i8 %x) {
 ; CHECK-LABEL: @and_uge_sge(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
@@ -878,7 +879,7 @@ define i1 @and_uge_sge(i8 %x) {
 
 define i1 @and_uge_sgt(i8 %x) {
 ; CHECK-LABEL: @and_uge_sgt(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
@@ -891,8 +892,8 @@ define i1 @and_uge_sgt(i8 %x) {
 
 define i1 @and_uge_sle(i8 %x) {
 ; CHECK-LABEL: @and_uge_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -906,8 +907,8 @@ define i1 @and_uge_sle(i8 %x) {
 
 define i1 @and_uge_slt(i8 %x) {
 ; CHECK-LABEL: @and_uge_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -921,7 +922,7 @@ define i1 @and_uge_slt(i8 %x) {
 
 define i1 @and_uge_uge(i8 %x) {
 ; CHECK-LABEL: @and_uge_uge(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
@@ -934,7 +935,7 @@ define i1 @and_uge_uge(i8 %x) {
 
 define i1 @and_uge_ugt(i8 %x) {
 ; CHECK-LABEL: @and_uge_ugt(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 13
@@ -947,8 +948,8 @@ define i1 @and_uge_ugt(i8 %x) {
 
 define i1 @and_uge_ule(i8 %x) {
 ; CHECK-LABEL: @and_uge_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -962,8 +963,8 @@ define i1 @and_uge_ule(i8 %x) {
 
 define i1 @and_uge_ult(i8 %x) {
 ; CHECK-LABEL: @and_uge_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -978,7 +979,7 @@ define i1 @and_uge_ult(i8 %x) {
 
 define i1 @and_ugt_eq(i8 %x) {
 ; CHECK-LABEL: @and_ugt_eq(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -991,8 +992,8 @@ define i1 @and_ugt_eq(i8 %x) {
 
 define i1 @and_ugt_ne(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1006,7 +1007,7 @@ define i1 @and_ugt_ne(i8 %x) {
 
 define i1 @and_ugt_sge(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sge(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -1019,7 +1020,7 @@ define i1 @and_ugt_sge(i8 %x) {
 
 define i1 @and_ugt_sgt(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sgt(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -1032,8 +1033,8 @@ define i1 @and_ugt_sgt(i8 %x) {
 
 define i1 @and_ugt_sle(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1047,8 +1048,8 @@ define i1 @and_ugt_sle(i8 %x) {
 
 define i1 @and_ugt_slt(i8 %x) {
 ; CHECK-LABEL: @and_ugt_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1062,7 +1063,7 @@ define i1 @and_ugt_slt(i8 %x) {
 
 define i1 @and_ugt_uge(i8 %x) {
 ; CHECK-LABEL: @and_ugt_uge(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -1075,7 +1076,7 @@ define i1 @and_ugt_uge(i8 %x) {
 
 define i1 @and_ugt_ugt(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ugt(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -1088,8 +1089,8 @@ define i1 @and_ugt_ugt(i8 %x) {
 
 define i1 @and_ugt_ule(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1103,8 +1104,8 @@ define i1 @and_ugt_ule(i8 %x) {
 
 define i1 @and_ugt_ult(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1131,7 +1132,7 @@ define i1 @and_ule_eq(i8 %x) {
 
 define i1 @and_ule_ne(i8 %x) {
 ; CHECK-LABEL: @and_ule_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
@@ -1168,7 +1169,7 @@ define i1 @and_ule_sgt(i8 %x) {
 
 define i1 @and_ule_sle(i8 %x) {
 ; CHECK-LABEL: @and_ule_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
@@ -1181,7 +1182,7 @@ define i1 @and_ule_sle(i8 %x) {
 
 define i1 @and_ule_slt(i8 %x) {
 ; CHECK-LABEL: @and_ule_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
@@ -1218,7 +1219,7 @@ define i1 @and_ule_ugt(i8 %x) {
 
 define i1 @and_ule_ule(i8 %x) {
 ; CHECK-LABEL: @and_ule_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
@@ -1231,7 +1232,7 @@ define i1 @and_ule_ule(i8 %x) {
 
 define i1 @and_ule_ult(i8 %x) {
 ; CHECK-LABEL: @and_ule_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 13
@@ -1257,7 +1258,7 @@ define i1 @and_ult_eq(i8 %x) {
 
 define i1 @and_ult_ne(i8 %x) {
 ; CHECK-LABEL: @and_ult_ne(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
@@ -1294,7 +1295,7 @@ define i1 @and_ult_sgt(i8 %x) {
 
 define i1 @and_ult_sle(i8 %x) {
 ; CHECK-LABEL: @and_ult_sle(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
@@ -1307,7 +1308,7 @@ define i1 @and_ult_sle(i8 %x) {
 
 define i1 @and_ult_slt(i8 %x) {
 ; CHECK-LABEL: @and_ult_slt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
@@ -1344,7 +1345,7 @@ define i1 @and_ult_ugt(i8 %x) {
 
 define i1 @and_ult_ule(i8 %x) {
 ; CHECK-LABEL: @and_ult_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
@@ -1357,7 +1358,7 @@ define i1 @and_ult_ule(i8 %x) {
 
 define i1 @and_ult_ult(i8 %x) {
 ; CHECK-LABEL: @and_ult_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 13
@@ -1383,7 +1384,7 @@ define i1 @and_eq_eq_swap(i8 %x) {
 
 define i1 @and_eq_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
@@ -1396,7 +1397,7 @@ define i1 @and_eq_ne_swap(i8 %x) {
 
 define i1 @and_eq_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
@@ -1409,7 +1410,7 @@ define i1 @and_eq_sge_swap(i8 %x) {
 
 define i1 @and_eq_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
@@ -1446,7 +1447,7 @@ define i1 @and_eq_slt_swap(i8 %x) {
 
 define i1 @and_eq_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
@@ -1459,7 +1460,7 @@ define i1 @and_eq_uge_swap(i8 %x) {
 
 define i1 @and_eq_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_eq_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp eq i8 %x, 23
@@ -1497,7 +1498,7 @@ define i1 @and_eq_ult_swap(i8 %x) {
 
 define i1 @and_ne_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_eq_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
@@ -1510,8 +1511,8 @@ define i1 @and_ne_eq_swap(i8 %x) {
 
 define i1 @and_ne_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1525,8 +1526,8 @@ define i1 @and_ne_ne_swap(i8 %x) {
 
 define i1 @and_ne_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1540,8 +1541,8 @@ define i1 @and_ne_sge_swap(i8 %x) {
 
 define i1 @and_ne_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1555,7 +1556,7 @@ define i1 @and_ne_sgt_swap(i8 %x) {
 
 define i1 @and_ne_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_sle_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
@@ -1568,7 +1569,7 @@ define i1 @and_ne_sle_swap(i8 %x) {
 
 define i1 @and_ne_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_slt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
@@ -1581,8 +1582,8 @@ define i1 @and_ne_slt_swap(i8 %x) {
 
 define i1 @and_ne_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1596,8 +1597,8 @@ define i1 @and_ne_uge_swap(i8 %x) {
 
 define i1 @and_ne_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1611,7 +1612,7 @@ define i1 @and_ne_ugt_swap(i8 %x) {
 
 define i1 @and_ne_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ule_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
@@ -1624,7 +1625,7 @@ define i1 @and_ne_ule_swap(i8 %x) {
 
 define i1 @and_ne_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ne_ult_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ne i8 %x, 23
@@ -1650,7 +1651,7 @@ define i1 @and_sge_eq_swap(i8 %x) {
 
 define i1 @and_sge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
@@ -1663,7 +1664,7 @@ define i1 @and_sge_ne_swap(i8 %x) {
 
 define i1 @and_sge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
@@ -1676,7 +1677,7 @@ define i1 @and_sge_sge_swap(i8 %x) {
 
 define i1 @and_sge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
@@ -1713,7 +1714,7 @@ define i1 @and_sge_slt_swap(i8 %x) {
 
 define i1 @and_sge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
@@ -1726,7 +1727,7 @@ define i1 @and_sge_uge_swap(i8 %x) {
 
 define i1 @and_sge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sge_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 23
@@ -1776,7 +1777,7 @@ define i1 @and_sgt_eq_swap(i8 %x) {
 
 define i1 @and_sgt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -1789,7 +1790,7 @@ define i1 @and_sgt_ne_swap(i8 %x) {
 
 define i1 @and_sgt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -1802,7 +1803,7 @@ define i1 @and_sgt_sge_swap(i8 %x) {
 
 define i1 @and_sgt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -1839,7 +1840,7 @@ define i1 @and_sgt_slt_swap(i8 %x) {
 
 define i1 @and_sgt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -1852,7 +1853,7 @@ define i1 @and_sgt_uge_swap(i8 %x) {
 
 define i1 @and_sgt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sgt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -1890,7 +1891,7 @@ define i1 @and_sgt_ult_swap(i8 %x) {
 
 define i1 @and_sle_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_eq_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
@@ -1903,8 +1904,8 @@ define i1 @and_sle_eq_swap(i8 %x) {
 
 define i1 @and_sle_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1918,8 +1919,8 @@ define i1 @and_sle_ne_swap(i8 %x) {
 
 define i1 @and_sle_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1933,8 +1934,8 @@ define i1 @and_sle_sge_swap(i8 %x) {
 
 define i1 @and_sle_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1948,7 +1949,7 @@ define i1 @and_sle_sgt_swap(i8 %x) {
 
 define i1 @and_sle_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_sle_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
@@ -1961,7 +1962,7 @@ define i1 @and_sle_sle_swap(i8 %x) {
 
 define i1 @and_sle_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_slt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
@@ -1974,8 +1975,8 @@ define i1 @and_sle_slt_swap(i8 %x) {
 
 define i1 @and_sle_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -1989,8 +1990,8 @@ define i1 @and_sle_uge_swap(i8 %x) {
 
 define i1 @and_sle_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2004,7 +2005,7 @@ define i1 @and_sle_ugt_swap(i8 %x) {
 
 define i1 @and_sle_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ule_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
@@ -2017,7 +2018,7 @@ define i1 @and_sle_ule_swap(i8 %x) {
 
 define i1 @and_sle_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_sle_ult_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 23
@@ -2031,7 +2032,7 @@ define i1 @and_sle_ult_swap(i8 %x) {
 
 define i1 @and_slt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_eq_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
@@ -2044,8 +2045,8 @@ define i1 @and_slt_eq_swap(i8 %x) {
 
 define i1 @and_slt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2059,8 +2060,8 @@ define i1 @and_slt_ne_swap(i8 %x) {
 
 define i1 @and_slt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2074,8 +2075,8 @@ define i1 @and_slt_sge_swap(i8 %x) {
 
 define i1 @and_slt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2089,7 +2090,7 @@ define i1 @and_slt_sgt_swap(i8 %x) {
 
 define i1 @and_slt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_sle_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
@@ -2102,7 +2103,7 @@ define i1 @and_slt_sle_swap(i8 %x) {
 
 define i1 @and_slt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_slt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
@@ -2115,8 +2116,8 @@ define i1 @and_slt_slt_swap(i8 %x) {
 
 define i1 @and_slt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2130,8 +2131,8 @@ define i1 @and_slt_uge_swap(i8 %x) {
 
 define i1 @and_slt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2145,7 +2146,7 @@ define i1 @and_slt_ugt_swap(i8 %x) {
 
 define i1 @and_slt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ule_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
@@ -2158,7 +2159,7 @@ define i1 @and_slt_ule_swap(i8 %x) {
 
 define i1 @and_slt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_slt_ult_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 23
@@ -2184,7 +2185,7 @@ define i1 @and_uge_eq_swap(i8 %x) {
 
 define i1 @and_uge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
@@ -2197,8 +2198,8 @@ define i1 @and_uge_ne_swap(i8 %x) {
 
 define i1 @and_uge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2212,8 +2213,8 @@ define i1 @and_uge_sge_swap(i8 %x) {
 
 define i1 @and_uge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2227,8 +2228,8 @@ define i1 @and_uge_sgt_swap(i8 %x) {
 
 define i1 @and_uge_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2242,8 +2243,8 @@ define i1 @and_uge_sle_swap(i8 %x) {
 
 define i1 @and_uge_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2257,7 +2258,7 @@ define i1 @and_uge_slt_swap(i8 %x) {
 
 define i1 @and_uge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
@@ -2270,7 +2271,7 @@ define i1 @and_uge_uge_swap(i8 %x) {
 
 define i1 @and_uge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_uge_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 23
@@ -2320,7 +2321,7 @@ define i1 @and_ugt_eq_swap(i8 %x) {
 
 define i1 @and_ugt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -2333,8 +2334,8 @@ define i1 @and_ugt_ne_swap(i8 %x) {
 
 define i1 @and_ugt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2348,8 +2349,8 @@ define i1 @and_ugt_sge_swap(i8 %x) {
 
 define i1 @and_ugt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2363,8 +2364,8 @@ define i1 @and_ugt_sgt_swap(i8 %x) {
 
 define i1 @and_ugt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2378,8 +2379,8 @@ define i1 @and_ugt_sle_swap(i8 %x) {
 
 define i1 @and_ugt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2393,7 +2394,7 @@ define i1 @and_ugt_slt_swap(i8 %x) {
 
 define i1 @and_ugt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -2406,7 +2407,7 @@ define i1 @and_ugt_uge_swap(i8 %x) {
 
 define i1 @and_ugt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ugt_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -2444,7 +2445,7 @@ define i1 @and_ugt_ult_swap(i8 %x) {
 
 define i1 @and_ule_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_eq_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
@@ -2457,8 +2458,8 @@ define i1 @and_ule_eq_swap(i8 %x) {
 
 define i1 @and_ule_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2472,8 +2473,8 @@ define i1 @and_ule_ne_swap(i8 %x) {
 
 define i1 @and_ule_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2487,8 +2488,8 @@ define i1 @and_ule_sge_swap(i8 %x) {
 
 define i1 @and_ule_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2502,8 +2503,8 @@ define i1 @and_ule_sgt_swap(i8 %x) {
 
 define i1 @and_ule_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2517,8 +2518,8 @@ define i1 @and_ule_sle_swap(i8 %x) {
 
 define i1 @and_ule_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2532,8 +2533,8 @@ define i1 @and_ule_slt_swap(i8 %x) {
 
 define i1 @and_ule_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2547,8 +2548,8 @@ define i1 @and_ule_uge_swap(i8 %x) {
 
 define i1 @and_ule_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2562,7 +2563,7 @@ define i1 @and_ule_ugt_swap(i8 %x) {
 
 define i1 @and_ule_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ule_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
@@ -2575,7 +2576,7 @@ define i1 @and_ule_ule_swap(i8 %x) {
 
 define i1 @and_ule_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ule_ult_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 23
@@ -2589,7 +2590,7 @@ define i1 @and_ule_ult_swap(i8 %x) {
 
 define i1 @and_ult_eq_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_eq_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
@@ -2602,8 +2603,8 @@ define i1 @and_ult_eq_swap(i8 %x) {
 
 define i1 @and_ult_ne_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ne_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2617,8 +2618,8 @@ define i1 @and_ult_ne_swap(i8 %x) {
 
 define i1 @and_ult_sge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2632,8 +2633,8 @@ define i1 @and_ult_sge_swap(i8 %x) {
 
 define i1 @and_ult_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2647,8 +2648,8 @@ define i1 @and_ult_sgt_swap(i8 %x) {
 
 define i1 @and_ult_sle_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2662,8 +2663,8 @@ define i1 @and_ult_sle_swap(i8 %x) {
 
 define i1 @and_ult_slt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2677,8 +2678,8 @@ define i1 @and_ult_slt_swap(i8 %x) {
 
 define i1 @and_ult_uge_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_uge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2692,8 +2693,8 @@ define i1 @and_ult_uge_swap(i8 %x) {
 
 define i1 @and_ult_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ugt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = and i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2707,7 +2708,7 @@ define i1 @and_ult_ugt_swap(i8 %x) {
 
 define i1 @and_ult_ule_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ule_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
@@ -2720,7 +2721,7 @@ define i1 @and_ult_ule_swap(i8 %x) {
 
 define i1 @and_ult_ult_swap(i8 %x) {
 ; CHECK-LABEL: @and_ult_ult_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 23
@@ -2734,8 +2735,8 @@ define i1 @and_ult_ult_swap(i8 %x) {
 
 define i1 @or_eq_eq(i8 %x) {
 ; CHECK-LABEL: @or_eq_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2749,7 +2750,7 @@ define i1 @or_eq_eq(i8 %x) {
 
 define i1 @or_eq_ne(i8 %x) {
 ; CHECK-LABEL: @or_eq_ne(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
@@ -2762,8 +2763,8 @@ define i1 @or_eq_ne(i8 %x) {
 
 define i1 @or_eq_sge(i8 %x) {
 ; CHECK-LABEL: @or_eq_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2777,8 +2778,8 @@ define i1 @or_eq_sge(i8 %x) {
 
 define i1 @or_eq_sgt(i8 %x) {
 ; CHECK-LABEL: @or_eq_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2792,7 +2793,7 @@ define i1 @or_eq_sgt(i8 %x) {
 
 define i1 @or_eq_sle(i8 %x) {
 ; CHECK-LABEL: @or_eq_sle(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
@@ -2805,7 +2806,7 @@ define i1 @or_eq_sle(i8 %x) {
 
 define i1 @or_eq_slt(i8 %x) {
 ; CHECK-LABEL: @or_eq_slt(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
@@ -2818,8 +2819,8 @@ define i1 @or_eq_slt(i8 %x) {
 
 define i1 @or_eq_uge(i8 %x) {
 ; CHECK-LABEL: @or_eq_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2833,8 +2834,8 @@ define i1 @or_eq_uge(i8 %x) {
 
 define i1 @or_eq_ugt(i8 %x) {
 ; CHECK-LABEL: @or_eq_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -2848,7 +2849,7 @@ define i1 @or_eq_ugt(i8 %x) {
 
 define i1 @or_eq_ule(i8 %x) {
 ; CHECK-LABEL: @or_eq_ule(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
@@ -2861,7 +2862,7 @@ define i1 @or_eq_ule(i8 %x) {
 
 define i1 @or_eq_ult(i8 %x) {
 ; CHECK-LABEL: @or_eq_ult(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 13
@@ -2875,7 +2876,7 @@ define i1 @or_eq_ult(i8 %x) {
 
 define i1 @or_ne_eq(i8 %x) {
 ; CHECK-LABEL: @or_ne_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
@@ -2900,7 +2901,7 @@ define i1 @or_ne_ne(i8 %x) {
 
 define i1 @or_ne_sge(i8 %x) {
 ; CHECK-LABEL: @or_ne_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
@@ -2913,7 +2914,7 @@ define i1 @or_ne_sge(i8 %x) {
 
 define i1 @or_ne_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ne_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
@@ -2950,7 +2951,7 @@ define i1 @or_ne_slt(i8 %x) {
 
 define i1 @or_ne_uge(i8 %x) {
 ; CHECK-LABEL: @or_ne_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
@@ -2963,7 +2964,7 @@ define i1 @or_ne_uge(i8 %x) {
 
 define i1 @or_ne_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ne_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 13
@@ -3001,7 +3002,7 @@ define i1 @or_ne_ult(i8 %x) {
 
 define i1 @or_sge_eq(i8 %x) {
 ; CHECK-LABEL: @or_sge_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
@@ -3026,7 +3027,7 @@ define i1 @or_sge_ne(i8 %x) {
 
 define i1 @or_sge_sge(i8 %x) {
 ; CHECK-LABEL: @or_sge_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
@@ -3039,7 +3040,7 @@ define i1 @or_sge_sge(i8 %x) {
 
 define i1 @or_sge_sgt(i8 %x) {
 ; CHECK-LABEL: @or_sge_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sge i8 %x, 13
@@ -3076,8 +3077,8 @@ define i1 @or_sge_slt(i8 %x) {
 
 define i1 @or_sge_uge(i8 %x) {
 ; CHECK-LABEL: @or_sge_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3091,8 +3092,8 @@ define i1 @or_sge_uge(i8 %x) {
 
 define i1 @or_sge_ugt(i8 %x) {
 ; CHECK-LABEL: @or_sge_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3106,8 +3107,8 @@ define i1 @or_sge_ugt(i8 %x) {
 
 define i1 @or_sge_ule(i8 %x) {
 ; CHECK-LABEL: @or_sge_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3121,8 +3122,8 @@ define i1 @or_sge_ule(i8 %x) {
 
 define i1 @or_sge_ult(i8 %x) {
 ; CHECK-LABEL: @or_sge_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3137,7 +3138,7 @@ define i1 @or_sge_ult(i8 %x) {
 
 define i1 @or_sgt_eq(i8 %x) {
 ; CHECK-LABEL: @or_sgt_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -3162,7 +3163,7 @@ define i1 @or_sgt_ne(i8 %x) {
 
 define i1 @or_sgt_sge(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -3175,7 +3176,7 @@ define i1 @or_sgt_sge(i8 %x) {
 
 define i1 @or_sgt_sgt(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sgt i8 %x, 13
@@ -3212,8 +3213,8 @@ define i1 @or_sgt_slt(i8 %x) {
 
 define i1 @or_sgt_uge(i8 %x) {
 ; CHECK-LABEL: @or_sgt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3227,8 +3228,8 @@ define i1 @or_sgt_uge(i8 %x) {
 
 define i1 @or_sgt_ugt(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3242,8 +3243,8 @@ define i1 @or_sgt_ugt(i8 %x) {
 
 define i1 @or_sgt_ule(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3257,8 +3258,8 @@ define i1 @or_sgt_ule(i8 %x) {
 
 define i1 @or_sgt_ult(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3273,8 +3274,8 @@ define i1 @or_sgt_ult(i8 %x) {
 
 define i1 @or_sle_eq(i8 %x) {
 ; CHECK-LABEL: @or_sle_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3288,7 +3289,7 @@ define i1 @or_sle_eq(i8 %x) {
 
 define i1 @or_sle_ne(i8 %x) {
 ; CHECK-LABEL: @or_sle_ne(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
@@ -3301,8 +3302,8 @@ define i1 @or_sle_ne(i8 %x) {
 
 define i1 @or_sle_sge(i8 %x) {
 ; CHECK-LABEL: @or_sle_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3316,8 +3317,8 @@ define i1 @or_sle_sge(i8 %x) {
 
 define i1 @or_sle_sgt(i8 %x) {
 ; CHECK-LABEL: @or_sle_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3331,7 +3332,7 @@ define i1 @or_sle_sgt(i8 %x) {
 
 define i1 @or_sle_sle(i8 %x) {
 ; CHECK-LABEL: @or_sle_sle(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
@@ -3344,7 +3345,7 @@ define i1 @or_sle_sle(i8 %x) {
 
 define i1 @or_sle_slt(i8 %x) {
 ; CHECK-LABEL: @or_sle_slt(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sle i8 %x, 13
@@ -3357,8 +3358,8 @@ define i1 @or_sle_slt(i8 %x) {
 
 define i1 @or_sle_uge(i8 %x) {
 ; CHECK-LABEL: @or_sle_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3372,8 +3373,8 @@ define i1 @or_sle_uge(i8 %x) {
 
 define i1 @or_sle_ugt(i8 %x) {
 ; CHECK-LABEL: @or_sle_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3387,8 +3388,8 @@ define i1 @or_sle_ugt(i8 %x) {
 
 define i1 @or_sle_ule(i8 %x) {
 ; CHECK-LABEL: @or_sle_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3402,8 +3403,8 @@ define i1 @or_sle_ule(i8 %x) {
 
 define i1 @or_sle_ult(i8 %x) {
 ; CHECK-LABEL: @or_sle_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3418,8 +3419,8 @@ define i1 @or_sle_ult(i8 %x) {
 
 define i1 @or_slt_eq(i8 %x) {
 ; CHECK-LABEL: @or_slt_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3433,7 +3434,7 @@ define i1 @or_slt_eq(i8 %x) {
 
 define i1 @or_slt_ne(i8 %x) {
 ; CHECK-LABEL: @or_slt_ne(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
@@ -3446,8 +3447,8 @@ define i1 @or_slt_ne(i8 %x) {
 
 define i1 @or_slt_sge(i8 %x) {
 ; CHECK-LABEL: @or_slt_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3461,8 +3462,8 @@ define i1 @or_slt_sge(i8 %x) {
 
 define i1 @or_slt_sgt(i8 %x) {
 ; CHECK-LABEL: @or_slt_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3476,7 +3477,7 @@ define i1 @or_slt_sgt(i8 %x) {
 
 define i1 @or_slt_sle(i8 %x) {
 ; CHECK-LABEL: @or_slt_sle(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
@@ -3489,7 +3490,7 @@ define i1 @or_slt_sle(i8 %x) {
 
 define i1 @or_slt_slt(i8 %x) {
 ; CHECK-LABEL: @or_slt_slt(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp slt i8 %x, 13
@@ -3502,8 +3503,8 @@ define i1 @or_slt_slt(i8 %x) {
 
 define i1 @or_slt_uge(i8 %x) {
 ; CHECK-LABEL: @or_slt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3517,8 +3518,8 @@ define i1 @or_slt_uge(i8 %x) {
 
 define i1 @or_slt_ugt(i8 %x) {
 ; CHECK-LABEL: @or_slt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3532,8 +3533,8 @@ define i1 @or_slt_ugt(i8 %x) {
 
 define i1 @or_slt_ule(i8 %x) {
 ; CHECK-LABEL: @or_slt_ule(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3547,8 +3548,8 @@ define i1 @or_slt_ule(i8 %x) {
 
 define i1 @or_slt_ult(i8 %x) {
 ; CHECK-LABEL: @or_slt_ult(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3563,7 +3564,7 @@ define i1 @or_slt_ult(i8 %x) {
 
 define i1 @or_uge_eq(i8 %x) {
 ; CHECK-LABEL: @or_uge_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
@@ -3588,7 +3589,7 @@ define i1 @or_uge_ne(i8 %x) {
 
 define i1 @or_uge_sge(i8 %x) {
 ; CHECK-LABEL: @or_uge_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
@@ -3601,7 +3602,7 @@ define i1 @or_uge_sge(i8 %x) {
 
 define i1 @or_uge_sgt(i8 %x) {
 ; CHECK-LABEL: @or_uge_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
@@ -3638,7 +3639,7 @@ define i1 @or_uge_slt(i8 %x) {
 
 define i1 @or_uge_uge(i8 %x) {
 ; CHECK-LABEL: @or_uge_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
@@ -3651,7 +3652,7 @@ define i1 @or_uge_uge(i8 %x) {
 
 define i1 @or_uge_ugt(i8 %x) {
 ; CHECK-LABEL: @or_uge_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp uge i8 %x, 13
@@ -3689,7 +3690,7 @@ define i1 @or_uge_ult(i8 %x) {
 
 define i1 @or_ugt_eq(i8 %x) {
 ; CHECK-LABEL: @or_ugt_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -3714,7 +3715,7 @@ define i1 @or_ugt_ne(i8 %x) {
 
 define i1 @or_ugt_sge(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -3727,7 +3728,7 @@ define i1 @or_ugt_sge(i8 %x) {
 
 define i1 @or_ugt_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -3764,7 +3765,7 @@ define i1 @or_ugt_slt(i8 %x) {
 
 define i1 @or_ugt_uge(i8 %x) {
 ; CHECK-LABEL: @or_ugt_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -3777,7 +3778,7 @@ define i1 @or_ugt_uge(i8 %x) {
 
 define i1 @or_ugt_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 13
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 13
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ugt i8 %x, 13
@@ -3815,8 +3816,8 @@ define i1 @or_ugt_ult(i8 %x) {
 
 define i1 @or_ule_eq(i8 %x) {
 ; CHECK-LABEL: @or_ule_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3830,7 +3831,7 @@ define i1 @or_ule_eq(i8 %x) {
 
 define i1 @or_ule_ne(i8 %x) {
 ; CHECK-LABEL: @or_ule_ne(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
@@ -3843,8 +3844,8 @@ define i1 @or_ule_ne(i8 %x) {
 
 define i1 @or_ule_sge(i8 %x) {
 ; CHECK-LABEL: @or_ule_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3858,8 +3859,8 @@ define i1 @or_ule_sge(i8 %x) {
 
 define i1 @or_ule_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ule_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3873,7 +3874,7 @@ define i1 @or_ule_sgt(i8 %x) {
 
 define i1 @or_ule_sle(i8 %x) {
 ; CHECK-LABEL: @or_ule_sle(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
@@ -3886,7 +3887,7 @@ define i1 @or_ule_sle(i8 %x) {
 
 define i1 @or_ule_slt(i8 %x) {
 ; CHECK-LABEL: @or_ule_slt(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
@@ -3899,8 +3900,8 @@ define i1 @or_ule_slt(i8 %x) {
 
 define i1 @or_ule_uge(i8 %x) {
 ; CHECK-LABEL: @or_ule_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3914,8 +3915,8 @@ define i1 @or_ule_uge(i8 %x) {
 
 define i1 @or_ule_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ule_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3929,7 +3930,7 @@ define i1 @or_ule_ugt(i8 %x) {
 
 define i1 @or_ule_ule(i8 %x) {
 ; CHECK-LABEL: @or_ule_ule(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
@@ -3942,7 +3943,7 @@ define i1 @or_ule_ule(i8 %x) {
 
 define i1 @or_ule_ult(i8 %x) {
 ; CHECK-LABEL: @or_ule_ult(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ule i8 %x, 13
@@ -3956,8 +3957,8 @@ define i1 @or_ule_ult(i8 %x) {
 
 define i1 @or_ult_eq(i8 %x) {
 ; CHECK-LABEL: @or_ult_eq(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3971,7 +3972,7 @@ define i1 @or_ult_eq(i8 %x) {
 
 define i1 @or_ult_ne(i8 %x) {
 ; CHECK-LABEL: @or_ult_ne(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
@@ -3984,8 +3985,8 @@ define i1 @or_ult_ne(i8 %x) {
 
 define i1 @or_ult_sge(i8 %x) {
 ; CHECK-LABEL: @or_ult_sge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -3999,8 +4000,8 @@ define i1 @or_ult_sge(i8 %x) {
 
 define i1 @or_ult_sgt(i8 %x) {
 ; CHECK-LABEL: @or_ult_sgt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4014,7 +4015,7 @@ define i1 @or_ult_sgt(i8 %x) {
 
 define i1 @or_ult_sle(i8 %x) {
 ; CHECK-LABEL: @or_ult_sle(
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
@@ -4027,7 +4028,7 @@ define i1 @or_ult_sle(i8 %x) {
 
 define i1 @or_ult_slt(i8 %x) {
 ; CHECK-LABEL: @or_ult_slt(
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
@@ -4040,8 +4041,8 @@ define i1 @or_ult_slt(i8 %x) {
 
 define i1 @or_ult_uge(i8 %x) {
 ; CHECK-LABEL: @or_ult_uge(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4055,8 +4056,8 @@ define i1 @or_ult_uge(i8 %x) {
 
 define i1 @or_ult_ugt(i8 %x) {
 ; CHECK-LABEL: @or_ult_ugt(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 13
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 13
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4070,7 +4071,7 @@ define i1 @or_ult_ugt(i8 %x) {
 
 define i1 @or_ult_ule(i8 %x) {
 ; CHECK-LABEL: @or_ult_ule(
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
@@ -4083,7 +4084,7 @@ define i1 @or_ult_ule(i8 %x) {
 
 define i1 @or_ult_ult(i8 %x) {
 ; CHECK-LABEL: @or_ult_ult(
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ult i8 %x, 13
@@ -4097,8 +4098,8 @@ define i1 @or_ult_ult(i8 %x) {
 
 define i1 @or_eq_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4112,7 +4113,7 @@ define i1 @or_eq_eq_swap(i8 %x) {
 
 define i1 @or_eq_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ne_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
@@ -4125,7 +4126,7 @@ define i1 @or_eq_ne_swap(i8 %x) {
 
 define i1 @or_eq_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_sge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
@@ -4138,7 +4139,7 @@ define i1 @or_eq_sge_swap(i8 %x) {
 
 define i1 @or_eq_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_sgt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
@@ -4151,8 +4152,8 @@ define i1 @or_eq_sgt_swap(i8 %x) {
 
 define i1 @or_eq_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4166,8 +4167,8 @@ define i1 @or_eq_sle_swap(i8 %x) {
 
 define i1 @or_eq_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4181,7 +4182,7 @@ define i1 @or_eq_slt_swap(i8 %x) {
 
 define i1 @or_eq_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_uge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
@@ -4194,7 +4195,7 @@ define i1 @or_eq_uge_swap(i8 %x) {
 
 define i1 @or_eq_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ugt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp eq i8 %x, 23
@@ -4207,8 +4208,8 @@ define i1 @or_eq_ugt_swap(i8 %x) {
 
 define i1 @or_eq_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4222,8 +4223,8 @@ define i1 @or_eq_ule_swap(i8 %x) {
 
 define i1 @or_eq_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_eq_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4238,7 +4239,7 @@ define i1 @or_eq_ult_swap(i8 %x) {
 
 define i1 @or_ne_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
@@ -4287,7 +4288,7 @@ define i1 @or_ne_sgt_swap(i8 %x) {
 
 define i1 @or_ne_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
@@ -4300,7 +4301,7 @@ define i1 @or_ne_sle_swap(i8 %x) {
 
 define i1 @or_ne_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
@@ -4337,7 +4338,7 @@ define i1 @or_ne_ugt_swap(i8 %x) {
 
 define i1 @or_ne_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
@@ -4350,7 +4351,7 @@ define i1 @or_ne_ule_swap(i8 %x) {
 
 define i1 @or_ne_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ne_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ne i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ne i8 %x, 23
@@ -4364,8 +4365,8 @@ define i1 @or_ne_ult_swap(i8 %x) {
 
 define i1 @or_sge_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4379,7 +4380,7 @@ define i1 @or_sge_eq_swap(i8 %x) {
 
 define i1 @or_sge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ne_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
@@ -4392,7 +4393,7 @@ define i1 @or_sge_ne_swap(i8 %x) {
 
 define i1 @or_sge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_sge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
@@ -4405,7 +4406,7 @@ define i1 @or_sge_sge_swap(i8 %x) {
 
 define i1 @or_sge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_sgt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
@@ -4418,8 +4419,8 @@ define i1 @or_sge_sgt_swap(i8 %x) {
 
 define i1 @or_sge_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4433,8 +4434,8 @@ define i1 @or_sge_sle_swap(i8 %x) {
 
 define i1 @or_sge_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4448,7 +4449,7 @@ define i1 @or_sge_slt_swap(i8 %x) {
 
 define i1 @or_sge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_uge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
@@ -4461,7 +4462,7 @@ define i1 @or_sge_uge_swap(i8 %x) {
 
 define i1 @or_sge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ugt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sge i8 %x, 23
@@ -4474,8 +4475,8 @@ define i1 @or_sge_ugt_swap(i8 %x) {
 
 define i1 @or_sge_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4489,8 +4490,8 @@ define i1 @or_sge_ule_swap(i8 %x) {
 
 define i1 @or_sge_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_sge_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4505,8 +4506,8 @@ define i1 @or_sge_ult_swap(i8 %x) {
 
 define i1 @or_sgt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4520,7 +4521,7 @@ define i1 @or_sgt_eq_swap(i8 %x) {
 
 define i1 @or_sgt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ne_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -4533,7 +4534,7 @@ define i1 @or_sgt_ne_swap(i8 %x) {
 
 define i1 @or_sgt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -4546,7 +4547,7 @@ define i1 @or_sgt_sge_swap(i8 %x) {
 
 define i1 @or_sgt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sgt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -4559,8 +4560,8 @@ define i1 @or_sgt_sgt_swap(i8 %x) {
 
 define i1 @or_sgt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4574,8 +4575,8 @@ define i1 @or_sgt_sle_swap(i8 %x) {
 
 define i1 @or_sgt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4589,7 +4590,7 @@ define i1 @or_sgt_slt_swap(i8 %x) {
 
 define i1 @or_sgt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_uge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -4602,7 +4603,7 @@ define i1 @or_sgt_uge_swap(i8 %x) {
 
 define i1 @or_sgt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ugt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp sgt i8 %x, 23
@@ -4615,8 +4616,8 @@ define i1 @or_sgt_ugt_swap(i8 %x) {
 
 define i1 @or_sgt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4630,8 +4631,8 @@ define i1 @or_sgt_ule_swap(i8 %x) {
 
 define i1 @or_sgt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_sgt_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp sgt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4646,7 +4647,7 @@ define i1 @or_sgt_ult_swap(i8 %x) {
 
 define i1 @or_sle_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
@@ -4695,7 +4696,7 @@ define i1 @or_sle_sgt_swap(i8 %x) {
 
 define i1 @or_sle_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
@@ -4708,7 +4709,7 @@ define i1 @or_sle_sle_swap(i8 %x) {
 
 define i1 @or_sle_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
@@ -4745,7 +4746,7 @@ define i1 @or_sle_ugt_swap(i8 %x) {
 
 define i1 @or_sle_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
@@ -4758,7 +4759,7 @@ define i1 @or_sle_ule_swap(i8 %x) {
 
 define i1 @or_sle_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_sle_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp sle i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp sle i8 %x, 23
@@ -4772,7 +4773,7 @@ define i1 @or_sle_ult_swap(i8 %x) {
 
 define i1 @or_slt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
@@ -4821,7 +4822,7 @@ define i1 @or_slt_sgt_swap(i8 %x) {
 
 define i1 @or_slt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
@@ -4834,7 +4835,7 @@ define i1 @or_slt_sle_swap(i8 %x) {
 
 define i1 @or_slt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
@@ -4871,7 +4872,7 @@ define i1 @or_slt_ugt_swap(i8 %x) {
 
 define i1 @or_slt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
@@ -4884,7 +4885,7 @@ define i1 @or_slt_ule_swap(i8 %x) {
 
 define i1 @or_slt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_slt_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp slt i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp slt i8 %x, 23
@@ -4898,8 +4899,8 @@ define i1 @or_slt_ult_swap(i8 %x) {
 
 define i1 @or_uge_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4913,7 +4914,7 @@ define i1 @or_uge_eq_swap(i8 %x) {
 
 define i1 @or_uge_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ne_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
@@ -4926,8 +4927,8 @@ define i1 @or_uge_ne_swap(i8 %x) {
 
 define i1 @or_uge_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4941,8 +4942,8 @@ define i1 @or_uge_sge_swap(i8 %x) {
 
 define i1 @or_uge_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4956,8 +4957,8 @@ define i1 @or_uge_sgt_swap(i8 %x) {
 
 define i1 @or_uge_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4971,8 +4972,8 @@ define i1 @or_uge_sle_swap(i8 %x) {
 
 define i1 @or_uge_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -4986,7 +4987,7 @@ define i1 @or_uge_slt_swap(i8 %x) {
 
 define i1 @or_uge_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_uge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
@@ -4999,7 +5000,7 @@ define i1 @or_uge_uge_swap(i8 %x) {
 
 define i1 @or_uge_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ugt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp uge i8 %x, 23
@@ -5012,8 +5013,8 @@ define i1 @or_uge_ugt_swap(i8 %x) {
 
 define i1 @or_uge_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5027,8 +5028,8 @@ define i1 @or_uge_ule_swap(i8 %x) {
 
 define i1 @or_uge_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_uge_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp uge i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5043,8 +5044,8 @@ define i1 @or_uge_ult_swap(i8 %x) {
 
 define i1 @or_ugt_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp eq i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5058,7 +5059,7 @@ define i1 @or_ugt_eq_swap(i8 %x) {
 
 define i1 @or_ugt_ne_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ne_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ne i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -5071,8 +5072,8 @@ define i1 @or_ugt_ne_swap(i8 %x) {
 
 define i1 @or_ugt_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5086,8 +5087,8 @@ define i1 @or_ugt_sge_swap(i8 %x) {
 
 define i1 @or_ugt_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5101,8 +5102,8 @@ define i1 @or_ugt_sgt_swap(i8 %x) {
 
 define i1 @or_ugt_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5116,8 +5117,8 @@ define i1 @or_ugt_sle_swap(i8 %x) {
 
 define i1 @or_ugt_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5131,7 +5132,7 @@ define i1 @or_ugt_slt_swap(i8 %x) {
 
 define i1 @or_ugt_uge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_uge_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp uge i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -5144,7 +5145,7 @@ define i1 @or_ugt_uge_swap(i8 %x) {
 
 define i1 @or_ugt_ugt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ugt_swap(
-; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 %x, 17
+; CHECK-NEXT:    [[B:%.*]] = icmp ugt i8 [[X:%.*]], 17
 ; CHECK-NEXT:    ret i1 [[B]]
 ;
   %a = icmp ugt i8 %x, 23
@@ -5157,8 +5158,8 @@ define i1 @or_ugt_ugt_swap(i8 %x) {
 
 define i1 @or_ugt_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ule i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5172,8 +5173,8 @@ define i1 @or_ugt_ule_swap(i8 %x) {
 
 define i1 @or_ugt_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ugt_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ugt i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp ult i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5188,7 +5189,7 @@ define i1 @or_ugt_ult_swap(i8 %x) {
 
 define i1 @or_ule_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
@@ -5213,8 +5214,8 @@ define i1 @or_ule_ne_swap(i8 %x) {
 
 define i1 @or_ule_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5228,8 +5229,8 @@ define i1 @or_ule_sge_swap(i8 %x) {
 
 define i1 @or_ule_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5243,8 +5244,8 @@ define i1 @or_ule_sgt_swap(i8 %x) {
 
 define i1 @or_ule_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5258,8 +5259,8 @@ define i1 @or_ule_sle_swap(i8 %x) {
 
 define i1 @or_ule_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5297,7 +5298,7 @@ define i1 @or_ule_ugt_swap(i8 %x) {
 
 define i1 @or_ule_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
@@ -5310,7 +5311,7 @@ define i1 @or_ule_ule_swap(i8 %x) {
 
 define i1 @or_ule_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ule_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ule i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ule i8 %x, 23
@@ -5324,7 +5325,7 @@ define i1 @or_ule_ult_swap(i8 %x) {
 
 define i1 @or_ult_eq_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_eq_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23
@@ -5349,8 +5350,8 @@ define i1 @or_ult_ne_swap(i8 %x) {
 
 define i1 @or_ult_sge_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_sge_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sge i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5364,8 +5365,8 @@ define i1 @or_ult_sge_swap(i8 %x) {
 
 define i1 @or_ult_sgt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_sgt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sgt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5379,8 +5380,8 @@ define i1 @or_ult_sgt_swap(i8 %x) {
 
 define i1 @or_ult_sle_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_sle_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp sle i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5394,8 +5395,8 @@ define i1 @or_ult_sle_swap(i8 %x) {
 
 define i1 @or_ult_slt_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_slt_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
-; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 %x, 17
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
+; CHECK-NEXT:    [[B:%.*]] = icmp slt i8 [[X]], 17
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[A]], [[B]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
@@ -5433,7 +5434,7 @@ define i1 @or_ult_ugt_swap(i8 %x) {
 
 define i1 @or_ult_ule_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ule_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23
@@ -5446,7 +5447,7 @@ define i1 @or_ult_ule_swap(i8 %x) {
 
 define i1 @or_ult_ult_swap(i8 %x) {
 ; CHECK-LABEL: @or_ult_ult_swap(
-; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 %x, 23
+; CHECK-NEXT:    [[A:%.*]] = icmp ult i8 [[X:%.*]], 23
 ; CHECK-NEXT:    ret i1 [[A]]
 ;
   %a = icmp ult i8 %x, 23

diff --git a/llvm/test/Transforms/InstSimplify/log10-pow10-intrinsic.ll b/llvm/test/Transforms/InstSimplify/log10-pow10-intrinsic.ll
index 0d98719..665ca01 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/log10-pow10-intrinsic.ll
+++ b/llvm/test/Transforms/InstSimplify/log10-pow10-intrinsic.ll
@@ -6,9 +6,9 @@ declare double @llvm.pow.f64(double, double)
 
 define double @log10_pow10(double %x) {
 ; CHECK-LABEL: @log10_pow10(
-; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]])
-; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log10.f64(double [[TMP1]])
-; CHECK-NEXT:    ret double [[TMP2]]
+; CHECK-NEXT:    [[TMP:%.*]] = call double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.log10.f64(double [[TMP]])
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %tmp = call double @llvm.pow.f64(double 1.000000e+01, double %x)
   %tmp1 = call double @llvm.log10.f64(double %tmp)
@@ -17,9 +17,9 @@ define double @log10_pow10(double %x) {
 
 define double @log10_strict_pow10_reassoc(double %x) {
 ; CHECK-LABEL: @log10_strict_pow10_reassoc(
-; CHECK-NEXT:    [[TMP1:%.*]] = call reassoc double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]])
-; CHECK-NEXT:    [[TMP2:%.*]] = call double @llvm.log10.f64(double [[TMP1]])
-; CHECK-NEXT:    ret double [[TMP2]]
+; CHECK-NEXT:    [[TMP:%.*]] = call reassoc double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.log10.f64(double [[TMP]])
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %tmp = call reassoc double @llvm.pow.f64(double 1.000000e+01, double %x)
   %tmp1 = call double @llvm.log10.f64(double %tmp)

diff --git a/llvm/test/Transforms/InstSimplify/logic-of-fcmps.ll b/llvm/test/Transforms/InstSimplify/logic-of-fcmps.ll
index b292933..5851ba5 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/logic-of-fcmps.ll
+++ b/llvm/test/Transforms/InstSimplify/logic-of-fcmps.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 ; Cycle through commuted variants where one operand of fcmp ord/uno is
@@ -5,7 +6,7 @@
 
 define i1 @ord1(float %x, float %y) {
 ; CHECK-LABEL: @ord1(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord float %x, %y
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp ord float 0.0, %x
@@ -16,7 +17,7 @@ define i1 @ord1(float %x, float %y) {
 
 define i1 @ord2(double %x, double %y) {
 ; CHECK-LABEL: @ord2(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord double %y, %x
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord double [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp ord double 42.0, %x
@@ -27,7 +28,7 @@ define i1 @ord2(double %x, double %y) {
 
 define <2 x i1> @ord3(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @ord3(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x float> %x, %y
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x float> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp ord <2 x float> %x, zeroinitializer
@@ -38,7 +39,7 @@ define <2 x i1> @ord3(<2 x float> %x, <2 x float> %y) {
 
 define <2 x i1> @ord4(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @ord4(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x double> %y, %x
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x double> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp ord <2 x double> %x, <double 42.0, double 42.0>
@@ -49,7 +50,7 @@ define <2 x i1> @ord4(<2 x double> %x, <2 x double> %y) {
 
 define i1 @ord5(float %x, float %y) {
 ; CHECK-LABEL: @ord5(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord float %x, %y
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %nnan = fdiv nnan float %x, %y
@@ -61,7 +62,7 @@ define i1 @ord5(float %x, float %y) {
 
 define i1 @ord6(double %x, double %y) {
 ; CHECK-LABEL: @ord6(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %y, %x
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp ord double %y, %x
@@ -72,7 +73,7 @@ define i1 @ord6(double %x, double %y) {
 
 define <2 x i1> @ord7(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @ord7(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x float> %x, %y
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x float> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp ord <2 x float> %x, %y
@@ -83,7 +84,7 @@ define <2 x i1> @ord7(<2 x float> %x, <2 x float> %y) {
 
 define <2 x i1> @ord8(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @ord8(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x double> %y, %x
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x double> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp ord <2 x double> %y, %x
@@ -94,7 +95,7 @@ define <2 x i1> @ord8(<2 x double> %x, <2 x double> %y) {
 
 define i1 @uno1(float %x, float %y) {
 ; CHECK-LABEL: @uno1(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno float %x, %y
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp uno float 0.0, %x
@@ -105,7 +106,7 @@ define i1 @uno1(float %x, float %y) {
 
 define i1 @uno2(double %x, double %y) {
 ; CHECK-LABEL: @uno2(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno double %y, %x
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno double [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp uno double 42.0, %x
@@ -116,7 +117,7 @@ define i1 @uno2(double %x, double %y) {
 
 define <2 x i1> @uno3(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @uno3(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x float> %x, %y
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x float> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp uno <2 x float> %x, zeroinitializer
@@ -127,7 +128,7 @@ define <2 x i1> @uno3(<2 x float> %x, <2 x float> %y) {
 
 define <2 x i1> @uno4(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @uno4(
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x double> %y, %x
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x double> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp uno <2 x double> %x, <double 42.0, double 42.0>
@@ -138,7 +139,7 @@ define <2 x i1> @uno4(<2 x double> %x, <2 x double> %y) {
 
 define i1 @uno5(float %x, float %y) {
 ; CHECK-LABEL: @uno5(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno float %x, %y
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp uno float %x, %y
@@ -149,7 +150,7 @@ define i1 @uno5(float %x, float %y) {
 
 define i1 @uno6(double %x, double %y) {
 ; CHECK-LABEL: @uno6(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double %y, %x
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp uno double %y, %x
@@ -160,7 +161,7 @@ define i1 @uno6(double %x, double %y) {
 
 define <2 x i1> @uno7(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @uno7(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x float> %x, %y
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x float> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %nnan = fdiv nnan <2 x float> %x, %y
@@ -172,7 +173,7 @@ define <2 x i1> @uno7(<2 x float> %x, <2 x float> %y) {
 
 define <2 x i1> @uno8(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @uno8(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x double> %y, %x
+; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x double> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp uno <2 x double> %y, %x

diff --git a/llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll b/llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll
index c1c2069..4c9c2af 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll
+++ b/llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll
@@ -2139,7 +2139,7 @@ define i8 @umax_add_nuw_2(i8 %x) {
 
 define i8 @umax_range_metadata(i8* %p1, i8* %p2) {
 ; CHECK-LABEL: @umax_range_metadata(
-; CHECK-NEXT:    [[Y:%.*]] = load i8, i8* [[P2:%.*]], align 1, [[RNG0:!range !.*]]
+; CHECK-NEXT:    [[Y:%.*]] = load i8, i8* [[P2:%.*]], align 1, !range [[RNG0:![0-9]+]]
 ; CHECK-NEXT:    ret i8 [[Y]]
 ;
   %x = load i8, i8* %p1, !range !{i8 0, i8 10}

diff --git a/llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll b/llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll
index bba44e1..e1d5df5 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll
+++ b/llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll
@@ -1,9 +1,11 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt  -passes=instsimplify -S < %s | FileCheck %s
 
 ; Test back to back reverse shuffles are eliminated.
 define <vscale x 4 x i32> @shuffle_b2b_reverse(<vscale x 4 x i32> %a) {
 ; CHECK-LABEL: @shuffle_b2b_reverse(
-; CHECK: ret <vscale x 4 x i32> %a
+; CHECK-NEXT:    ret <vscale x 4 x i32> [[A:%.*]]
+;
   %rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %a)
   %rev.rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %rev)
   ret <vscale x 4 x i32> %rev.rev

diff --git a/llvm/test/Transforms/InstSimplify/noalias-ptr.ll b/llvm/test/Transforms/InstSimplify/noalias-ptr.ll
index d15e1d0..4d5dc4e 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/noalias-ptr.ll
+++ b/llvm/test/Transforms/InstSimplify/noalias-ptr.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
@@ -22,6 +23,15 @@ target triple = "x86_64-unknown-linux-gnu"
 ;   }
 
 define void @_Z2p1v() #0 {
+; CHECK-LABEL: @_Z2p1v(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    br i1 false, label [[TMP3:%.*]], label [[TMP2:%.*]]
+; CHECK:       2:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4:[0-9]+]]
+; CHECK-NEXT:    br label [[TMP3]]
+; CHECK:       3:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = tail call noalias i8* @_Znam(i64 48) #4
@@ -30,9 +40,6 @@ define void @_Z2p1v() #0 {
   %5 = icmp eq i32* %3, %4
   br i1 %5, label %7, label %6
 
-; CHECK-LABEL: @_Z2p1v
-; CHECK-NOT: icmp
-; CHECK: ret void
 
 ; <label>:6                                       ; preds = %0
   call void @_ZdaPv(i8* %2) #5
@@ -45,6 +52,17 @@ define void @_Z2p1v() #0 {
 ; Also check a more-complicated case with multiple underlying objects.
 
 define void @_Z2p2bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p2bb(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    br i1 false, label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP2]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       4:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -56,9 +74,6 @@ define void @_Z2p2bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p2bb
-; CHECK-NOT: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -70,6 +85,17 @@ define void @_Z2p2bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 }
 
 define void @_Z2p4bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p4bb(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    br i1 false, label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP2]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       4:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -81,9 +107,6 @@ define void @_Z2p4bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p4bb
-; CHECK-NOT: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -95,6 +118,17 @@ define void @_Z2p4bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 }
 
 define void @_Z2p5bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p5bb(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    br i1 false, label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP2]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       4:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -106,9 +140,6 @@ define void @_Z2p5bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p5bb
-; CHECK-NOT: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -120,6 +151,17 @@ define void @_Z2p5bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 }
 
 define void @_Z2p6bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p6bb(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    br i1 false, label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP2]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       4:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -131,9 +173,6 @@ define void @_Z2p6bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p6bb
-; CHECK-NOT: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -149,6 +188,23 @@ define void @_Z2p6bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 ; argument).
 
 define void @_Z4nopebbPi(i1 zeroext %b1, i1 zeroext %b2, i32* readnone %q) #0 {
+; CHECK-LABEL: @_Z4nopebbPi(
+; CHECK-NEXT:    [[MSTACKDATA:%.*]] = alloca [10 x i32], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[MSTACKDATA]], i64 0, i64 0
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B1:%.*]], i32* [[TMP1]], i32* [[Q:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[DOTV:%.*]] = select i1 [[B2:%.*]], i8* [[TMP3]], i8* [[TMP4]]
+; CHECK-NEXT:    [[TMP5:%.*]] = bitcast i8* [[DOTV]] to i32*
+; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i32* [[TMP5]], [[TMP2]]
+; CHECK-NEXT:    br i1 [[TMP6]], label [[TMP8:%.*]], label [[TMP7:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP3]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP4]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP8]]
+; CHECK:       8:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -160,9 +216,6 @@ define void @_Z4nopebbPi(i1 zeroext %b1, i1 zeroext %b2, i32* readnone %q) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z4nopebbPi
-; CHECK: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -174,6 +227,23 @@ define void @_Z4nopebbPi(i1 zeroext %b1, i1 zeroext %b2, i32* readnone %q) #0 {
 }
 
 define void @_Z2p3bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p3bb(
+; CHECK-NEXT:    [[MSTACKDATA:%.*]] = alloca [10 x i32], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[MSTACKDATA]], i64 0, i64 0
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B1:%.*]], i32* [[TMP1]], i32* @g1
+; CHECK-NEXT:    [[TMP3:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[DOTV:%.*]] = select i1 [[B2:%.*]], i8* [[TMP3]], i8* [[TMP4]]
+; CHECK-NEXT:    [[TMP5:%.*]] = bitcast i8* [[DOTV]] to i32*
+; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i32* [[TMP5]], [[TMP2]]
+; CHECK-NEXT:    br i1 [[TMP6]], label [[TMP8:%.*]], label [[TMP7:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP3]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP4]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP8]]
+; CHECK:       8:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -185,9 +255,6 @@ define void @_Z2p3bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p3bb
-; CHECK: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -199,6 +266,23 @@ define void @_Z2p3bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 }
 
 define void @_Z2p7bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
+; CHECK-LABEL: @_Z2p7bb(
+; CHECK-NEXT:    [[MSTACKDATA:%.*]] = alloca [10 x i32], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[MSTACKDATA]], i64 0, i64 0
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[B1:%.*]], i32* [[TMP1]], i32* @g6
+; CHECK-NEXT:    [[TMP3:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[DOTV:%.*]] = select i1 [[B2:%.*]], i8* [[TMP3]], i8* [[TMP4]]
+; CHECK-NEXT:    [[TMP5:%.*]] = bitcast i8* [[DOTV]] to i32*
+; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i32* [[TMP5]], [[TMP2]]
+; CHECK-NEXT:    br i1 [[TMP6]], label [[TMP8:%.*]], label [[TMP7:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP3]]) #[[ATTR4]]
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP4]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP8]]
+; CHECK:       8:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = getelementptr inbounds [10 x i32], [10 x i32]* %mStackData, i64 0, i64 0
@@ -210,9 +294,6 @@ define void @_Z2p7bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
   %7 = icmp eq i32* %6, %3
   br i1 %7, label %9, label %8
 
-; CHECK-LABEL: @_Z2p7bb
-; CHECK: icmp
-; CHECK: ret void
 
 ; <label>:8                                       ; preds = %0
   call void @_ZdaPv(i8* %4) #5
@@ -224,6 +305,19 @@ define void @_Z2p7bb(i1 zeroext %b1, i1 zeroext %b2) #0 {
 }
 
 define void @_Z2p2v(i32 %c) #0 {
+; CHECK-LABEL: @_Z2p2v(
+; CHECK-NEXT:    [[MSTACKDATA:%.*]] = alloca [10 x i32], i32 [[C:%.*]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call noalias i8* @_Znam(i64 48) #[[ATTR3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
+; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [10 x i32], [10 x i32]* [[MSTACKDATA]], i64 0, i64 0
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32* [[TMP2]], [[TMP3]]
+; CHECK-NEXT:    br i1 [[TMP4]], label [[TMP6:%.*]], label [[TMP5:%.*]]
+; CHECK:       5:
+; CHECK-NEXT:    call void @_ZdaPv(i8* [[TMP1]]) #[[ATTR4]]
+; CHECK-NEXT:    br label [[TMP6]]
+; CHECK:       6:
+; CHECK-NEXT:    ret void
+;
   %mStackData = alloca [10 x i32], i32 %c, align 16
   %1 = bitcast [10 x i32]* %mStackData to i8*
   %2 = tail call noalias i8* @_Znam(i64 48) #4
@@ -232,9 +326,6 @@ define void @_Z2p2v(i32 %c) #0 {
   %5 = icmp eq i32* %3, %4
   br i1 %5, label %7, label %6
 
-; CHECK-LABEL: @_Z2p2v
-; CHECK: icmp
-; CHECK: ret void
 
 ; <label>:6                                       ; preds = %0
   call void @_ZdaPv(i8* %2) #5

diff --git a/llvm/test/Transforms/InstSimplify/or-icmps-same-ops.ll b/llvm/test/Transforms/InstSimplify/or-icmps-same-ops.ll
index 74b6173..0878a52 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/or-icmps-same-ops.ll
+++ b/llvm/test/Transforms/InstSimplify/or-icmps-same-ops.ll
@@ -6,7 +6,7 @@
 
 define i1 @eq_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_eq(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -27,7 +27,7 @@ define i1 @eq_ne(i8 %a, i8 %b) {
 
 define i1 @eq_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_sge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -38,8 +38,8 @@ define i1 @eq_sge(i8 %a, i8 %b) {
 
 define i1 @eq_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -51,7 +51,7 @@ define i1 @eq_sgt(i8 %a, i8 %b) {
 
 define i1 @eq_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_sle(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -62,8 +62,8 @@ define i1 @eq_sle(i8 %a, i8 %b) {
 
 define i1 @eq_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -75,7 +75,7 @@ define i1 @eq_slt(i8 %a, i8 %b) {
 
 define i1 @eq_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_uge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -86,8 +86,8 @@ define i1 @eq_uge(i8 %a, i8 %b) {
 
 define i1 @eq_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -99,7 +99,7 @@ define i1 @eq_ugt(i8 %a, i8 %b) {
 
 define i1 @eq_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_ule(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp eq i8 %a, %b
@@ -110,8 +110,8 @@ define i1 @eq_ule(i8 %a, i8 %b) {
 
 define i1 @eq_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @eq_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -135,7 +135,7 @@ define i1 @ne_eq(i8 %a, i8 %b) {
 
 define i1 @ne_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ne(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -156,7 +156,7 @@ define i1 @ne_sge(i8 %a, i8 %b) {
 
 define i1 @ne_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -177,7 +177,7 @@ define i1 @ne_sle(i8 %a, i8 %b) {
 
 define i1 @ne_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -198,7 +198,7 @@ define i1 @ne_uge(i8 %a, i8 %b) {
 
 define i1 @ne_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -219,7 +219,7 @@ define i1 @ne_ule(i8 %a, i8 %b) {
 
 define i1 @ne_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ne_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ne i8 %a, %b
@@ -232,7 +232,7 @@ define i1 @ne_ult(i8 %a, i8 %b) {
 
 define i1 @sge_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -253,7 +253,7 @@ define i1 @sge_ne(i8 %a, i8 %b) {
 
 define i1 @sge_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_sge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -264,7 +264,7 @@ define i1 @sge_sge(i8 %a, i8 %b) {
 
 define i1 @sge_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sge i8 %a, %b
@@ -295,8 +295,8 @@ define i1 @sge_slt(i8 %a, i8 %b) {
 
 define i1 @sge_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -308,8 +308,8 @@ define i1 @sge_uge(i8 %a, i8 %b) {
 
 define i1 @sge_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -321,8 +321,8 @@ define i1 @sge_ugt(i8 %a, i8 %b) {
 
 define i1 @sge_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -334,8 +334,8 @@ define i1 @sge_ule(i8 %a, i8 %b) {
 
 define i1 @sge_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sge_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -349,8 +349,8 @@ define i1 @sge_ult(i8 %a, i8 %b) {
 
 define i1 @sgt_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -362,7 +362,7 @@ define i1 @sgt_eq(i8 %a, i8 %b) {
 
 define i1 @sgt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ne(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -373,7 +373,7 @@ define i1 @sgt_ne(i8 %a, i8 %b) {
 
 define i1 @sgt_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_sge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -384,7 +384,7 @@ define i1 @sgt_sge(i8 %a, i8 %b) {
 
 define i1 @sgt_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_sgt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sgt i8 %a, %b
@@ -405,8 +405,8 @@ define i1 @sgt_sle(i8 %a, i8 %b) {
 
 define i1 @sgt_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -418,8 +418,8 @@ define i1 @sgt_slt(i8 %a, i8 %b) {
 
 define i1 @sgt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -431,8 +431,8 @@ define i1 @sgt_uge(i8 %a, i8 %b) {
 
 define i1 @sgt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -444,8 +444,8 @@ define i1 @sgt_ugt(i8 %a, i8 %b) {
 
 define i1 @sgt_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -457,8 +457,8 @@ define i1 @sgt_ule(i8 %a, i8 %b) {
 
 define i1 @sgt_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sgt_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -472,7 +472,7 @@ define i1 @sgt_ult(i8 %a, i8 %b) {
 
 define i1 @sle_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -513,7 +513,7 @@ define i1 @sle_sgt(i8 %a, i8 %b) {
 
 define i1 @sle_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_sle(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -524,7 +524,7 @@ define i1 @sle_sle(i8 %a, i8 %b) {
 
 define i1 @sle_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp sle i8 %a, %b
@@ -535,8 +535,8 @@ define i1 @sle_slt(i8 %a, i8 %b) {
 
 define i1 @sle_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -548,8 +548,8 @@ define i1 @sle_uge(i8 %a, i8 %b) {
 
 define i1 @sle_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -561,8 +561,8 @@ define i1 @sle_ugt(i8 %a, i8 %b) {
 
 define i1 @sle_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -574,8 +574,8 @@ define i1 @sle_ule(i8 %a, i8 %b) {
 
 define i1 @sle_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @sle_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -589,8 +589,8 @@ define i1 @sle_ult(i8 %a, i8 %b) {
 
 define i1 @slt_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -602,7 +602,7 @@ define i1 @slt_eq(i8 %a, i8 %b) {
 
 define i1 @slt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ne(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -623,8 +623,8 @@ define i1 @slt_sge(i8 %a, i8 %b) {
 
 define i1 @slt_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -636,7 +636,7 @@ define i1 @slt_sgt(i8 %a, i8 %b) {
 
 define i1 @slt_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_sle(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -647,7 +647,7 @@ define i1 @slt_sle(i8 %a, i8 %b) {
 
 define i1 @slt_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_slt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp slt i8 %a, %b
@@ -658,8 +658,8 @@ define i1 @slt_slt(i8 %a, i8 %b) {
 
 define i1 @slt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_uge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -671,8 +671,8 @@ define i1 @slt_uge(i8 %a, i8 %b) {
 
 define i1 @slt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -684,8 +684,8 @@ define i1 @slt_ugt(i8 %a, i8 %b) {
 
 define i1 @slt_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ule(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -697,8 +697,8 @@ define i1 @slt_ule(i8 %a, i8 %b) {
 
 define i1 @slt_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @slt_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -712,7 +712,7 @@ define i1 @slt_ult(i8 %a, i8 %b) {
 
 define i1 @uge_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -733,8 +733,8 @@ define i1 @uge_ne(i8 %a, i8 %b) {
 
 define i1 @uge_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -746,8 +746,8 @@ define i1 @uge_sge(i8 %a, i8 %b) {
 
 define i1 @uge_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -759,8 +759,8 @@ define i1 @uge_sgt(i8 %a, i8 %b) {
 
 define i1 @uge_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -772,8 +772,8 @@ define i1 @uge_sle(i8 %a, i8 %b) {
 
 define i1 @uge_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -785,7 +785,7 @@ define i1 @uge_slt(i8 %a, i8 %b) {
 
 define i1 @uge_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_uge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -796,7 +796,7 @@ define i1 @uge_uge(i8 %a, i8 %b) {
 
 define i1 @uge_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @uge_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp uge i8 %a, %b
@@ -829,8 +829,8 @@ define i1 @uge_ult(i8 %a, i8 %b) {
 
 define i1 @ugt_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -842,7 +842,7 @@ define i1 @ugt_eq(i8 %a, i8 %b) {
 
 define i1 @ugt_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_ne(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -853,8 +853,8 @@ define i1 @ugt_ne(i8 %a, i8 %b) {
 
 define i1 @ugt_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -866,8 +866,8 @@ define i1 @ugt_sge(i8 %a, i8 %b) {
 
 define i1 @ugt_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -879,8 +879,8 @@ define i1 @ugt_sgt(i8 %a, i8 %b) {
 
 define i1 @ugt_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -892,8 +892,8 @@ define i1 @ugt_sle(i8 %a, i8 %b) {
 
 define i1 @ugt_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -905,7 +905,7 @@ define i1 @ugt_slt(i8 %a, i8 %b) {
 
 define i1 @ugt_uge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_uge(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -916,7 +916,7 @@ define i1 @ugt_uge(i8 %a, i8 %b) {
 
 define i1 @ugt_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_ugt(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ugt i8 %a, %b
@@ -937,8 +937,8 @@ define i1 @ugt_ule(i8 %a, i8 %b) {
 
 define i1 @ugt_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ugt_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -952,7 +952,7 @@ define i1 @ugt_ult(i8 %a, i8 %b) {
 
 define i1 @ule_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -973,8 +973,8 @@ define i1 @ule_ne(i8 %a, i8 %b) {
 
 define i1 @ule_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -986,8 +986,8 @@ define i1 @ule_sge(i8 %a, i8 %b) {
 
 define i1 @ule_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -999,8 +999,8 @@ define i1 @ule_sgt(i8 %a, i8 %b) {
 
 define i1 @ule_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1012,8 +1012,8 @@ define i1 @ule_sle(i8 %a, i8 %b) {
 
 define i1 @ule_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1045,7 +1045,7 @@ define i1 @ule_ugt(i8 %a, i8 %b) {
 
 define i1 @ule_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_ule(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -1056,7 +1056,7 @@ define i1 @ule_ule(i8 %a, i8 %b) {
 
 define i1 @ule_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ule_ult(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = icmp ule i8 %a, %b
@@ -1069,8 +1069,8 @@ define i1 @ule_ult(i8 %a, i8 %b) {
 
 define i1 @ult_eq(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_eq(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1082,7 +1082,7 @@ define i1 @ult_eq(i8 %a, i8 %b) {
 
 define i1 @ult_ne(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ne(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1093,8 +1093,8 @@ define i1 @ult_ne(i8 %a, i8 %b) {
 
 define i1 @ult_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sge(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sge i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1106,8 +1106,8 @@ define i1 @ult_sge(i8 %a, i8 %b) {
 
 define i1 @ult_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sgt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1119,8 +1119,8 @@ define i1 @ult_sgt(i8 %a, i8 %b) {
 
 define i1 @ult_sle(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_sle(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sle i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1132,8 +1132,8 @@ define i1 @ult_sle(i8 %a, i8 %b) {
 
 define i1 @ult_slt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_slt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1155,8 +1155,8 @@ define i1 @ult_uge(i8 %a, i8 %b) {
 
 define i1 @ult_ugt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ugt(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 %a, %b
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1168,7 +1168,7 @@ define i1 @ult_ugt(i8 %a, i8 %b) {
 
 define i1 @ult_ule(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ule(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1179,7 +1179,7 @@ define i1 @ult_ule(i8 %a, i8 %b) {
 
 define i1 @ult_ult(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ult(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = icmp ult i8 %a, %b
@@ -1202,7 +1202,7 @@ define <2 x i1> @ult_uge_vec(<2 x i8> %a, <2 x i8> %b) {
 
 define <2 x i1> @ult_ule_vec(<2 x i8> %a, <2 x i8> %b) {
 ; CHECK-LABEL: @ult_ule_vec(
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule <2 x i8> %a, %b
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ule <2 x i8> [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = icmp ult <2 x i8> %a, %b
@@ -1213,8 +1213,8 @@ define <2 x i1> @ult_ule_vec(<2 x i8> %a, <2 x i8> %b) {
 
 define i1 @ult_ne_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ne_swap(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 %b, %a
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
@@ -1226,8 +1226,8 @@ define i1 @ult_ne_swap(i8 %a, i8 %b) {
 
 define i1 @ult_ule_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @ult_ule_swap(
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 %a, %b
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 %b, %a
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp uge i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP1]], [[CMP2]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/require-dominator.ll b/llvm/test/Transforms/InstSimplify/require-dominator.ll
index bce7549..f1da236 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/require-dominator.ll
+++ b/llvm/test/Transforms/InstSimplify/require-dominator.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify
 
 ; instsimplify pass should explicitly require DominatorTreeAnalysis

diff --git a/llvm/test/Transforms/InstSimplify/returned.ll b/llvm/test/Transforms/InstSimplify/returned.ll
index 5d12efb..320e1f0 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/returned.ll
+++ b/llvm/test/Transforms/InstSimplify/returned.ll
@@ -1,7 +1,10 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
 
 define i1 @bitcast() {
 ; CHECK-LABEL: @bitcast(
+; CHECK-NEXT:    ret i1 false
+;
   %a = alloca i32
   %b = alloca i64
   %x = bitcast i32* %a to i8*
@@ -9,20 +12,20 @@ define i1 @bitcast() {
   %y = call i8* @func1(i8* %z)
   %cmp = icmp eq i8* %x, %y
   ret i1 %cmp
-; CHECK-NEXT: ret i1 false
 }
 
 %gept = type { i32, i32 }
 
 define i1 @gep3() {
 ; CHECK-LABEL: @gep3(
+; CHECK-NEXT:    ret i1 false
+;
   %x = alloca %gept, align 8
   %a = getelementptr %gept, %gept* %x, i64 0, i32 0
   %y = call %gept* @func2(%gept* %x)
   %b = getelementptr %gept, %gept* %y, i64 0, i32 1
   %equal = icmp eq i32* %a, %b
   ret i1 %equal
-; CHECK-NEXT: ret i1 false
 }
 
 declare i8* @func1(i8* returned) nounwind readnone willreturn

diff --git a/llvm/test/Transforms/InstSimplify/sdiv.ll b/llvm/test/Transforms/InstSimplify/sdiv.ll
index 1d026a1..2514d90 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/sdiv.ll
+++ b/llvm/test/Transforms/InstSimplify/sdiv.ll
@@ -43,7 +43,7 @@ define i32 @negated_operand_2(i32 %t) {
 ; CHECK-LABEL: @negated_operand_2(
 ; CHECK-NEXT:    ret i32 -1
 ;
-  %x = sub i32 %t, 5 
+  %x = sub i32 %t, 5
   %negx = sub nsw i32 0, %x
   %div = sdiv i32 %negx, %x
   ret i32 %div

diff --git a/llvm/test/Transforms/InstSimplify/select-implied.ll b/llvm/test/Transforms/InstSimplify/select-implied.ll
index 57b8b35..2a1b402 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/select-implied.ll
+++ b/llvm/test/Transforms/InstSimplify/select-implied.ll
@@ -98,8 +98,8 @@ end:
 }
 
 ; We know the condition of the select is true based on a dominating condition.
-; Therefore, we can replace %cond with %len. 
-; TODO: len == 8 is known false in bb. This is handled by other passes, but should it be handled here? 
+; Therefore, we can replace %cond with %len.
+; TODO: len == 8 is known false in bb. This is handled by other passes, but should it be handled here?
 
 define void @test4(i32 %len) {
 ; CHECK-LABEL: @test4(

diff --git a/llvm/test/Transforms/InstSimplify/shr-nop.ll b/llvm/test/Transforms/InstSimplify/shr-nop.ll
index ade6f9e..90d49cc 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/shr-nop.ll
+++ b/llvm/test/Transforms/InstSimplify/shr-nop.ll
@@ -3,7 +3,7 @@
 
 define i32 @foo(i32 %x) {
 ; CHECK-LABEL: @foo(
-; CHECK-NEXT:    [[O:%.*]] = and i32 %x, 1
+; CHECK-NEXT:    [[O:%.*]] = and i32 [[X:%.*]], 1
 ; CHECK-NEXT:    [[N:%.*]] = add i32 [[O]], -1
 ; CHECK-NEXT:    ret i32 [[N]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/signed-div-rem.ll b/llvm/test/Transforms/InstSimplify/signed-div-rem.ll
index 6036c0a..b2316e8 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/signed-div-rem.ll
+++ b/llvm/test/Transforms/InstSimplify/signed-div-rem.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 define i32 @sdiv_sext_big_divisor(i8 %x) {
@@ -11,7 +12,7 @@ define i32 @sdiv_sext_big_divisor(i8 %x) {
 
 define i32 @not_sdiv_sext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @not_sdiv_sext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[CONV]], 128
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -31,7 +32,7 @@ define i32 @sdiv_sext_small_divisor(i8 %x) {
 
 define i32 @not_sdiv_sext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @not_sdiv_sext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[CONV]], -128
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -51,7 +52,7 @@ define i32 @sdiv_zext_big_divisor(i8 %x) {
 
 define i32 @not_sdiv_zext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @not_sdiv_zext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[CONV]], 255
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -71,7 +72,7 @@ define i32 @sdiv_zext_small_divisor(i8 %x) {
 
 define i32 @not_sdiv_zext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @not_sdiv_zext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[CONV]], -255
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -91,7 +92,7 @@ define i32 @sdiv_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x) {
 
 define i32 @not_sdiv_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @not_sdiv_dividend_known_smaller_than_pos_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[AND]], 253
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -111,7 +112,7 @@ define i32 @sdiv_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x) {
 
 define i32 @not_sdiv_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @not_sdiv_dividend_known_smaller_than_neg_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[AND]], -253
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -131,7 +132,7 @@ define i32 @sdiv_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 
 define i32 @not_sdiv_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @not_sdiv_dividend_known_smaller_than_pos_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[OR]], 253
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -151,7 +152,7 @@ define i32 @sdiv_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 
 define i32 @not_sdiv_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @not_sdiv_dividend_known_smaller_than_neg_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[OR]], -253
 ; CHECK-NEXT:    ret i32 [[DIV]]
 ;
@@ -162,7 +163,7 @@ define i32 @not_sdiv_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 
 define i32 @srem_sext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @srem_sext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %conv = sext i8 %x to i32
@@ -172,7 +173,7 @@ define i32 @srem_sext_big_divisor(i8 %x) {
 
 define i32 @not_srem_sext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @not_srem_sext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[CONV]], 128
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -183,7 +184,7 @@ define i32 @not_srem_sext_big_divisor(i8 %x) {
 
 define i32 @srem_sext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @srem_sext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %conv = sext i8 %x to i32
@@ -193,7 +194,7 @@ define i32 @srem_sext_small_divisor(i8 %x) {
 
 define i32 @not_srem_sext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @not_srem_sext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = sext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = sext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[CONV]], -128
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -204,7 +205,7 @@ define i32 @not_srem_sext_small_divisor(i8 %x) {
 
 define i32 @srem_zext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @srem_zext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %conv = zext i8 %x to i32
@@ -214,7 +215,7 @@ define i32 @srem_zext_big_divisor(i8 %x) {
 
 define i32 @not_srem_zext_big_divisor(i8 %x) {
 ; CHECK-LABEL: @not_srem_zext_big_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[CONV]], 255
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -225,7 +226,7 @@ define i32 @not_srem_zext_big_divisor(i8 %x) {
 
 define i32 @srem_zext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @srem_zext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %conv = zext i8 %x to i32
@@ -235,7 +236,7 @@ define i32 @srem_zext_small_divisor(i8 %x) {
 
 define i32 @not_srem_zext_small_divisor(i8 %x) {
 ; CHECK-LABEL: @not_srem_zext_small_divisor(
-; CHECK-NEXT:    [[CONV:%.*]] = zext i8 %x to i32
+; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[X:%.*]] to i32
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[CONV]], -255
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -246,7 +247,7 @@ define i32 @not_srem_zext_small_divisor(i8 %x) {
 
 define i32 @srem_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @srem_dividend_known_smaller_than_pos_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %and = and i32 %x, 253
@@ -256,7 +257,7 @@ define i32 @srem_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x) {
 
 define i32 @not_srem_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @not_srem_dividend_known_smaller_than_pos_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[AND]], 253
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -267,7 +268,7 @@ define i32 @not_srem_dividend_known_smaller_than_pos_divisor_clear_bits(i32 %x)
 
 define i32 @srem_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @srem_dividend_known_smaller_than_neg_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %and = and i32 %x, 253
@@ -277,7 +278,7 @@ define i32 @srem_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x) {
 
 define i32 @not_srem_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x) {
 ; CHECK-LABEL: @not_srem_dividend_known_smaller_than_neg_divisor_clear_bits(
-; CHECK-NEXT:    [[AND:%.*]] = and i32 %x, 253
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 253
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[AND]], -253
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -288,7 +289,7 @@ define i32 @not_srem_dividend_known_smaller_than_neg_divisor_clear_bits(i32 %x)
 
 define i32 @srem_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @srem_dividend_known_smaller_than_pos_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    ret i32 [[OR]]
 ;
   %or = or i32 %x, -253
@@ -298,7 +299,7 @@ define i32 @srem_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 
 define i32 @not_srem_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @not_srem_dividend_known_smaller_than_pos_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[OR]], 253
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -309,7 +310,7 @@ define i32 @not_srem_dividend_known_smaller_than_pos_divisor_set_bits(i32 %x) {
 
 define i32 @srem_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @srem_dividend_known_smaller_than_neg_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    ret i32 [[OR]]
 ;
   %or = or i32 %x, -253
@@ -319,7 +320,7 @@ define i32 @srem_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 
 define i32 @not_srem_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 ; CHECK-LABEL: @not_srem_dividend_known_smaller_than_neg_divisor_set_bits(
-; CHECK-NEXT:    [[OR:%.*]] = or i32 %x, -253
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -253
 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[OR]], -253
 ; CHECK-NEXT:    ret i32 [[REM]]
 ;
@@ -332,7 +333,7 @@ define i32 @not_srem_dividend_known_smaller_than_neg_divisor_set_bits(i32 %x) {
 
 define i16 @sdiv_min_dividend(i8 %x) {
 ; CHECK-LABEL: @sdiv_min_dividend(
-; CHECK-NEXT:    [[Z:%.*]] = zext i8 %x to i16
+; CHECK-NEXT:    [[Z:%.*]] = zext i8 [[X:%.*]] to i16
 ; CHECK-NEXT:    [[D:%.*]] = sdiv i16 -32768, [[Z]]
 ; CHECK-NEXT:    ret i16 [[D]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/undef.ll b/llvm/test/Transforms/InstSimplify/undef.ll
index cb049bf..b32744f 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/undef.ll
+++ b/llvm/test/Transforms/InstSimplify/undef.ll
@@ -1,8 +1,9 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
 
 define i64 @test0() {
 ; CHECK-LABEL: @test0(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = mul i64 undef, undef
   ret i64 %r
@@ -10,7 +11,7 @@ define i64 @test0() {
 
 define i64 @test1() {
 ; CHECK-LABEL: @test1(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = mul i64 3, undef
   ret i64 %r
@@ -18,7 +19,7 @@ define i64 @test1() {
 
 define i64 @test2() {
 ; CHECK-LABEL: @test2(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = mul i64 undef, 3
   ret i64 %r
@@ -26,7 +27,7 @@ define i64 @test2() {
 
 define i64 @test3() {
 ; CHECK-LABEL: @test3(
-; CHECK:         ret i64 0
+; CHECK-NEXT:    ret i64 0
 ;
   %r = mul i64 undef, 6
   ret i64 %r
@@ -34,7 +35,7 @@ define i64 @test3() {
 
 define i64 @test4() {
 ; CHECK-LABEL: @test4(
-; CHECK:         ret i64 0
+; CHECK-NEXT:    ret i64 0
 ;
   %r = mul i64 6, undef
   ret i64 %r
@@ -42,7 +43,7 @@ define i64 @test4() {
 
 define i64 @test5() {
 ; CHECK-LABEL: @test5(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = and i64 undef, undef
   ret i64 %r
@@ -50,7 +51,7 @@ define i64 @test5() {
 
 define i64 @test6() {
 ; CHECK-LABEL: @test6(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = or i64 undef, undef
   ret i64 %r
@@ -58,7 +59,7 @@ define i64 @test6() {
 
 define i64 @test7() {
 ; CHECK-LABEL: @test7(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = udiv i64 undef, 1
   ret i64 %r
@@ -66,7 +67,7 @@ define i64 @test7() {
 
 define i64 @test8() {
 ; CHECK-LABEL: @test8(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = sdiv i64 undef, 1
   ret i64 %r
@@ -74,7 +75,7 @@ define i64 @test8() {
 
 define i64 @test9() {
 ; CHECK-LABEL: @test9(
-; CHECK:         ret i64 0
+; CHECK-NEXT:    ret i64 0
 ;
   %r = urem i64 undef, 1
   ret i64 %r
@@ -82,7 +83,7 @@ define i64 @test9() {
 
 define i64 @test10() {
 ; CHECK-LABEL: @test10(
-; CHECK:         ret i64 0
+; CHECK-NEXT:    ret i64 0
 ;
   %r = srem i64 undef, 1
   ret i64 %r
@@ -90,7 +91,7 @@ define i64 @test10() {
 
 define i64 @test11() {
 ; CHECK-LABEL: @test11(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = shl i64 undef, undef
   ret i64 %r
@@ -98,7 +99,7 @@ define i64 @test11() {
 
 define i64 @test11b(i64 %a) {
 ; CHECK-LABEL: @test11b(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = shl i64 %a, undef
   ret i64 %r
@@ -106,7 +107,7 @@ define i64 @test11b(i64 %a) {
 
 define i64 @test12() {
 ; CHECK-LABEL: @test12(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = ashr i64 undef, undef
   ret i64 %r
@@ -114,7 +115,7 @@ define i64 @test12() {
 
 define i64 @test12b(i64 %a) {
 ; CHECK-LABEL: @test12b(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = ashr i64 %a, undef
   ret i64 %r
@@ -122,7 +123,7 @@ define i64 @test12b(i64 %a) {
 
 define i64 @test13() {
 ; CHECK-LABEL: @test13(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = lshr i64 undef, undef
   ret i64 %r
@@ -130,7 +131,7 @@ define i64 @test13() {
 
 define i64 @test13b(i64 %a) {
 ; CHECK-LABEL: @test13b(
-; CHECK:         ret i64 poison
+; CHECK-NEXT:    ret i64 poison
 ;
   %r = lshr i64 %a, undef
   ret i64 %r
@@ -138,7 +139,7 @@ define i64 @test13b(i64 %a) {
 
 define i1 @test14() {
 ; CHECK-LABEL: @test14(
-; CHECK:         ret i1 undef
+; CHECK-NEXT:    ret i1 undef
 ;
   %r = icmp slt i64 undef, undef
   ret i1 %r
@@ -146,7 +147,7 @@ define i1 @test14() {
 
 define i1 @test15() {
 ; CHECK-LABEL: @test15(
-; CHECK:         ret i1 undef
+; CHECK-NEXT:    ret i1 undef
 ;
   %r = icmp ult i64 undef, undef
   ret i1 %r
@@ -154,7 +155,7 @@ define i1 @test15() {
 
 define i64 @test16(i64 %a) {
 ; CHECK-LABEL: @test16(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = select i1 undef, i64 %a, i64 undef
   ret i64 %r
@@ -162,7 +163,7 @@ define i64 @test16(i64 %a) {
 
 define i64 @test17(i64 %a) {
 ; CHECK-LABEL: @test17(
-; CHECK:         ret i64 undef
+; CHECK-NEXT:    ret i64 undef
 ;
   %r = select i1 undef, i64 undef, i64 %a
   ret i64 %r
@@ -170,7 +171,7 @@ define i64 @test17(i64 %a) {
 
 define i64 @test18(i64 %a) {
 ; CHECK-LABEL: @test18(
-; CHECK:         [[R:%.*]] = call i64 undef(i64 %a)
+; CHECK-NEXT:    [[R:%.*]] = call i64 undef(i64 [[A:%.*]])
 ; CHECK-NEXT:    ret i64 poison
 ;
   %r = call i64 (i64) undef(i64 %a)
@@ -179,7 +180,7 @@ define i64 @test18(i64 %a) {
 
 define <4 x i8> @test19(<4 x i8> %a) {
 ; CHECK-LABEL: @test19(
-; CHECK:         ret <4 x i8> poison
+; CHECK-NEXT:    ret <4 x i8> poison
 ;
   %b = shl <4 x i8> %a, <i8 8, i8 9, i8 undef, i8 -1>
   ret <4 x i8> %b
@@ -187,7 +188,7 @@ define <4 x i8> @test19(<4 x i8> %a) {
 
 define i32 @test20(i32 %a) {
 ; CHECK-LABEL: @test20(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = udiv i32 %a, 0
   ret i32 %b
@@ -203,7 +204,7 @@ define <2 x i32> @test20vec(<2 x i32> %a) {
 
 define i32 @test21(i32 %a) {
 ; CHECK-LABEL: @test21(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = sdiv i32 %a, 0
   ret i32 %b
@@ -219,7 +220,7 @@ define <2 x i32> @test21vec(<2 x i32> %a) {
 
 define i32 @test22(i32 %a) {
 ; CHECK-LABEL: @test22(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = ashr exact i32 undef, %a
   ret i32 %b
@@ -227,7 +228,7 @@ define i32 @test22(i32 %a) {
 
 define i32 @test23(i32 %a) {
 ; CHECK-LABEL: @test23(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = lshr exact i32 undef, %a
   ret i32 %b
@@ -235,7 +236,7 @@ define i32 @test23(i32 %a) {
 
 define i32 @test24() {
 ; CHECK-LABEL: @test24(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = udiv i32 undef, 0
   ret i32 %b
@@ -243,7 +244,7 @@ define i32 @test24() {
 
 define i32 @test25() {
 ; CHECK-LABEL: @test25(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = lshr i32 0, undef
   ret i32 %b
@@ -251,7 +252,7 @@ define i32 @test25() {
 
 define i32 @test26() {
 ; CHECK-LABEL: @test26(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = ashr i32 0, undef
   ret i32 %b
@@ -259,7 +260,7 @@ define i32 @test26() {
 
 define i32 @test27() {
 ; CHECK-LABEL: @test27(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = shl i32 0, undef
   ret i32 %b
@@ -267,7 +268,7 @@ define i32 @test27() {
 
 define i32 @test28(i32 %a) {
 ; CHECK-LABEL: @test28(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = shl nsw i32 undef, %a
   ret i32 %b
@@ -275,7 +276,7 @@ define i32 @test28(i32 %a) {
 
 define i32 @test29(i32 %a) {
 ; CHECK-LABEL: @test29(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = shl nuw i32 undef, %a
   ret i32 %b
@@ -283,7 +284,7 @@ define i32 @test29(i32 %a) {
 
 define i32 @test30(i32 %a) {
 ; CHECK-LABEL: @test30(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = shl nsw nuw i32 undef, %a
   ret i32 %b
@@ -291,7 +292,7 @@ define i32 @test30(i32 %a) {
 
 define i32 @test31(i32 %a) {
 ; CHECK-LABEL: @test31(
-; CHECK:         ret i32 0
+; CHECK-NEXT:    ret i32 0
 ;
   %b = shl i32 undef, %a
   ret i32 %b
@@ -299,7 +300,7 @@ define i32 @test31(i32 %a) {
 
 define i32 @test32(i32 %a) {
 ; CHECK-LABEL: @test32(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = shl i32 undef, 0
   ret i32 %b
@@ -307,7 +308,7 @@ define i32 @test32(i32 %a) {
 
 define i32 @test33(i32 %a) {
 ; CHECK-LABEL: @test33(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = ashr i32 undef, 0
   ret i32 %b
@@ -315,7 +316,7 @@ define i32 @test33(i32 %a) {
 
 define i32 @test34(i32 %a) {
 ; CHECK-LABEL: @test34(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = lshr i32 undef, 0
   ret i32 %b
@@ -323,7 +324,7 @@ define i32 @test34(i32 %a) {
 
 define i32 @test35(<4 x i32> %V) {
 ; CHECK-LABEL: @test35(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = extractelement <4 x i32> %V, i32 4
   ret i32 %b
@@ -331,7 +332,7 @@ define i32 @test35(<4 x i32> %V) {
 
 define i32 @test36(i32 %V) {
 ; CHECK-LABEL: @test36(
-; CHECK:         ret i32 undef
+; CHECK-NEXT:    ret i32 undef
 ;
   %b = extractelement <4 x i32> undef, i32 %V
   ret i32 %b
@@ -339,7 +340,7 @@ define i32 @test36(i32 %V) {
 
 define i32 @test37() {
 ; CHECK-LABEL: @test37(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = udiv i32 undef, undef
   ret i32 %b
@@ -347,7 +348,7 @@ define i32 @test37() {
 
 define i32 @test38(i32 %a) {
 ; CHECK-LABEL: @test38(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = udiv i32 %a, undef
   ret i32 %b
@@ -355,7 +356,7 @@ define i32 @test38(i32 %a) {
 
 define i32 @test39() {
 ; CHECK-LABEL: @test39(
-; CHECK:         ret i32 poison
+; CHECK-NEXT:    ret i32 poison
 ;
   %b = udiv i32 0, undef
   ret i32 %b

diff --git a/llvm/test/Transforms/InstSimplify/vec-cmp.ll b/llvm/test/Transforms/InstSimplify/vec-cmp.ll
index 07dfad4..6391e9a 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/vec-cmp.ll
+++ b/llvm/test/Transforms/InstSimplify/vec-cmp.ll
@@ -30,7 +30,7 @@ define <2 x i1> @nonzero_vec_undef_elt(<2 x i32> %x) {
 
 define <2 x i1> @may_be_zero_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @may_be_zero_vec(
-; CHECK-NEXT:    [[Y:%.*]] = or <2 x i32> %x, <i32 0, i32 1>
+; CHECK-NEXT:    [[Y:%.*]] = or <2 x i32> [[X:%.*]], <i32 0, i32 1>
 ; CHECK-NEXT:    [[C:%.*]] = icmp ne <2 x i32> [[Y]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 ;

diff --git a/llvm/test/Transforms/InstSimplify/vector_ptr_bitcast.ll b/llvm/test/Transforms/InstSimplify/vector_ptr_bitcast.ll
index 04c9720..80142e1 100644 (file)
--- a/llvm/test/Transforms/InstSimplify/vector_ptr_bitcast.ll
+++ b/llvm/test/Transforms/InstSimplify/vector_ptr_bitcast.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 
@@ -5,31 +6,33 @@ target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 %mst2 = type { i32*, i32*, i32*, i32* }
 
 @a = private unnamed_addr constant %mst { i8* inttoptr (i64 -1 to i8*),
-                                          i8* inttoptr (i64 -1 to i8*)},
-                                          align 8
+  i8* inttoptr (i64 -1 to i8*)},
+  align 8
 @b = private unnamed_addr constant %mst2 { i32* inttoptr (i64 42 to i32*),
-                                           i32* inttoptr (i64 67 to i32*),
-                                           i32* inttoptr (i64 33 to i32*),
-                                           i32* inttoptr (i64 58 to i32*)},
-                                          align 8
+  i32* inttoptr (i64 67 to i32*),
+  i32* inttoptr (i64 33 to i32*),
+  i32* inttoptr (i64 58 to i32*)},
+  align 8
 
 define i64 @fn() {
+; CHECK-LABEL: @fn(
+; CHECK-NEXT:    ret i64 -1
+;
   %x = load <2 x i8*>, <2 x i8*>* bitcast (%mst* @a to <2 x i8*>*), align 8
   %b = extractelement <2 x i8*> %x, i32 0
   %c = ptrtoint i8* %b to i64
-  ; CHECK-LABEL: @fn
-  ; CHECK-NEXT: ret i64 -1
   ret i64 %c
 }
 
 define i64 @fn2() {
+; CHECK-LABEL: @fn2(
+; CHECK-NEXT:    ret i64 100
+;
   %x = load <4 x i32*>, <4 x i32*>* bitcast (%mst2* @b to <4 x i32*>*), align 8
   %b = extractelement <4 x i32*> %x, i32 0
   %c = extractelement <4 x i32*> %x, i32 3
   %d = ptrtoint i32* %b to i64
   %e = ptrtoint i32* %c to i64
   %r = add i64 %d, %e
-  ; CHECK-LABEL: @fn2
-  ; CHECK-NEXT: ret i64 100
   ret i64 %r
 }