[InstCombine] Fold calls to strnlen (PR46455)

[msebor]

Summary

This patch adds support for folding simple strnlen calls to SimplifyLibCalls.cpp. It extends the optimizeStringLength member function to accept the bound AKA maxlen argument to strnlen and attempt to fold calls to it analogously to strlen. To keep optimizeStringLength from growing unwieldy the patch factors out the string length logic into a new helper function, minStringLength, and adds most of the strnlen folding there.

The new minStringLength function can be called recursively to simplify some less than completely trivial calls with conditional expressions such as strnlen(x ? "123" : "12345" + i, n). In case one of the recursive calls fails, rather than creating and inserting the simplified instructions into the IR as it goes, the function returns a pointer to a function/lambda that does that. On success the caller then evaluates the lambda to create and insert the instructions (or constants) into the IR.

I have tested the patch by bootstrapping LLVM + Clang on x86_64-linux and running check-all.

If there are better solutions than the lambda approach above I'd be happy to learn about them and adjust the patch (and follow up on the question I posted about this on Discourse: https://discourse.llvm.org/t/61309).

The new minStringLength function can also be called to implement wcsnlen folding. I have done that in a separate patch that I'll submit if/when this is accepted.

https://github.com/llvm/llvm-project/issues/46455

[nikic]

It would be good to split this up into smaller parts where possible. Two obvious bits would be to precommit the tests with baseline checks (NFC) and land the addition of nonnull attributes on strnlen (which is trivial).

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

644

It would be fine to just emit the umin unconditionally here and let it fold away if it happens to be constant, something like:

Value *Min = ConstantInt::get(CI->getType(), Len - 1);
return [&]() {
  return Bound ? B.CreateBinaryIntrinsic(Intrinsic::umin, Min, Bound) : Min;
};

672

I had a bit of a hard time understanding this new special case. I'm wondering, if you have no null and use strnlen, can't we simply always return Bound as the result? Either the result will be Bound, or we're reading past the extent of the global and have UB. Or if we don't want to optimize the latter case we can keep the MaxLen < ArraySize check, but in either case I think mixing it with the code below is kind of confusing -- in particular the sub bit doesn't seem relevant?

710

If we moved handling of the isOnlyUsedInZeroEqualityComparison() check in optimizeStringLength() before the minStringLength() handling, could we drop the special check here?

768

Might be more elegant with m_ConstantInt, something like...

