[InstCombine] Fold strtoul and strtoull and avoid PR #56293

[msebor]

Summary

PR #56293 points out a minor portability issue with the atoi,strtol, and strtoll folders as a result of relying on a nonportable aspect of strtoull for empty sequences. The issue is easy to avoid for just the limited subset of supported folders, but relying on srtroull turns out be problematic also due to overflow handling.

Rather than working around just the root cause of PR #56293, this patch replaces the use of strtoull with a hand-written conversion algorithm that doesn't suffer from either of these issues. Besides resolving the problem in the PR it enhances the libcall simplifier to handle the rest of the standard integer conversion functions.

In the PR @efriedma suggests using llvm::consumeSignedInteger. I ran into a couple of problems when trying that:

• The function recognizes other base prefixes besides 0 for octal and 0x for hex (0b for binary and 0o for octal), and these interfere with the rules of strtol. The prefixes would need to be disabled for the function to be usable in this context (e.g., by adding another argument).
• Like the current convertStrToNumber helper, the function doesn't make it possible to reliably detect whether or not the parsed number is representable in the destination type (which may be narrower than uint64_t). This too would require a change to the API to handle.

Rather than making intrusive changes to the existing "public" API I decided to instead modify the static helper function just for the libcall simplifier.

Besides the two problems noted above, llvm::consumeSignedInteger also doesn't strip leading space and succeeds even when the subject sequence isn't at the end of the string. Unlike those above, both of these could be handled by the caller.

Tested by running make check-all on x86_64-linux.

[xbolva00]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2591

This should go to BuildLibcalls as it is added unconditionally

[efriedma]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

108

uint64_t Max = AsSigned && Negate is clever, but confusing at first glance; maybe just write out the conditional?

146

This assumes the string is null-terminated? I mean, we don't have to guarantee any particular behavior if it isn't, but we shouldn't read past the end of the string.

148

Please use llvm::isDigit etc. The C library routines interact with the current locale.

177

Maybe this would be easier to read using the SaturatingMultiplyAdd helper?

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

146

Right. I forgot that getConstantStringInfo actually returns an unterminated array. Thanks for pointing it out! Let me fix that, add some tests, and update the comment above the function to make it clear.

148

Sure, I didn't notice the capitalization in existing code.

(My understanding was that the compiler sets the C locale but using the llvm routines makes sense to me, especially if there's any expectation to support EBCDIC in -finput-charset= at some point.)

177

Sure. (It requires making sure the first three arguments all have the same type, hence the further changes.)

2591

Where in BuildCalls would you suggest to add it?

For what it's worth, llvm::inferNonMandatoryLibFuncAttrs already handles LibFunc_atoi but it's not invoked for calls to the function already in the source. (I was under the impression is that BuildCalls is used when library call is being synthesized by the middle end, but I have very little experience in this area.)

[msebor]

Revision 2 of the patch addressing reviewer suggestions:

• Use a conditional instead of conversion from bool.
• Avoid assuming atoi etc. argument is a nul-terminated string.
• Use llvm::isDigit et al. instead of the C standard functions.
• Use SaturatingMultiplyAdd to detect overflow.
• Update getConstantStringInfo to make it clear it need not return a nul-terminated string.
• Add tests.

[yurai007]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

91

Couldn't it be simplified a bit to something like: Str = Str.drop_while([](char c) { return isSpace(c); }); ?

127

Couldn't it be simplified a bit to something like:

if (Str.startswith_insensitive("0x") {
Base = 16;
Str = Str.drop_front(2);
} else {...}

?

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2591

inferNonMandatoryLibFuncAttrs() is called for existing function declarations. The attribute is placed on the called function, not on the call.

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

110

NBytes -> NBits?

120

Can avoid the separate cases via AsSigned ? maxUIntN(NBits) : maxIntN(NBits)?

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

91

Yes, it could be rewritten like that. I'm not sure everyone will find the more compact form as readable. Not every compiler also inlines the lambda invocation (Clang does but GCC doesn't, likely due to exceeding some inlining limit), so there may be a runtime cost to pay. On balance I'm not sure it matters enough one way or the other so unless there's a strong preference for the lambda I'd just as soon leave it as is.

120

Yes, that's simpler, thanks.

127

Thanks for the suggestion. The code tests for '0' first, before testing for 'x', and I'd rather keep it that way than repeating the former if the "0x" test fails.

[msebor]

Revision 3 with one change from previous:

• Use maxUIntN(unsigned) instead of a case/switch statement.

[efriedma]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

102

I think the check for the empty string should come after the check for a +/- sign?

[efriedma]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

120

The standard requires that a "0x" prefix be followed by a hexadecimal digit. Similarly, the standard requires that a "0" prefix be followed by an octal digit. If there isn't an appropriate digit after, the subject sequence (the part that's actually parsed as a number) is just a decimal "0". And the rest is treated as "unrecognized characters".

The standard allows a "0x" prefix if the base is explicitly specified to be 16.

[msebor]

Revision 4 with the following changes:

• correct base autodetection to consume the 0x prefix also in base 16,
• reject more variants of empty subject sequences including sole "+" and "0x",
• add tests for the above.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

102

Sure. I don't have access to Darwin but based on the dated Apple strtol.c source I found online it looks like it also sets errno to EINVAL for calls like strtol("+", 0, 0) and also strtol("0x", 0, 0) that Glibc succeeds for so I adjusted the code to fail for those sequences as well.

120

Whoops, yes, we need to consume the hex prefix even in base 16. Thanks for pointing out this mistake!

