From 544ac6a05645da56e517962001a1b6f002b1cdda Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Mon, 21 Aug 2017 15:16:25 +0000 Subject: [PATCH] revert r311333: [LibCallSimplifier] try harder to fold memcmp with constant arguments We're getting lots of compile-timeout bot failures like: http://lab.llvm.org:8011/builders/clang-native-arm-lnt/builds/7119 http://lab.llvm.org:8011/builders/clang-cmake-x86_64-avx2-linux git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@311340 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Utils/SimplifyLibCalls.cpp | 36 +++------- .../InstCombine/memcmp-constant-fold.ll | 65 ------------------- 2 files changed, 10 insertions(+), 91 deletions(-) delete mode 100644 test/Transforms/InstCombine/memcmp-constant-fold.ll diff --git a/lib/Transforms/Utils/SimplifyLibCalls.cpp b/lib/Transforms/Utils/SimplifyLibCalls.cpp index b2319945a2c..8257dbcf858 100644 --- a/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -18,7 +18,6 @@ #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/Triple.h" -#include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/OptimizationDiagnosticInfo.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/ValueTracking.h" @@ -752,44 +751,29 @@ Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilder<> &B) { } // memcmp(S1,S2,N/8)==0 -> (*(intN_t*)S1 != *(intN_t*)S2)==0 - // TODO: The case where both inputs are constants does not need to be limited - // to legal integers or equality comparison. See block below this. if (DL.isLegalInteger(Len * 8) && isOnlyUsedInZeroEqualityComparison(CI)) { + IntegerType *IntType = IntegerType::get(CI->getContext(), Len * 8); unsigned PrefAlignment = DL.getPrefTypeAlignment(IntType); - // First, see if we can fold either argument to a constant. - Value *LHSV = nullptr; - if (auto *LHSC = dyn_cast(LHS)) { - LHSC = ConstantExpr::getBitCast(LHSC, IntType->getPointerTo()); - LHSV = ConstantFoldLoadFromConstPtr(LHSC, IntType, DL); - } - Value *RHSV = nullptr; - if (auto *RHSC = dyn_cast(RHS)) { - RHSC = ConstantExpr::getBitCast(RHSC, IntType->getPointerTo()); - RHSV = ConstantFoldLoadFromConstPtr(RHSC, IntType, DL); - } + if (getKnownAlignment(LHS, DL, CI) >= PrefAlignment && + getKnownAlignment(RHS, DL, CI) >= PrefAlignment) { - // Don't generate unaligned loads. If either source is constant data, - // alignment doesn't matter for that source because there is no load. - if (!LHSV && getKnownAlignment(LHS, DL, CI) >= PrefAlignment) { Type *LHSPtrTy = IntType->getPointerTo(LHS->getType()->getPointerAddressSpace()); - LHSV = B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy), "lhsv"); - } - - if (!RHSV && getKnownAlignment(RHS, DL, CI) >= PrefAlignment) { Type *RHSPtrTy = IntType->getPointerTo(RHS->getType()->getPointerAddressSpace()); - RHSV = B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy), "rhsv"); - } - if (LHSV && RHSV) + Value *LHSV = + B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy, "lhsc"), "lhsv"); + Value *RHSV = + B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy, "rhsc"), "rhsv"); + return B.CreateZExt(B.CreateICmpNE(LHSV, RHSV), CI->getType(), "memcmp"); + } } - // Constant folding: memcmp(x, y, Len) -> constant (all arguments are const). - // TODO: This is limited to i8 arrays. + // Constant folding: memcmp(x, y, l) -> cnst (all arguments are constant) StringRef LHSStr, RHSStr; if (getConstantStringInfo(LHS, LHSStr) && getConstantStringInfo(RHS, RHSStr)) { diff --git a/test/Transforms/InstCombine/memcmp-constant-fold.ll b/test/Transforms/InstCombine/memcmp-constant-fold.ll deleted file mode 100644 index 84ad96161f4..00000000000 --- a/test/Transforms/InstCombine/memcmp-constant-fold.ll +++ /dev/null @@ -1,65 +0,0 @@ -; RUN: opt < %s -instcombine -S -data-layout=e-n32 | FileCheck %s --check-prefix=ALL --check-prefix=LE -; RUN: opt < %s -instcombine -S -data-layout=E-n32 | FileCheck %s --check-prefix=ALL --check-prefix=BE - -declare i32 @memcmp(i8*, i8*, i64) - -; The alignment of this constant does not matter. We constant fold the load. - -@charbuf = private unnamed_addr constant [4 x i8] [i8 0, i8 0, i8 0, i8 1], align 1 - -define i1 @memcmp_4bytes_unaligned_constant_i8(i8* align 4 %x) { -; LE-LABEL: @memcmp_4bytes_unaligned_constant_i8( -; LE-NEXT: [[TMP1:%.*]] = bitcast i8* %x to i32* -; LE-NEXT: [[LHSV:%.*]] = load i32, i32* [[TMP1]], align 4 -; LE-NEXT: [[TMP2:%.*]] = icmp eq i32 [[LHSV]], 16777216 -; LE-NEXT: ret i1 [[TMP2]] -; -; BE-LABEL: @memcmp_4bytes_unaligned_constant_i8( -; BE-NEXT: [[TMP1:%.*]] = bitcast i8* %x to i32* -; BE-NEXT: [[LHSV:%.*]] = load i32, i32* [[TMP1]], align 4 -; BE-NEXT: [[TMP2:%.*]] = icmp eq i32 [[LHSV]], 1 -; BE-NEXT: ret i1 [[TMP2]] -; - %call = tail call i32 @memcmp(i8* %x, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @charbuf, i64 0, i64 0), i64 4) - %cmpeq0 = icmp eq i32 %call, 0 - ret i1 %cmpeq0 -} - -; We still don't care about alignment of the constant. We are not limited to constant folding only i8 arrays. -; It doesn't matter if the constant operand is the first operand to the memcmp. - -@intbuf_unaligned = private unnamed_addr constant [4 x i16] [i16 1, i16 2, i16 3, i16 4], align 1 - -define i1 @memcmp_4bytes_unaligned_constant_i16(i8* align 4 %x) { -; LE-LABEL: @memcmp_4bytes_unaligned_constant_i16( -; LE-NEXT: [[TMP1:%.*]] = bitcast i8* %x to i32* -; LE-NEXT: [[RHSV:%.*]] = load i32, i32* [[TMP1]], align 4 -; LE-NEXT: [[TMP2:%.*]] = icmp eq i32 [[RHSV]], 131073 -; LE-NEXT: ret i1 [[TMP2]] -; -; BE-LABEL: @memcmp_4bytes_unaligned_constant_i16( -; BE-NEXT: [[TMP1:%.*]] = bitcast i8* %x to i32* -; BE-NEXT: [[RHSV:%.*]] = load i32, i32* [[TMP1]], align 4 -; BE-NEXT: [[TMP2:%.*]] = icmp eq i32 [[RHSV]], 65538 -; BE-NEXT: ret i1 [[TMP2]] -; - %call = tail call i32 @memcmp(i8* bitcast (i16* getelementptr inbounds ([4 x i16], [4 x i16]* @intbuf_unaligned, i64 0, i64 0) to i8*), i8* %x, i64 4) - %cmpeq0 = icmp eq i32 %call, 0 - ret i1 %cmpeq0 -} - -; TODO: Any memcmp where all arguments are constants should be constant folded. Currently, we only handle i8 array constants. - -@intbuf = private unnamed_addr constant [2 x i32] [i32 0, i32 1], align 4 - -define i1 @memcmp_3bytes_aligned_constant_i32(i8* align 4 %x) { -; ALL-LABEL: @memcmp_3bytes_aligned_constant_i32( -; ALL-NEXT: [[CALL:%.*]] = tail call i32 @memcmp(i8* bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 1) to i8*), i8* bitcast ([2 x i32]* @intbuf to i8*), i64 3) -; ALL-NEXT: [[CMPEQ0:%.*]] = icmp eq i32 [[CALL]], 0 -; ALL-NEXT: ret i1 [[CMPEQ0]] -; - %call = tail call i32 @memcmp(i8* bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 1) to i8*), i8* bitcast (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @intbuf, i64 0, i64 0) to i8*), i64 3) - %cmpeq0 = icmp eq i32 %call, 0 - ret i1 %cmpeq0 -} - -- 2.40.0