uint64_t MaxLen;
if (!Bound || !match(Bound, m_ConstantInt(MaxLen))
  MaxLen = UINT64_MAX;

if (MaxLen == 0)
  return ConstantInt::get(CI->getType(), 0);

777

Why does this need the MaxLen == UINT64_MAX check?

llvm/test/Transforms/InstCombine/strlen-4.ll

4

Please use llvm/utils/update_test_checks.py to generate InstCombine test checks.

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

2

This test file could probably be called strnlen-icmp.ll or something? Just numbering them isn't super meaningful.

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

53

This test output looks wrong?

[msebor]

Thanks for the review! Let me upload a new diff with the suggested changes. I'm not sure what the process is for submitting the baseline tests: do I need to open a separate review for those? Likewise for the nonnull attribute for strnlen? I'm also not sure I have commit rights yet so if/when any of this is approved someone might need to commit the changes for me.

Finally, the build bot shows unit test failures that I'm not sure I understand yet and could use some guidance with. Are ASan test timeouts expected? Any idea about the BOLT failures?

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

644

Done, thanks.

672

That's a good question. I was mostly trying to follow the strlen handling here. But if there's no concern with the unterminated array being followed by another that does have a nul I'm okay with your suggestion. The specific case I have in mind is an aggregate with two consecutive arrays only the second one of which is terminated, for example like so:

const char a[][4] = { "1234", "56" };

int f (void)
{
  return strnlen (a[0], sizeof a);
}

I see that aggregates aren't handled by the folder yet so this is only hypothetical at the moment. But eventually I think there is an expectation to handle them and then the question of whether use cases like the above should be supported will need to be answered.

710

Yes, I think we can. It doesn't seem like there are any cases when minStringLength() could fold away the memory load.

768

Done, thanks.

777

I've simplified/changed the conditional while moving it earlier.

llvm/test/Transforms/InstCombine/strlen-4.ll

4

I have run the script to update the assertions.

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

53

Yes, there are a couple of typos here, one keeping the other from causing the test to fail. Good catch! There were a few others just like that in a couple of tests.

[msebor]

v2 with changes suggested in review. (I'm still learning the review process and tools so hopefully I didn't do something too stupid.)

[nikic]

In D122686#3420785, @msebor wrote:

Thanks for the review! Let me upload a new diff with the suggested changes. I'm not sure what the process is for submitting the baseline tests: do I need to open a separate review for those? Likewise for the nonnull attribute for strnlen? I'm also not sure I have commit rights yet so if/when any of this is approved someone might need to commit the changes for me.

For baseline tests, you can just commit them directly. As you don't have commit access yet, I went ahead and committed them for you. But otherwise yes, the usual pattern is to create a patch stack (with "Depends on DNNN") where each patch adds one transform. That makes it easier to review and bisect problems later. (Though there may be some reasonable disagreement on how fine-grained changes should be...)

Finally, the build bot shows unit test failures that I'm not sure I understand yet and could use some guidance with. Are ASan test timeouts expected? Any idea about the BOLT failures?

Unfortunately the pre-merge checks have been pretty flaky lately. If the test times out, you can generally assume it's a false positive. Generally, if it doesn't look obviously related to the area you changed, it's probably a false positive.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

672

I don't think getConstantDataArrayInfo() could return true for such a case, it needs to return the string up to the end of the global. Though now that I look at the implementation, it does support an offset into the global, so if the GEP has a negative index it could move the start of the search before a null byte, and we'd get something less than the bound in that case.

I'm having a hard time convincing myself of the correctness of the code as implemented -- I'd suggest to put the entire dynamic GEP handling behind a !Bound check for the initial patch and revisit this afterwards.

710

Drop the check now?

747

This is redundant: You already computed the bounded string lengths for both branches above, so there should be no need to bound the result here again.

[xbolva00]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

770

This is an opportunity to extend this opt more

see https://github.com/llvm/llvm-project/issues/48940

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

672

Okay, let me break up the patch then and resubmit.

710

Right, will do.

747

I agree the umin is not necessary. At the same time, removing it makes the code look like it's missing. It should get folded away, but I don't have a strong preference one way or the other.

770

Let me look into it, thanks for the pointer!

[msebor]

"put the entire dynamic GEP handling behind a !Bound check"

@nikic is this what close to what you're looking for?

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

747

The alternative here would be to first always calculate the unbounded string length and then do the umin once at the end. Actually, I think that would be cleaner than the current code structure, because most of the logic would be independent of the bound, and we'd only have to insert the umin at one place at the end, rather than in each branch of the string length computation.

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

747

I suppose that would be fine too. Switching between strlen and strnlen computations in the same recursive call assumes there's no material difference between them elsewhere. Ultimately, there shouldn't be, but as it is, doing as you propose bypasses the constraint of putting the "dynamic GEP handling behind a !Bound check" that you suggested to temporarily put in place.

[msebor]

Since @nikic requested to break this patch up into a series I'm going to abandon this review and open new ones, one for each of the smaller pieces.

[msebor]

Abandoning as per previous comment.

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

   Value *optimizeStpCpy(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrNCpy(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrLen(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrnLen(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrPBrk(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrTo(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrSpn(CallInst *CI, IRBuilderBase &B);

   /// function by checking for an existing function with name FuncName + f
   bool hasFloatVersion(StringRef FuncName);
 
-  /// Shared code to optimize strlen+wcslen.
-  Value *optimizeStringLength(CallInst *CI, IRBuilderBase &B, unsigned CharSize);
+  /// Shared code to optimize strlen+wcslen and strnlen+wcsnlen.
+  Value *optimizeStringLength(CallInst *CI, IRBuilderBase &B, unsigned CharSize,
+                              Value *Bound = nullptr);
+
+  /// Recursively compute strnlen(Src, Bound), returning the sequence
+  /// of instructions as a function object to evaluate to insert into
+  /// the IR.
+  typedef std::function<Value *()> CreateInsnFuncTy;
+  CreateInsnFuncTy minStringLength(CallInst *CI, Value *Src, IRBuilderBase &B,
+                                   unsigned CharSize, uint64_t MaxLen,
+                                   Value *Bound);
 };
-} // End llvm namespace
+} // namespace llvm
 
 #endif

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

   return Dst;
 }
 
-Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
-                                               unsigned CharSize) {
-  Value *Src = CI->getArgOperand(0);
-
-  // Constant folding: strlen("xyz") -> 3
-  if (uint64_t Len = GetStringLength(Src, CharSize))
-    return ConstantInt::get(CI->getType(), Len - 1);
+LibCallSimplifier::CreateInsnFuncTy
+LibCallSimplifier::minStringLength(CallInst *CI, Value *Src, IRBuilderBase &B,
+                                   unsigned CharSize, uint64_t MaxLen,
+                                   Value *Bound) {
+  if (uint64_t Len = GetStringLength(Src, CharSize)) {
+    Value *Min = ConstantInt::get(CI->getType(), Len - 1);
+    // Fold strlen("xyz") -> 3 and strnlen("xyz", 2) -> 2
+    // and strnlen("xyz", Bound) -> min(3, Bound)
+    return [&B, Min, Bound]() {
+      return Bound ? B.CreateBinaryIntrinsic(Intrinsic::umin, Min, Bound) : Min;
+    };
+  }
 
   // If s is a constant pointer pointing to a string literal, we can fold
   // strlen(s + x) to strlen(s) - x, when x is known to be in the range

             break;
           }
         }
-        // If the string does not have '\0', leave it to strlen to compute
-        // its length.
-        if (NullTermIdx == ~((uint64_t)0))
+        if (NullTermIdx == ~((uint64_t)0) && MaxLen > Slice.Length)
+          // If the array does not have '\0', leave it to either strlen
+          // or strnlen with an excessive Bound to compute its length.
           return nullptr;
       }
 
       Value *Offset = GEP->getOperand(2);
+      if (!dyn_cast<Constant>(Offset) && Bound)
+  // Avoid handling strnlen with a nonconstant offset for now.
+  return nullptr;
+
       KnownBits Known = computeKnownBits(Offset, DL, 0, nullptr, CI, nullptr);
       Known.Zero.flipAllBits();
       uint64_t ArrSize =

       // optimize if we can prove that the program has undefined behavior when
       // Offset is outside that range. That is the case when GEP->getOperand(0)
       // is a pointer to an object whose memory extent is NullTermIdx+1.
+      // Similar logic applies to strnlen with a bound less than or equal
+      // to the unterminated array size.
       if ((Known.Zero.isNonNegative() && Known.Zero.ule(NullTermIdx)) ||
           (GEP->isInBounds() && isa<GlobalVariable>(GEP->getOperand(0)) &&
-           NullTermIdx == ArrSize - 1)) {
+           (NullTermIdx == ArrSize - 1 ||
+            (NullTermIdx == UINT64_MAX && MaxLen <= ArrSize)))) {
         Offset = B.CreateSExtOrTrunc(Offset, CI->getType());
-        return B.CreateSub(ConstantInt::get(CI->getType(), NullTermIdx),
-                           Offset);
+        uint64_t Max = std::min(NullTermIdx, ArrSize);
+        if (!Bound)
+          return [&B, CI, Max, Offset]() {
+            return B.CreateSub(ConstantInt::get(CI->getType(), Max), Offset);
+          };
+
+        // Fold strnlen(s + x, Bound) -> min(strlen(s) - x, Bound)
+        // for both constant and variable Bound.
+        return [&B, CI, Max, Offset, Bound]() {
+          Value *Res =
+              B.CreateSub(ConstantInt::get(CI->getType(), Max), Offset);
+          return B.CreateBinaryIntrinsic(Intrinsic::umin, Res, Bound);
+        };
       }
     }
   }
 
