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

Still a few stability issues on windows.

This reverts commit 67e3db9bc121ba244e20337aabc7cf341a62b545.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@315058 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Transforms/Scalar/MergeICmps.cpp b/lib/Transforms/Scalar/MergeICmps.cpp
index 1244a9776fac254df785c292bb79c0df5077e258..a56cffcdfa0a5382fa935e7253af470f985493f5 100644 (file)
--- a/lib/Transforms/Scalar/MergeICmps.cpp
+++ b/lib/Transforms/Scalar/MergeICmps.cpp
@@ -28,8 +28,6 @@
 #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"
@@ -43,6 +41,8 @@ namespace {
 
 #define DEBUG_TYPE "mergeicmps"
 
+#define MERGEICMPS_DOT_ON
+
 // A BCE atom.
 struct BCEAtom {
   BCEAtom() : GEP(nullptr), LoadI(nullptr), Offset() {}
@@ -50,21 +50,7 @@ struct BCEAtom {
   const Value *Base() const { return GEP ? GEP->getPointerOperand() : nullptr; }
 
   bool operator<(const BCEAtom &O) const {
-    assert(Base() && "invalid atom");
-    assert(O.Base() && "invalid atom");
-    // Just ordering by (Base(), Offset) is sufficient. However because this
-    // means that the ordering will depend on the addresses of the base
-    // values, which are not reproducible from run to run. To guarantee
-    // stability, we use the names of the values if they exist; we sort by:
-    // (Base.getName(), Base(), Offset).
-    const int NameCmp = Base()->getName().compare(O.Base()->getName());
-    if (NameCmp == 0) {
-      if (Base() == O.Base()) {
-        return Offset.slt(O.Offset);
-      }
-      return Base() < O.Base();
-    }
-    return NameCmp < 0;
+    return Base() == O.Base() ? Offset.slt(O.Offset) : Base() < O.Base();
   }
 
   GetElementPtrInst *GEP;
@@ -113,9 +99,7 @@ BCEAtom visitICmpLoadOperand(Value *const Val) {
 
 // A basic block with a comparison between two BCE atoms.
 // Note: the terminology is misleading: the comparison is symmetric, so there
-// is no real {l/r}hs. What we want though is to have the same base on the
-// left (resp. right), so that we can detect consecutive loads. To ensure this
-// we put the smallest atom on the left.
+// is no real {l/r}hs. To break the symmetry, we use the smallest atom as Lhs.
 class BCECmpBlock {
  public:
   BCECmpBlock() {}
@@ -446,9 +430,10 @@ void BCECmpChain::mergeComparisons(ArrayRef<BCECmpBlock> Comparisons,
 
     IRBuilder<> Builder(BB);
     const auto &DL = Phi.getModule()->getDataLayout();
-    Value *const MemCmpCall = emitMemCmp(
-        FirstComparison.Lhs().GEP, FirstComparison.Rhs().GEP, ConstantInt::get(DL.getIntPtrType(Context), TotalSize),
-        Builder, DL, TLI);
+    Value *const MemCmpCall =
+        emitMemCmp(FirstComparison.Lhs().GEP, FirstComparison.Rhs().GEP,
+                   ConstantInt::get(DL.getIntPtrType(Context), TotalSize),
+                   Builder, DL, TLI);
     Value *const MemCmpIsZero = Builder.CreateICmpEQ(
         MemCmpCall, ConstantInt::get(Type::getInt32Ty(Context), 0));
 
@@ -604,30 +589,22 @@ class MergeICmps : public FunctionPass {
   bool runOnFunction(Function &F) override {
     if (skipFunction(F)) return false;
     const auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
-    const auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
-    auto PA = runImpl(F, &TLI, &TTI);
+    auto PA = runImpl(F, &TLI);
     return !PA.areAllPreserved();
   }
 
  private:
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
-    AU.addRequired<TargetTransformInfoWrapperPass>();
   }
 
-  PreservedAnalyses runImpl(Function &F, const TargetLibraryInfo *TLI,
-                            const TargetTransformInfo *TTI);
+  PreservedAnalyses runImpl(Function &F, const TargetLibraryInfo *TLI);
 };
 
-PreservedAnalyses MergeICmps::runImpl(Function &F, const TargetLibraryInfo *TLI,
-                                      const TargetTransformInfo *TTI) {
+PreservedAnalyses MergeICmps::runImpl(Function &F,
+                                      const TargetLibraryInfo *TLI) {
   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) {
@@ -646,7 +623,6 @@ 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)
 

diff --git a/test/Transforms/MergeICmps/X86/lit.local.cfg b/test/Transforms/MergeICmps/X86/lit.local.cfg
deleted file mode 100644 (file)
index e71f3cc..0000000
--- a/test/Transforms/MergeICmps/X86/lit.local.cfg
+++ /dev/null
@@ -1,3 +0,0 @@
-if not 'X86' in config.root.targets:
-    config.unsupported = True
-

diff --git a/test/Transforms/MergeICmps/X86/pair-int32-int32.ll b/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
deleted file mode 100644 (file)
index e3c70bc..0000000
--- a/test/Transforms/MergeICmps/X86/pair-int32-int32.ll
+++ /dev/null
@@ -1,91 +0,0 @@
-; 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(
-; 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]]
-;
-  %"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 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
-; The entry block with zero-offset GEPs is kept, loads are removed.
-; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; The branch is now a direct branch; the other block has been removed.
-; The phi is updated.
-}
-
-; Same as above, but the two blocks are in inverse order.
-define zeroext i1 @opeq1_inverse(
-; 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]]
-;
-  %"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 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
-; The second block with zero-offset GEPs is kept, loads are removed.
-; CHECK: land.rhs.i
-; The two 4 byte loads and compares are replaced with a single 8-byte memcmp.
-; The branch is now a direct branch; the other block has been removed.
-; The phi is updated.
-}
-
-
-

diff --git a/test/Transforms/MergeICmps/X86/volatile.ll b/test/Transforms/MergeICmps/X86/volatile.ll
deleted file mode 100644 (file)
index 3e9af6c..0000000
--- a/test/Transforms/MergeICmps/X86/volatile.ll
+++ /dev/null
@@ -1,48 +0,0 @@
-; 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
-}
-

diff --git a/test/Transforms/MergeICmps/pair-int32-int32.ll b/test/Transforms/MergeICmps/pair-int32-int32.ll
index 7544b84d861308fb72af36ffcd36302ee1de73c0..351cb2adedf5bb458d7daacb6075d0476a64bc45 100644 (file)
--- a/test/Transforms/MergeICmps/pair-int32-int32.ll
+++ b/test/Transforms/MergeICmps/pair-int32-int32.ll
@@ -1,30 +1,10 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -mergeicmps -S | FileCheck %s --check-prefix=NOEXPANSION
+; RUN: opt -mergeicmps -S -o - %s | FileCheck %s
 
 %"struct.std::pair" = type { i32, i32 }
 
 define zeroext i1 @opeq1(
-; 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]]
-;
-  %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-  %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+    %"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
@@ -44,31 +24,28 @@ land.rhs.i:
 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(
-; 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]]
-;
-  %"struct.std::pair"* nocapture readonly dereferenceable(8) %a,
-  %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
+    %"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 1
   %0 = load i32, i32* %first.i, align 4
