[InstCombine] Fold comparison of integers by parts

[nikic]

Summary

Let's say you represent (i32, i32) as an i64 from which the parts are extracted with lshr/trunc. Then, if you compare two tuples by parts you get something like A[0] == B[0] && A[1] == B[1], just that the part extraction happens by lshr/trunc and not a narrow load or similar.

The fold implemented here reduces such equality comparisons by converting them into a comparison on a larger part of the integer (which might be the whole integer). It handle both the "and of eq" and the conjugated "or of ne" case.

I'm being conservative with one-use for now, though this could be relaxed if profitable (the base pattern converts 11 instructions into 5 instructions, but there's quite a few variations on how it can play out).

[nikic]

Also handle "or of ne". Doesn't really make sense to only handle half of the pattern, and it doesn't come at any additional complexity.

[nikic]

Ping!

[spatel]

Sorry for the delay - LGTM.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

static Value *foldUnsignedUnderflowCheck(ICmpInst *ZeroICmp,
   // Base > Offset || (Base - Offset) == 0  -->  Base >= Offset
   if (UnsignedPred == ICmpInst::ICMP_UGT && EqPred == ICmpInst::ICMP_EQ &&
       !IsAnd)
     return Builder.CreateICmpUGE(Base, Offset);
 
   return nullptr;
 }
 
