[InstCombine] Enable strtol folding with nonnull endptr

[msebor]

Summary

The strtol folding is conditional on the second argument, endptr, being a constant null pointer. However, since the idiomatic use case is to pass the function the address of a local end pointer as endptr, this restriction prevents the folding from taking place in the common case when the pointer is known not to be null.

Not having been able to find a rationale for this decision in D45418 (only tests), this change enables the folding also for endptr that's known to be nonnull by having the folder store the address of the nul character in *endptr. It stops short of attempting to handle arbitrary pointers since I suspect the cases where nothing is known about the pointer are rare.

Tested on x86_64-linux.

(This patch will need to be rebased on top of D129224 once it's committed.)

[nikic]

LG

llvm/test/Transforms/InstCombine/str-int-2.ll

43–45

enptr -> endptr

51

i8** nonnull %pend would be more obvious?

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

 }
 
 static bool callHasFP128Argument(const CallInst *CI) {
   return any_of(CI->operands(), [](const Use &OI) {
     return OI->getType()->isFP128Ty();
   });
 }
 
-static Value *convertStrToNumber(CallInst *CI, StringRef &Str, int64_t Base) {
+static Value *convertStrToNumber(CallInst *CI, StringRef &Str, Value *EndPtr,
+                                 int64_t Base, IRBuilderBase &B) {
   if (Base < 2 || Base > 36)
     // handle special zero base
     if (Base != 0)
       return nullptr;
 
   char *End;
   std::string nptr = Str.str();
   errno = 0;
   long long int Result = strtoll(nptr.c_str(), &End, Base);
   if (errno)
     return nullptr;
 
   // if we assume all possible target locales are ASCII supersets,
   // then if strtoll successfully parses a number on the host,
   // it will also successfully parse the same way on the target
   if (*End != '\0')
     return nullptr;
 
   if (!isIntN(CI->getType()->getPrimitiveSizeInBits(), Result))
     return nullptr;
 
+  if (EndPtr) {
+    // Store the pointer to the end.
+    uint64_t ILen = End - nptr.c_str();
+    Value *Off = B.getInt64(ILen);
+    Value *StrBeg = CI->getArgOperand(0);
+    Value *StrEnd = B.CreateInBoundsGEP(B.getInt8Ty(), StrBeg, Off, "endptr");
+    B.CreateStore(StrEnd, EndPtr);
+  }
+
   return ConstantInt::get(CI->getType(), Result);
 }
 
 static bool isOnlyUsedInComparisonWithZero(Value *V) {
   for (User *U : V->users()) {
     if (ICmpInst *IC = dyn_cast<ICmpInst>(U))
       if (Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
         if (C->isNullValue())
return B.CreateAnd(CI->getArgOperand(0),
                      ConstantInt::get(CI->getType(), 0x7F));
 }
 
 Value *LibCallSimplifier::optimizeAtoi(CallInst *CI, IRBuilderBase &B) {
   StringRef Str;
   if (!getConstantStringInfo(CI->getArgOperand(0), Str))
     return nullptr;
 
-  return convertStrToNumber(CI, Str, 10);
+  return convertStrToNumber(CI, Str, nullptr, 10, B);
 }
 
 Value *LibCallSimplifier::optimizeStrtol(CallInst *CI, IRBuilderBase &B) {
   StringRef Str;
   if (!getConstantStringInfo(CI->getArgOperand(0), Str))
     return nullptr;
 
-  if (!isa<ConstantPointerNull>(CI->getArgOperand(1)))
+  Value *EndPtr = CI->getArgOperand(1);
+  if (isa<ConstantPointerNull>(EndPtr))
+    EndPtr = nullptr;
+  else if (!isKnownNonZero(EndPtr, DL))
     return nullptr;
 
   if (ConstantInt *CInt = dyn_cast<ConstantInt>(CI->getArgOperand(2))) {
-    return convertStrToNumber(CI, Str, CInt->getSExtValue());
+    return convertStrToNumber(CI, Str, EndPtr, CInt->getSExtValue(), B);
   }
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Formatting and IO Library Call Optimizations
 //===----------------------------------------------------------------------===//

llvm/test/Transforms/InstCombine/str-int-2.ll

 define i64 @strtol_hex() #0 {
 ; CHECK-LABEL: @strtol_hex(
 ; CHECK-NEXT:    ret i64 18
 ;
   %call = call i64 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 16) #2
   ret i64 %call
 }
 
-define i64 @strtol_endptr_not_null() #0 {
+; Fold a call to strtol with an endptr known to be nonnull.
+
+define i64 @strtol_endptr_not_null(i8** nonnull %pend) {
 ; CHECK-LABEL: @strtol_endptr_not_null(
-; CHECK-NEXT:    [[END:%.*]] = alloca i8*, align 4
-; CHECK-NEXT:    [[CALL:%.*]] = call i64 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8** nonnull [[END]], i32 10)
+; CHECK-NEXT:    store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 2), i8** [[PEND:%.*]], align 8
+; CHECK-NEXT:    ret i64 12
+;
+  %call = call i64 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** %pend, i32 10)
+  ret i64 %call
+}
+
+; Don't fold a call to strtol with an endptr that's not known to be nonnull.
+
+define i64 @strtol_endptr_maybe_null(i8** %end) {
+; CHECK-LABEL: @strtol_endptr_maybe_null(
+; CHECK-NEXT:    [[CALL:%.*]] = call i64 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8** [[END:%.*]], i32 10)
 ; CHECK-NEXT:    ret i64 [[CALL]]
 ;
-  %end = alloca i8*, align 4
-  %call = call i64 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8** %end, i32 10) #2
+  %call = call i64 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8** %end, i32 10)
   ret i64 %call
 }
 
 define i32 @atoi_test() #0 {
 ; CHECK-LABEL: @atoi_test(
 ; CHECK-NEXT:    ret i32 12
 ;
   %call = call i32 @atoi(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0)) #4