@@ -88,6 +65,22 @@ land.rhs.i:
 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
 }
 
 

diff --git a/test/Transforms/MergeICmps/X86/tuple-four-int8.ll b/test/Transforms/MergeICmps/tuple-four-int8.ll
similarity index 57%
rename from test/Transforms/MergeICmps/X86/tuple-four-int8.ll
rename to test/Transforms/MergeICmps/tuple-four-int8.ll
index bd21511ca2363a8a3eafa885d4708c339569cb97..f5e2ab57e04859aa479f76c979cddb9597ba48a9 100644 (file)
--- a/test/Transforms/MergeICmps/X86/tuple-four-int8.ll
+++ b/test/Transforms/MergeICmps/tuple-four-int8.ll
@@ -1,5 +1,4 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -mergeicmps -mtriple=x86_64-unknown-unknown -S | FileCheck %s
+; RUN: opt -mergeicmps -S -o - %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
@@ -18,33 +17,8 @@
 %"struct.std::_Head_base.6" = type { i8 }
 
 define zeroext i1 @opeq(
-; 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:%.*]], 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 i1 [[TMP4]], label [[LAND_RHS_I_I_I_I:%.*]], 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 label [[OPEQ_EXIT]]
-; CHECK:       opeq.exit:
-; CHECK-NEXT:    [[TMP7:%.*]] = phi i1 [ false, [[ENTRY:%.*]] ], [ false, [[LAND_RHS_I_I_I]] ], [ [[CMP_I_I_I_I_I]], [[LAND_RHS_I_I_I_I]] ]
-; CHECK-NEXT:    ret i1 [[TMP7]]
-;
-  %"class.std::tuple"* nocapture readonly dereferenceable(4) %a,
-  %"class.std::tuple"* nocapture readonly dereferenceable(4) %b) local_unnamed_addr #1 {
+    %"class.std::tuple"* nocapture readonly dereferenceable(4) %a,
+    %"class.std::tuple"* nocapture readonly dereferenceable(4) %b) local_unnamed_addr #1 {
 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
@@ -80,11 +54,18 @@ land.rhs.i.i.i.i:
 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

diff --git a/test/Transforms/MergeICmps/volatile.ll b/test/Transforms/MergeICmps/volatile.ll
new file mode 100644 (file)
index 0000000..1df2257
--- /dev/null
+++ b/test/Transforms/MergeICmps/volatile.ll
@@ -0,0 +1,30 @@
+; 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
+}
+