[InstCombine] Fold memcmp of constant arrays and variable size

[msebor]

Summary

The memcmp simplifier is limited to folding to constants calls with constant arrays and constant sizes. This change adds the ability to simplify memcmp(A, B, N) calls with constant A and B and variable N to the pseudocode equivalent of

N <= Pos ? 0 : (A < B ? -1 : B < A ? +1 : 0)

where Pos is the offset of the first mismatch between A and B.

[courbet]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1163–1168

This feels a bit convoluted. Why not something like:

Value *Zero = ConstantInt::get(CI->getType(), 0);

uint64_t MinSize = std::min(LStr.size(), RStr.size());
for (uint64_t Pos = 0; Pos < MinSize; ++Pos) {
  if (LStr[Pos] != RStr[Pos]) {
    Value *MaxSize = ConstantInt::get(Size->getType(), Pos);
    Value *Cmp = B.CreateICmp(ICmpInst::ICMP_ULE, Size, MaxSize);
    int IRes = LStr[Pos] < RStr[Pos] ? -1 : 1;
    Value *Res = ConstantInt::get(CI->getType(), IRes);
    return B.CreateSelect(Cmp, Zero, Res);
  }
}
// One array is a leading part of the other of equal or greater size.   
// Fold the result to zero.  Size is assumed to be in bounds, since  
// otherwise the call would be undefined. 
return  Zero;

1276

[nit] It feels weird to have if(!constant) { /*handle general case*/ } /*handle constant case*/ . Can you rewrite it as if(constant) { /*handle constant case*/ } /*handle general case*/ ?

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1276

We can probably also always check the variable case first (because it also works fine for the all-constant case, right? The extra condition will fold afterwards) and drop the getConstantStringInfo() handling from optimizeMemCmpConstantSize().

[msebor]

Revision 2 of the patch including:

• Handle same arguments in the new optimizeMemCmpVarSize and adjust loop.
• Remove constant string handling from optimizeMemCmpConstantSize.
• Remove special cases from LibCallSimplifier::optimizeMemCmpBCmpCommon.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1163–1168

