[MergeICmps] Disable mergeicmps if the target does not want to handle memcmp expansion.

[courbet]

Summary

This is to avoid e.g. merging two cheap icmps if the target is not going to expand to something nice later.

[courbet]

Ping

[spatel]

Adding llvm-commits to subscribers.

[spatel]

lib/Transforms/Scalar/MergeICmps.cpp

45–46

Remove rather than comment out?

614

formatting - more spacious.

test/Transforms/MergeICmps/pair-int32-int32.ll

1–2

I suspect (because I've done it a few times myself!) that these tests are going to fail on bots that don't build the x86 target. I think you'll need to create target-specific subdirectories for these tests and split them up into target-independent and target-required RUNs.

You can probably use the test structure under tests/Transforms/SimplifyCFG as a model for how it needs to be done.

[courbet]

• cosmetics
• split the tests into x86 and non-x86

[courbet]

This comment was removed by courbet.

[courbet]

• cosmetics
• split the tests into x86 and non-x86

[courbet]

Thanks, PTAL.

test/Transforms/MergeICmps/pair-int32-int32.ll

1–2

Thanks for the pointer !

[spatel]

lib/Transforms/Scalar/MergeICmps.cpp

581–583

The indentation is non-standard; you should run clang-format before this patch to cleanup.

614

Sorry - that comment wasn't clear. I meant there should be a space after 'if':

if(!TTI...

should be:

if (!TTI...

test/Transforms/MergeICmps/X86/pair-int32-int32.ll

1–2

Here and in the other test files, you should prefer to read the input from file rather than specify a file name as param:
; RUN: opt < %s ...

The benefit is that if you let 'opt' know the filename, it could potentially print that name and the path to that file as part of some debug string. Now if that string happens to match a CHECK line or (more likely) that string happens to match a CHECK-NOT line, the test will fail for that user. This leads to seemingly random test failures and causes great suffering.

This is another reason to prefer complete auto-generation of the CHECK lines using the script at 'utils/update_test_checks.py'. It doesn't generate 'NOT' lines, so there's less risk of hard-to-debug test failure.

40–41

Here and in the other files, I don't think this is working as you expected. If you specify a '--check-prefix', then generic 'CHECK' is no longer used for that RUN. You should make this 'X86-LABEL' in this case.

[courbet]

Rebase on clang-formatted MergeIcmps.cpp

[courbet]

• use update_test_checks.py to generate tests.

[courbet]

Thanks, PTAL.

lib/Transforms/Scalar/MergeICmps.cpp

581–583

I don't know why, but clang-format keeps indenting "public" and "private" to one space (even after I fix these manually). Anything I missed ?

test/Transforms/MergeICmps/X86/pair-int32-int32.ll

1–2

Thanks for the comments. I've regenerated the tests with 'utils/update_test_checks.py'.

[spatel]

LGTM.

lib/Transforms/Scalar/MergeICmps.cpp

581–583

Strange - when I run clang-format locally, it puts the 'public' at the left edge (no indent). Oh well, it was just a nit. :)

[courbet]

Thanks for the review.

lib/Transforms/Scalar/MergeICmps.cpp

 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <numeric>
 #include <utility>
 #include <vector>
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Analysis/Loads.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BuildLibCalls.h"
 
 using namespace llvm;
 
 namespace {
 
 #define DEBUG_TYPE "mergeicmps"
 
-#define MERGEICMPS_DOT_ON
-
 // A BCE atom.
 struct BCEAtom {
   BCEAtom() : GEP(nullptr), LoadI(nullptr), Offset() {}
 
   const Value *Base() const { return GEP ? GEP->getPointerOperand() : nullptr; }
 
   bool operator<(const BCEAtom &O) const {
     return Base() == O.Base() ? Offset.slt(O.Offset) : Base() < O.Base();
   }
bool processPhi(PHINode &Phi, const TargetLibraryInfo *const TLI) {
   if (CmpChain.size() < 2) {
     DEBUG(dbgs() << "skip: only one compare block\n");
     return false;
   }
 
   return CmpChain.simplify(TLI);
 }
 
 class MergeICmps : public FunctionPass {
  public:
   static char ID;
 
   MergeICmps() : FunctionPass(ID) {
     initializeMergeICmpsPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnFunction(Function &F) override {
     if (skipFunction(F)) return false;
     const auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
-    auto PA = runImpl(F, &TLI);
+    const auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
+    auto PA = runImpl(F, &TLI, &TTI);
     return !PA.areAllPreserved();
   }
 
  private:
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
+    AU.addRequired<TargetTransformInfoWrapperPass>();
   }
 
-  PreservedAnalyses runImpl(Function &F, const TargetLibraryInfo *TLI);
+  PreservedAnalyses runImpl(Function &F, const TargetLibraryInfo *TLI,
+                            const TargetTransformInfo *TTI);
 };
 
-PreservedAnalyses MergeICmps::runImpl(Function &F,
-                                      const TargetLibraryInfo *TLI) {
+PreservedAnalyses MergeICmps::runImpl(Function &F, const TargetLibraryInfo *TLI,
+                                      const TargetTransformInfo *TTI) {
   DEBUG(dbgs() << "MergeICmpsPass: " << F.getName() << "\n");
 
+  // We only try merging comparisons if the target wants to expand memcmp later.
+  // The rationale is to avoid turning small chains into memcmp calls.
+  unsigned MaxLoadSize;
+  if (!TTI->enableMemCmpExpansion(MaxLoadSize)) return PreservedAnalyses::all();
+
   bool MadeChange = false;
 
   for (auto BBIt = ++F.begin(); BBIt != F.end(); ++BBIt) {
     // A Phi operation is always first in a basic block.
     if (auto *const Phi = dyn_cast<PHINode>(&*BBIt->begin()))
       MadeChange |= processPhi(*Phi, TLI);
   }
 
   if (MadeChange) return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
 
 }  // namespace
 
 char MergeICmps::ID = 0;
 INITIALIZE_PASS_BEGIN(MergeICmps, "mergeicmps",
                       "Merge contiguous icmps into a memcmp", false, false)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(MergeICmps, "mergeicmps",
                     "Merge contiguous icmps into a memcmp", false, false)
 
 Pass *llvm::createMergeICmpsPass() { return new MergeICmps(); }

test/Transforms/MergeICmps/X86/lit.local.cfg

+if not 'X86' in config.root.targets:
+    config.unsupported = True
+

test/Transforms/MergeICmps/X86/pair-int32-int32.ll

-; RUN: opt -mergeicmps -S -o - %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mergeicmps -mtriple=x86_64-unknown-unknown -S | FileCheck %s --check-prefix=X86
 
 %"struct.std::pair" = type { i32, i32 }
 
 define zeroext i1 @opeq1(
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+; X86-LABEL: @opeq1(
+; X86-NEXT:  entry:
+; X86-NEXT:    [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 0
+; X86-NEXT:    [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 0
+; X86-NEXT:    [[CSTR:%.*]] = bitcast i32* [[FIRST_I]] to i8*
+; X86-NEXT:    [[CSTR1:%.*]] = bitcast i32* [[FIRST1_I]] to i8*
+; X86-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
+; X86-NEXT:    [[TMP0:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; X86-NEXT:    br label [[OPEQ1_EXIT:%.*]]
+; X86:       opeq1.exit:
+; X86-NEXT:    [[TMP1:%.*]] = phi i1 [ [[TMP0]], [[ENTRY:%.*]] ]
+; X86-NEXT:    ret i1 [[TMP1]]
+;
 entry:
   %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
   %0 = load i32, i32* %first.i, align 4
   %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
   %1 = load i32, i32* %first1.i, align 4
   %cmp.i = icmp eq i32 %0, %1
   br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
 
 land.rhs.i:
   %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
   %2 = load i32, i32* %second.i, align 4
   %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
   %3 = load i32, i32* %second2.i, align 4
   %cmp3.i = icmp eq i32 %2, %3
   br label %opeq1.exit
 
 opeq1.exit:
   %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
   ret i1 %4
-; CHECK-LABEL: @opeq1(
 ; The entry block with zero-offset GEPs is kept, loads are removed.
-; CHECK: entry
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
 ; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; CHECK:     @memcmp({{.*}}8)
-; CHECK:     icmp eq {{.*}} 0
 ; The branch is now a direct branch; the other block has been removed.
-; CHECK:     br label %opeq1.exit
-; CHECK-NOT: br
 ; The phi is updated.
-; CHECK:      phi i1 [ %{{[^,]*}}, %entry ]
-; CHECK-NEXT: ret
 }
 
 ; Same as above, but the two blocks are in inverse order.
 define zeroext i1 @opeq1_inverse(
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+; X86-LABEL: @opeq1_inverse(
+; X86-NEXT:  land.rhs.i:
+; X86-NEXT:    [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 0
+; X86-NEXT:    [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 0
+; X86-NEXT:    [[CSTR:%.*]] = bitcast i32* [[SECOND_I]] to i8*
+; X86-NEXT:    [[CSTR1:%.*]] = bitcast i32* [[SECOND2_I]] to i8*
+; X86-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[CSTR]], i8* [[CSTR1]], i64 8)
+; X86-NEXT:    [[TMP0:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; X86-NEXT:    br label [[OPEQ1_EXIT:%.*]]
+; X86:       opeq1.exit:
+; X86-NEXT:    [[TMP1:%.*]] = phi i1 [ [[TMP0]], [[LAND_RHS_I:%.*]] ]
+; X86-NEXT:    ret i1 [[TMP1]]
+;
 entry:
   %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
   %0 = load i32, i32* %first.i, align 4
   %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
   %1 = load i32, i32* %first1.i, align 4
   %cmp.i = icmp eq i32 %0, %1
   br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
 
 land.rhs.i:
   %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
   %2 = load i32, i32* %second.i, align 4
   %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
   %3 = load i32, i32* %second2.i, align 4
   %cmp3.i = icmp eq i32 %2, %3
   br label %opeq1.exit
 
 opeq1.exit:
   %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
   ret i1 %4
-; CHECK-LABEL: @opeq1_inverse(
 ; The second block with zero-offset GEPs is kept, loads are removed.
 ; CHECK: land.rhs.i
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
 ; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; CHECK:     @memcmp({{.*}}8)
-; CHECK:     icmp eq {{.*}} 0
 ; The branch is now a direct branch; the other block has been removed.
-; CHECK:     br label %opeq1.exit
-; CHECK-NOT: br
 ; The phi is updated.
-; CHECK:      phi i1 [ %{{[^,]*}}, %land.rhs.i ]
-; CHECK-NEXT: ret
 }
 
 
 

test/Transforms/MergeICmps/X86/tuple-four-int8.ll

-; RUN: opt -mergeicmps -S -o - %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mergeicmps -mtriple=x86_64-unknown-unknown -S | FileCheck %s
 
 ; This is a more involved test: clang generates this weird pattern for
 ; tuple<uint8_t, uint8_t, uint8_t, uint8_t>. Right now we skip the entry block
 ; (which defines the base pointer for other blocks) and the last one (which
 ; does not have the expected structure). Only middle blocks (bytes [1,2]) are
 ; merged.
 
 %"class.std::tuple" = type { %"struct.std::_Tuple_impl" }
 %"struct.std::_Tuple_impl" = type { %"struct.std::_Tuple_impl.0", %"struct.std::_Head_base.6" }
 %"struct.std::_Tuple_impl.0" = type { %"struct.std::_Tuple_impl.1", %"struct.std::_Head_base.5" }
 %"struct.std::_Tuple_impl.1" = type { %"struct.std::_Tuple_impl.2", %"struct.std::_Head_base.4" }
 %"struct.std::_Tuple_impl.2" = type { %"struct.std::_Head_base" }
 %"struct.std::_Head_base" = type { i8 }
 %"struct.std::_Head_base.4" = type { i8 }
 %"struct.std::_Head_base.5" = type { i8 }
 %"struct.std::_Head_base.6" = type { i8 }
 
 define zeroext i1 @opeq(
-    %"class.std::tuple"* nocapture readonly dereferenceable(4) %a,
-    %"class.std::tuple"* nocapture readonly dereferenceable(4) %b) local_unnamed_addr #1 {
+; CHECK-LABEL: @opeq(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* [[A:%.*]], i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
+; CHECK-NEXT:    [[ADD_PTR_I_I_I_I_I:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i64 3
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[ADD_PTR_I_I_I_I_I]], align 1
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* [[B:%.*]], i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
+; CHECK-NEXT:    [[ADD_PTR_I_I_I6_I_I:%.*]] = getelementptr inbounds i8, i8* [[TMP2]], i64 3
+; CHECK-NEXT:    [[TMP3:%.*]] = load i8, i8* [[ADD_PTR_I_I_I6_I_I]], align 1
+; CHECK-NEXT:    [[CMP_I_I:%.*]] = icmp eq i8 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    br i1 [[CMP_I_I]], label [[LAND_RHS_I_I_I_I:%.*]], label [[OPEQ_EXIT:%.*]]
+; CHECK:       land.rhs.i.i.i:
+; CHECK-NEXT:    [[ADD_PTR_I_I_I_I_I_I_I:%.*]] = getelementptr inbounds i8, i8* [[TMP0]], i64 1
+; CHECK-NEXT:    [[ADD_PTR_I_I_I6_I_I_I_I:%.*]] = getelementptr inbounds i8, i8* [[TMP2]], i64 1
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* [[ADD_PTR_I_I_I6_I_I_I_I]], i8* [[ADD_PTR_I_I_I_I_I_I_I]], i64 2)
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i32 [[MEMCMP]], 0
+; CHECK-NEXT:    br label [[OPEQ_EXIT]]
+; CHECK:       land.rhs.i.i.i.i:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT:    [[TMP6:%.*]] = load i8, i8* [[TMP2]], align 1
+; CHECK-NEXT:    [[CMP_I_I_I_I_I:%.*]] = icmp eq i8 [[TMP5]], [[TMP6]]
+; CHECK-NEXT:    br i1 [[CMP_I_I_I_I_I]], label [[LAND_RHS_I_I_I:%.*]], label [[OPEQ_EXIT]]
+; CHECK:       opeq.exit:
+; CHECK-NEXT:    [[TMP7:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP_I_I_I_I_I]], [[LAND_RHS_I_I_I_I]] ], [ [[TMP4]], [[LAND_RHS_I_I_I]] ]
+; CHECK-NEXT:    ret i1 [[TMP7]]
+;
 entry:
   %0 = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* %a, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
   %add.ptr.i.i.i.i.i = getelementptr inbounds i8, i8* %0, i64 3
   %1 = load i8, i8* %add.ptr.i.i.i.i.i, align 1
   %2 = getelementptr inbounds %"class.std::tuple", %"class.std::tuple"* %b, i64 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0
   %add.ptr.i.i.i6.i.i = getelementptr inbounds i8, i8* %2, i64 3
   %3 = load i8, i8* %add.ptr.i.i.i6.i.i, align 1
   %cmp.i.i = icmp eq i8 %1, %3
land.rhs.i.i.i.i:
   %8 = load i8, i8* %0, align 1
   %9 = load i8, i8* %2, align 1
   %cmp.i.i.i.i.i = icmp eq i8 %8, %9
   br label %opeq.exit
 
 opeq.exit:
   %10 = phi i1 [ false, %entry ], [ false, %land.rhs.i.i ], [ false, %land.rhs.i.i.i ], [ %cmp.i.i.i.i.i, %land.rhs.i.i.i.i ]
   ret i1 %10
-; CHECK-LABEL: @opeq(
 ; The entry block is kept as is, but the next block is now the merged comparison
 ; block for bytes [1,2] or the block for the head.
-; CHECK:     entry
-; CHECK:     br i1 %cmp.i.i, label %land.rhs.i.i.i{{(.i)?}}, label %opeq.exit
 ; The two 1 byte loads and compares at offset 1 are replaced with a single
 ; 2-byte memcmp.
-; CHECK:     land.rhs.i.i.i
-; CHECK:     @memcmp({{.*}}2)
-; CHECK:     icmp eq {{.*}} 0
 ; In the end we have three blocks.
-; CHECK: phi i1
 ; CHECK-SAME %entry
 ; CHECK-SAME %land.rhs.i.i.i.i
 ; CHECK-SAME %land.rhs.i.i.i
 }
 

test/Transforms/MergeICmps/X86/volatile.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mergeicmps -mtriple=x86_64-unknown-unknown -S | FileCheck %s
+
+%"struct.std::pair" = type { i32, i32 }
+
+define zeroext i1 @opeq(
+; CHECK-LABEL: @opeq(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 0
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
+; CHECK-NEXT:    [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
+; CHECK-NEXT:    br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
+; CHECK:       land.rhs.i:
+; CHECK-NEXT:    [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A]], i64 0, i32 1
+; CHECK-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[SECOND_I]], align 4
+; CHECK-NEXT:    [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B]], i64 0, i32 1
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; CHECK-NEXT:    [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
+; CHECK-NEXT:    br label [[OPEQ1_EXIT]]
+; CHECK:       opeq1.exit:
+; CHECK-NEXT:    [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
+; CHECK-NEXT:    ret i1 [[TMP4]]
+;
+  %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
+  %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+entry:
+  %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
+  %0 = load i32, i32* %first.i, align 4
+  %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
+  %1 = load i32, i32* %first1.i, align 4
+  %cmp.i = icmp eq i32 %0, %1
+  br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
+
+land.rhs.i:
+  %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
+  %2 = load volatile i32, i32* %second.i, align 4
+  %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
+  %3 = load i32, i32* %second2.i, align 4
+  %cmp3.i = icmp eq i32 %2, %3
+  br label %opeq1.exit
+
+opeq1.exit:
+  %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
+  ret i1 %4
+}
+

test/Transforms/MergeICmps/pair-int32-int32.ll

-; RUN: opt -mergeicmps -S -o - %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mergeicmps -S | FileCheck %s --check-prefix=NOEXPANSION
 
 %"struct.std::pair" = type { i32, i32 }
 
 define zeroext i1 @opeq1(
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+; NOEXPANSION-LABEL: @opeq1(
+; NOEXPANSION-NEXT:  entry:
+; NOEXPANSION-NEXT:    [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 0
+; NOEXPANSION-NEXT:    [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
+; NOEXPANSION-NEXT:    [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 0
+; NOEXPANSION-NEXT:    [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; NOEXPANSION-NEXT:    [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
+; NOEXPANSION-NEXT:    br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
+; NOEXPANSION:       land.rhs.i:
+; NOEXPANSION-NEXT:    [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A]], i64 0, i32 1
+; NOEXPANSION-NEXT:    [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
+; NOEXPANSION-NEXT:    [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B]], i64 0, i32 1
+; NOEXPANSION-NEXT:    [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; NOEXPANSION-NEXT:    [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
+; NOEXPANSION-NEXT:    br label [[OPEQ1_EXIT]]
+; NOEXPANSION:       opeq1.exit:
+; NOEXPANSION-NEXT:    [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
+; NOEXPANSION-NEXT:    ret i1 [[TMP4]]
+;
 entry:
   %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
   %0 = load i32, i32* %first.i, align 4
   %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
   %1 = load i32, i32* %first1.i, align 4
   %cmp.i = icmp eq i32 %0, %1
   br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
 
 land.rhs.i:
   %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
   %2 = load i32, i32* %second.i, align 4
   %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
   %3 = load i32, i32* %second2.i, align 4
   %cmp3.i = icmp eq i32 %2, %3
   br label %opeq1.exit
 
 opeq1.exit:
   %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
   ret i1 %4
-; CHECK-LABEL: @opeq1(
-; The entry block with zero-offset GEPs is kept, loads are removed.
-; CHECK: entry
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; CHECK:     @memcmp({{.*}}8)
-; CHECK:     icmp eq {{.*}} 0
-; The branch is now a direct branch; the other block has been removed.
-; CHECK:     br label %opeq1.exit
-; CHECK-NOT: br
-; The phi is updated.
-; CHECK:      phi i1 [ %{{[^,]*}}, %entry ]
-; CHECK-NEXT: ret
 }
 
 ; Same as above, but the two blocks are in inverse order.
 define zeroext i1 @opeq1_inverse(
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+; NOEXPANSION-LABEL: @opeq1_inverse(
+; NOEXPANSION-NEXT:  entry:
+; NOEXPANSION-NEXT:    [[FIRST_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A:%.*]], i64 0, i32 1
+; NOEXPANSION-NEXT:    [[TMP0:%.*]] = load i32, i32* [[FIRST_I]], align 4
+; NOEXPANSION-NEXT:    [[FIRST1_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B:%.*]], i64 0, i32 1
+; NOEXPANSION-NEXT:    [[TMP1:%.*]] = load i32, i32* [[FIRST1_I]], align 4
+; NOEXPANSION-NEXT:    [[CMP_I:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
+; NOEXPANSION-NEXT:    br i1 [[CMP_I]], label [[LAND_RHS_I:%.*]], label [[OPEQ1_EXIT:%.*]]
+; NOEXPANSION:       land.rhs.i:
+; NOEXPANSION-NEXT:    [[SECOND_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[A]], i64 0, i32 0
+; NOEXPANSION-NEXT:    [[TMP2:%.*]] = load i32, i32* [[SECOND_I]], align 4
+; NOEXPANSION-NEXT:    [[SECOND2_I:%.*]] = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* [[B]], i64 0, i32 0
+; NOEXPANSION-NEXT:    [[TMP3:%.*]] = load i32, i32* [[SECOND2_I]], align 4
+; NOEXPANSION-NEXT:    [[CMP3_I:%.*]] = icmp eq i32 [[TMP2]], [[TMP3]]
+; NOEXPANSION-NEXT:    br label [[OPEQ1_EXIT]]
+; NOEXPANSION:       opeq1.exit:
+; NOEXPANSION-NEXT:    [[TMP4:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ [[CMP3_I]], [[LAND_RHS_I]] ]
+; NOEXPANSION-NEXT:    ret i1 [[TMP4]]
+;
 entry:
   %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
   %0 = load i32, i32* %first.i, align 4
   %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
   %1 = load i32, i32* %first1.i, align 4
   %cmp.i = icmp eq i32 %0, %1
   br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
 
 land.rhs.i:
   %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
   %2 = load i32, i32* %second.i, align 4
   %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
   %3 = load i32, i32* %second2.i, align 4
   %cmp3.i = icmp eq i32 %2, %3
   br label %opeq1.exit
 
 opeq1.exit:
   %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
   ret i1 %4
-; CHECK-LABEL: @opeq1_inverse(
-; The second block with zero-offset GEPs is kept, loads are removed.
-; CHECK: land.rhs.i
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; CHECK:     getelementptr {{.*}} i32 0
-; CHECK-NOT: load
-; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; CHECK:     @memcmp({{.*}}8)
-; CHECK:     icmp eq {{.*}} 0
-; The branch is now a direct branch; the other block has been removed.
-; CHECK:     br label %opeq1.exit
-; CHECK-NOT: br
-; The phi is updated.
-; CHECK:      phi i1 [ %{{[^,]*}}, %land.rhs.i ]
-; CHECK-NEXT: ret
 }
 
 
 

test/Transforms/MergeICmps/volatile.ll

-; RUN: opt -mergeicmps -S -o - %s | FileCheck %s
-
-%"struct.std::pair" = type { i32, i32 }
-
-define zeroext i1 @opeq(
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-    %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
-entry:
-  %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
-  %0 = load i32, i32* %first.i, align 4
-  %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
-  %1 = load i32, i32* %first1.i, align 4
-  %cmp.i = icmp eq i32 %0, %1
-  br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
-
-land.rhs.i:
-  %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
-  %2 = load volatile i32, i32* %second.i, align 4
-  %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
-  %3 = load i32, i32* %second2.i, align 4
-  %cmp3.i = icmp eq i32 %2, %3
-  br label %opeq1.exit
-
-opeq1.exit:
-  %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
-  ret i1 %4
-; CHECK-LABEL: @opeq(
-; CHECK-NOT: memcmp
-}
-