Revert "Reland [MergeICmps] Adapt to non-eq comparisons, bugfix"

[bgraur]

Summary

Causes miscompile. See https://reviews.llvm.org/D141188.

This reverts commit fb2c98a929aa65603e9d984307a41325e577e9d3

[bgraur]

Thanks to @goncharov for submitting the revert in df3a8f376084cf5e319bccd843105979d0f3b6f1!

Nothing more to be done here.

[Allen]

This patch lands with commit df3a8f3760

llvm/lib/Transforms/Scalar/MergeICmps.cpp

if (!Rhs.BaseId)
     return std::nullopt;
   const auto &DL = CmpI->getModule()->getDataLayout();
   return BCECmp(std::move(Lhs), std::move(Rhs),
                 DL.getTypeSizeInBits(CmpI->getOperand(0)->getType()), CmpI);
 }
 
 // Visit the given comparison block. If this is a comparison between two valid
 // BCE atoms, returns the comparison.
-std::optional<BCECmpBlock>
-visitCmpBlock(Value *const Baseline, ICmpInst::Predicate &Predicate,
-              Value *const Val, BasicBlock *const Block,
-              const BasicBlock *const PhiBlock, BaseIdentifier &BaseId) {
+std::optional<BCECmpBlock> visitCmpBlock(Value *const Val,
+                                         BasicBlock *const Block,
+                                         const BasicBlock *const PhiBlock,
+                                         BaseIdentifier &BaseId) {
   if (Block->empty())
     return std::nullopt;
   auto *const BranchI = dyn_cast<BranchInst>(Block->getTerminator());
   if (!BranchI)
     return std::nullopt;
   LLVM_DEBUG(dbgs() << "branch\n");
   Value *Cond;
   ICmpInst::Predicate ExpectedPredicate;
   if (BranchI->isUnconditional()) {
     // In this case, we expect an incoming value which is the result of the
     // comparison. This is the last link in the chain of comparisons (note
     // that this does not mean that this is the last incoming value, blocks
     // can be reordered).
     Cond = Val;
-    const auto *const ConstBase = cast<ConstantInt>(Baseline);
-    assert(ConstBase->getType()->isIntegerTy(1) &&
-           "Select condition is not an i1?");
-    ExpectedPredicate =
-        ConstBase->isOne() ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ;
-
-    // Remember the correct predicate.
-    Predicate = ExpectedPredicate;
+    ExpectedPredicate = ICmpInst::ICMP_EQ;
   } else {
-    // All the incoming values must be consistent.
-    if (Baseline != Val)
-      return std::nullopt;
     // In this case, we expect a constant incoming value (the comparison is
     // chained).
     const auto *const Const = cast<ConstantInt>(Val);
-    assert(Const->getType()->isIntegerTy(1) &&
-           "Incoming value is not an i1?");
-    LLVM_DEBUG(dbgs() << "const i1 value\n");
-    if (!Const->isZero() && !Const->isOne())
+    LLVM_DEBUG(dbgs() << "const\n");
+    if (!Const->isZero())
       return std::nullopt;
-    LLVM_DEBUG(dbgs() << *Const << "\n");
+    LLVM_DEBUG(dbgs() << "false\n");
     assert(BranchI->getNumSuccessors() == 2 && "expecting a cond branch");
     BasicBlock *const FalseBlock = BranchI->getSuccessor(1);
     Cond = BranchI->getCondition();
     ExpectedPredicate =
         FalseBlock == PhiBlock ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE;
   }
 
   auto *CmpI = dyn_cast<ICmpInst>(Cond);
public:
   }
 
 private:
   PHINode &Phi_;
   // The list of all blocks in the chain, grouped by contiguity.
   std::vector<ContiguousBlocks> MergedBlocks_;
   // The original entry block (before sorting);
   BasicBlock *EntryBlock_;
-  // Remember the predicate type of the chain.
-  ICmpInst::Predicate Predicate_;
 };
 
 static bool areContiguous(const BCECmpBlock &First, const BCECmpBlock &Second) {
   return First.Lhs().BaseId == Second.Lhs().BaseId &&
          First.Rhs().BaseId == Second.Rhs().BaseId &&
          First.Lhs().Offset + First.SizeBits() / 8 == Second.Lhs().Offset &&
          First.Rhs().Offset + First.SizeBits() / 8 == Second.Rhs().Offset;
 }

 
 BCECmpChain::BCECmpChain(const std::vector<BasicBlock *> &Blocks, PHINode &Phi,
                          AliasAnalysis &AA)
     : Phi_(Phi) {
   assert(!Blocks.empty() && "a chain should have at least one block");
   // Now look inside blocks to check for BCE comparisons.
   std::vector<BCECmpBlock> Comparisons;
   BaseIdentifier BaseId;
-  Value *const Baseline = Phi.getIncomingValueForBlock(Blocks[0]);
-  Predicate_ = CmpInst::BAD_ICMP_PREDICATE;
   for (BasicBlock *const Block : Blocks) {
     assert(Block && "invalid block");
-    std::optional<BCECmpBlock> Comparison =
-        visitCmpBlock(Baseline, Predicate_, Phi.getIncomingValueForBlock(Block),
-                      Block, Phi.getParent(), BaseId);
+    std::optional<BCECmpBlock> Comparison = visitCmpBlock(
+        Phi.getIncomingValueForBlock(Block), Block, Phi.getParent(), BaseId);
     if (!Comparison) {
       LLVM_DEBUG(dbgs() << "chain with invalid BCECmpBlock, no merge.\n");
       return;
     }
     if (Comparison->doesOtherWork()) {
       LLVM_DEBUG(dbgs() << "block '" << Comparison->BB->getName()
                         << "' does extra work besides compare\n");
       if (Comparisons.empty()) {
for (int I = 1, E = Comparisons.size(); I < E; ++I) {
         append(BB->getName());
       }
     }
     return Scratch.str();
   }
 };
 } // namespace
 