Sure, I can do that, thanks for the suggestion. (I have a follow-up patch that extends the handling to strncmp so the code won't look exactly the same but should stay close enough.)

1276

Yes, that sounds good to me.

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1170

Whoops, the comparison is required to be done in unsigned char. Let me fix that.

I also spoke too soon about the loop The suggested form seems to have made the strncmp handling quite a bit more cumbersome than the original.

[msebor]

Revision 3 performs the memcmp character comparison in unsigned char.

I've left the loop as suggested but I expect to need to go back to something closer to the original in the strncmp followup.

[courbet]

In D127766#3587383, @msebor wrote:

I've left the loop as suggested but I expect to need to go back to something closer to the original in the strncmp followup.

SGTM, but let's do it when we get there :)

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1004

Please run clang-format before pushing.

[nikic]

LG. I think this will temporarily regress handling of zeroinitializer, but that should get addressed by D127443 soon.

llvm/test/Transforms/InstCombine/memcmp-6.ll

14

charcater -> character

17

The pcmp argument is dead.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
   Value *SrcPlus = B.CreateGEP(Int8Ty, SrcStr, SizeM1, "memrchr.ptr_plus");
   return B.CreateSelect(And, SrcPlus, NullPtr, "memrchr.sel");
 }
 
 Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) {
   Value *SrcStr = CI->getArgOperand(0);
   Value *Size = CI->getArgOperand(2);
   if (isKnownNonZero(Size, DL))
     annotateNonNullNoUndefBasedOnAccess(CI, 0);
 
   Value *CharVal = CI->getArgOperand(1);
   ConstantInt *CharC = dyn_cast<ConstantInt>(CharVal);
   ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
   Value *NullPtr = Constant::getNullValue(CI->getType());
 
   // memchr(x, y, 0) -> null
   if (LenC) {
Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) {
   Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
 
   // Finally merge both checks and cast to pointer type. The inttoptr
   // implicitly zexts the i1 to intptr type.
   return B.CreateIntToPtr(B.CreateLogicalAnd(Bounds, Bits, "memchr"),
                           CI->getType());
 }
 
+// Optimize a memcmp call CI with constant arrays LHS and RHS and nonconstant
+// Size.
+static Value *optimizeMemCmpVarSize(CallInst *CI, Value *LHS, Value *RHS,
+                                    Value *Size, IRBuilderBase &B,
+                                    const DataLayout &DL) {
+  if (LHS == RHS) // memcmp(s,s,x) -> 0
+    return Constant::getNullValue(CI->getType());
+
+  StringRef LStr, RStr;
+  if (!getConstantStringInfo(LHS, LStr, 0, /*TrimAtNul=*/false) ||
+      !getConstantStringInfo(RHS, RStr, 0, /*TrimAtNul=*/false))
+    return nullptr;
+
+  // If the contents of both constant arrays are known, fold a call to
+  // memcmp(A, B, N) to
+  //   N <= Pos ? 0 : (A < B ? -1 : B < A ? +1 : 0)
+  // where Pos is the first mismatch between A and B, determined below.
+
+  Value *Zero = ConstantInt::get(CI->getType(), 0);
+
+  uint64_t MinSize = std::min(LStr.size(), RStr.size());
+  for (uint64_t Pos = 0; Pos < MinSize; ++Pos) {
+    if (LStr[Pos] != RStr[Pos]) {
+      Value *MaxSize = ConstantInt::get(Size->getType(), Pos);
+      Value *Cmp = B.CreateICmp(ICmpInst::ICMP_ULE, Size, MaxSize);
+      typedef unsigned char UChar;
+      int IRes = UChar(LStr[Pos]) < UChar(RStr[Pos]) ? -1 : 1;
+      Value *Res = ConstantInt::get(CI->getType(), IRes);
+      return B.CreateSelect(Cmp, Zero, Res);
+    }
+  }
+
+  // One array is a leading part of the other of equal or greater size.
+  // Fold the result to zero.  Size is assumed to be in bounds, since
+  // otherwise the call would be undefined.
+  return Zero;
+}
+
+// Optimize a memcmp call CI with constant size Len.
 static Value *optimizeMemCmpConstantSize(CallInst *CI, Value *LHS, Value *RHS,
                                          uint64_t Len, IRBuilderBase &B,
                                          const DataLayout &DL) {
   if (Len == 0) // memcmp(s1,s2,0) -> 0
     return Constant::getNullValue(CI->getType());
 
   // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
   if (Len == 1) {
if ((LHSV || getKnownAlignment(LHS, DL, CI) >= PrefAlignment) &&
         Type *RHSPtrTy =
             IntType->getPointerTo(RHS->getType()->getPointerAddressSpace());
         RHSV = B.CreateLoad(IntType, B.CreateBitCast(RHS, RHSPtrTy), "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.
-  StringRef LHSStr, RHSStr;
-  if (getConstantStringInfo(LHS, LHSStr) &&
-      getConstantStringInfo(RHS, RHSStr)) {
-    // Make sure we're not reading out-of-bounds memory.
-    if (Len > LHSStr.size() || Len > RHSStr.size())
-      return nullptr;
-    // Fold the memcmp and normalize the result.  This way we get consistent
-    // results across multiple platforms.
-    uint64_t Ret = 0;
-    int Cmp = memcmp(LHSStr.data(), RHSStr.data(), Len);
-    if (Cmp < 0)
-      Ret = -1;
-    else if (Cmp > 0)
-      Ret = 1;
-    return ConstantInt::get(CI->getType(), Ret);
-  }
-
   return nullptr;
 }
 
 // Most simplifications for memcmp also apply to bcmp.
 Value *LibCallSimplifier::optimizeMemCmpBCmpCommon(CallInst *CI,
                                                    IRBuilderBase &B) {
   Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
 
-  if (LHS == RHS) // memcmp(s,s,x) -> 0
-    return Constant::getNullValue(CI->getType());
-
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
-  // Handle constant lengths.
+
+  if (Value *Res = optimizeMemCmpVarSize(CI, LHS, RHS, Size, B, DL))
+    return Res;
+
+  // Handle constant Size.
   ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
   if (!LenC)
     return nullptr;
 
-  if (Value *Res =
-          optimizeMemCmpConstantSize(CI, LHS, RHS, LenC->getZExtValue(), B, DL))
-    return Res;
-  return nullptr;
+  return optimizeMemCmpConstantSize(CI, LHS, RHS, LenC->getZExtValue(), B, DL);
 }
 
 Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilderBase &B) {
   Module *M = CI->getModule();
   if (Value *V = optimizeMemCmpBCmpCommon(CI, B))
     return V;
 
   // memcmp(x, y, Len) == 0 -> bcmp(x, y, Len) == 0
   // bcmp can be more efficient than memcmp because it only has to know that
   // there is a difference, not how different one is to the other.
   if (isLibFuncEmittable(M, TLI, LibFunc_bcmp) &&
       isOnlyUsedInZeroEqualityComparison(CI)) {
     Value *LHS = CI->getArgOperand(0);
     Value *RHS = CI->getArgOperand(1);
     Value *Size = CI->getArgOperand(2);
     return copyFlags(*CI, emitBCmp(LHS, RHS, Size, B, DL, TLI));
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeBCmp(CallInst *CI, IRBuilderBase &B) {
   return optimizeMemCmpBCmpCommon(CI, B);
 }
 
 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Size = CI->getArgOperand(2);

llvm/test/Transforms/InstCombine/memcmp-5.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+;
+; Exercise folding of memcmp calls with constant arrays and nonconstant
+; sizes.
+
+declare i32 @memcmp(i8*, i8*, i64)
+
+@ax = external constant [8 x i8]
+@a01230123 = constant [8 x i8] c"01230123"
+@b01230123 = constant [8 x i8] c"01230123"
+@c01230129 = constant [8 x i8] c"01230129"
+@d9123012  = constant [7 x i8] c"9123012"
+
+
+; Exercise memcmp(A, B, N) folding of arrays with the same bytes.
+
+define void @fold_memcmp_a_b_n(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @fold_memcmp_a_b_n(
+; CHECK-NEXT:    store i32 0, i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[N:%.*]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = sext i1 [[TMP1]] to i32
+; CHECK-NEXT:    [[S0_1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
+; CHECK-NEXT:    store i32 [[TMP2]], i32* [[S0_1]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP4:%.*]] = sext i1 [[TMP3]] to i32
+; CHECK-NEXT:    [[S0_2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
+; CHECK-NEXT:    store i32 [[TMP4]], i32* [[S0_2]], align 4
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP6:%.*]] = sext i1 [[TMP5]] to i32
+; CHECK-NEXT:    [[S0_3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
+; CHECK-NEXT:    store i32 [[TMP6]], i32* [[S0_3]], align 4
+; CHECK-NEXT:    [[S0_4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
+; CHECK-NEXT:    store i32 0, i32* [[S0_4]], align 4
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP8:%.*]] = sext i1 [[TMP7]] to i32
+; CHECK-NEXT:    [[S0_5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
+; CHECK-NEXT:    store i32 [[TMP8]], i32* [[S0_5]], align 4
+; CHECK-NEXT:    ret void
+;
+
+  %p0 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 0
+
+  %q0 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 0
+  %q1 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 1
+  %q2 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 2
+  %q3 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 3
+  %q4 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 4
+  %q5 = getelementptr [8 x i8], [8 x i8]* @b01230123, i64 0, i64 5
+
+  ; Fold memcmp(a, b, n) to 0.
+  %c0_0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %n)
+  %s0_0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %c0_0, i32* %s0_0
+
+  ; Fold memcmp(a, b + 1, n) to N != 0 ? -1 : 0.
+  %c0_1 = call i32 @memcmp(i8* %p0, i8* %q1, i64 %n)
+  %s0_1 = getelementptr i32, i32* %pcmp, i64 1
+  store i32 %c0_1, i32* %s0_1
+
+  ; Fold memcmp(a, b + 2, n) to N != 0 ? -1 : 0.
+  %c0_2 = call i32 @memcmp(i8* %p0, i8* %q2, i64 %n)
+  %s0_2 = getelementptr i32, i32* %pcmp, i64 2
+  store i32 %c0_2, i32* %s0_2
+
+  ; Fold memcmp(a, b + 3, n) to N != 0 ? -1 : 0.
+  %c0_3 = call i32 @memcmp(i8* %p0, i8* %q3, i64 %n)
+  %s0_3 = getelementptr i32, i32* %pcmp, i64 3
+  store i32 %c0_3, i32* %s0_3
+
+  ; Fold memcmp(a, b + 4, n) to 0.
+  %c0_4 = call i32 @memcmp(i8* %p0, i8* %q4, i64 %n)
+  %s0_4 = getelementptr i32, i32* %pcmp, i64 4
+  store i32 %c0_4, i32* %s0_4
+
+  ; Fold memcmp(a, b + 5, n) to N != 0 ? -1 : 0.
+  %c0_5 = call i32 @memcmp(i8* %p0, i8* %q5, i64 %n)
+  %s0_5 = getelementptr i32, i32* %pcmp, i64 5
+  store i32 %c0_5, i32* %s0_5
+
+  ret void
+}
+
+; Vefify that a memcmp() call involving a constant array with unknown
+; contents is not folded.
+
+define void @call_memcmp_a_ax_n(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @call_memcmp_a_ax_n(
+; CHECK-NEXT:    [[C0_0:%.*]] = call i32 @memcmp(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @a01230123, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @ax, i64 0, i64 0), i64 [[N:%.*]])
+; CHECK-NEXT:    store i32 [[C0_0]], i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    ret void
+;
+
+  %p0 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 0
+  %q0 = getelementptr [8 x i8], [8 x i8]* @ax, i64 0, i64 0
+
+  ; Do not fold memcmp(a, ax, n).
+  %c0_0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %n)
+  %s0_0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %c0_0, i32* %s0_0
+
+  ret void
+}
+
+
+; Exercise memcmp(A, C, N) folding of arrays with the same leading bytes
+; but a difference in the trailing byte.
+
+define void @fold_memcmp_a_c_n(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @fold_memcmp_a_c_n(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ugt i64 [[N:%.*]], 7
+; CHECK-NEXT:    [[TMP2:%.*]] = sext i1 [[TMP1]] to i32
+; CHECK-NEXT:    store i32 [[TMP2]], i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP4:%.*]] = sext i1 [[TMP3]] to i32
+; CHECK-NEXT:    [[S0_1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
+; CHECK-NEXT:    store i32 [[TMP4]], i32* [[S0_1]], align 4
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP6:%.*]] = sext i1 [[TMP5]] to i32
+; CHECK-NEXT:    [[S0_2:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
+; CHECK-NEXT:    store i32 [[TMP6]], i32* [[S0_2]], align 4
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP8:%.*]] = sext i1 [[TMP7]] to i32
+; CHECK-NEXT:    [[S0_3:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
+; CHECK-NEXT:    store i32 [[TMP8]], i32* [[S0_3]], align 4
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp ugt i64 [[N]], 3
+; CHECK-NEXT:    [[TMP10:%.*]] = sext i1 [[TMP9]] to i32
+; CHECK-NEXT:    [[S0_4:%.*]] = getelementptr i32, i32* [[PCMP]], i64 4
+; CHECK-NEXT:    store i32 [[TMP10]], i32* [[S0_4]], align 4
+; CHECK-NEXT:    [[TMP11:%.*]] = icmp ugt i64 [[N]], 3
+; CHECK-NEXT:    [[TMP12:%.*]] = sext i1 [[TMP11]] to i32
+; CHECK-NEXT:    [[S0_5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 5
+; CHECK-NEXT:    store i32 [[TMP12]], i32* [[S0_5]], align 4
+; CHECK-NEXT:    ret void
+;
+
+  %p0 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 0
+
+  %q0 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 0
+  %q1 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 1
+  %q2 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 2
+  %q3 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 3
+  %q4 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 4
+  %q5 = getelementptr [8 x i8], [8 x i8]* @c01230129, i64 0, i64 5
+
+  ; Fold memcmp(a, c, n) to N > 7 ? -1 : 0.
+  %c0_0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %n)
+  %s0_0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %c0_0, i32* %s0_0
+
+  ; Fold memcmp(a, c + 1, n) to N != 0 ? -1 : 0.
+  %c0_1 = call i32 @memcmp(i8* %p0, i8* %q1, i64 %n)
+  %s0_1 = getelementptr i32, i32* %pcmp, i64 1
+  store i32 %c0_1, i32* %s0_1
+
+  ; Fold memcmp(a, c + 2, n) to N != 0 ? -1 : 0.
+  %c0_2 = call i32 @memcmp(i8* %p0, i8* %q2, i64 %n)
+  %s0_2 = getelementptr i32, i32* %pcmp, i64 2
+  store i32 %c0_2, i32* %s0_2
+
+  ; Fold memcmp(a, c + 3, n) to N != 0 ? -1 : 0.
+  %c0_3 = call i32 @memcmp(i8* %p0, i8* %q3, i64 %n)
+  %s0_3 = getelementptr i32, i32* %pcmp, i64 3
+  store i32 %c0_3, i32* %s0_3
+
+  ; Fold memcmp(a, c + 4, n) to N > 3 ? -1 : 0.
+  %c0_4 = call i32 @memcmp(i8* %p0, i8* %q4, i64 %n)
+  %s0_4 = getelementptr i32, i32* %pcmp, i64 4
+  store i32 %c0_4, i32* %s0_4
+
+  ; Fold memcmp(a, c + 5, n) to N != 0 ? -1 : 0.
+  %c0_5 = call i32 @memcmp(i8* %p0, i8* %q4, i64 %n)
+  %s0_5 = getelementptr i32, i32* %pcmp, i64 5
+  store i32 %c0_5, i32* %s0_5
+
+  ret void
+}
+
+
+; Exercise memcmp(A, D, N) folding of arrays of different sizes and
+; a difference in the leading byte.
+
+define void @fold_memcmp_a_d_n(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @fold_memcmp_a_d_n(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[N:%.*]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = sext i1 [[TMP1]] to i32
+; CHECK-NEXT:    store i32 [[TMP2]], i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP4:%.*]] = sext i1 [[TMP3]] to i32
+; CHECK-NEXT:    [[S0_1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
+; CHECK-NEXT:    store i32 [[TMP4]], i32* [[S0_1]], align 4
+; CHECK-NEXT:    [[S1_1:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
+; CHECK-NEXT:    store i32 0, i32* [[S1_1]], align 4
+; CHECK-NEXT:    [[S6_6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
+; CHECK-NEXT:    store i32 0, i32* [[S6_6]], align 4
+; CHECK-NEXT:    ret void
+;
+
+  %p0 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 0
+  %p1 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 1
+  %p6 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 6
+
+  %q0 = getelementptr [7 x i8], [7 x i8]* @d9123012, i64 0, i64 0
+  %q1 = getelementptr [7 x i8], [7 x i8]* @d9123012, i64 0, i64 1
+  %q6 = getelementptr [7 x i8], [7 x i8]* @d9123012, i64 0, i64 6
+
+  ; Fold memcmp(a, d, n) to N != 0 ? -1 : 0.
+  %c0_0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %n)
+  %s0_0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %c0_0, i32* %s0_0
+
+  ; Fold memcmp(a, d + 1, n) to N != 0 -1 : 0.
+  %c0_1 = call i32 @memcmp(i8* %p0, i8* %q1, i64 %n)
+  %s0_1 = getelementptr i32, i32* %pcmp, i64 1
+  store i32 %c0_1, i32* %s0_1
+
+  ; Fold memcmp(a + 1, d + 1, n) to 0.
+  %c1_1 = call i32 @memcmp(i8* %p1, i8* %q1, i64 %n)
+  %s1_1 = getelementptr i32, i32* %pcmp, i64 2
+  store i32 %c1_1, i32* %s1_1
+
+  ; Fold memcmp(a + 6, d + 6, n) to 0.
+  %c6_6 = call i32 @memcmp(i8* %p6, i8* %q6, i64 %n)
+  %s6_6 = getelementptr i32, i32* %pcmp, i64 3
+  store i32 %c6_6, i32* %s6_6
+
+  ret void
+}
+
+
+; Exercise memcmp(A, D, N) folding of arrays with the same bytes and
+; a nonzero size.
+
+define void @fold_memcmp_a_d_nz(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @fold_memcmp_a_d_nz(
+; CHECK-NEXT:    store i32 -1, i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    ret void
+;
+
+  %p0 = getelementptr [8 x i8], [8 x i8]* @a01230123, i64 0, i64 0
+  %q0 = getelementptr [7 x i8], [7 x i8]* @d9123012, i64 0, i64 0
+  %nz = or i64 %n, 1
+
+  %c0_0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %nz)
+  %s0_0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %c0_0, i32* %s0_0
+
+  ret void
+}

llvm/test/Transforms/InstCombine/memcmp-6.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+;
+; Exercise folding of memcmp calls with constant arrays including both
+; negative and positive characters and both constant and nonconstant sizes.
+
+declare i32 @memcmp(i8*, i8*, i64)
+
+@a = constant [7 x i8] c"abcdef\7f"
+@b = constant [7 x i8] c"abcdef\80"
+
+
+; Exercise memcmp(A + C, B + C, 2) folding of small arrays that differ in
+; a character with the opposite sign and a constant size.
+
+define void @fold_memcmp_cst_cst(i32* %pcmp) {
+; CHECK-LABEL: @fold_memcmp_cst_cst(
+; CHECK-NEXT:    store i32 -1, i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    [[SB5_A5:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
+; CHECK-NEXT:    store i32 1, i32* [[SB5_A5]], align 4
+; CHECK-NEXT:    [[SA6_B6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
+; CHECK-NEXT:    store i32 -1, i32* [[SA6_B6]], align 4
+; CHECK-NEXT:    [[SB6_A6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
+; CHECK-NEXT:    store i32 1, i32* [[SB6_A6]], align 4
+; CHECK-NEXT:    ret void
+;
+  %p5 = getelementptr [7 x i8], [7 x i8]* @a, i64 0, i64 5
+  %p6 = getelementptr [7 x i8], [7 x i8]* @a, i64 0, i64 6
+
+  %q5 = getelementptr [7 x i8], [7 x i8]* @b, i64 0, i64 5
+  %q6 = getelementptr [7 x i8], [7 x i8]* @b, i64 0, i64 6
+
+  ; Fold memcmp(a + 5, b + 5, 2) to -1.
+  %ca5_b5 = call i32 @memcmp(i8* %p5, i8* %q5, i64 2)
+  %sa5_b5 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %ca5_b5, i32* %sa5_b5
+
+  ; Fold memcmp(b + 5, a + 5, 2) to +1.
+  %cb5_a5 = call i32 @memcmp(i8* %q5, i8* %p5, i64 2)
+  %sb5_a5 = getelementptr i32, i32* %pcmp, i64 1
+  store i32 %cb5_a5, i32* %sb5_a5
+
+  ; Fold memcmp(a + 6, b + 6, 1) to -1.
+  %ca6_b6 = call i32 @memcmp(i8* %p6, i8* %q6, i64 1)
+  %sa6_b6 = getelementptr i32, i32* %pcmp, i64 2
+  store i32 %ca6_b6, i32* %sa6_b6
+
+  ; Fold memcmp(b + 6, a + 6, 1) to  +1.
+  %cb6_a6 = call i32 @memcmp(i8* %q6, i8* %p6, i64 1)
+  %sb6_a6 = getelementptr i32, i32* %pcmp, i64 3
+  store i32 %cb6_a6, i32* %sb6_a6
+
+  ret void
+}
+
+
+; Exercise memcmp(A, B, N) folding of arrays that differ in a character
+; with the opposite sign and a variable size
+
+define void @fold_memcmp_cst_var(i32* %pcmp, i64 %n) {
+; CHECK-LABEL: @fold_memcmp_cst_var(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ugt i64 [[N:%.*]], 6
+; CHECK-NEXT:    [[TMP2:%.*]] = sext i1 [[TMP1]] to i32
+; CHECK-NEXT:    store i32 [[TMP2]], i32* [[PCMP:%.*]], align 4
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ugt i64 [[N]], 6
+; CHECK-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; CHECK-NEXT:    [[SB0_A0:%.*]] = getelementptr i32, i32* [[PCMP]], i64 1
+; CHECK-NEXT:    store i32 [[TMP4]], i32* [[SB0_A0]], align 4
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP6:%.*]] = sext i1 [[TMP5]] to i32
+; CHECK-NEXT:    [[SA6_B6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 2
+; CHECK-NEXT:    store i32 [[TMP6]], i32* [[SA6_B6]], align 4
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ne i64 [[N]], 0
+; CHECK-NEXT:    [[TMP8:%.*]] = zext i1 [[TMP7]] to i32
+; CHECK-NEXT:    [[SB6_A6:%.*]] = getelementptr i32, i32* [[PCMP]], i64 3
+; CHECK-NEXT:    store i32 [[TMP8]], i32* [[SB6_A6]], align 4
+; CHECK-NEXT:    ret void
+;
+  %p0 = getelementptr [7 x i8], [7 x i8]* @a, i64 0, i64 0
+  %p6 = getelementptr [7 x i8], [7 x i8]* @a, i64 0, i64 6
+
+  %q0 = getelementptr [7 x i8], [7 x i8]* @b, i64 0, i64 0
+  %q6 = getelementptr [7 x i8], [7 x i8]* @b, i64 0, i64 6
+
+  ; Fold memcmp(a, b, n) to -1.
+  %ca0_b0 = call i32 @memcmp(i8* %p0, i8* %q0, i64 %n)
+  %sa0_b0 = getelementptr i32, i32* %pcmp, i64 0
+  store i32 %ca0_b0, i32* %sa0_b0
+
+  ; Fold memcmp(b, a, n) to +1.
+  %cb0_a0 = call i32 @memcmp(i8* %q0, i8* %p0, i64 %n)
+  %sb0_a0 = getelementptr i32, i32* %pcmp, i64 1
+  store i32 %cb0_a0, i32* %sb0_a0
+
+  ; Fold memcmp(a + 6, b + 6, n) to -1.
+  %ca6_b6 = call i32 @memcmp(i8* %p6, i8* %q6, i64 %n)
+  %sa6_b6 = getelementptr i32, i32* %pcmp, i64 2
+  store i32 %ca6_b6, i32* %sa6_b6
+
+  ; Fold memcmp(b + 6, a + 6, n) to +1.
+  %cb6_a6 = call i32 @memcmp(i8* %q6, i8* %p6, i64 %n)
+  %sb6_a6 = getelementptr i32, i32* %pcmp, i64 3
+  store i32 %cb6_a6, i32* %sb6_a6
+
+  ret void
+}