-  // strlen(x?"foo":"bars") --> x ? 3 : 4
   if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {
-    uint64_t LenTrue = GetStringLength(SI->getTrueValue(), CharSize);
-    uint64_t LenFalse = GetStringLength(SI->getFalseValue(), CharSize);
-    if (LenTrue && LenFalse) {
-      ORE.emit([&]() {
-        return OptimizationRemark("instcombine", "simplify-libcalls", CI)
-               << "folded strlen(select) to select of constants";
-      });
-      return B.CreateSelect(SI->getCondition(),
-                            ConstantInt::get(CI->getType(), LenTrue - 1),
-                            ConstantInt::get(CI->getType(), LenFalse - 1));
-    }
+    Value *SrcTrue = SI->getTrueValue();
+    Value *SrcFalse = SI->getFalseValue();
+
+    auto MinTrue = minStringLength(CI, SrcTrue, B, CharSize, MaxLen, Bound);
+    if (!MinTrue)
+      return nullptr;
+
+    auto MinFalse = minStringLength(CI, SrcFalse, B, CharSize, MaxLen, Bound);
+    if (!MinFalse)
+      return nullptr;
+
+    ORE.emit([&]() {
+      return OptimizationRemark("instcombine", "simplify-libcalls", CI)
+             << "folded strlen(select) to select of constants";
+    });
+
+    if (!Bound)
+      // Fold strlen(x?"foo":"bars") --> x ? 3 : 4
+      return [&B, SI, MinTrue, MinFalse]() {
+        return B.CreateSelect(SI->getCondition(), MinTrue(), MinFalse());
+      };
+
+    // Fold strnlen(x?"foo":"bars", Bound) --> min(x ? 3 : 4, Bound)
+    return [&B, SI, MinTrue, MinFalse, Bound]() {
+      // Since MinTrue and MinFalse are already constrained to Bound there
+      // is no need to do that again here.
+      return B.CreateSelect(SI->getCondition(), MinTrue(), MinFalse());
+    };
   }
 