-// Check whether the current comparisons is the last comparisons.
-// Only the last comparisons chain include the last link (unconditional jmp).
-// Due to reordering of contiguous comparison blocks, the unconditional
-// comparison of a chain maybe not placed at the end of the array comparisons.
-static bool isLastLinkComparison(ArrayRef<BCECmpBlock> Comparisons) {
-  for (unsigned i = 0; i < Comparisons.size(); i++) {
-    BasicBlock *const BB = Comparisons[i].BB;
-    auto *const BranchI = cast<BranchInst>(BB->getTerminator());
-    // Only the last comparisons chain include the unconditional jmp
-    if (BranchI->isUnconditional())
-      return true;
-  }
-  return false;
-}
-
 // Merges the given contiguous comparison blocks into one memcmp block.
 static BasicBlock *mergeComparisons(ArrayRef<BCECmpBlock> Comparisons,
                                     BasicBlock *const InsertBefore,
                                     BasicBlock *const NextCmpBlock,
                                     PHINode &Phi, const TargetLibraryInfo &TLI,
-                                    AliasAnalysis &AA, DomTreeUpdater &DTU,
-                                    ICmpInst::Predicate Predicate) {
+                                    AliasAnalysis &AA, DomTreeUpdater &DTU) {
   assert(!Comparisons.empty() && "merging zero comparisons");
   LLVMContext &Context = NextCmpBlock->getContext();
   const BCECmpBlock &FirstCmp = Comparisons[0];
 
   // Create a new cmp block before next cmp block.
   BasicBlock *const BB =
       BasicBlock::Create(Context, MergedBlockName(Comparisons).Name,
                          NextCmpBlock->getParent(), InsertBefore);
   IRBuilder<> Builder(BB);
   // Add the GEPs from the first BCECmpBlock.
   Value *Lhs, *Rhs;
   if (FirstCmp.Lhs().GEP)
     Lhs = Builder.Insert(FirstCmp.Lhs().GEP->clone());
   else
     Lhs = FirstCmp.Lhs().LoadI->getPointerOperand();
   if (FirstCmp.Rhs().GEP)
     Rhs = Builder.Insert(FirstCmp.Rhs().GEP->clone());
   else
     Rhs = FirstCmp.Rhs().LoadI->getPointerOperand();
 
-  Value *ICmpValue = nullptr;
+  Value *IsEqual = nullptr;
   LLVM_DEBUG(dbgs() << "Merging " << Comparisons.size() << " comparisons -> "
                     << BB->getName() << "\n");
 
   // If there is one block that requires splitting, we do it now, i.e.
   // just before we know we will collapse the chain. The instructions
   // can be executed before any of the instructions in the chain.
   const auto ToSplit = llvm::find_if(
       Comparisons, [](const BCECmpBlock &B) { return B.RequireSplit; });
   if (ToSplit != Comparisons.end()) {
     LLVM_DEBUG(dbgs() << "Splitting non_BCE work to header\n");
     ToSplit->split(BB, AA);
   }
 
-  // For a Icmp chain, the Predicate is record the last link in the chain of
-  // comparisons. When we spilt the chain The new spilted chain of comparisons
-  // is end with ICMP_EQ.
-  ICmpInst::Predicate Pred =
-      isLastLinkComparison(Comparisons) ? Predicate : ICmpInst::ICMP_EQ;
   if (Comparisons.size() == 1) {
     LLVM_DEBUG(dbgs() << "Only one comparison, updating branches\n");
     // Use clone to keep the metadata
     Instruction *const LhsLoad = Builder.Insert(FirstCmp.Lhs().LoadI->clone());
     Instruction *const RhsLoad = Builder.Insert(FirstCmp.Rhs().LoadI->clone());
     LhsLoad->replaceUsesOfWith(LhsLoad->getOperand(0), Lhs);
     RhsLoad->replaceUsesOfWith(RhsLoad->getOperand(0), Rhs);
     // There are no blocks to merge, just do the comparison.
-    ICmpValue = Builder.CreateICmp(Pred, LhsLoad, RhsLoad);
+    IsEqual = Builder.CreateICmpEQ(LhsLoad, RhsLoad);
   } else {
     const unsigned TotalSizeBits = std::accumulate(
         Comparisons.begin(), Comparisons.end(), 0u,
         [](int Size, const BCECmpBlock &C) { return Size + C.SizeBits(); });
 
     // memcmp expects a 'size_t' argument and returns 'int'.
     unsigned SizeTBits = TLI.getSizeTSize(*Phi.getModule());
     unsigned IntBits = TLI.getIntSize();
 
     // Create memcmp() == 0.
     const auto &DL = Phi.getModule()->getDataLayout();
     Value *const MemCmpCall = emitMemCmp(
         Lhs, Rhs,
         ConstantInt::get(Builder.getIntNTy(SizeTBits), TotalSizeBits / 8),
         Builder, DL, &TLI);
-    ICmpValue = Builder.CreateICmp(
-        Pred, MemCmpCall, ConstantInt::get(Builder.getIntNTy(IntBits), 0));
+    IsEqual = Builder.CreateICmpEQ(
+        MemCmpCall, ConstantInt::get(Builder.getIntNTy(IntBits), 0));
   }
 
   BasicBlock *const PhiBB = Phi.getParent();
   // Add a branch to the next basic block in the chain.
   if (NextCmpBlock == PhiBB) {
     // Continue to phi, passing it the comparison result.
     Builder.CreateBr(PhiBB);
-    Phi.addIncoming(ICmpValue, BB);
+    Phi.addIncoming(IsEqual, BB);
     DTU.applyUpdates({{DominatorTree::Insert, BB, PhiBB}});
   } else {
     // Continue to next block if equal, exit to phi else.
-    Builder.CreateCondBr(ICmpValue, NextCmpBlock, PhiBB);
-    Value *ConstantVal = Predicate == CmpInst::ICMP_NE
-                             ? ConstantInt::getTrue(Context)
-                             : ConstantInt::getFalse(Context);
-    Phi.addIncoming(ConstantVal, BB);
+    Builder.CreateCondBr(IsEqual, NextCmpBlock, PhiBB);
+    Phi.addIncoming(ConstantInt::getFalse(Context), BB);
     DTU.applyUpdates({{DominatorTree::Insert, BB, NextCmpBlock},
                       {DominatorTree::Insert, BB, PhiBB}});
   }
   return BB;
 }
 
 bool BCECmpChain::simplify(const TargetLibraryInfo &TLI, AliasAnalysis &AA,
                            DomTreeUpdater &DTU) {
   assert(atLeastOneMerged() && "simplifying trivial BCECmpChain");
   LLVM_DEBUG(dbgs() << "Simplifying comparison chain starting at block "
                     << EntryBlock_->getName() << "\n");
 
   // Effectively merge blocks. We go in the reverse direction from the phi block
   // so that the next block is always available to branch to.
   BasicBlock *InsertBefore = EntryBlock_;
   BasicBlock *NextCmpBlock = Phi_.getParent();
-  assert(Predicate_ != CmpInst::BAD_ICMP_PREDICATE &&
-         "Got the chain of comparisons");
   for (const auto &Blocks : reverse(MergedBlocks_)) {
     InsertBefore = NextCmpBlock = mergeComparisons(
-        Blocks, InsertBefore, NextCmpBlock, Phi_, TLI, AA, DTU, Predicate_);
+        Blocks, InsertBefore, NextCmpBlock, Phi_, TLI, AA, DTU);
   }
 
   // Replace the original cmp chain with the new cmp chain by pointing all
   // predecessors of EntryBlock_ to NextCmpBlock instead. This makes all cmp
   // blocks in the old chain unreachable.
   while (!pred_empty(EntryBlock_)) {
     BasicBlock* const Pred = *pred_begin(EntryBlock_);
     LLVM_DEBUG(dbgs() << "Updating jump into old chain from " << Pred->getName()

llvm/test/Transforms/MergeICmps/X86/pr59740.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=mergeicmps -verify-dom-info -S -mtriple=x86_64-unknown-unknown | FileCheck %s
 
 %struct.S = type { i8, i8, i8, i8 }
 %struct1.S = type { i32, i32, i32, i8 }
 %"struct.media::WebrtcVideoStatsDB::VideoDescKey" = type { i8, i32, i8, i32 }
 %"c" = type { i32, i32, i32, float}
 
 define noundef i1 @full_sequent_ne(ptr nocapture readonly align 1 dereferenceable(4) %s0, ptr nocapture readonly align 1 dereferenceable(4) %s1) {
 ; CHECK-LABEL: @full_sequent_ne(
-; CHECK-NEXT:  "bb0+bb1+bb2+bb3":
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[S0:%.*]], ptr [[S1:%.*]], i64 4)
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i32 [[MEMCMP]], 0
-; CHECK-NEXT:    br label [[BB4:%.*]]
+; CHECK-NEXT:  bb0:
+; CHECK-NEXT:    [[V0:%.*]] = load i8, ptr [[S0:%.*]], align 1
+; CHECK-NEXT:    [[V1:%.*]] = load i8, ptr [[S1:%.*]], align 1
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i8 [[V0]], [[V1]]
+; CHECK-NEXT:    br i1 [[CMP0]], label [[BB1:%.*]], label [[BB4:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[S2:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], ptr [[S0]], i64 0, i32 1
+; CHECK-NEXT:    [[V2:%.*]] = load i8, ptr [[S2]], align 1
+; CHECK-NEXT:    [[S3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S1]], i64 0, i32 1
+; CHECK-NEXT:    [[V3:%.*]] = load i8, ptr [[S3]], align 1
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[V2]], [[V3]]
+; CHECK-NEXT:    br i1 [[CMP1]], label [[BB2:%.*]], label [[BB4]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[S4:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S0]], i64 0, i32 2
+; CHECK-NEXT:    [[V4:%.*]] = load i8, ptr [[S4]], align 1
+; CHECK-NEXT:    [[S5:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S1]], i64 0, i32 2
+; CHECK-NEXT:    [[V5:%.*]] = load i8, ptr [[S5]], align 1
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[V4]], [[V5]]
+; CHECK-NEXT:    br i1 [[CMP2]], label [[BB3:%.*]], label [[BB4]]
+; CHECK:       bb3:
+; CHECK-NEXT:    [[S6:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S0]], i64 0, i32 3
+; CHECK-NEXT:    [[V6:%.*]] = load i8, ptr [[S6]], align 1
+; CHECK-NEXT:    [[S7:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S1]], i64 0, i32 3
+; CHECK-NEXT:    [[V7:%.*]] = load i8, ptr [[S7]], align 1
+; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i8 [[V6]], [[V7]]
+; CHECK-NEXT:    br label [[BB4]]
 ; CHECK:       bb4:
-; CHECK-NEXT:    ret i1 [[TMP0]]
+; CHECK-NEXT:    [[CMP:%.*]] = phi i1 [ true, [[BB0:%.*]] ], [ true, [[BB1]] ], [ true, [[BB2]] ], [ [[CMP3]], [[BB3]] ]
+; CHECK-NEXT:    ret i1 [[CMP]]
 ;
 bb0:
   %v0 = load i8, ptr %s0, align 1
   %v1 = load i8, ptr %s1, align 1
   %cmp0 = icmp eq i8 %v0, %v1
   br i1 %cmp0, label %bb1, label %bb4
 
 bb1:                                              ; preds = %bb0

 bb3:                                               ; preds = %bb0, %bb1, %bb2
   %cmp = phi i1 [ false, %bb0 ], [ false, %bb1 ], [ %cmp3, %bb2 ]
   ret i1 %cmp
 }
 
 ; https://alive2.llvm.org/ce/z/sL5Uz6
 define noundef i1 @partial_sequent_ne(ptr nocapture readonly dereferenceable(16) %s0, ptr nocapture readonly dereferenceable(16) %s1) {
 ; CHECK-LABEL: @partial_sequent_ne(
-; CHECK-NEXT:  bb01:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[S0:%.*]], align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[S1:%.*]], align 8
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
-; CHECK-NEXT:    br i1 [[TMP2]], label %"bb1+bb2", label [[BB3:%.*]]
-; CHECK:       "bb1+bb2":
-; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[STRUCT1_S:%.*]], ptr [[S0]], i64 0, i32 2
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [[STRUCT1_S]], ptr [[S1]], i64 0, i32 2
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP3]], ptr [[TMP4]], i64 5)
-; CHECK-NEXT:    [[TMP5:%.*]] = icmp ne i32 [[MEMCMP]], 0
+; CHECK-NEXT:  bb0:
+; CHECK-NEXT:    [[V0:%.*]] = load i32, ptr [[S0:%.*]], align 8
+; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[S1:%.*]], align 8
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i32 [[V0]], [[V1]]
+; CHECK-NEXT:    br i1 [[CMP0]], label [[BB1:%.*]], label [[BB3:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[S2:%.*]] = getelementptr inbounds [[STRUCT1_S:%.*]], ptr [[S0]], i64 0, i32 2
+; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[S2]], align 8
+; CHECK-NEXT:    [[S3:%.*]] = getelementptr inbounds [[STRUCT1_S]], ptr [[S1]], i64 0, i32 2
+; CHECK-NEXT:    [[V3:%.*]] = load i32, ptr [[S3]], align 8
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[V2]], [[V3]]
+; CHECK-NEXT:    br i1 [[CMP1]], label [[BB2:%.*]], label [[BB3]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[S6:%.*]] = getelementptr inbounds [[STRUCT1_S]], ptr [[S0]], i64 0, i32 3
+; CHECK-NEXT:    [[V6:%.*]] = load i8, ptr [[S6]], align 1
+; CHECK-NEXT:    [[S7:%.*]] = getelementptr inbounds [[STRUCT1_S]], ptr [[S1]], i64 0, i32 3
+; CHECK-NEXT:    [[V7:%.*]] = load i8, ptr [[S7]], align 1
+; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i8 [[V6]], [[V7]]
 ; CHECK-NEXT:    br label [[BB3]]
 ; CHECK:       bb3:
-; CHECK-NEXT:    [[CMP:%.*]] = phi i1 [ [[TMP5]], %"bb1+bb2" ], [ true, [[BB01:%.*]] ]
+; CHECK-NEXT:    [[CMP:%.*]] = phi i1 [ true, [[BB0:%.*]] ], [ true, [[BB1]] ], [ [[CMP3]], [[BB2]] ]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
 bb0:
   %v0 = load i32, ptr %s0, align 8
   %v1 = load i32, ptr %s1, align 8
   %cmp0 = icmp eq i32 %v0, %v1
   br i1 %cmp0, label %bb1, label %bb3
 

 bb3:                                               ; preds = %bb0, %bb1, %bb2
   %cmp = phi i1 [ true, %bb0 ], [ true, %bb1 ], [ %cmp3, %bb2 ]
   ret i1 %cmp
 }
 
 ; https://alive2.llvm.org/ce/z/EQtb_S
 define i1 @WebrtcVideoStats(ptr nocapture noundef dereferenceable(16) %S0, ptr nocapture noundef dereferenceable(16) %S1) {
 ; CHECK-LABEL: @WebrtcVideoStats(
-; CHECK-NEXT:  bb02:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[S0:%.*]], align 4
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[S1:%.*]], align 4
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i8 [[TMP0]], [[TMP1]]
-; CHECK-NEXT:    br i1 [[TMP2]], label %"bb1+bb2", label [[BB4:%.*]]
-; CHECK:       "bb1+bb2":
-; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S0]], i64 0, i32 1
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S1]], i64 0, i32 1
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP3]], ptr [[TMP4]], i64 5)
-; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i32 [[MEMCMP]], 0
-; CHECK-NEXT:    br i1 [[TMP5]], label [[BB31:%.*]], label [[BB4]]
-; CHECK:       bb31:
-; CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S0]], i64 0, i32 3
-; CHECK-NEXT:    [[TMP7:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S1]], i64 0, i32 3
-; CHECK-NEXT:    [[TMP8:%.*]] = load i32, ptr [[TMP6]], align 4
-; CHECK-NEXT:    [[TMP9:%.*]] = load i32, ptr [[TMP7]], align 4
-; CHECK-NEXT:    [[TMP10:%.*]] = icmp ne i32 [[TMP8]], [[TMP9]]
+; CHECK-NEXT:  bb0:
+; CHECK-NEXT:    [[V0:%.*]] = load i8, ptr [[S0:%.*]], align 4
+; CHECK-NEXT:    [[V1:%.*]] = load i8, ptr [[S1:%.*]], align 4
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i8 [[V0]], [[V1]]
+; CHECK-NEXT:    br i1 [[CMP0]], label [[BB1:%.*]], label [[BB4:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[BASE2:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S0]], i64 0, i32 1
+; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[BASE2]], align 4
+; CHECK-NEXT:    [[BASE3:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S1]], i64 0, i32 1
+; CHECK-NEXT:    [[V3:%.*]] = load i32, ptr [[BASE3]], align 4
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[V2]], [[V3]]
+; CHECK-NEXT:    br i1 [[CMP1]], label [[BB2:%.*]], label [[BB4]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[BASE4:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S0]], i64 0, i32 2
+; CHECK-NEXT:    [[V4:%.*]] = load i8, ptr [[BASE4]], align 4
+; CHECK-NEXT:    [[BASE5:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S1]], i64 0, i32 2
+; CHECK-NEXT:    [[V5:%.*]] = load i8, ptr [[BASE5]], align 4
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i8 [[V4]], [[V5]]
+; CHECK-NEXT:    br i1 [[CMP2]], label [[BB3:%.*]], label [[BB4]]
+; CHECK:       bb3:
+; CHECK-NEXT:    [[BASE6:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S0]], i64 0, i32 3
+; CHECK-NEXT:    [[V6:%.*]] = load i32, ptr [[BASE6]], align 4
+; CHECK-NEXT:    [[BASE7:%.*]] = getelementptr inbounds %"struct.media::WebrtcVideoStatsDB::VideoDescKey", ptr [[S1]], i64 0, i32 3
+; CHECK-NEXT:    [[V7:%.*]] = load i32, ptr [[BASE7]], align 4
+; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i32 [[V6]], [[V7]]
 ; CHECK-NEXT:    br label [[BB4]]
 ; CHECK:       bb4:
-; CHECK-NEXT:    [[RESULT:%.*]] = phi i1 [ [[TMP10]], [[BB31]] ], [ true, %"bb1+bb2" ], [ true, [[BB02:%.*]] ]
+; CHECK-NEXT:    [[RESULT:%.*]] = phi i1 [ [[CMP3]], [[BB3]] ], [ true, [[BB2]] ], [ true, [[BB1]] ], [ true, [[BB0:%.*]] ]
 ; CHECK-NEXT:    ret i1 [[RESULT]]
 ;
 bb0:
   %V0 = load i8, ptr %S0, align 4
   %V1 = load i8, ptr %S1, align 4
   %Cmp0 = icmp eq i8 %V0, %V1
   br i1 %Cmp0, label %bb1, label %bb4
 

 
 bb4:                                               ; preds = %bb3, %bb2, %bb1, %bb0
   %result = phi i1 [ %Cmp3, %bb3 ], [ true, %bb2 ], [ true, %bb1 ], [ true, %bb0 ]
   ret i1 %result
 }
 
 ; the comparison link sequence will be reordered according the memory offset,
 ; and the unconditionla comparison will not at the end of the chain.
-define i1 @full_revert_order_ne(ptr nocapture noundef nonnull readonly dereferenceable(24) %0,
+define i1 @full_revert_order_ne(ptr nocapture noundef nonnull readonly dereferenceable(24) %0, ptr nocapture noundef nonnull readonly dereferenceable(24) %1) {
 ; CHECK-LABEL: @full_revert_order_ne(
-; CHECK-NEXT:  "bb2+bb1+bb0":
-; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds [[C:%.*]], ptr [[TMP0:%.*]], i64 0, i32 0
-; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[C]], ptr [[TMP1:%.*]], i64 0, i32 0
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(ptr [[TMP2]], ptr [[TMP3]], i64 12)
-; CHECK-NEXT:    [[TMP4:%.*]] = icmp ne i32 [[MEMCMP]], 0
-; CHECK-NEXT:    br label [[BB3:%.*]]
+; CHECK-NEXT:  bb0:
+; CHECK-NEXT:    [[S0:%.*]] = getelementptr inbounds [[C:%.*]], ptr [[TMP0:%.*]], i64 0, i32 2
+; CHECK-NEXT:    [[V0:%.*]] = load i32, ptr [[S0]], align 4
+; CHECK-NEXT:    [[S1:%.*]] = getelementptr inbounds [[C]], ptr [[TMP1:%.*]], i64 0, i32 2
+; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[S1]], align 4
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp eq i32 [[V0]], [[V1]]
+; CHECK-NEXT:    br i1 [[CMP0]], label [[BB1:%.*]], label [[BB3:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[S2:%.*]] = getelementptr inbounds [[C]], ptr [[TMP0]], i64 0, i32 1
+; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[S2]], align 4
+; CHECK-NEXT:    [[S3:%.*]] = getelementptr inbounds [[C]], ptr [[TMP1]], i64 0, i32 1
+; CHECK-NEXT:    [[V3:%.*]] = load i32, ptr [[S3]], align 4
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[V2]], [[V3]]
+; CHECK-NEXT:    br i1 [[CMP1]], label [[BB2:%.*]], label [[BB3]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[S4:%.*]] = getelementptr inbounds [[C]], ptr [[TMP0]], i64 0, i32 0
+; CHECK-NEXT:    [[V4:%.*]] = load i32, ptr [[S4]], align 4
+; CHECK-NEXT:    [[S5:%.*]] = getelementptr inbounds [[C]], ptr [[TMP1]], i64 0, i32 0
+; CHECK-NEXT:    [[V5:%.*]] = load i32, ptr [[S5]], align 4
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i32 [[V4]], [[V5]]
+; CHECK-NEXT:    br label [[BB3]]
 ; CHECK:       bb3:
-; CHECK-NEXT:    ret i1 [[TMP4]]
+; CHECK-NEXT:    [[CMP3:%.*]] = phi i1 [ true, [[BB1]] ], [ true, [[BB0:%.*]] ], [ [[CMP2]], [[BB2]] ]
+; CHECK-NEXT:    ret i1 [[CMP3]]
 ;
-  ptr nocapture noundef nonnull readonly dereferenceable(24) %1) {
 bb0:
   %s0 = getelementptr inbounds %"c", ptr %0, i64 0, i32 2
   %v0 = load i32, ptr %s0, align 4
   %s1 = getelementptr inbounds %"c", ptr %1, i64 0, i32 2
   %v1 = load i32, ptr %s1, align 4
   %cmp0 = icmp eq i32 %v0, %v1
   br i1 %cmp0, label %bb1, label %bb3