llvm/test/Transforms/InstCombine/str-int.ll

 define i32 @strtol_hex() #0 {
 ; CHECK-LABEL: @strtol_hex(
 ; CHECK-NEXT:    ret i32 18
 ;
   %call = call i32 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 16) #2
   ret i32 %call
 }
 
-define i32 @strtol_endptr_not_null() #0 {
+; Fold a call to strtol with an endptr known to be nonnull (the result
+; of pointer increment).
+
+define i32 @strtol_endptr_not_null(i8** %pend) {
 ; CHECK-LABEL: @strtol_endptr_not_null(
-; CHECK-NEXT:    [[END:%.*]] = alloca i8*, align 4
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8** nonnull [[END]], i32 10)
+; CHECK-NEXT:    [[ENDP1:%.*]] = getelementptr inbounds i8*, i8** [[PEND:%.*]], i64 1
+; CHECK-NEXT:    store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 2), i8** [[ENDP1]], align 8
+; CHECK-NEXT:    ret i32 12
+;
+  %endp1 = getelementptr inbounds i8*, i8** %pend, i32 1
+  %call = call i32 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** %endp1, i32 10)
+  ret i32 %call
+}
+
+; Don't fold a call to strtol with an endptr that's not known to be nonnull.
+
+define i32 @strtol_endptr_maybe_null(i8** %end) {
+; CHECK-LABEL: @strtol_endptr_maybe_null(
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8** [[END:%.*]], i32 10)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
-  %end = alloca i8*, align 4
-  %call = call i32 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8** %end, i32 10) #2
+  %call = call i32 @strtol(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8** %end, i32 10)
   ret i32 %call
 }
 
 define i32 @atoi_test() #0 {
 ; CHECK-LABEL: @atoi_test(
 ; CHECK-NEXT:    ret i32 12
 ;
   %call = call i32 @atoi(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0)) #4