-  // strlen(x) != 0 --> *x != 0
-  // strlen(x) == 0 --> *x == 0
-  if (isOnlyUsedInZeroEqualityComparison(CI))
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
+                                               unsigned CharSize,
+                                               Value *Bound) {
+  // For strnlen, set to the constant bound.  Otherwise, for strlen
+  // or strnlen with nonconstant bound, set to the maximum.
+  uint64_t MaxLen;
+  if (!Bound || !match(Bound, m_ConstantInt(MaxLen)))
+    MaxLen = UINT64_MAX;
+
+  if (MaxLen == 0)
+    // Fold strnlen(s, 0) -> 0 for any s, constant or otherwise.
+    return ConstantInt::get(CI->getType(), 0);
+
+  Value *Src = CI->getArgOperand(0);
+  if (isOnlyUsedInZeroEqualityComparison(CI) &&
+      (!Bound || isKnownNonZero(Bound, DL))) {
+    // Fold strlen:
+    //   strlen(x) != 0 --> *x != 0
+    //   strlen(x) == 0 --> *x == 0
+    // and likewise strnlen with constant N > 0:
+    //   strnlen(x, N) != 0 --> *x != 0
+    //   strnlen(x, N) == 0 --> *x == 0
     return B.CreateZExt(B.CreateLoad(B.getIntNTy(CharSize), Src, "strlenfirst"),
                         CI->getType());
+  }
+
+  if (auto Insns = minStringLength(CI, Src, B, CharSize, MaxLen, Bound))
+    // Invoke the returned lambdas to create and insert the simplified
+    // instructions or constants into the IR and return the result.
+    return Insns();
 
   return nullptr;
 }

   return nullptr;
 }
 