+struct IntPart {
+  Value *From;
+  unsigned StartBit;
+  unsigned NumBits;
+};
+
+/// Match an extraction of bits from an integer.
+static Optional<IntPart> matchIntPart(Value *V) {
+  Value *X;
+  if (!match(V, m_OneUse(m_Trunc(m_Value(X)))))
+    return None;
+
+  unsigned NumOriginalBits = X->getType()->getScalarSizeInBits();
+  unsigned NumExtractedBits = V->getType()->getScalarSizeInBits();
+  Value *Y;
+  const APInt *Shift;
+  // For a trunc(lshr Y, Shift) pattern, make sure we're only extracting bits
+  // from Y, not any shifted-in zeroes.
+  if (match(X, m_OneUse(m_LShr(m_Value(Y), m_APInt(Shift)))) &&
+      Shift->ule(NumOriginalBits - NumExtractedBits))
+    return {{Y, (unsigned) Shift->getZExtValue(), NumExtractedBits}};
+  return {{X, 0, NumExtractedBits}};
+}
+
+/// Materialize an extraction of bits from an integer in IR.
+static Value *extractIntPart(const IntPart &P, IRBuilderBase &Builder) {
+  Value *V = P.From;
+  if (P.StartBit)
+    V = Builder.CreateLShr(V, P.StartBit);
+  Type *TruncTy = V->getType()->getWithNewBitWidth(P.NumBits);
+  if (TruncTy != V->getType())
+    V = Builder.CreateTrunc(V, TruncTy);
+  return V;
+}
+
+/// (icmp eq X0, Y0) & (icmp eq X1, Y1) -> icmp eq X01, Y01
+/// where X0, X1 and Y0, Y1 are adjacent parts extracted from an integer.
+static Value *foldEqOfParts(ICmpInst *Cmp0, ICmpInst *Cmp1,
+                            InstCombiner::BuilderTy &Builder) {
+  if (Cmp0->getPredicate() != ICmpInst::ICMP_EQ ||
+      Cmp1->getPredicate() != ICmpInst::ICMP_EQ)
+    return nullptr;
+
+  if (!Cmp0->hasOneUse() || !Cmp1->hasOneUse())
+    return nullptr;
+
+  Optional<IntPart> L0 = matchIntPart(Cmp0->getOperand(0));
+  Optional<IntPart> R0 = matchIntPart(Cmp0->getOperand(1));
+  Optional<IntPart> L1 = matchIntPart(Cmp1->getOperand(0));
+  Optional<IntPart> R1 = matchIntPart(Cmp1->getOperand(1));
+  if (!L0 || !R0 || !L1 || !R1)
+    return nullptr;
+
+  // Make sure the LHS/RHS compare a part of the same value, possibly after
+  // an operand swap.
+  if (L0->From != L1->From || R0->From != R1->From) {
+    if (L0->From != R1->From || R0->From != L1->From)
+      return nullptr;
+    std::swap(L1, R1);
+  }
+
+  // Make sure the extracted parts are adjacent, canonicalizing to L0/R0 being
+  // the low part and L1/R1 being the high part.
+  if (L0->StartBit + L0->NumBits != L1->StartBit ||
+      R0->StartBit + R0->NumBits != R1->StartBit) {
+    if (L1->StartBit + L1->NumBits != L0->StartBit ||
+        R1->StartBit + R1->NumBits != R0->StartBit)
+      return nullptr;
+    std::swap(L0, L1);
+    std::swap(R0, R1);
+  }
+
+  // We can simplify to a comparison of these larger parts of the integers.
+  IntPart L = {L0->From, L0->StartBit, L0->NumBits + L1->NumBits};
+  IntPart R = {R0->From, R0->StartBit, R0->NumBits + R1->NumBits};
+  Value *LValue = extractIntPart(L, Builder);
+  Value *RValue = extractIntPart(R, Builder);
+  return Builder.CreateICmpEQ(LValue, RValue);
+}
+
 /// Reduce logic-of-compares with equality to a constant by substituting a
 /// common operand with the constant. Callers are expected to call this with
 /// Cmp0/Cmp1 switched to handle logic op commutativity.
 static Value *foldAndOrOfICmpsWithConstEq(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                           BinaryOperator &Logic,
                                           InstCombiner::BuilderTy &Builder,
                                           const SimplifyQuery &Q) {
   bool IsAnd = Logic.getOpcode() == Instruction::And;
Value *InstCombinerImpl::foldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS,
 
   if (Value *X =
           foldUnsignedUnderflowCheck(LHS, RHS, /*IsAnd=*/true, Q, Builder))
     return X;
   if (Value *X =
           foldUnsignedUnderflowCheck(RHS, LHS, /*IsAnd=*/true, Q, Builder))
     return X;
 
+  if (Value *X = foldEqOfParts(LHS, RHS, Builder))
+    return X;
+
   // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2).
   Value *LHS0 = LHS->getOperand(0), *RHS0 = RHS->getOperand(0);
 
   ConstantInt *LHSC, *RHSC;
   if (!match(LHS->getOperand(1), m_ConstantInt(LHSC)) ||
       !match(RHS->getOperand(1), m_ConstantInt(RHSC)))
     return nullptr;
 

llvm/test/Transforms/InstCombine/eq-of-parts.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
 ; Combine equality comparisons of adjacent extracted integers parts into
 ; a comparison of a larger part. Start with some examples...
 
 define i1 @eq_10(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_10(
-; CHECK-NEXT:    [[X_0:%.*]] = trunc i32 [[X:%.*]] to i8
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[Y_0:%.*]] = trunc i32 [[Y:%.*]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[C_0:%.*]] = icmp eq i8 [[X_0]], [[Y_0]]
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_10:%.*]] = and i1 [[C_0]], [[C_1]]
-; CHECK-NEXT:    ret i1 [[C_10]]
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[X:%.*]] to i16
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[Y:%.*]] to i16
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i16 [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret i1 [[TMP3]]
 ;
   %x.0 = trunc i32 %x to i8
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %y.0 = trunc i32 %y to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %c.0 = icmp eq i8 %x.0, %y.0
   %c.1 = icmp eq i8 %x.1, %y.1
   %c.10 = and i1 %c.0, %c.1
   ret i1 %c.10
 }
 
 define i1 @eq_210(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_210(
-; CHECK-NEXT:    [[X_0:%.*]] = trunc i32 [[X:%.*]] to i8
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[Y_0:%.*]] = trunc i32 [[Y:%.*]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[C_0:%.*]] = icmp eq i8 [[X_0]], [[Y_0]]
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_10:%.*]] = and i1 [[C_0]], [[C_1]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_10]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[X:%.*]] to i24
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[Y:%.*]] to i24
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i24 [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret i1 [[TMP3]]
 ;
   %x.0 = trunc i32 %x to i8
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %y.0 = trunc i32 %y to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %y.32 = lshr i32 %y, 16
   %y.2 = trunc i32 %y.32 to i8
   %c.0 = icmp eq i8 %x.0, %y.0
   %c.1 = icmp eq i8 %x.1, %y.1
   %c.2 = icmp eq i8 %x.2, %y.2
   %c.10 = and i1 %c.0, %c.1
   %c.210 = and i1 %c.2, %c.10
   ret i1 %c.210
 }
 
 define i1 @eq_3210(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_3210(
-; CHECK-NEXT:    [[X_0:%.*]] = trunc i32 [[X:%.*]] to i8
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[X_3_EXT:%.*]] = lshr i32 [[X]], 24
-; CHECK-NEXT:    [[X_3:%.*]] = trunc i32 [[X_3_EXT]] to i8
-; CHECK-NEXT:    [[Y_0:%.*]] = trunc i32 [[Y:%.*]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[Y_3_EXT:%.*]] = lshr i32 [[Y]], 24
-; CHECK-NEXT:    [[Y_3:%.*]] = trunc i32 [[Y_3_EXT]] to i8
-; CHECK-NEXT:    [[C_0:%.*]] = icmp eq i8 [[X_0]], [[Y_0]]
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_3:%.*]] = icmp eq i8 [[X_3]], [[Y_3]]
-; CHECK-NEXT:    [[C_10:%.*]] = and i1 [[C_0]], [[C_1]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_10]]
-; CHECK-NEXT:    [[C_3210:%.*]] = and i1 [[C_3]], [[C_210]]
-; CHECK-NEXT:    ret i1 [[C_3210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %x.0 = trunc i32 %x to i8
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %x.3.ext = lshr i32 %x, 24
   %x.3 = trunc i32 %x.3.ext to i8
;
   %c.10 = and i1 %c.0, %c.1
   %c.210 = and i1 %c.2, %c.10
   %c.3210 = and i1 %c.3, %c.210
   ret i1 %c.3210
 }
 
 define i1 @eq_21(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_21(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X:%.*]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y:%.*]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_1]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i32 [[X:%.*]], 8
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr i32 [[Y:%.*]], 8
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc i32 [[TMP3]] to i16
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i16 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret i1 [[TMP5]]
 ;
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %y.32 = lshr i32 %y, 16
   %y.2 = trunc i32 %y.32 to i8
   %c.1 = icmp eq i8 %x.1, %y.1
   %c.2 = icmp eq i8 %x.2, %y.2
   %c.210 = and i1 %c.2, %c.1
   ret i1 %c.210
 }
 
 ; Test commuted variants of eq_21.
 
 define i1 @eq_21_comm_and(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_21_comm_and(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X:%.*]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y:%.*]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_1]], [[C_2]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i32 [[X:%.*]], 8
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr i32 [[Y:%.*]], 8
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc i32 [[TMP3]] to i16
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i16 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret i1 [[TMP5]]
 ;
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %y.32 = lshr i32 %y, 16
   %y.2 = trunc i32 %y.32 to i8
   %c.1 = icmp eq i8 %x.1, %y.1
   %c.2 = icmp eq i8 %x.2, %y.2
   %c.210 = and i1 %c.1, %c.2
   ret i1 %c.210
 }
 
 define i1 @eq_21_comm_eq(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_21_comm_eq(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X:%.*]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y:%.*]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[Y_2]], [[X_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_1]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i32 [[Y:%.*]], 8
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr i32 [[X:%.*]], 8
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc i32 [[TMP3]] to i16
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i16 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret i1 [[TMP5]]
 ;
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %y.32 = lshr i32 %y, 16
   %y.2 = trunc i32 %y.32 to i8
   %c.1 = icmp eq i8 %x.1, %y.1
   %c.2 = icmp eq i8 %y.2, %x.2
   %c.210 = and i1 %c.2, %c.1
   ret i1 %c.210
 }
 
 define i1 @eq_21_comm_eq2(i32 %x, i32 %y) {
 ; CHECK-LABEL: @eq_21_comm_eq2(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i32 [[X:%.*]], 8
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i32 [[X_321]] to i8
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i32 [[X]], 16
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i32 [[X_32]] to i8
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i32 [[Y:%.*]], 8
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i32 [[Y_321]] to i8
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i32 [[Y]], 16
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i32 [[Y_32]] to i8
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i8 [[Y_1]], [[X_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i8 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_1]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i32 [[X:%.*]], 8
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr i32 [[Y:%.*]], 8
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc i32 [[TMP3]] to i16
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i16 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret i1 [[TMP5]]
 ;
   %x.321 = lshr i32 %x, 8
   %x.1 = trunc i32 %x.321 to i8
   %x.32 = lshr i32 %x, 16
   %x.2 = trunc i32 %x.32 to i8
   %y.321 = lshr i32 %y, 8
   %y.1 = trunc i32 %y.321 to i8
   %y.32 = lshr i32 %y, 16
   %y.2 = trunc i32 %y.32 to i8
   %c.1 = icmp eq i8 %y.1, %x.1
   %c.2 = icmp eq i8 %x.2, %y.2
   %c.210 = and i1 %c.2, %c.1
   ret i1 %c.210
 }
 
 ; Test vector variant.
 
 define <2x i1> @eq_21_vector(<2x i32> %x, <2x i32> %y) {
 ; CHECK-LABEL: @eq_21_vector(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 8, i32 8>
-; CHECK-NEXT:    [[X_1:%.*]] = trunc <2 x i32> [[X_321]] to <2 x i8>
-; CHECK-NEXT:    [[X_32:%.*]] = lshr <2 x i32> [[X]], <i32 16, i32 16>
-; CHECK-NEXT:    [[X_2:%.*]] = trunc <2 x i32> [[X_32]] to <2 x i8>
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr <2 x i32> [[Y:%.*]], <i32 8, i32 8>
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc <2 x i32> [[Y_321]] to <2 x i8>
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr <2 x i32> [[Y]], <i32 16, i32 16>
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc <2 x i32> [[Y_32]] to <2 x i8>
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq <2 x i8> [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq <2 x i8> [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and <2 x i1> [[C_2]], [[C_1]]
-; CHECK-NEXT:    ret <2 x i1> [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 8, i32 8>
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc <2 x i32> [[TMP1]] to <2 x i16>
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr <2 x i32> [[Y:%.*]], <i32 8, i32 8>
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc <2 x i32> [[TMP3]] to <2 x i16>
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq <2 x i16> [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret <2 x i1> [[TMP5]]
 ;
   %x.321 = lshr <2x i32> %x, <i32 8, i32 8>
   %x.1 = trunc <2x i32> %x.321 to <2x i8>
   %x.32 = lshr <2x i32> %x, <i32 16, i32 16>
   %x.2 = trunc <2x i32> %x.32 to <2x i8>
   %y.321 = lshr <2x i32> %y, <i32 8, i32 8>
   %y.1 = trunc <2x i32> %y.321 to <2x i8>
   %y.32 = lshr <2x i32> %y, <i32 16, i32 16>
   %y.2 = trunc <2x i32> %y.32 to <2x i8>
   %c.1 = icmp eq <2x i8> %x.1, %y.1
   %c.2 = icmp eq <2x i8> %x.2, %y.2
   %c.210 = and <2x i1> %c.2, %c.1
   ret <2 x i1> %c.210
 }
 
 ; Test irregular bit widths. This also tests the case where
 ; all the involved bit widths and offsets are different.
 
 define i1 @eq_irregular_bit_widths(i31 %x, i31 %y) {
 ; CHECK-LABEL: @eq_irregular_bit_widths(
-; CHECK-NEXT:    [[X_321:%.*]] = lshr i31 [[X:%.*]], 7
-; CHECK-NEXT:    [[X_1:%.*]] = trunc i31 [[X_321]] to i6
-; CHECK-NEXT:    [[X_32:%.*]] = lshr i31 [[X]], 13
-; CHECK-NEXT:    [[X_2:%.*]] = trunc i31 [[X_32]] to i5
-; CHECK-NEXT:    [[Y_321:%.*]] = lshr i31 [[Y:%.*]], 7
-; CHECK-NEXT:    [[Y_1:%.*]] = trunc i31 [[Y_321]] to i6
-; CHECK-NEXT:    [[Y_32:%.*]] = lshr i31 [[Y]], 13
-; CHECK-NEXT:    [[Y_2:%.*]] = trunc i31 [[Y_32]] to i5
-; CHECK-NEXT:    [[C_1:%.*]] = icmp eq i6 [[X_1]], [[Y_1]]
-; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i5 [[X_2]], [[Y_2]]
-; CHECK-NEXT:    [[C_210:%.*]] = and i1 [[C_2]], [[C_1]]
-; CHECK-NEXT:    ret i1 [[C_210]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i31 [[X:%.*]], 7
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i31 [[TMP1]] to i11
+; CHECK-NEXT:    [[TMP3:%.*]] = lshr i31 [[Y:%.*]], 7
+; CHECK-NEXT:    [[TMP4:%.*]] = trunc i31 [[TMP3]] to i11
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i11 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    ret i1 [[TMP5]]
 ;
   %x.321 = lshr i31 %x, 7
   %x.1 = trunc i31 %x.321 to i6
   %x.32 = lshr i31 %x, 13
   %x.2 = trunc i31 %x.32 to i5
   %y.321 = lshr i31 %y, 7
   %y.1 = trunc i31 %y.321 to i6
   %y.32 = lshr i31 %y, 13