I'm aware of what the C and POSIX standards require but I'm not sure I understand the first part of your comment, but just for clarity: 1) a lone zero is valid in any base (i.e., it doesn't need to be followed by other digits), and 2) the function fails if the whole subject sequence isn't consumed (i.e., has "unrecognized characters").

[efriedma]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

120

I think strictly interpreting the standard, if you have something like "0xg", or "09", they should also parse to "0". But if we're rejecting them anyway, I guess that's fine... might want to add a comment somewhere to clarify why we're rejecting strings with unrecognized trailing characters.

[msebor]

Revision 5 with an expanded comment explaining why sequences that end parsing prior to the terminating nul are not accepted.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

120

That's right. The rationale for rejecting valid sequences with trailing characters is already in one of the new tests but I can repeat it in the function.

(In practice it would probably be safe to accept sequences terminated by most unrecognizable characters except a comma or a space but I'm not sure it's worth it since it's possible to create a wacky locale with a thousands separator set to pretty much any nonnumeric character.)

[barannikov88]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

131

This comment is not true for the case when AsSigned and Negate are both true. I.e. 0x80 is not the maximum possible representable value in i8 type. Something like "maximum possible value of the magnitude of a number which could be encoded" might be better.
Excuse my English

135

Honestly, I'd prefer more verbose code to this bit manipulation (it took me two minutes to figure out that the added 1 deals with two's complement representation). E.g.

if (AsSigned)
  Max = Negate ? -(uint64_t)minIntN(NBits) : maxIntN(NBits)
else
  Max = maxUIntN(NBits);

or, if you prefer one-liners:
Max = AsSigned ? Negate ? -(uint64_t)minIntN(NBits) : maxIntN(NBits) : maxUIntN(NBits)

[msebor]

Ping: @efriedma, please let me know if you have any further comments or suggestions, or if the last revisions is good enough to commit. Thanks!

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

131

I agree that magnitude might be more accurate, although to me the suggested rewording sounds too cumbersome to be an overall improvement. I'll see if I can work the word into the comment without making it harder to understand. Thanks!

135

I don't see either of the suggested forms as an improvement, although (obviously) others might feel differently. Since it's a matter of taste I'm going to leave it as is.

[efriedma]

LGTM

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2589

This call should still get dropped (the other one is fine, as it is conditional).

2604

That sounds like the parameter can still be readonly, just not the function.

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2589

I'm not familiar with the guidelines for and against applying attributes to calls (or if there are any), but I added this one because I noticed that nocapture was missing from calls to atol while it was present in calls to strtol. That seemed unexpected.

It sounds like you're suggesting that an attribute should only be applied to an argument of a call when it's not implied either by the explicit declaration of the called function in the IL, or by whatever might be implicitly added to it by the middle end.

I would find that subtle and surprising. It would mean that an attribute could be used for codegen decisions even though it didn't actually appear anywhere in the IL. From what I've seen, the IL is quite verbose and commonly redundant (e.g., the noundef and nonnull annotations added to calls to string function like strlen even when they are implied by accesses to declared objects that are readily apparent in the IL).

So with that I prefer to leave this code in place for this change. That said, in my testing not all calls with the same access semantics are annotated with the same attributes (e.g., a call to atoi is annotated differently than the corresponding call to strlen). So I think there's room for improvement here and I'll try to look into it in a followup.

2604

I'm not sure I understand what you're suggesting here but the first argument is of course read-only regardless of whether or not the second one is null. It seems that it could be annotated Attribute::ReadOnly unconditionally, as could many others in this file. I just copied this bit from LibCallSimplifier::optimizeStrTo without thinking about what other attributes might be appropriate to add and under what conditions. As there are no uses of Attribute::ReadOnly in this file I'm not sure that adding it just in this one case would be appropriate. But as in the other case, I'd be happy to look in a followup into what other attributes these functions might benefit from.

(As an aside, annotating just the argument readonly doesn't have the effect I'd expect: calls to strtol are assumed to modify the object the first argument points to. This is in contrast to calls to atol etc., where the whole function is annotated readonly.)

[nikic]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2589

Attribute queries on calls work by first checking whether the attribute exists on the call, and if it doesn't, checking whether it exists on the called function. If the called function has the attribute, then that implies that all calls have it as well.

The policy for libcall attributes is that all attributes that are unconditional are inferred on the declaration using inferNonMandatoryLibFuncAttrs(). This happens as part of the InferFunctionAttrs pass. Attributes that are conditional and cannot be inferred on the declaration, are placed by SimplifyLibCalls instead.

This is why the responsibility for inferring nocapture on atol falls to InferFunctionAttrs (it holds for all atol calls), while inferring nocapture on strtol falls to SimplifyLibCalls (it holds only for some strtol calls). If you run just InstCombine, it may look like nocapture doesn't get inferred, but it will get inferred in a complete optimization pipeline.

While inferring unconditional attributes in SimplifyLibCalls is fine from a correctness perspective, it is also unnecessary. We do not need (or want) to duplicate the functionality already present in inferNonMandatoryLibFuncAttrs() inside SimplifyLibCalls as well.

2604

I just checked, and the readonly attribute will already get added by InferFunctionAttrs, so there is nothing to do here.

As an aside, annotating just the argument readonly doesn't have the effect I'd expect: calls to strtol are assumed to modify the object the first argument points to.

Do you have an example for this handy? I would expect this to work as long as the object is non-escaping. If it is potentially captured (say a function argument), then a non-argmemonly call might modify it through the capture. (LLVM doesn't model errno specially).

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

2604

This might be easier to discuss outside of a review so I created PR #56744 with the details of both of the issues I was referring to here.

[alexfh]

There's a problem after this commit: the endptr pointer is not set correctly in some cases. https://gcc.godbolt.org/z/dvcPWcz1T

[alexfh]

In D129224#3690667, @alexfh wrote:

There's a problem after this commit: the endptr pointer is not set correctly in some cases. https://gcc.godbolt.org/z/dvcPWcz1T

Apologies, hit "enter" too early. Here's an example:

#include <stdlib.h>
#include <stdio.h>

int main(int, char**) {
   char *endptr = nullptr;
   const char *src = "-9223372036854775808";
   long long result = strtoll(src, &endptr, 0);
   printf("source: <%s>, result: %lld, endptr: <%s>\n", src, result, endptr);
}

When compiled with -O1 or higher optimization level, it now outputs source: <-9223372036854775808>, result: -9223372036854775808, endptr: <8>. For -O0 the output is correct: source: <-9223372036854775808>, result: -9223372036854775808, endptr: <>.

Do you see an obvious fix?

(and btw, the fix will need to be cherrypicked to the release: @tstellar, fyi)

[msebor]

In D129224#3690668, @alexfh wrote:

Thanks for the test case! The bug is in skipping over the leading part of the string up to the first digit and not accounting for it in the end pointer. It should be straightforward to fix. I'll take care of it today.

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

private:
   // Integer Library Call Optimizations
   Value *optimizeFFS(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFls(CallInst *CI, IRBuilderBase &B);
   Value *optimizeAbs(CallInst *CI, IRBuilderBase &B);
   Value *optimizeIsDigit(CallInst *CI, IRBuilderBase &B);
   Value *optimizeIsAscii(CallInst *CI, IRBuilderBase &B);
   Value *optimizeToAscii(CallInst *CI, IRBuilderBase &B);
   Value *optimizeAtoi(CallInst *CI, IRBuilderBase &B);
-  Value *optimizeStrtol(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeStrToInt(CallInst *CI, IRBuilderBase &B, bool AsSigned);
 
   // Formatting and IO Library Call Optimizations
   Value *optimizeErrorReporting(CallInst *CI, IRBuilderBase &B,
                                 int StreamArg = -1);
   Value *optimizePrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSnPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPrintF(CallInst *CI, IRBuilderBase &B);

llvm/lib/Analysis/ValueTracking.cpp

     return false;
 
   Slice.Array = Array;
   Slice.Offset = Offset;
   Slice.Length = NumElts - Offset;
   return true;
 }
 
-/// This function computes the length of a null-terminated C string pointed to
-/// by V. If successful, it returns true and returns the string in Str.
-/// If unsuccessful, it returns false.
+/// Extract bytes from the initializer of the constant array V, which need
+/// not be a nul-terminated string.  On success, store the bytes in Str and
+/// return true.  When TrimAtNul is set, Str will contain only the bytes up
+/// to but not including the first nul.  Return false on failure.
 bool llvm::getConstantStringInfo(const Value *V, StringRef &Str,
                                  uint64_t Offset, bool TrimAtNul) {
   ConstantDataArraySlice Slice;
   if (!getConstantDataArrayInfo(V, Slice, 8, Offset))
     return false;
 
   if (Slice.Array == nullptr) {
     if (TrimAtNul) {

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) {
+// Convert the entire string Str representing an integer in Base, up to
+// the terminating nul if present, to a constant according to the rules
+// of strtoul[l] or, when AsSigned is set, of strtol[l].  On success
+// return the result, otherwise null.
+// The function assumes the string is encoded in ASCII.
+static Value *convertStrToInt(CallInst *CI, StringRef &Str, uint64_t Base,
+                              bool AsSigned) {
   if (Base < 2 || Base > 36)
-    // handle special zero base
     if (Base != 0)
+      // Fail for an invalid base (required by POSIX).
       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;
+  // Strip leading whitespace.
+  for (unsigned i = 0; i != Str.size(); ++i)
+    if (!isSpace((unsigned char)Str[i])) {
+      Str = Str.substr(i);
+      break;
+    }
 
-  // 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')
+  if (Str.empty())
+    // Fail for empty subject sequences (POSIX allows but doesn't require
+    // strtol[l]/strtoul[l] to fail with EINVAL).
     return nullptr;
 
-  if (!isIntN(CI->getType()->getPrimitiveSizeInBits(), Result))
+  // Strip but remember the sign.
+  bool Negate = Str[0] == '-';
+  if (Str[0] == '-' || Str[0] == '+')
+    Str = Str.drop_front();
+
+  // Set Max to the maximum positive representable value in the type.
+  uint64_t Max = AsSigned && Negate ? 1 : 0;
+  Type *RetTy = CI->getType();
+  unsigned NBytes = RetTy->getPrimitiveSizeInBits();
+  switch (NBytes) {
+  case 16:
+    Max += AsSigned ? INT16_MAX : UINT16_MAX;
+    break;
+  case 32:
+    Max += AsSigned ? INT32_MAX : UINT32_MAX;
+    break;
+  case 64:
+    Max += AsSigned ? INT64_MAX : UINT64_MAX;
+    break;
+  default:
     return nullptr;
+  }
+
+  if (Base == 0) {
+    // Autodetect Base.
+    if (Str.size() > 1) {
+      if (Str[0] == '0') {
+        if (toUpper((unsigned char)Str[1]) == 'X') {
+          Base = 16;
+          Str = Str.drop_front(2);
+        }
+        else
+          Base = 8;
+      } else
+        Base = 10;
+    }
+    else
+      Base = 10;
+  }
+
+  // Convert the rest of the subject sequence, not including the sign,
+  // to its uint64_t representation (this assumes the source character
+  // set is ASCII).
+  uint64_t Result = 0;
+  for (unsigned i = 0; i != Str.size(); ++i) {
+    unsigned char DigVal = Str[i];
+    if (isDigit(DigVal))
+      DigVal = DigVal - '0';
+    else {
+      DigVal = toUpper(DigVal);
+      if (isAlpha(DigVal))
+        DigVal = DigVal - 'A' + 10;
+      else
+        return nullptr;
+    }
+
+    if (DigVal >= Base)
+      // Fail if the digit is not valid in the Base.
+      return nullptr;
+
+    // Add the digit and fail if the result is not representable in
+    // the (unsigned form of the) destination type.
+    bool VFlow;
+    Result = SaturatingMultiplyAdd(Result, Base, (uint64_t)DigVal, &VFlow);
+    if (VFlow || Result > Max)
+      return nullptr;
+  }
 
-  return ConstantInt::get(CI->getType(), Result);
+  if (Negate)
+    // Unsigned negation doesn't overflow.
+    Result = -Result;
+
+  return ConstantInt::get(RetTy, 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())
           continue;
     // Unknown instruction.
     return false;
   }

 }
 
 Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilderBase &B) {
   // toascii(c) -> c & 0x7f
   return B.CreateAnd(CI->getArgOperand(0),
                      ConstantInt::get(CI->getType(), 0x7F));
 }
 
+// Fold calls to atoi, atol, and atoll.
 Value *LibCallSimplifier::optimizeAtoi(CallInst *CI, IRBuilderBase &B) {
+  CI->addParamAttr(0, Attribute::NoCapture);
+
   StringRef Str;
   if (!getConstantStringInfo(CI->getArgOperand(0), Str))
     return nullptr;
 
-  return convertStrToNumber(CI, Str, 10);
+  return convertStrToInt(CI, Str, 10, /*AsSigned=*/true);
 }
 
-Value *LibCallSimplifier::optimizeStrtol(CallInst *CI, IRBuilderBase &B) {
+// Fold calls to strtol, strtoll, strtoul, and strtoull.
+Value *LibCallSimplifier::optimizeStrToInt(CallInst *CI, IRBuilderBase &B,
+                                           bool AsSigned) {
+  Value *EndPtr = CI->getArgOperand(1);
+  if (isa<ConstantPointerNull>(EndPtr))
+    // With a null EndPtr, this function won't capture the main argument.
+    // It would be readonly too, except that it still may write to errno.
+    CI->addParamAttr(0, Attribute::NoCapture);
+
   StringRef Str;
   if (!getConstantStringInfo(CI->getArgOperand(0), Str))
     return nullptr;
 
   if (!isa<ConstantPointerNull>(CI->getArgOperand(1)))
     return nullptr;
 
   if (ConstantInt *CInt = dyn_cast<ConstantInt>(CI->getArgOperand(2))) {
-    return convertStrToNumber(CI, Str, CInt->getSExtValue());
+    return convertStrToInt(CI, Str, CInt->getSExtValue(), AsSigned);
   }
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Formatting and IO Library Call Optimizations
 //===----------------------------------------------------------------------===//

     case LibFunc_toascii:
       return optimizeToAscii(CI, Builder);
     case LibFunc_atoi:
     case LibFunc_atol:
     case LibFunc_atoll:
       return optimizeAtoi(CI, Builder);
     case LibFunc_strtol:
     case LibFunc_strtoll:
-      return optimizeStrtol(CI, Builder);
+      return optimizeStrToInt(CI, Builder, /*AsSigned=*/true);
+    case LibFunc_strtoul:
+    case LibFunc_strtoull:
+      return optimizeStrToInt(CI, Builder, /*AsSigned=*/false);
     case LibFunc_printf:
       return optimizePrintF(CI, Builder);
     case LibFunc_sprintf:
       return optimizeSPrintF(CI, Builder);
     case LibFunc_snprintf:
       return optimizeSnPrintF(CI, Builder);
     case LibFunc_fprintf:
       return optimizeFPrintF(CI, Builder);

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

 ; CHECK-NEXT:    ret i64 [[CALL]]
 ;
   %call = call i64 @strtol(i8* %s, i8** null, i32 10) #3
   ret i64 %call
 }
 
 define i32 @atoi_not_const_str(i8* %s) #0 {
 ; CHECK-LABEL: @atoi_not_const_str(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoi(i8* [[S:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoi(i8* nocapture [[S:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @atoi(i8* %s) #4
   ret i32 %call
 }
 
 define i64 @strtol_not_const_base(i32 %b) #0 {
 ; CHECK-LABEL: @strtol_not_const_base(

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; Verify that calls to strtol and strtoll are interpreted correctly even
+; in corner cases (or not folded).
+;
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+declare i32 @strtol(i8*, i8**, i32)
+declare i64 @strtoll(i8*, i8**, i32)
+
+
+; All POSIX whitespace characters.
+@ws = constant [7 x i8] c"\09\0d\0a\0b\0c \00"
+
+; A negative and positive number preceded by all POSIX whitespace.
+@ws_im123 = constant [11 x i8] c"\09\0d\0a\0b\0c -123\00"
+@ws_ip234 = constant [11 x i8] c"\09\0d\0a\0b\0c +234\00"
+
+@i0 = constant [3 x i8] c" 0\00"
+@i9 = constant [3 x i8] c" 9\00"
+@i19azAZ = constant [7 x i8] c"19azAZ\00"
+@i32min = constant [13 x i8] c" -2147483648\00"
+@i32min_m1 = constant [13 x i8] c" -2147483649\00"
+@o32min = constant [15 x i8] c" +020000000000\00"
+@mo32min = constant [15 x i8] c" -020000000000\00"
+@x32min = constant [13 x i8] c" +0x80000000\00"
+@mx32min = constant [13 x i8] c" -0x80000000\00"
+
+@i32max = constant [12 x i8] c" 2147483647\00"
+@x32max = constant [12 x i8] c" 0x7fffffff\00"
+@i32max_p1 = constant [12 x i8] c" 2147483648\00"
+
+@ui32max = constant [12 x i8] c" 4294967295\00"
+@ui32max_p1 = constant [12 x i8] c" 4294967296\00"
+
+
+; Exercise folding calls to 32-bit strtol.
+
+define void @fold_strtol(i32* %ps) {
+; CHECK-LABEL: @fold_strtol(
+; CHECK-NEXT:    store i32 -123, i32* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i32, i32* [[PS]], i64 1
+; CHECK-NEXT:    store i32 234, i32* [[PS1]], align 4
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i32, i32* [[PS]], i64 2
+; CHECK-NEXT:    store i32 0, i32* [[PS2]], align 4
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i32, i32* [[PS]], i64 3
+; CHECK-NEXT:    store i32 9, i32* [[PS3]], align 4
+; CHECK-NEXT:    [[PS4:%.*]] = getelementptr i32, i32* [[PS]], i64 4
+; CHECK-NEXT:    store i32 76095035, i32* [[PS4]], align 4
+; CHECK-NEXT:    [[PS5:%.*]] = getelementptr i32, i32* [[PS]], i64 5
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS5]], align 4
+; CHECK-NEXT:    [[PS6:%.*]] = getelementptr i32, i32* [[PS]], i64 6
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS6]], align 4
+; CHECK-NEXT:    [[PS7:%.*]] = getelementptr i32, i32* [[PS]], i64 7
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS7]], align 4
+; CHECK-NEXT:    [[PS8:%.*]] = getelementptr i32, i32* [[PS]], i64 8
+; CHECK-NEXT:    store i32 2147483647, i32* [[PS8]], align 4
+; CHECK-NEXT:    [[PS9:%.*]] = getelementptr i32, i32* [[PS]], i64 9
+; CHECK-NEXT:    store i32 2147483647, i32* [[PS9]], align 4
+; CHECK-NEXT:    ret void
+;
+; Fold a valid sequence with leading POSIX whitespace and a minus to -123.
+  %pwsm123 = getelementptr [11 x i8], [11 x i8]* @ws_im123, i32 0, i32 0
+  %im123 = call i32 @strtol(i8* %pwsm123, i8** null, i32 10)
+  %ps0 = getelementptr i32, i32* %ps, i32 0
+  store i32 %im123, i32* %ps0
+
+; Fold a valid sequence with leading POSIX whitespace and a plus to +234.
+  %pwsp234 = getelementptr [11 x i8], [11 x i8]* @ws_ip234, i32 0, i32 0
+  %ip234 = call i32 @strtol(i8* %pwsp234, i8** null, i32 10)
+  %ps1 = getelementptr i32, i32* %ps, i32 1
+  store i32 %ip234, i32* %ps1
+
+; Fold "0" in base 0 to verify correct base autodetection.
+  %psi0 = getelementptr [3 x i8], [3 x i8]* @i0, i32 0, i32 0
+  %i0 = call i32 @strtol(i8* %psi0, i8** null, i32 0)
+  %ps2 = getelementptr i32, i32* %ps, i32 2
+  store i32 %i0, i32* %ps2
+
+; Fold "9" in base 0 to verify correct base autodetection.
+  %psi9 = getelementptr [3 x i8], [3 x i8]* @i9, i32 0, i32 0
+  %i9 = call i32 @strtol(i8* %psi9, i8** null, i32 0)
+  %ps3 = getelementptr i32, i32* %ps, i32 3
+  store i32 %i9, i32* %ps3
+
+; Fold "19azAZ" in base 36 to 76095035.
+  %psi19azAZ = getelementptr [7 x i8], [7 x i8]* @i19azAZ, i32 0, i32 0
+  %i19azAZ = call i32 @strtol(i8* %psi19azAZ, i8** null, i32 36)
+  %ps4 = getelementptr i32, i32* %ps, i32 4
+  store i32 %i19azAZ, i32* %ps4
+
+; Fold INT32_MIN.
+  %psmin = getelementptr [13 x i8], [13 x i8]* @i32min, i32 0, i32 0
+  %min = call i32 @strtol(i8* %psmin, i8** null, i32 10)
+  %ps5 = getelementptr i32, i32* %ps, i32 5
+  store i32 %min, i32* %ps5
+
+; Fold -INT32_MIN in octal.
+  %psmo32min = getelementptr [15 x i8], [15 x i8]* @mo32min, i32 0, i32 0
+  %mo32min = call i32 @strtol(i8* %psmo32min, i8** null, i32 0)
+  %ps6 = getelementptr i32, i32* %ps, i32 6
+  store i32 %mo32min, i32* %ps6
+
+; Fold -INT32_MIN in hex.
+  %psmx32min = getelementptr [13 x i8], [13 x i8]* @mx32min, i32 0, i32 0
+  %mx32min = call i32 @strtol(i8* %psmx32min, i8** null, i32 0)
+  %ps7 = getelementptr i32, i32* %ps, i32 7
+  store i32 %mx32min, i32* %ps7
+
+; Fold INT32_MAX.
+  %psmax = getelementptr [12 x i8], [12 x i8]* @i32max, i32 0, i32 0
+  %max = call i32 @strtol(i8* %psmax, i8** null, i32 10)
+  %ps8 = getelementptr i32, i32* %ps, i32 8
+  store i32 %max, i32* %ps8
+
+; Fold INT32_MAX in hex.
+  %psxmax = getelementptr [12 x i8], [12 x i8]* @x32max, i32 0, i32 0
+  %xmax = call i32 @strtol(i8* %psxmax, i8** null, i32 0)
+  %ps9 = getelementptr i32, i32* %ps, i32 9
+  store i32 %xmax, i32* %ps9
+
+  ret void
+}
+
+
+; Exercise not folding calls to 32-bit strtol.
+
+define void @call_strtol(i32* %ps) {
+; CHECK-LABEL: @call_strtol(
+; CHECK-NEXT:    [[MINM1:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([13 x i8], [13 x i8]* @i32min_m1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    store i32 [[MINM1]], i32* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[MAXP1:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([12 x i8], [12 x i8]* @i32max_p1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i32, i32* [[PS]], i64 1
+; CHECK-NEXT:    store i32 [[MAXP1]], i32* [[PS1]], align 4
+; CHECK-NEXT:    [[O32MIN:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([15 x i8], [15 x i8]* @o32min, i64 0, i64 0), i8** null, i32 0)
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i32, i32* [[PS]], i64 2
+; CHECK-NEXT:    store i32 [[O32MIN]], i32* [[PS2]], align 4
+; CHECK-NEXT:    [[X32MIN:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([13 x i8], [13 x i8]* @x32min, i64 0, i64 0), i8** null, i32 0)
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i32, i32* [[PS]], i64 3
+; CHECK-NEXT:    store i32 [[X32MIN]], i32* [[PS3]], align 4
+; CHECK-NEXT:    [[NWS:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS4:%.*]] = getelementptr i32, i32* [[PS]], i64 4
+; CHECK-NEXT:    store i32 [[NWS]], i32* [[PS4]], align 4
+; CHECK-NEXT:    [[NWSP6:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 6), i8** null, i32 10)
+; CHECK-NEXT:    [[PS5:%.*]] = getelementptr i32, i32* [[PS]], i64 5
+; CHECK-NEXT:    store i32 [[NWSP6]], i32* [[PS5]], align 4
+; CHECK-NEXT:    [[I0B1:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([3 x i8], [3 x i8]* @i0, i64 0, i64 0), i8** null, i32 1)
+; CHECK-NEXT:    [[PS6:%.*]] = getelementptr i32, i32* [[PS]], i64 6
+; CHECK-NEXT:    store i32 [[I0B1]], i32* [[PS6]], align 4
+; CHECK-NEXT:    [[I0B256:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([3 x i8], [3 x i8]* @i0, i64 0, i64 0), i8** null, i32 256)
+; CHECK-NEXT:    [[PS7:%.*]] = getelementptr i32, i32* [[PS]], i64 7
+; CHECK-NEXT:    store i32 [[I0B256]], i32* [[PS7]], align 4
+; CHECK-NEXT:    ret void
+;
+
+; Do not fold the result of conversion that's less than INT32_MIN.
+  %psminm1 = getelementptr [13 x i8], [13 x i8]* @i32min_m1, i32 0, i32 0
+  %minm1 = call i32 @strtol(i8* %psminm1, i8** null, i32 10)
+  %ps0 = getelementptr i32, i32* %ps, i32 0
+  store i32 %minm1, i32* %ps0
+
+; Do not fold the result of conversion that's greater than INT32_MAX.
+  %psmaxp1 = getelementptr [12 x i8], [12 x i8]* @i32max_p1, i32 0, i32 0
+  %maxp1 = call i32 @strtol(i8* %psmaxp1, i8** null, i32 10)
+  %ps1 = getelementptr i32, i32* %ps, i32 1
+  store i32 %maxp1, i32* %ps1
+
+; Do not fold INT32_MIN in octal.
+  %pso32min = getelementptr [15 x i8], [15 x i8]* @o32min, i32 0, i32 0
+  %o32min = call i32 @strtol(i8* %pso32min, i8** null, i32 0)
+  %ps2 = getelementptr i32, i32* %ps, i32 2
+  store i32 %o32min, i32* %ps2
+
+; Do not fold INT32_MIN in hex.
+  %psx32min = getelementptr [13 x i8], [13 x i8]* @x32min, i32 0, i32 0
+  %x32min = call i32 @strtol(i8* %psx32min, i8** null, i32 0)
+  %ps3 = getelementptr i32, i32* %ps, i32 3
+  store i32 %x32min, i32* %ps3
+
+; Do not fold a sequence consisting of just whitespace characters.
+  %psws = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 0
+  %nws = call i32 @strtol(i8* %psws, i8** null, i32 10)
+  %ps4 = getelementptr i32, i32* %ps, i32 4
+  store i32 %nws, i32* %ps4
+
+; Do not fold an empty sequence.
+  %pswsp6 = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 6
+  %nwsp6 = call i32 @strtol(i8* %pswsp6, i8** null, i32 10)
+  %ps5 = getelementptr i32, i32* %ps, i32 5
+  store i32 %nwsp6, i32* %ps5
+
+; Do not fold the invalid base 1.
+  %psi0 = getelementptr [3 x i8], [3 x i8]* @i0, i32 0, i32 0
+  %i0b1 = call i32 @strtol(i8* %psi0, i8** null, i32 1)
+  %ps6 = getelementptr i32, i32* %ps, i32 6
+  store i32 %i0b1, i32* %ps6
+
+; Do not fold the invalid base 256.
+  %i0b256 = call i32 @strtol(i8* %psi0, i8** null, i32 256)
+  %ps7 = getelementptr i32, i32* %ps, i32 7
+  store i32 %i0b256, i32* %ps7
+
+  ret void
+}
+
+
+@i64min = constant [22 x i8] c" -9223372036854775808\00"
+@i64min_m1 = constant [22 x i8] c" -9223372036854775809\00"
+
+@i64max = constant [21 x i8] c" 9223372036854775807\00"
+@i64max_p1 = constant [21 x i8] c" 9223372036854775808\00"
+
+@ui64max = constant [22 x i8] c" 18446744073709551615\00"
+@ui64max_p1 = constant [22 x i8] c" 18446744073709551616\00"
+
+
+; Exercise folding calls to the 64-bit strtoll.
+
+define void @fold_strtoll(i64* %ps) {
+; CHECK-LABEL: @fold_strtoll(
+; CHECK-NEXT:    store i64 -123, i64* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i64, i64* [[PS]], i64 1
+; CHECK-NEXT:    store i64 234, i64* [[PS1]], align 4
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i64, i64* [[PS]], i64 2
+; CHECK-NEXT:    store i64 -9223372036854775808, i64* [[PS2]], align 4
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i64, i64* [[PS]], i64 3
+; CHECK-NEXT:    store i64 9223372036854775807, i64* [[PS3]], align 4
+; CHECK-NEXT:    ret void
+;
+; Fold a valid sequence with leading POSIX whitespace and a minus to -123.
+  %pwsm123 = getelementptr [11 x i8], [11 x i8]* @ws_im123, i32 0, i32 0
+  %im123 = call i64 @strtoll(i8* %pwsm123, i8** null, i32 10)
+  %ps0 = getelementptr i64, i64* %ps, i32 0
+  store i64 %im123, i64* %ps0
+
+; Fold a valid sequence with leading POSIX whitespace and a plus to +234.
+  %pwsp234 = getelementptr [11 x i8], [11 x i8]* @ws_ip234, i32 0, i32 0
+  %ip234 = call i64 @strtoll(i8* %pwsp234, i8** null, i32 10)
+  %ps1 = getelementptr i64, i64* %ps, i32 1
+  store i64 %ip234, i64* %ps1
+
+; Fold INT64_MIN.
+  %psmin = getelementptr [22 x i8], [22 x i8]* @i64min, i32 0, i32 0
+  %min = call i64 @strtoll(i8* %psmin, i8** null, i32 10)
+  %ps2 = getelementptr i64, i64* %ps, i32 2
+  store i64 %min, i64* %ps2
+
+; Fold INT64_MAX.
+  %psmax = getelementptr [21 x i8], [21 x i8]* @i64max, i32 0, i32 0
+  %max = call i64 @strtoll(i8* %psmax, i8** null, i32 10)
+  %ps3 = getelementptr i64, i64* %ps, i32 3
+  store i64 %max, i64* %ps3
+
+  ret void
+}
+
+
+; Exercise not folding calls to the 64-bit strtoll.
+
+define void @call_strtoll(i64* %ps) {
+; CHECK-LABEL: @call_strtoll(
+; CHECK-NEXT:    [[MINM1:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([22 x i8], [22 x i8]* @i64min_m1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    store i64 [[MINM1]], i64* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[MAXP1:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([21 x i8], [21 x i8]* @i64max_p1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i64, i64* [[PS]], i64 1
+; CHECK-NEXT:    store i64 [[MAXP1]], i64* [[PS1]], align 4
+; CHECK-NEXT:    [[NWS:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i64, i64* [[PS]], i64 2
+; CHECK-NEXT:    store i64 [[NWS]], i64* [[PS2]], align 4
+; CHECK-NEXT:    [[NWSP6:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 6), i8** null, i32 10)
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i64, i64* [[PS]], i64 3
+; CHECK-NEXT:    store i64 [[NWSP6]], i64* [[PS3]], align 4
+; CHECK-NEXT:    ret void
+;
+; Do not fold the result of conversion that's less than INT64_MIN.
+  %psminm1 = getelementptr [22 x i8], [22 x i8]* @i64min_m1, i32 0, i32 0
+  %minm1 = call i64 @strtoll(i8* %psminm1, i8** null, i32 10)
+  %ps0 = getelementptr i64, i64* %ps, i32 0
+  store i64 %minm1, i64* %ps0
+
+; Do not fold the result of conversion that's greater than INT64_MAX.
+  %psmaxp1 = getelementptr [21 x i8], [21 x i8]* @i64max_p1, i32 0, i32 0
+  %maxp1 = call i64 @strtoll(i8* %psmaxp1, i8** null, i32 10)
+  %ps1 = getelementptr i64, i64* %ps, i32 1
+  store i64 %maxp1, i64* %ps1
+
+; Do not fold a sequence consisting of just whitespace characters.
+  %psws = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 0
+  %nws = call i64 @strtoll(i8* %psws, i8** null, i32 10)
+  %ps2 = getelementptr i64, i64* %ps, i32 2
+  store i64 %nws, i64* %ps2
+
+; Do not fold an empty sequence.
+  %pswsp6 = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 6
+  %nwsp6 = call i64 @strtoll(i8* %pswsp6, i8** null, i32 10)
+  %ps3 = getelementptr i64, i64* %ps, i32 3
+  store i64 %nwsp6, i64* %ps3
+
+  ret void
+}
+
+@i_1_2_3_ = constant [9 x i8] c" 1 2\09\3\0a\00";
+
+; Verify that strings of digits that are followed by whitespace are not
+; folded (the whitespace could be interpreted in locales other than C
+; as part of the leading digits, such as "123 456" is interepreted as
+; 123456 in the French locale).
+
+define void @call_strtol_trailing_space(i32* %ps) {
+; CHECK-LABEL: @call_strtol_trailing_space(
+; CHECK-NEXT:    [[N1:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([9 x i8], [9 x i8]* @i_1_2_3_, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i32, i32* [[PS:%.*]], i64 1
+; CHECK-NEXT:    store i32 [[N1]], i32* [[PS1]], align 4
+; CHECK-NEXT:    [[N2:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([9 x i8], [9 x i8]* @i_1_2_3_, i64 0, i64 2), i8** null, i32 10)
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i32, i32* [[PS]], i64 2
+; CHECK-NEXT:    store i32 [[N2]], i32* [[PS2]], align 4
+; CHECK-NEXT:    [[N3:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([9 x i8], [9 x i8]* @i_1_2_3_, i64 0, i64 4), i8** null, i32 10)
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i32, i32* [[PS]], i64 3
+; CHECK-NEXT:    store i32 [[N3]], i32* [[PS3]], align 4
+; CHECK-NEXT:    ret void
+;
+  %p1 = getelementptr [9 x i8], [9 x i8]* @i_1_2_3_, i32 0, i32 0
+  %n1 = call i32 @strtol(i8* %p1, i8** null, i32 10)
+  %ps1 = getelementptr i32, i32* %ps, i32 1
+  store i32 %n1, i32* %ps1
+
+  %p2 = getelementptr [9 x i8], [9 x i8]* @i_1_2_3_, i32 0, i32 2
+  %n2 = call i32 @strtol(i8* %p2, i8** null, i32 10)
+  %ps2 = getelementptr i32, i32* %ps, i32 2
+  store i32 %n2, i32* %ps2
+
+  %p3 = getelementptr [9 x i8], [9 x i8]* @i_1_2_3_, i32 0, i32 4
+  %n3 = call i32 @strtol(i8* %p3, i8** null, i32 10)
+  %ps3 = getelementptr i32, i32* %ps, i32 3
+  store i32 %n3, i32* %ps3
+
+  ret void
+}

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; Verify that calls to strtoul and strtoull are interpreted correctly even
+; in corner cases (or not folded).
+;
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+declare i32 @strtoul(i8*, i8**, i32)
+declare i64 @strtoull(i8*, i8**, i32)
+
+
+; All POSIX whitespace characters.
+@ws = constant [7 x i8] c"\09\0d\0a\0b\0c \00"
+
+; A negative and positive number preceded by all POSIX whitespace.
+@ws_im123 = constant [11 x i8] c"\09\0d\0a\0b\0c -123\00"
+@ws_ip234 = constant [11 x i8] c"\09\0d\0a\0b\0c +234\00"
+
+@i32min = constant [13 x i8] c" -2147483648\00"
+@i32min_m1 = constant [13 x i8] c" -2147483649\00"
+@o32min = constant [15 x i8] c" +020000000000\00"
+@mo32min = constant [15 x i8] c" -020000000000\00"
+@x32min = constant [13 x i8] c" +0x80000000\00"
+@mx32min = constant [13 x i8] c" +0x80000000\00"
+
+@i32max = constant [12 x i8] c" 2147483647\00"
+@i32max_p1 = constant [12 x i8] c" 2147483648\00"
+@mX01 = constant [6 x i8] c" -0X1\00"
+
+@ui32max = constant [12 x i8] c" 4294967295\00"
+@ui32max_p1 = constant [12 x i8] c" 4294967296\00"
+
+@i64min = constant [22 x i8] c" -9223372036854775808\00"
+@i64min_m1 = constant [22 x i8] c" -9223372036854775809\00"
+
+@i64max = constant [21 x i8] c" 9223372036854775807\00"
+@i64max_p1 = constant [21 x i8] c" 9223372036854775808\00"
+
+@ui64max = constant [22 x i8] c" 18446744073709551615\00"
+@x64max = constant [20 x i8] c" 0xffffffffffffffff\00"
+@ui64max_p1 = constant [22 x i8] c" 18446744073709551616\00"
+
+
+; Exercise folding calls to 32-bit strtoul.
+
+define void @fold_strtoul(i32* %ps) {
+; CHECK-LABEL: @fold_strtoul(
+; CHECK-NEXT:    store i32 -123, i32* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i32, i32* [[PS]], i64 1
+; CHECK-NEXT:    store i32 234, i32* [[PS1]], align 4
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i32, i32* [[PS]], i64 2
+; CHECK-NEXT:    store i32 2147483647, i32* [[PS2]], align 4
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i32, i32* [[PS]], i64 3
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS3]], align 4
+; CHECK-NEXT:    [[PS4:%.*]] = getelementptr i32, i32* [[PS]], i64 4
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS4]], align 4
+; CHECK-NEXT:    [[PS5:%.*]] = getelementptr i32, i32* [[PS]], i64 5
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS5]], align 4
+; CHECK-NEXT:    [[PS6:%.*]] = getelementptr i32, i32* [[PS]], i64 6
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS6]], align 4
+; CHECK-NEXT:    [[PS7:%.*]] = getelementptr i32, i32* [[PS]], i64 7
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS7]], align 4
+; CHECK-NEXT:    [[PS8:%.*]] = getelementptr i32, i32* [[PS]], i64 8
+; CHECK-NEXT:    store i32 2147483647, i32* [[PS8]], align 4
+; CHECK-NEXT:    [[PS9:%.*]] = getelementptr i32, i32* [[PS]], i64 9
+; CHECK-NEXT:    store i32 -1, i32* [[PS9]], align 4
+; CHECK-NEXT:    [[PS10:%.*]] = getelementptr i32, i32* [[PS]], i64 10
+; CHECK-NEXT:    store i32 -2147483648, i32* [[PS10]], align 4
+; CHECK-NEXT:    [[PS11:%.*]] = getelementptr i32, i32* [[PS]], i64 11
+; CHECK-NEXT:    store i32 -1, i32* [[PS11]], align 4
+; CHECK-NEXT:    ret void
+;
+; Fold a valid sequence with leading POSIX whitespace and a minus to
+; (uint32_t)-123.
+  %pwsm123 = getelementptr [11 x i8], [11 x i8]* @ws_im123, i32 0, i32 0
+  %im123 = call i32 @strtoul(i8* %pwsm123, i8** null, i32 10)
+  %ps0 = getelementptr i32, i32* %ps, i32 0
+  store i32 %im123, i32* %ps0
+
+; Fold a valid sequence with leading POSIX whitespace and a plus to +234.
+  %pwsp234 = getelementptr [11 x i8], [11 x i8]* @ws_ip234, i32 0, i32 0
+  %ip234 = call i32 @strtoul(i8* %pwsp234, i8** null, i32 10)
+  %ps1 = getelementptr i32, i32* %ps, i32 1
+  store i32 %ip234, i32* %ps1
+
+; Fold the result of conversion that's equal to INT32_MIN - 1.
+  %psi32minm1 = getelementptr [13 x i8], [13 x i8]* @i32min_m1, i32 0, i32 0
+  %i32min32m1 = call i32 @strtoul(i8* %psi32minm1, i8** null, i32 10)
+  %ps2 = getelementptr i32, i32* %ps, i32 2
+  store i32 %i32min32m1, i32* %ps2
+
+; Fold INT32_MIN.
+  %psi32min = getelementptr [13 x i8], [13 x i8]* @i32min, i32 0, i32 0
+  %i32min = call i32 @strtoul(i8* %psi32min, i8** null, i32 10)
+  %ps3 = getelementptr i32, i32* %ps, i32 3
+  store i32 %i32min, i32* %ps3
+
+; Fold INT32_MIN in octal.
+  %pso32min = getelementptr [15 x i8], [15 x i8]* @o32min, i32 0, i32 0
+  %o32min = call i32 @strtoul(i8* %pso32min, i8** null, i32 0)
+  %ps4 = getelementptr i32, i32* %ps, i32 4
+  store i32 %o32min, i32* %ps4
+
+; Fold -INT32_MIN in octal.
+  %psmo32min = getelementptr [15 x i8], [15 x i8]* @mo32min, i32 0, i32 0
+  %mo32min = call i32 @strtoul(i8* %psmo32min, i8** null, i32 0)
+  %ps5 = getelementptr i32, i32* %ps, i32 5
+  store i32 %mo32min, i32* %ps5
+
+; Fold INT32_MIN in hex.
+  %psx32min = getelementptr [13 x i8], [13 x i8]* @x32min, i32 0, i32 0
+  %x32min = call i32 @strtoul(i8* %psx32min, i8** null, i32 0)
+  %ps6 = getelementptr i32, i32* %ps, i32 6
+  store i32 %x32min, i32* %ps6
+
+; Fold -INT32_MIN in hex.
+  %psmx32min = getelementptr [13 x i8], [13 x i8]* @mx32min, i32 0, i32 0
+  %mx32min = call i32 @strtoul(i8* %psmx32min, i8** null, i32 0)
+  %ps7 = getelementptr i32, i32* %ps, i32 7
+  store i32 %x32min, i32* %ps7
+
+; Fold INT32_MAX.
+  %psi32max = getelementptr [12 x i8], [12 x i8]* @i32max, i32 0, i32 0
+  %i32max = call i32 @strtoul(i8* %psi32max, i8** null, i32 10)
+  %ps8 = getelementptr i32, i32* %ps, i32 8
+  store i32 %i32max, i32* %ps8
+
+; Fold -0x01.
+  %psmX01 = getelementptr [6 x i8], [6 x i8]* @mX01, i32 0, i32 0
+  %mX01 = call i32 @strtoul(i8* %psmX01, i8** null, i32 0)
+  %ps9 = getelementptr i32, i32* %ps, i32 9
+  store i32 %mX01, i32* %ps9
+
+; Fold the result of conversion that's equal to INT32_MAX + 1.
+  %psmax32p1 = getelementptr [12 x i8], [12 x i8]* @i32max_p1, i32 0, i32 0
+  %i32max32p1 = call i32 @strtoul(i8* %psmax32p1, i8** null, i32 10)
+  %ps10 = getelementptr i32, i32* %ps, i32 10
+  store i32 %i32max32p1, i32* %ps10
+
+; Fold UINT32_MAX.
+  %psmax = getelementptr [12 x i8], [12 x i8]* @ui32max, i32 0, i32 0
+  %ui32max = call i32 @strtoul(i8* %psmax, i8** null, i32 10)
+  %ps11 = getelementptr i32, i32* %ps, i32 11
+  store i32 %ui32max, i32* %ps11
+
+  ret void
+}
+
+
+; Exercise not folding calls to 32-bit strtoul.
+
+define void @call_strtoul(i32* %ps) {
+; CHECK-LABEL: @call_strtoul(
+; CHECK-NEXT:    [[MINM1:%.*]] = call i32 @strtoul(i8* nocapture getelementptr inbounds ([22 x i8], [22 x i8]* @i64min_m1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    store i32 [[MINM1]], i32* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[MAXP1:%.*]] = call i32 @strtoul(i8* nocapture getelementptr inbounds ([12 x i8], [12 x i8]* @ui32max_p1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i32, i32* [[PS]], i64 1
+; CHECK-NEXT:    store i32 [[MAXP1]], i32* [[PS1]], align 4
+; CHECK-NEXT:    [[NWS:%.*]] = call i32 @strtoul(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i32, i32* [[PS]], i64 2
+; CHECK-NEXT:    store i32 [[NWS]], i32* [[PS2]], align 4
+; CHECK-NEXT:    [[NWSP6:%.*]] = call i32 @strtoul(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 6), i8** null, i32 10)
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i32, i32* [[PS]], i64 3
+; CHECK-NEXT:    store i32 [[NWSP6]], i32* [[PS3]], align 4
+; CHECK-NEXT:    ret void
+;
+; Do not fold the result of conversion that overflows uint32_t.  This
+; could be folded into a constant provided errnor were set to ERANGE.
+  %psminm1 = getelementptr [22 x i8], [22 x i8]* @i64min_m1, i32 0, i32 0
+  %minm1 = call i32 @strtoul(i8* %psminm1, i8** null, i32 10)
+  %ps0 = getelementptr i32, i32* %ps, i32 0
+  store i32 %minm1, i32* %ps0
+
+; Do not fold the result of conversion that's greater than UINT32_MAX
+; (same logic as above applies here).
+  %psui32maxp1 = getelementptr [12 x i8], [12 x i8]* @ui32max_p1, i32 0, i32 0
+  %maxp1 = call i32 @strtoul(i8* %psui32maxp1, i8** null, i32 10)
+  %ps1 = getelementptr i32, i32* %ps, i32 1
+  store i32 %maxp1, i32* %ps1
+
+; Do not fold a sequence consisting of just whitespace characters.
+  %psws = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 0
+  %nws = call i32 @strtoul(i8* %psws, i8** null, i32 10)
+  %ps2 = getelementptr i32, i32* %ps, i32 2
+  store i32 %nws, i32* %ps2
+
+; Do not fold an empty sequence.  The library call may or may not end up
+; storing EINVAL in errno.
+  %pswsp6 = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 6
+  %nwsp6 = call i32 @strtoul(i8* %pswsp6, i8** null, i32 10)
+  %ps3 = getelementptr i32, i32* %ps, i32 3
+  store i32 %nwsp6, i32* %ps3
+
+  ret void
+}
+
+
+; Exercise folding calls to 64-bit strtoull.
+
+define void @fold_strtoull(i64* %ps) {
+; CHECK-LABEL: @fold_strtoull(
+; CHECK-NEXT:    store i64 -123, i64* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i64, i64* [[PS]], i64 1
+; CHECK-NEXT:    store i64 234, i64* [[PS1]], align 4
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i64, i64* [[PS]], i64 2
+; CHECK-NEXT:    store i64 9223372036854775807, i64* [[PS2]], align 4
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i64, i64* [[PS]], i64 3
+; CHECK-NEXT:    store i64 -2147483648, i64* [[PS3]], align 4
+; CHECK-NEXT:    [[PS4:%.*]] = getelementptr i64, i64* [[PS]], i64 4
+; CHECK-NEXT:    store i64 2147483648, i64* [[PS4]], align 4
+; CHECK-NEXT:    [[PS5:%.*]] = getelementptr i64, i64* [[PS]], i64 5
+; CHECK-NEXT:    store i64 2147483648, i64* [[PS5]], align 4
+; CHECK-NEXT:    [[PS6:%.*]] = getelementptr i64, i64* [[PS]], i64 6
+; CHECK-NEXT:    store i64 -9223372036854775808, i64* [[PS6]], align 4
+; CHECK-NEXT:    [[PS7:%.*]] = getelementptr i64, i64* [[PS]], i64 7
+; CHECK-NEXT:    store i64 9223372036854775807, i64* [[PS7]], align 4
+; CHECK-NEXT:    [[PS8:%.*]] = getelementptr i64, i64* [[PS]], i64 8
+; CHECK-NEXT:    store i64 -9223372036854775808, i64* [[PS8]], align 4
+; CHECK-NEXT:    [[PS9:%.*]] = getelementptr i64, i64* [[PS]], i64 9
+; CHECK-NEXT:    store i64 -1, i64* [[PS9]], align 4
+; CHECK-NEXT:    [[PS10:%.*]] = getelementptr i64, i64* [[PS]], i64 10
+; CHECK-NEXT:    store i64 -1, i64* [[PS10]], align 4
+; CHECK-NEXT:    ret void
+;
+; Fold a valid sequence with leading POSIX whitespace and a minus to
+; (uint64_t)-123.
+  %pwsm123 = getelementptr [11 x i8], [11 x i8]* @ws_im123, i32 0, i32 0
+  %im123 = call i64 @strtoull(i8* %pwsm123, i8** null, i32 10)
+  %ps0 = getelementptr i64, i64* %ps, i32 0
+  store i64 %im123, i64* %ps0
+
+; Fold a valid sequence with leading POSIX whitespace and a plus to +234.
+  %pwsp234 = getelementptr [11 x i8], [11 x i8]* @ws_ip234, i32 0, i32 0
+  %ip234 = call i64 @strtoull(i8* %pwsp234, i8** null, i32 10)
+  %ps1 = getelementptr i64, i64* %ps, i32 1
+  store i64 %ip234, i64* %ps1
+
+; Fold the result of conversion that's equal to INT64_MIN - 1.
+  %psi64minm1 = getelementptr [22 x i8], [22 x i8]* @i64min_m1, i32 0, i32 0
+  %i64min32m1 = call i64 @strtoull(i8* %psi64minm1, i8** null, i32 10)
+  %ps2 = getelementptr i64, i64* %ps, i32 2
+  store i64 %i64min32m1, i64* %ps2
+
+; Fold INT32_MIN.
+  %psi32min = getelementptr [13 x i8], [13 x i8]* @i32min, i32 0, i32 0
+  %i32min = call i64 @strtoull(i8* %psi32min, i8** null, i32 10)
+  %ps3 = getelementptr i64, i64* %ps, i32 3
+  store i64 %i32min, i64* %ps3
+
+; Fold INT32_MIN in octal.
+  %pso32min = getelementptr [15 x i8], [15 x i8]* @o32min, i32 0, i32 0
+  %o32min = call i64 @strtoull(i8* %pso32min, i8** null, i32 0)
+  %ps4 = getelementptr i64, i64* %ps, i32 4
+  store i64 %o32min, i64* %ps4
+
+; Fold INT32_MIN in hex.
+  %psx32min = getelementptr [13 x i8], [13 x i8]* @x32min, i32 0, i32 0
+  %x32min = call i64 @strtoull(i8* %psx32min, i8** null, i32 0)
+  %ps5 = getelementptr i64, i64* %ps, i32 5
+  store i64 %x32min, i64* %ps5
+
+; Fold INT64_MIN.
+  %psi64min = getelementptr [22 x i8], [22 x i8]* @i64min, i32 0, i32 0
+  %i64min = call i64 @strtoull(i8* %psi64min, i8** null, i32 10)
+  %ps6 = getelementptr i64, i64* %ps, i32 6
+  store i64 %i64min, i64* %ps6
+
+; Fold INT64_MAX.
+  %psi64max = getelementptr [21 x i8], [21 x i8]* @i64max, i32 0, i32 0
+  %i64max = call i64 @strtoull(i8* %psi64max, i8** null, i32 10)
+  %ps7 = getelementptr i64, i64* %ps, i32 7
+  store i64 %i64max, i64* %ps7
+
+; Fold the result of conversion that's equal to INT64_MAX + 1 to INT64_MIN.
+  %psmax32p1 = getelementptr [21 x i8], [21 x i8]* @i64max_p1, i32 0, i32 0
+  %i64max32p1 = call i64 @strtoull(i8* %psmax32p1, i8** null, i32 10)
+  %ps8 = getelementptr i64, i64* %ps, i32 8
+  store i64 %i64max32p1, i64* %ps8
+
+; Fold UINT64_MAX.
+  %psmax = getelementptr [22 x i8], [22 x i8]* @ui64max, i32 0, i32 0
+  %ui64max = call i64 @strtoull(i8* %psmax, i8** null, i32 10)
+  %ps9 = getelementptr i64, i64* %ps, i32 9
+  store i64 %ui64max, i64* %ps9
+
+; Fold UINT64_MAX in hex.
+  %psxmax = getelementptr [20 x i8], [20 x i8]* @x64max, i32 0, i32 0
+  %x64max = call i64 @strtoull(i8* %psxmax, i8** null, i32 0)
+  %ps10 = getelementptr i64, i64* %ps, i32 10
+  store i64 %x64max, i64* %ps10
+
+  ret void
+}
+
+
+; Exercise not folding calls to 64-bit strtoull.
+
+define void @call_strtoull(i64* %ps) {
+; CHECK-LABEL: @call_strtoull(
+; CHECK-NEXT:    [[MAXP1:%.*]] = call i64 @strtoull(i8* nocapture getelementptr inbounds ([22 x i8], [22 x i8]* @ui64max_p1, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS1:%.*]] = getelementptr i64, i64* [[PS:%.*]], i64 1
+; CHECK-NEXT:    store i64 [[MAXP1]], i64* [[PS1]], align 4
+; CHECK-NEXT:    [[NWS:%.*]] = call i64 @strtoull(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[PS2:%.*]] = getelementptr i64, i64* [[PS]], i64 2
+; CHECK-NEXT:    store i64 [[NWS]], i64* [[PS2]], align 4
+; CHECK-NEXT:    [[NWSP6:%.*]] = call i64 @strtoull(i8* nocapture getelementptr inbounds ([7 x i8], [7 x i8]* @ws, i64 0, i64 6), i8** null, i32 10)
+; CHECK-NEXT:    [[PS3:%.*]] = getelementptr i64, i64* [[PS]], i64 3
+; CHECK-NEXT:    store i64 [[NWSP6]], i64* [[PS3]], align 4
+; CHECK-NEXT:    ret void
+;
+; Do not fold the result of conversion that overflows uint64_t.  This
+; could be folded into a constant provided errnor were set to ERANGE.
+  %psui64maxp1 = getelementptr [22 x i8], [22 x i8]* @ui64max_p1, i32 0, i32 0
+  %maxp1 = call i64 @strtoull(i8* %psui64maxp1, i8** null, i32 10)
+  %ps1 = getelementptr i64, i64* %ps, i32 1
+  store i64 %maxp1, i64* %ps1
+
+; Do not fold a sequence consisting of just whitespace characters.
+  %psws = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 0
+  %nws = call i64 @strtoull(i8* %psws, i8** null, i32 10)
+  %ps2 = getelementptr i64, i64* %ps, i32 2
+  store i64 %nws, i64* %ps2
+
+; Do not fold an empty sequence.  The library call may or may not end up
+; storing EINVAL in errno.
+  %pswsp6 = getelementptr [7 x i8], [7 x i8]* @ws, i32 0, i32 6
+  %nwsp6 = call i64 @strtoull(i8* %pswsp6, i8** null, i32 10)
+  %ps3 = getelementptr i64, i64* %ps, i32 3
+  store i64 %nwsp6, i64* %ps3
+
+  ret void
+}

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

 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @strtol(i8* %s, i8** null, i32 10) #3
   ret i32 %call
 }
 
 define i32 @atoi_not_const_str(i8* %s) #0 {
 ; CHECK-LABEL: @atoi_not_const_str(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoi(i8* [[S:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoi(i8* nocapture [[S:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @atoi(i8* %s) #4
   ret i32 %call
 }
 
 define i32 @strtol_not_const_base(i32 %b) #0 {
 ; CHECK-LABEL: @strtol_not_const_base(

 ;
 ; CHECK-NEXT
   %call = call i32 @atol(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0)) #4
   ret i32 %call
 }
 
 define i32 @atoll_test() #0 {
 ; CHECK-LABEL: @atoll_test(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoll(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0))
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @atoll(i8* nocapture getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0))
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 @atoll(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0)) #3
   ret i32 %call
 }
 
 define i32 @strtoll_test() #0 {
 ; CHECK-LABEL: @strtoll_test(
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtoll(i8* nocapture getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0), i8** null, i32 10)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
 ; CHECK-NEXT
   %call = call i32 @strtoll(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i32 0, i32 0), i8** null, i32 10) #5
   ret i32 %call
 }

llvm/test/Transforms/InstCombine/strcall-no-nul.ll

 declare i64 @strlen(i8*)
 declare i64 @strnlen(i8*, i64)
 
 declare i8* @strpbrk(i8*, i8*)
 
 declare i64 @strspn(i8*, i8*)
 declare i64 @strcspn(i8*, i8*)
 
+declare i32 @atoi(i8*)
+declare i64 @atol(i8*)
+declare i64 @atoll(i8*)
+declare i64 @strtol(i8*, i8**, i32)
+declare i64 @strtoll(i8*, i8**, i32)
+declare i64 @strtoul(i8*, i8**, i32)
+declare i64 @strtoull(i8*, i8**, i32)
+
 declare i32 @sprintf(i8*, i8*, ...)
 declare i32 @snprintf(i8*, i64, i8*, ...)
 
 
 @a5 = constant [5 x i8] c"%s\0045";
 
 
 ; Fold strchr(a5 + 5, '\0') to null.
;
   %o50 = call i64 @strcspn(i8* %p5, i8* %p0)
   %po50 = getelementptr i64, i64* %poff, i32 1
   store i64 %o50, i64* %po50
 
   ret void
 }
 
 
+; TODO: Fold the 32-bit atoi(a5 + 5) to zero.
+; Verify that processing the invalid call doesn't run into trouble.
+
+define i32 @fold_atoi_past_end() {
+; CHECK-LABEL: @fold_atoi_past_end(
+; CHECK-NEXT:    [[I:%.*]] = call i32 @atoi(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0))
+; CHECK-NEXT:    ret i32 [[I]]
+;
+  %p5 = getelementptr [5 x i8], [5 x i8]* @a5, i32 0, i32 5
+  %i = call i32 @atoi(i8* %p5)
+  ret i32 %i
+}
+
+; TODO: Likewise, fold the 64-bit atol(a5 + 5) to zero, and similarly
+; for atoll and strtrol and similar.
+; Verify that processing the invalid call doesn't run into trouble.
+
+define void @fold_atol_strtol_past_end(i64* %ps) {
+; CHECK-LABEL: @fold_atol_strtol_past_end(
+; CHECK-NEXT:    [[I0:%.*]] = call i64 @atol(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0))
+; CHECK-NEXT:    store i64 [[I0]], i64* [[PS:%.*]], align 4
+; CHECK-NEXT:    [[I1:%.*]] = call i64 @atoll(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0))
+; CHECK-NEXT:    [[P1:%.*]] = getelementptr i64, i64* [[PS]], i64 1
+; CHECK-NEXT:    store i64 [[I1]], i64* [[P1]], align 4
+; CHECK-NEXT:    [[I2:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0), i8** null, i32 0)
+; CHECK-NEXT:    [[P2:%.*]] = getelementptr i64, i64* [[PS]], i64 2
+; CHECK-NEXT:    store i64 [[I2]], i64* [[P2]], align 4
+; CHECK-NEXT:    [[I3:%.*]] = call i64 @strtoul(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0), i8** null, i32 8)
+; CHECK-NEXT:    [[P3:%.*]] = getelementptr i64, i64* [[PS]], i64 3
+; CHECK-NEXT:    store i64 [[I3]], i64* [[P3]], align 4
+; CHECK-NEXT:    [[I4:%.*]] = call i64 @strtoll(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    [[P4:%.*]] = getelementptr i64, i64* [[PS]], i64 4
+; CHECK-NEXT:    store i64 [[I4]], i64* [[P4]], align 4
+; CHECK-NEXT:    [[I5:%.*]] = call i64 @strtoul(i8* nocapture getelementptr inbounds ([5 x i8], [5 x i8]* @a5, i64 1, i64 0), i8** null, i32 16)
+; CHECK-NEXT:    [[P5:%.*]] = getelementptr i64, i64* [[PS]], i64 5
+; CHECK-NEXT:    store i64 [[I5]], i64* [[P5]], align 4
+; CHECK-NEXT:    ret void
+;
+  %pa5 = getelementptr [5 x i8], [5 x i8]* @a5, i32 0, i32 5
+
+  %i0 = call i64 @atol(i8* %pa5)
+  %p0 = getelementptr i64, i64* %ps, i32 0
+  store i64 %i0, i64* %p0
+
+  %i1 = call i64 @atoll(i8* %pa5)
+  %p1 = getelementptr i64, i64* %ps, i32 1
+  store i64 %i1, i64* %p1
+
+  %i2 = call i64 @strtol(i8* %pa5, i8** null, i32 0)
+  %p2 = getelementptr i64, i64* %ps, i32 2
+  store i64 %i2, i64* %p2
+
+  %i3 = call i64 @strtoul(i8* %pa5, i8** null, i32 8)
+  %p3 = getelementptr i64, i64* %ps, i32 3
+  store i64 %i3, i64* %p3
+
+  %i4 = call i64 @strtoll(i8* %pa5, i8** null, i32 10)
+  %p4 = getelementptr i64, i64* %ps, i32 4
+  store i64 %i4, i64* %p4
+
+  %i5 = call i64 @strtoul(i8* %pa5, i8** null, i32 16)
+  %p5 = getelementptr i64, i64* %ps, i32 5
+  store i64 %i5, i64* %p5
+
+  ret void
+}
+
+
 ; Fold sprintf(dst, a5 + 5) to zero, and also
 ; TODO: fold sprintf(dst, "%s", a5 + 5) to zero.
 
 define void @fold_sprintf_past_end(i32* %pcnt, i8* %dst) {
 ; CHECK-LABEL: @fold_sprintf_past_end(
 ; CHECK-NEXT:    store i32 0, i32* [[PCNT:%.*]], align 4
 ; CHECK-NEXT:    [[PN05:%.*]] = getelementptr i32, i32* [[PCNT]], i64 1
 ; CHECK-NEXT:    store i32 0, i32* [[PN05]], align 4