This is an archive of the discontinued LLVM Phabricator instance.

Differential D38232

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

Authored by courbet on Sep 25 2017, 4:15 AM.

Details

Reviewers
• dberlin
spatel
Commits
rG902eef32ebd1: [MergeICmps] Disable mergeicmps if the target does not want to handle memcmp…
rL314970: [MergeICmps] Disable mergeicmps if the target does not want to handle memcmp…
Summary

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

Diff Detail

Repository
rL LLVM

Event Timeline

courbet created this revision.Sep 25 2017, 4:15 AM
Harbormaster completed remote builds in B10568: Diff 116514.Sep 25 2017, 5:05 AM
courbet added a comment.Oct 3 2017, 3:58 AM

Ping

spatel edited edge metadata.Oct 3 2017, 2:32 PM
spatel added a subscriber: llvm-commits.

Adding llvm-commits to subscribers.

spatel added inline comments.Oct 3 2017, 2:40 PM
lib/Transforms/Scalar/MergeICmps.cpp
46 ↗(On Diff #116514)

Remove rather than comment out?

633 ↗(On Diff #116514)

formatting - more spacious.

test/Transforms/MergeICmps/pair-int32-int32.ll
1 ↗(On Diff #116514)

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 updated this revision to Diff 117644.Oct 4 2017, 2:43 AM
courbet marked 3 inline comments as done.
  • cosmetics
  • split the tests into x86 and non-x86
Herald added a subscriber: kbarton. · View Herald TranscriptOct 4 2017, 2:43 AM
courbet updated this revision to Diff 117645.Oct 4 2017, 2:46 AM
This comment was removed by courbet.
Harbormaster completed remote builds in B10816: Diff 117645.Oct 4 2017, 2:46 AM
courbet updated this revision to Diff 117647.Oct 4 2017, 2:50 AM
  • cosmetics
  • split the tests into x86 and non-x86
courbet added a comment.Oct 4 2017, 2:51 AM

Thanks, PTAL.

test/Transforms/MergeICmps/pair-int32-int32.ll
1 ↗(On Diff #116514)

Thanks for the pointer !

spatel added inline comments.Oct 4 2017, 7:17 AM
lib/Transforms/Scalar/MergeICmps.cpp
597–599 ↗(On Diff #117647)

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

631 ↗(On Diff #117647)

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 ↗(On Diff #117647)

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.

27 ↗(On Diff #117647)

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 updated this revision to Diff 117675.Oct 4 2017, 8:17 AM

Rebase on clang-formatted MergeIcmps.cpp

Harbormaster completed remote builds in B10829: Diff 117675.Oct 4 2017, 8:17 AM
courbet updated this revision to Diff 117683.Oct 4 2017, 9:21 AM
courbet marked 3 inline comments as done.
  • use update_test_checks.py to generate tests.
courbet added a comment.Oct 4 2017, 9:22 AM

Thanks, PTAL.

lib/Transforms/Scalar/MergeICmps.cpp
597–599 ↗(On Diff #117647)

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 ↗(On Diff #117647)

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

spatel accepted this revision.Oct 4 2017, 9:31 AM

LGTM.

lib/Transforms/Scalar/MergeICmps.cpp
597–599 ↗(On Diff #117647)

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

This revision is now accepted and ready to land.Oct 4 2017, 9:31 AM
courbet added a comment.Oct 5 2017, 12:48 AM

Thanks for the review.

Closed by commit rL314970: [MergeICmps] Disable mergeicmps if the target does not want to handle memcmp… (authored by courbet). · Explain WhyOct 5 2017, 12:50 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
Transforms/
Scalar/
21 lines
test/
Transforms/
MergeICmps/
X86/
3 lines
91 lines
92 lines
48 lines
81 lines
73 lines
30 lines

Diff 117780

llvm/trunk/lib/Transforms/Scalar/MergeICmps.cpp

Show All 22 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <algorithm> #include <algorithm>
#include <numeric> #include <numeric>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
#include "llvm/Analysis/Loads.h" #include "llvm/Analysis/Loads.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/BuildLibCalls.h" #include "llvm/Transforms/Utils/BuildLibCalls.h"
using namespace llvm; using namespace llvm;
namespace { namespace {
#define DEBUG_TYPE "mergeicmps" #define DEBUG_TYPE "mergeicmps"
#define MERGEICMPS_DOT_ON
// A BCE atom. // A BCE atom.
struct BCEAtom { struct BCEAtom {
BCEAtom() : GEP(nullptr), LoadI(nullptr), Offset() {} BCEAtom() : GEP(nullptr), LoadI(nullptr), Offset() {}
const Value *Base() const { return GEP ? GEP->getPointerOperand() : nullptr; } const Value *Base() const { return GEP ? GEP->getPointerOperand() : nullptr; }
bool operator<(const BCEAtom &O) const { bool operator<(const BCEAtom &O) const {
return Base() == O.Base() ? Offset.slt(O.Offset) : Base() < O.Base(); return Base() == O.Base() ? Offset.slt(O.Offset) : Base() < O.Base();
▲ Show 20 Lines • Show All 530 Lines • ▼ Show 20 Lines public:
MergeICmps() : FunctionPass(ID) { MergeICmps() : FunctionPass(ID) {
initializeMergeICmpsPass(*PassRegistry::getPassRegistry()); initializeMergeICmpsPass(*PassRegistry::getPassRegistry());
} }
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
if (skipFunction(F)) return false; if (skipFunction(F)) return false;
const auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); 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(); return !PA.areAllPreserved();
} }
private: private:
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>(); 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, PreservedAnalyses MergeICmps::runImpl(Function &F, const TargetLibraryInfo *TLI,
const TargetLibraryInfo *TLI) { const TargetTransformInfo *TTI) {
DEBUG(dbgs() << "MergeICmpsPass: " << F.getName() << "\n"); 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; bool MadeChange = false;
for (auto BBIt = ++F.begin(); BBIt != F.end(); ++BBIt) { for (auto BBIt = ++F.begin(); BBIt != F.end(); ++BBIt) {
// A Phi operation is always first in a basic block. // A Phi operation is always first in a basic block.
if (auto *const Phi = dyn_cast<PHINode>(&*BBIt->begin())) if (auto *const Phi = dyn_cast<PHINode>(&*BBIt->begin()))
MadeChange |= processPhi(*Phi, TLI); MadeChange |= processPhi(*Phi, TLI);
} }
if (MadeChange) return PreservedAnalyses::none(); if (MadeChange) return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
} // namespace } // namespace
char MergeICmps::ID = 0; char MergeICmps::ID = 0;
INITIALIZE_PASS_BEGIN(MergeICmps, "mergeicmps", INITIALIZE_PASS_BEGIN(MergeICmps, "mergeicmps",
"Merge contiguous icmps into a memcmp", false, false) "Merge contiguous icmps into a memcmp", false, false)
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
INITIALIZE_PASS_END(MergeICmps, "mergeicmps", INITIALIZE_PASS_END(MergeICmps, "mergeicmps",
"Merge contiguous icmps into a memcmp", false, false) "Merge contiguous icmps into a memcmp", false, false)
Pass *llvm::createMergeICmpsPass() { return new MergeICmps(); } Pass *llvm::createMergeICmpsPass() { return new MergeICmps(); }

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

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

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

; 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.
}

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

; 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(
; 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]]
;
%"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
%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
br i1 %cmp.i.i, label %land.rhs.i.i, label %opeq.exit
land.rhs.i.i:
%add.ptr.i.i.i.i.i.i = getelementptr inbounds i8, i8* %0, i64 2
%4 = load i8, i8* %add.ptr.i.i.i.i.i.i, align 1
%add.ptr.i.i.i6.i.i.i = getelementptr inbounds i8, i8* %2, i64 2
%5 = load i8, i8* %add.ptr.i.i.i6.i.i.i, align 1
%cmp.i.i.i = icmp eq i8 %4, %5
br i1 %cmp.i.i.i, label %land.rhs.i.i.i, label %opeq.exit
land.rhs.i.i.i:
%add.ptr.i.i.i.i.i.i.i = getelementptr inbounds i8, i8* %0, i64 1
%6 = load i8, i8* %add.ptr.i.i.i.i.i.i.i, align 1
%add.ptr.i.i.i6.i.i.i.i = getelementptr inbounds i8, i8* %2, i64 1
%7 = load i8, i8* %add.ptr.i.i.i6.i.i.i.i, align 1
%cmp.i.i.i.i = icmp eq i8 %6, %7
br i1 %cmp.i.i.i.i, label %land.rhs.i.i.i.i, label %opeq.exit
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
; 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.
; The two 1 byte loads and compares at offset 1 are replaced with a single
; 2-byte memcmp.
; In the end we have three blocks.
; CHECK-SAME %entry
; CHECK-SAME %land.rhs.i.i.i.i
; CHECK-SAME %land.rhs.i.i.i
}

llvm/trunk/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
}

llvm/trunk/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 } %"struct.std::pair" = type { i32, i32 }
define zeroext i1 @opeq1( 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) %a,
%"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 { %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry: entry:
%first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0 %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
%0 = load i32, i32* %first.i, align 4 %0 = load i32, i32* %first.i, align 4
%first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0 %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
%1 = load i32, i32* %first1.i, align 4 %1 = load i32, i32* %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1 %cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i: land.rhs.i:
%second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1 %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
%2 = load i32, i32* %second.i, align 4 %2 = load i32, i32* %second.i, align 4
%second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1 %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
%3 = load i32, i32* %second2.i, align 4 %3 = load i32, i32* %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3 %cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit br label %opeq1.exit
opeq1.exit: opeq1.exit:
%4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ] %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
ret i1 %4 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. ; Same as above, but the two blocks are in inverse order.
define zeroext i1 @opeq1_inverse( 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) %a,
%"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 { %"struct.std::pair"* nocapture readonly dereferenceable(8) %b) local_unnamed_addr #0 {
entry: entry:
%first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1 %first.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 1
%0 = load i32, i32* %first.i, align 4 %0 = load i32, i32* %first.i, align 4
%first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1 %first1.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 1
%1 = load i32, i32* %first1.i, align 4 %1 = load i32, i32* %first1.i, align 4
%cmp.i = icmp eq i32 %0, %1 %cmp.i = icmp eq i32 %0, %1
br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit br i1 %cmp.i, label %land.rhs.i, label %opeq1.exit
land.rhs.i: land.rhs.i:
%second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0 %second.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %a, i64 0, i32 0
%2 = load i32, i32* %second.i, align 4 %2 = load i32, i32* %second.i, align 4
%second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0 %second2.i = getelementptr inbounds %"struct.std::pair", %"struct.std::pair"* %b, i64 0, i32 0
%3 = load i32, i32* %second2.i, align 4 %3 = load i32, i32* %second2.i, align 4
%cmp3.i = icmp eq i32 %2, %3 %cmp3.i = icmp eq i32 %2, %3
br label %opeq1.exit br label %opeq1.exit
opeq1.exit: opeq1.exit:
%4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ] %4 = phi i1 [ false, %entry ], [ %cmp3.i, %land.rhs.i ]
ret i1 %4 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
} }

llvm/trunk/test/Transforms/MergeICmps/tuple-four-int8.ll

; 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
; (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 {
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
br i1 %cmp.i.i, label %land.rhs.i.i, label %opeq.exit
land.rhs.i.i:
%add.ptr.i.i.i.i.i.i = getelementptr inbounds i8, i8* %0, i64 2
%4 = load i8, i8* %add.ptr.i.i.i.i.i.i, align 1
%add.ptr.i.i.i6.i.i.i = getelementptr inbounds i8, i8* %2, i64 2
%5 = load i8, i8* %add.ptr.i.i.i6.i.i.i, align 1
%cmp.i.i.i = icmp eq i8 %4, %5
br i1 %cmp.i.i.i, label %land.rhs.i.i.i, label %opeq.exit
land.rhs.i.i.i:
%add.ptr.i.i.i.i.i.i.i = getelementptr inbounds i8, i8* %0, i64 1
%6 = load i8, i8* %add.ptr.i.i.i.i.i.i.i, align 1
%add.ptr.i.i.i6.i.i.i.i = getelementptr inbounds i8, i8* %2, i64 1
%7 = load i8, i8* %add.ptr.i.i.i6.i.i.i.i, align 1
%cmp.i.i.i.i = icmp eq i8 %6, %7
br i1 %cmp.i.i.i.i, label %land.rhs.i.i.i.i, label %opeq.exit
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
}

llvm/trunk/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
}
llvm/trunk/test/Transforms/MergeICmps/tuple-four-int8.ll