+Value *LibCallSimplifier::optimizeStrnLen(CallInst *CI, IRBuilderBase &B) {
+  Value *Bound = CI->getArgOperand(1);
+  if (Value *V = optimizeStringLength(CI, B, 8, Bound))
+    return V;
+
+  if (isKnownNonZero(Bound, DL))
+    annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  return nullptr;
+}
+
 Value *LibCallSimplifier::optimizeWcslen(CallInst *CI, IRBuilderBase &B) {
   Module &M = *CI->getModule();
   unsigned WCharSize = TLI->getWCharSize(M) * 8;

       return optimizeStrNCpy(CI, Builder);
     case LibFunc_strlen:
       return optimizeStrLen(CI, Builder);
+    case LibFunc_strnlen:
+      return optimizeStrnLen(CI, Builder);
     case LibFunc_strpbrk:
       return optimizeStrPBrk(CI, Builder);
     case LibFunc_strndup:

llvm/test/Transforms/InstCombine/strlen-4.ll

 
 define i64 @fold_strlen_s3_pi_s5(i1 %0, i64 %1) {
 ; CHECK-LABEL: @fold_strlen_s3_pi_s5(
-; CHECK-NEXT:    [[PS3_PI:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i8* [[PS3_PI]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 3, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 [[TMP3]], i64 5
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps3_pi = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %1

 
 define i64 @call_strlen_s5_3_s5_pj(i1 %0, i64 %1) {
 ; CHECK-LABEL: @call_strlen_s5_3_s5_pj(
-; CHECK-NEXT:    [[PS5:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([10 x i8], [10 x i8]* @s5_3, i64 0, i64 0), i8* [[PS5]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 5, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 5, i64 [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps5_3_pi = getelementptr [10 x i8], [10 x i8]* @s5_3, i64 0, i64 0

 
 define i64 @fold_strlen_s3_s5_pj(i1 %0, i64 %1) {
 ; CHECK-LABEL: @fold_strlen_s3_s5_pj(
-; CHECK-NEXT:    [[PS5_PJ:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* [[PS5_PJ]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 5, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 3, i64 [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps3 = getelementptr [4 x i8], [4 x i8]* @s3, i64 0, i64 0

 
 define i64 @fold_strlen_s3_pi_s5_pj(i1 %0, i64 %1, i64 %2) {
 ; CHECK-LABEL: @fold_strlen_s3_pi_s5_pj(
-; CHECK-NEXT:    [[PS3_PI:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[PS5_PJ:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 [[TMP2:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i8* [[PS3_PI]], i8* [[PS5_PJ]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strlen(i8* noundef nonnull [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; Use CHECK-DAG since the two instructions below might be emitted in reverse
+; order.
+; CHECK-DAG:     [[TMP4:%.*]] = sub i64 5, [[TMP2:%.*]]
+; CHECK-DAG:     [[TMP5:%.*]] = sub i64 3, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP6:%.*]] = select i1 [[TMP0:%.*]], i64 [[TMPX:%.*]], i64 [[TMPY:%.*]]
+; CHECK-NEXT:    ret i64 [[TMP6]]
 ;
 
   %ps3_pi = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %1

 ; CHECK-LABEL: @fold_strlen_s3_s5_s7(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 3
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 5
-; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @s7, i64 0, i64 0)
-; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* [[TMP4]]
-; CHECK-NEXT:    [[TMP6:%.*]] = tail call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[TMP5]])
-; CHECK-NEXT:    ret i64 [[TMP6]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i64 5, i64 7
+; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i64 3, i64 [[TMP4]]
+; CHECK-NEXT:    ret i64 [[TMP5]]
 ;
 
   %2 = icmp eq i32 %0, 3

llvm/test/Transforms/InstCombine/strnlen-1.ll

 
 define i64 @fold_strnlen_s5_0() {
 ; CHECK-LABEL: @fold_strnlen_s5_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [6 x i8], [6 x i8]* @s5, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 0)

 
 define i64 @fold_strnlen_s5_4() {
 ; CHECK-LABEL: @fold_strnlen_s5_4(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i64 4)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 4
 ;
   %ptr = getelementptr [6 x i8], [6 x i8]* @s5, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 4)

 
 define i64 @fold_strnlen_s5_5() {
 ; CHECK-LABEL: @fold_strnlen_s5_5(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i64 5)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 5
 ;
   %ptr = getelementptr [6 x i8], [6 x i8]* @s5, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 5)

 
 define i64 @fold_strnlen_s5_m1() {
 ; CHECK-LABEL: @fold_strnlen_s5_m1(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i64 -1)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 5
 ;
   %ptr = getelementptr [6 x i8], [6 x i8]* @s5, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 -1)

 
 define i64 @fold_strnlen_s5_3_p4_5() {
 ; CHECK-LABEL: @fold_strnlen_s5_3_p4_5(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @s5_3, i64 0, i64 4), i64 5)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = getelementptr [9 x i8], [9 x i8]* @s5_3, i32 0, i32 4
   %len = call i64 @strnlen(i8* %ptr, i64 5)

 
 define i64 @fold_strnlen_s5_3_p5_5() {
 ; CHECK-LABEL: @fold_strnlen_s5_3_p5_5(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @s5_3, i64 0, i64 5), i64 5)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [9 x i8], [9 x i8]* @s5_3, i32 0, i32 5
   %len = call i64 @strnlen(i8* %ptr, i64 5)

 
 define i64 @fold_strnlen_s5_3_p6_5() {
 ; CHECK-LABEL: @fold_strnlen_s5_3_p6_5(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @s5_3, i64 0, i64 6), i64 5)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 3
 ;
   %ptr = getelementptr [9 x i8], [9 x i8]* @s5_3, i32 0, i32 6
   %len = call i64 @strnlen(i8* %ptr, i64 5)

llvm/test/Transforms/InstCombine/strnlen-2.ll

 
 define i64 @fold_strnlen_s3_s5_0(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_0(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = select i1 %0, i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
 

 
 define i64 @fold_strnlen_s3_s5_1(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_1(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 1)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 1
 ;
   %ptr = select i1 %0, i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
 

 
 define i64 @fold_strnlen_s3_s5_3(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_3(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 3)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 3
 ;
   %ptr = select i1 %0, i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
 

 
 define i64 @fold_strnlen_s3_s5_4(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_4(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 4)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP0:%.*]], i64 3, i64 4
+; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
   %ptr = select i1 %0, i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
 

 
 define i64 @fold_strnlen_s3_s5_5(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_5(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 5)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP0:%.*]], i64 3, i64 5
+; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
   %ptr = select i1 %0, i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
 

 
 define i64 @fold_strnlen_s5_6(i1 %0) {
 ; CHECK-LABEL: @fold_strnlen_s5_6(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 6)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP0:%.*]], i64 5, i64 6
+; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
 
   %ptr = select i1 %0, i8* getelementptr ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr ([7 x i8], [7 x i8]* @s6, i64 0, i64 0)

 define i64 @fold_strnlen_s3_s5_s7_4(i32 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_s7_4(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 3
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 5
-; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @s7, i64 0, i64 0)
-; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* [[TMP4]]
-; CHECK-NEXT:    [[TMP6:%.*]] = tail call i64 @strnlen(i8* [[TMP5]], i64 4)
-; CHECK-NEXT:    ret i64 [[TMP6]]
+; CHECK-NEXT:    [[TMP3:%.*]] = select i1 [[TMP2]], i64 3, i64 4
+; CHECK-NEXT:    ret i64 [[TMP3]]
 ;
 
   %2 = icmp eq i32 %0, 3

 ; CHECK-LABEL: @fold_strnlen_s3_s5_s7_6(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 3
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 5
-; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @s7, i64 0, i64 0)
-; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* [[TMP4]]
-; CHECK-NEXT:    [[TMP6:%.*]] = tail call i64 @strnlen(i8* [[TMP5]], i64 6)
-; CHECK-NEXT:    ret i64 [[TMP6]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i64 5, i64 6
+; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i64 3, i64 [[TMP4]]
+; CHECK-NEXT:    ret i64 [[TMP5]]
 ;
 
   %2 = icmp eq i32 %0, 3

 ; CHECK-LABEL: @fold_strnlen_s3_s5_s7_8(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 3
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 5
-; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @s7, i64 0, i64 0)
-; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i8* [[TMP4]]
-; CHECK-NEXT:    [[TMP6:%.*]] = tail call i64 @strnlen(i8* [[TMP5]], i64 8)
-; CHECK-NEXT:    ret i64 [[TMP6]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP3]], i64 5, i64 7
+; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP2]], i64 3, i64 [[TMP4]]
+; CHECK-NEXT:    ret i64 [[TMP5]]
 ;
 
   %2 = icmp eq i32 %0, 3

llvm/test/Transforms/InstCombine/strnlen-3.ll

 
 define i64 @fold_strnlen_sx_pi_0(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_sx_pi_0(
-; CHECK-NEXT:    [[PTR:%.*]] = getelementptr [0 x i8], [0 x i8]* @sx, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
 
   %ptr = getelementptr [0 x i8], [0 x i8]* @sx, i64 0, i64 %0

 define i64 @call_strnlen_a3_pi_2(i64 %0) {
 ; CHECK-LABEL: @call_strnlen_a3_pi_2(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [3 x i8], [3 x i8]* @a3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 2)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 2)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

 define i64 @call_strnlen_a3_pi_3(i64 %0) {
 ; CHECK-LABEL: @call_strnlen_a3_pi_3(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [3 x i8], [3 x i8]* @a3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 3)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 3)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

 
 define i64 @fold_strnlen_s3_pi_0(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_pi_0(
-; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %0
   %len = call i64 @strnlen(i8* %ptr, i64 0)

 
 define i64 @call_strnlen_s5_pi_0(i64 zeroext %0) {
 ; CHECK-LABEL: @call_strnlen_s5_pi_0(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [6 x i8], [6 x i8]* @s5, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 0)

 
 define i64 @fold_strnlen_s5_3_pi_0(i64 zeroext %0) {
 ; CHECK-LABEL: @fold_strnlen_s5_3_pi_0(
-; CHECK-NEXT:    [[PTR:%.*]] = getelementptr [10 x i8], [10 x i8]* @s5_3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 0)
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    ret i64 0
 ;
   %ptr = getelementptr [10 x i8], [10 x i8]* @s5_3, i32 0, i64 %0
   %len = call i64 @strnlen(i8* %ptr, i64 0)

 
 define i64 @fold_strnlen_a3_n(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_a3_n(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @a3, i64 0, i64 0), i64 [[TMP0:%.*]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call i64 @llvm.umin.i64(i64 [[TMP0:%.*]], i64 3)
+; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
 
   %ptr = getelementptr [3 x i8], [3 x i8]* @a3, i64 0, i64 0

 
 define i64 @fold_strnlen_s3_n(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_n(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0), i64 [[TMP0:%.*]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call i64 @llvm.umin.i64(i64 [[TMP0:%.*]], i64 3)
+; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
 
   %ptr = getelementptr [4 x i8], [4 x i8]* @s3, i64 0, i64 0

 define i64 @fold_strnlen_a3_pi_2(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_a3_pi_2(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [3 x i8], [3 x i8]* @a3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 2)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 2)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

 define i64 @fold_strnlen_s3_pi_2(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_pi_2(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 2)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 2)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

 define i64 @fold_strnlen_s3_pi_3(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_s3_pi_3(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 3)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 3)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

 define i64 @call_strnlen_s5_3_pi_2(i64 %0) {
 ; CHECK-LABEL: @call_strnlen_s5_3_pi_2(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* @s5_3, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 2)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 2)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 

llvm/test/Transforms/InstCombine/strnlen-4.ll

 
 define i64 @fold_strnlen_s3_s5_pi_n(i1 %0, i64 %1, i64 %2) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_pi_n(
-; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[TMP0:%.*]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 [[TMP1:%.*]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[MINMAXOP:%.*]] = select i1 [[TMP0:%.*]], i64 5, i64 3
+; CHECK-NEXT:    [[TMP4:%.*]] = call i64 @llvm.umin.i64(i64 [[MINMAXOP]], i64 [[TMP1:%.*]])
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ptr = select i1 %0, i8* getelementptr ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0)

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

 
 define i1 @fold_strnlen_ax_0_eqz() {
 ; CHECK-LABEL: @fold_strnlen_ax_0_eqz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 0)
-; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
-; CHECK-NEXT:    ret i1 [[EQZ]]
+; CHECK-NEXT:    ret i1 true
 ;
 
   %ptr = getelementptr [0 x i8], [0 x i8]* @ax, i64 0, i64 0

 
 define i1 @fold_strnlen_ax_0_gtz() {
 ; CHECK-LABEL: @fold_strnlen_ax_0_gtz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 0)
-; CHECK-NEXT:    [[GTZ:%.*]] = icmp ne i64 [[LEN]], 0
-; CHECK-NEXT:    ret i1 [[GTZ]]
+; CHECK-NEXT:    ret i1 false
 ;
 
   %ptr = getelementptr [0 x i8], [0 x i8]* @ax, i64 0, i64 0

 
 define i1 @fold_strnlen_ax_1_eqz() {
 ; CHECK-LABEL: @fold_strnlen_ax_1_eqz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 1)
-; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
+; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 

 
 define i1 @fold_strnlen_ax_1_neqz() {
 ; CHECK-LABEL: @fold_strnlen_ax_1_neqz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 1)
-; CHECK-NEXT:    [[NEZ:%.*]] = icmp ne i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
+; CHECK-NEXT:    [[NEZ:%.*]] = icmp ne i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[NEZ]]
 ;
 

 
 define i1 @fold_strnlen_ax_9_eqz() {
 ; CHECK-LABEL: @fold_strnlen_ax_9_eqz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 9)
-; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
+; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 

 
 define i1 @fold_strnlen_ax_nz_eqz(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_ax_nz_eqz(
-; CHECK-NEXT:    [[MAX:%.*]] = or i64 [[TMP0:%.*]], 1
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 [[MAX]])
-; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
+; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 

 
 define i1 @fold_strnlen_ax_nz_gtz(i64 %0) {
 ; CHECK-LABEL: @fold_strnlen_ax_nz_gtz(
-; CHECK-NEXT:    [[MAX:%.*]] = or i64 [[TMP0:%.*]], 1
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 [[MAX]])
-; CHECK-NEXT:    [[GTZ:%.*]] = icmp ne i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
+; CHECK-NEXT:    [[GTZ:%.*]] = icmp ne i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[GTZ]]
 ;
 

 
 define i1 @fold_strnlen_a5_pi_nz_eqz(i64 %0, i64 %1) {
 ; CHECK-LABEL: @fold_strnlen_a5_pi_nz_eqz(
-; CHECK-NEXT:    [[NZ:%.*]] = or i64 [[TMP1:%.*]], 1
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [5 x i8], [5 x i8]* @a5, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 [[NZ]])
-; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
+; CHECK-NEXT:    [[STRLENFIRST:%.*]] = load i8, i8* [[PTR]], align 1
+; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 

 
 define i1 @fold_strnlen_s5_pi_nz_eqz(i64 %0, i64 %1) {
 ; CHECK-LABEL: @fold_strnlen_s5_pi_nz_eqz(
-; CHECK-NEXT:    [[TMP3:%.*]] = or i64 [[TMP1:%.*]], 1
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 [[TMP0:%.*]]
-; CHECK-NEXT:    [[TMP5:%.*]] = call i64 @strnlen(i8* nonnull [[TMP4]], i64 [[TMP3]])
-; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i64 [[TMP5]], 0
-; CHECK-NEXT:    ret i1 [[TMP6]]
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[TMP0:%.*]], 5
+; CHECK-NEXT:    ret i1 [[TMP3]]
 ;
 
   %3 = or i64 %1, 1

 }
 
 
-; Do not fold strnlen(s5 + %0, %1) for a constant s5 when %1 might be zero.
+; TODO: Fold strnlen(s5 + %0, %1) == 0 to min(5 - %0, %1).
 
 define i1 @call_strnlen_s5_pi_n_eqz(i64 %0, i64 %1) {
 ; CHECK-LABEL: @call_strnlen_s5_pi_n_eqz(

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

 define i64 @deref_strnlen_ecp_3() {
 ; CHECK-LABEL: @deref_strnlen_ecp_3(
 ; CHECK-NEXT:    [[PTR:%.*]] = load i8*, i8** @ecp, align 8
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 3)
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull dereferenceable(1) [[PTR]], i64 3)
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %ptr = load i8*, i8** @ecp

 ; CHECK-LABEL: @deref_strnlen_ecp_nz(
 ; CHECK-NEXT:    [[NONZERO:%.*]] = or i64 [[N:%.*]], 1
 ; CHECK-NEXT:    [[PTR:%.*]] = load i8*, i8** @ecp, align 8
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 [[NONZERO]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull dereferenceable(1) [[PTR]], i64 [[NONZERO]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %nonzero = or i64 %n, 1

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

 
 define dso_local i64 @fold_wcslen_s3_pi_s5(i1 zeroext %0, i64 %1) {
 ; CHECK-LABEL: @fold_wcslen_s3_pi_s5(
-; CHECK-NEXT:    [[PS3_PI:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @ws3, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i32* [[PS3_PI]], i32* getelementptr inbounds ([6 x i32], [6 x i32]* @ws5, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @wcslen(i32* [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 3, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 [[TMP3]], i64 5
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps3_pi = getelementptr inbounds [4 x i32], [4 x i32]* @ws3, i64 0, i64 %1

 
 define dso_local i64 @call_wcslen_s5_3_s5_pj(i1 zeroext %0, i64 %1) {
 ; CHECK-LABEL: @call_wcslen_s5_3_s5_pj(
-; CHECK-NEXT:    [[PS5:%.*]] = getelementptr inbounds [6 x i32], [6 x i32]* @ws5, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i32* getelementptr inbounds ([10 x i32], [10 x i32]* @ws5_3, i64 0, i64 0), i32* [[PS5]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @wcslen(i32* [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 5, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 5, i64 [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps5_3_pi = getelementptr inbounds [10 x i32], [10 x i32]* @ws5_3, i64 0, i64 0

 
 define dso_local i64 @fold_wcslen_s3_s5_pj(i1 zeroext %0, i64 %1) {
 ; CHECK-LABEL: @fold_wcslen_s3_s5_pj(
-; CHECK-NEXT:    [[PS5_PJ:%.*]] = getelementptr inbounds [6 x i32], [6 x i32]* @ws5, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i32* getelementptr inbounds ([4 x i32], [4 x i32]* @ws3, i64 0, i64 0), i32* [[PS5_PJ]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @wcslen(i32* [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; CHECK-NEXT:    [[TMP3:%.*]] = sub i64 5, [[TMP1:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = select i1 [[TMP0:%.*]], i64 3, i64 [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
 ;
 
   %ps3 = getelementptr inbounds [4 x i32], [4 x i32]* @ws3, i64 0, i64 0

 
 define dso_local i64 @fold_wcslen_s3_pi_s5_pj(i1 zeroext %0, i64 %1, i64 %2) {
 ; CHECK-LABEL: @fold_wcslen_s3_pi_s5_pj(
-; CHECK-NEXT:    [[PS3_PI:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @ws3, i64 0, i64 [[TMP1:%.*]]
-; CHECK-NEXT:    [[PS5_PJ:%.*]] = getelementptr inbounds [6 x i32], [6 x i32]* @ws5, i64 0, i64 [[TMP2:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[TMP0:%.*]], i32* [[PS3_PI]], i32* [[PS5_PJ]]
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @wcslen(i32* nonnull [[SEL]])
-; CHECK-NEXT:    ret i64 [[LEN]]
+; Use CHECK-DAG since the two instructions below might be emitted in reverse
+; order.
+; CHECK-DAG:     [[TMP4:%.*]] = sub i64 3, [[TMP2:%.*]]
+; CHECK-DAG:     [[TMP5:%.*]] = sub i64 5, [[TMP1:%.*]]
+; CHECK:         [[TMP6:%.*]] = select i1 [[TMP0:%.*]], i64 [[TMPX:%.*]], i64 [[TMPY:%.*]]
+; CHECK:         ret i64 [[TMP6]]
 ;
 
   %ps3_pi = getelementptr inbounds [4 x i32], [4 x i32]* @ws3, i64 0, i64 %1