[SimplifyLibcalls] Atoi, strtol replacements

[lebedev.ri]

test/Transforms/InstCombine/str-int.ll

6 ↗

(On Diff #141570)

@strtol_dec?

10 ↗

(On Diff #141570)

Needs negative test with endptr not being null.

11 ↗

(On Diff #141570)

Do we care about the return type here?
I'd think you can simplify the tests and drop trunc.

16 ↗

(On Diff #141570)

I'd like to see one test with base = 0.

18 ↗

(On Diff #141570)

I'm not sure these ; Function Attrs comments are needed.

19 ↗

(On Diff #141570)

@strtol_hex?

[lebedev.ri]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1693 ↗

(On Diff #141684)

1. elide {}
2. this is clearly broken. you check the same operand here and in the next if().

I'm guessing you want to check the third operand here, not the second one.
And do add the test.

[lebedev.ri]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

base is i32, but strtol returns long int (i64?), so i don't think using CI->getType() is correct.

test/Transforms/InstCombine/str-int.ll

5 ↗

(On Diff #141686)

So i suppose this needs a test with larger-than-32bit-integer.

[lebedev.ri]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

Oh, CI is CallInst, not ConstantInt, never mind then.

test/Transforms/InstCombine/str-int.ll

5 ↗

(On Diff #141686)

The STRTOL(3) says that strtol returns long int, so it would still be good for the tests to represent that.
(i.e. please change this strtol to return i64, and add a test from ^ that comment.)

[lebedev.ri]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1683 ↗

(On Diff #141694)

Both of these getConstantStringInfo() == false are also not covered with tests, i think?

1696 ↗

(On Diff #141694)

You also probably want a negative test with this third operand being not a constant (an argument of the test function)

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

4 ↗

(On Diff #141694)

But this is just 1<<31, it fits into i32 as-is.
Maybe 4294967296 (1<<32) ?

6 ↗

(On Diff #141694)

I'm not sure why you need to separate it into two test files?
Couldn't strtol in str-int.ll simply return i64?

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1685 ↗

(On Diff #141712)

I'm worried about host behavior leaking through here; specifically, the "undefined" values for overflow might vary. Could you use some function with more predictable behavior here? (Maybe something based on llvm::consumeSignedInteger()?)

1697 ↗

(On Diff #141686)

This is missing some checks. In particular, what happens if the host's "long" is a different width from the target's "long"? What happens if strtol sets errno? What happens if the target program is using a locale where isspace() doesn't match the C locale's isspace()?

[xbolva00]

Abandoned.

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

Ah yes. So I will have to close this patch since we cant optimize this calls.

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

4 ↗

(On Diff #141694)

Updated.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

I dont know about that thing with locale. I dont think we have to care about this weirdness.

[xbolva00]

Errno fix

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

isspace() in all locales should return true for all the characters where it returns true in the C locale; it's just a question of whether there are some additional characters which also count as spaces. So I think you'll get the right behavior if you refuse to fold in cases where strtol would fail in the C locale.

[xbolva00]

Added locale check for atoi

[xbolva00]

Is patch now ok for you, @efriedma ?

lib/Transforms/Utils/SimplifyLibCalls.cpp

1685 ↗

(On Diff #141712)

We should call that function when we can call strtol directly?

1697 ↗

(On Diff #141686)

Errno can be checked, can be fixed in this patch.

But why we should check target host vs host long ?

1697 ↗

(On Diff #141686)

Updated patch. Check for "C" locale added.

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1697 ↗

(On Diff #141686)

The result of strtol("2147483648", 0, 0) varies depending on whether long is 32 bits or 64 bits.

[xbolva00]

Fixed things noted by @efriedma

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1685 ↗

(On Diff #141712)

I guess we can just call strtol, sure.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1685 ↗

(On Diff #141712)

So now is this patch good to go?

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

DL.getTypeAllocSize(CI->getType()) != sizeof(long int) will cause your testcase to fail on 32-bit hosts (because we'll refuse the fold the call).

Can you use strtoll plus a range check, instead?

1685 ↗

(On Diff #141712)

You didn't actually change the code to call strtol instead of atoi.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

But problem is ..

errs() << std::numeric_limits<long int>::max() << "\n";
errs() << std::numeric_limits<long long int>::max() << "\n";

9223372036854775807
9223372036854775807

So we need to rely on errno, I think

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

By "range check", I mean in addition to the errno check, if CI->getType() is a 32-bit integer, check that the result of strtoll fits into a 32-bit integer.

[xbolva00]

Updated, use strtoll now. @efriedma

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

Oh :D ok. Will fix.

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

The range check is still wrong. You can try building 32-bit LLVM yourself by setting the CMake option LLVM_BUILD_32_BITS.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

So how to fix it?

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

I have no idea what I should do to fix it... :/

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

I think the most readable solution is something like int Bits = CI->getType()->getPrimitiveSizeInBits(); if (Result < llvm::minIntN(Bits) || Result > llvm::maxIntN(Bits)) return nullptr;.

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

Actually, you can simplify that to just if (!isIntN(CI->getType()->getPrimitiveSizeInBits(), Result)) return nullptr;.

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1716 ↗

(On Diff #142087)

Thank you so much! (I have no idea about that API)

[xbolva00]

@efriedma , is now everything ok?

I would send some more patches for SimplifyLibCalls where I would like to use newly introduced isCLocale function.

[efriedma]

I'd like to see a second testcase which checks our transforms on declare i32 @strtol(i8*, i8**, i32) (which is the signature on 32-bit targets).

lib/Transforms/Utils/SimplifyLibCalls.cpp

108 ↗

(On Diff #142568)

We can safely assume nobody is messing with the locale in the compiler itself. The problem comes when someone uses setlocale on the target (in the compiled program); that's not something you can detect in general.

Fortunately, we can still handle the interesting cases, I think: if we assume all possible target locales are ASCII supersets, or something close (which we already assume in other places), then if strtoll successfully parses a number on the host (i.e. nptr != endptr), it will also successfully parse the same way on the target. If the string starts with a non-ASCII character, we probably have to assume it could be a space in some locale.

1702 ↗

(On Diff #142568)

Can you just return Result here, instead of calling atoi?

1720 ↗

(On Diff #142568)

strtoll can also fail with EINVAL, if the base is invalid. But the exact behavior isn't specified in the C standard, so probably better to check the base ourselves, explicitly.

2329 ↗

(On Diff #142568)

Can you also add cases here for atol, atoll, and strtoll? (Your current implementations should just work.)

[xbolva00]

Updated with changes requested by @efriedma .

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1720 ↗

(On Diff #142568)

So I will add check for base if zero or between 2 and 36.

2329 ↗

(On Diff #142568)

Ok, I can add it.

Current tests in this patch are good enough or then should be new ones for atol, atoll, and strtoll too?

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1723 ↗

(On Diff #142680)

Where did 32 come from?

1734 ↗

(On Diff #142680)

This is a use-after-free (Str.str() allocates a temporary std::string).

[efriedma]

lib/Transforms/Utils/SimplifyLibCalls.cpp

2329 ↗

(On Diff #142568)

Maybe one test each to make sure we recognize the names, and a test to make sure 64-bit atoll actually allows inputs greater than 2**32; we don't need all the tests for each one given the code is the same.

[xbolva00]

Updated, fixed things.

[xbolva00]

Added tests for atol, atoll, strtoll.

lib/Transforms/Utils/SimplifyLibCalls.cpp

1723 ↗

(On Diff #142680)

:) Ahh

[xbolva00]

ping

[efriedma]

Can you share some of the code between optimizeAtoi and optimizeStrtol?

lib/Transforms/Utils/SimplifyLibCalls.cpp

1719 ↗

(On Diff #142684)

Like I mentioned before, we don't need this check; it's safe to assume the compiler is running in the C locale.

1737 ↗

(On Diff #142684)

Needs a comment here to explain why you're checking this.

[xbolva00]

Adressed notes by @efriedma

[efriedma]

LGTM

[xbolva00]

Now you can merge this patch, @spatel

[spatel]

In D45418#1072571, @xbolva00 wrote:

Now you can merge this patch, @spatel

It's better to ask someone who looked at this patch to commit it; I didn't follow this review this at all.

[xbolva00]

In D45418#1072729, @spatel wrote:

In D45418#1072571, @xbolva00 wrote:

Now you can merge this patch, @spatel

It's better to ask someone who looked at this patch to commit it; I didn't follow this review this at all.

Ok, I was not sure if @efriedma can merge it since I see you merge patches every day in the "InstCombine" part. Sorry then :)

[efriedma]

I'll merge it tomorrow.

[efriedma]

I was going to commit this, but then I discovered that str-int.ll and str-int-2.ll are identical. Did you accidentally overwrite your changes?

[xbolva00]

In D45418#1074260, @efriedma wrote:

I was going to commit this, but then I discovered that str-int.ll and str-int-2.ll are identical. Did you accidentally overwrite your changes?

Updated.

[xbolva00]

Ping (merge request)

[xbolva00]

This comment was removed by xbolva00.

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

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

llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp

 }
 
 static bool callHasFloatingPointArgument(const CallInst *CI) {
   return any_of(CI->operands(), [](const Use &OI) {
     return OI->getType()->isFloatingPointTy();
   });
 }
 
+static Value *convertStrToNumber(CallInst *CI, StringRef &Str, int64_t Base) {
+  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;
+
+  return ConstantInt::get(CI->getType(), Result);
+}
+
 //===----------------------------------------------------------------------===//
 // String and Memory Library Call Optimizations
 //===----------------------------------------------------------------------===//
 
 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
   // Extract some information from the instruction
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);

 }
 
 Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilder<> &B) {
   // toascii(c) -> c & 0x7f
   return B.CreateAnd(CI->getArgOperand(0),
                      ConstantInt::get(CI->getType(), 0x7F));
 }
 
+Value *LibCallSimplifier::optimizeAtoi(CallInst *CI, IRBuilder<> &B) {
+  StringRef Str;
+  if (!getConstantStringInfo(CI->getArgOperand(0), Str))
+    return nullptr;
+
+  return convertStrToNumber(CI, Str, 10);
+}
+
+Value *LibCallSimplifier::optimizeStrtol(CallInst *CI, IRBuilder<> &B) {
+  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 nullptr;
+}
+
 //===----------------------------------------------------------------------===//
 // Formatting and IO Library Call Optimizations
 //===----------------------------------------------------------------------===//
 
 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg);
 
 Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
                                                  int StreamArg) {
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
     case LibFunc_llabs:
       return optimizeAbs(CI, Builder);
     case LibFunc_isdigit:
       return optimizeIsDigit(CI, Builder);
     case LibFunc_isascii:
       return optimizeIsAscii(CI, Builder);
     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);
     case LibFunc_printf:
       return optimizePrintF(CI, Builder);
     case LibFunc_sprintf:
       return optimizeSPrintF(CI, Builder);
     case LibFunc_fprintf:
       return optimizeFPrintF(CI, Builder);
     case LibFunc_fwrite:
       return optimizeFWrite(CI, Builder);

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+@.str = private unnamed_addr constant [3 x i8] c"12\00", align 1
+@.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
+@.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1
+@.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1
+@.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1
+@.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
+@.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1
+@.str.7 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
+
+declare i64 @strtol(i8*, i8**, i32)
+declare i32 @atoi(i8*)
+declare i64 @atol(i8*)
+declare i64 @atoll(i8*)
+declare i64 @strtoll(i8*, i8**, i32)
+
+define i64 @strtol_dec() #0 {
+; CHECK-LABEL: @strtol_dec(
+; CHECK-NEXT:    ret i64 12
+;
+  %call = call i64 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 10) #2
+  ret i64 %call
+}
+
+define i64 @strtol_base_zero() #0 {
+; CHECK-LABEL: @strtol_base_zero(
+; CHECK-NEXT:    ret i64 12
+;
+  %call = call i64 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 0) #2
+  ret i64 %call
+}
+
+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 {
+; 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:    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
+  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
+  ret i32 %call
+}
+
+define i64 @strtol_not_const_str(i8* %s) #0 {
+; CHECK-LABEL: @strtol_not_const_str(
+; CHECK-NEXT:    [[CALL:%.*]] = call i64 @strtol(i8* nocapture [[S:%.*]], i8** null, i32 10)
+; 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:    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(
+; CHECK-NEXT:    [[CALL:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8** null, i32 [[B:%.*]])
+; CHECK-NEXT:    ret i64 [[CALL]]
+;
+  %call = call i64 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 %b) #2
+  ret i64 %call
+}
+
+define i64 @strtol_long_int() #0 {
+; CHECK-LABEL: @strtol_long_int(
+; CHECK-NEXT:    ret i64 4294967296
+;
+  %call = call i64 @strtol(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), i8** null, i32 10) #3
+  ret i64 %call
+}
+
+
+define i64 @strtol_big_overflow() #0 {
+; CHECK-LABEL: @strtol_big_overflow(
+; CHECK-NEXT:    [[CALL:%.*]] = call i64 @strtol(i8* nocapture getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    ret i64 [[CALL]]
+;
+  %call = call i64 @strtol(i8* nocapture getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i8** null, i32 10) #2
+  ret i64 %call
+}
+
+define i64 @atol_test() #0 {
+; CHECK-LABEL: @atol_test(
+; CHECK-NEXT:    ret i64 499496729
+;
+; CHECK-NEXT
+  %call = call i64 @atol(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0)) #4
+  ret i64 %call
+}
+
+define i64 @atoll_test() #0 {
+; CHECK-LABEL: @atoll_test(
+; CHECK-NEXT:    ret i64 4994967295
+;
+  %call = call i64 @atoll(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0)) #3
+  ret i64 %call
+}
+
+define i64 @strtoll_test() #0 {
+; CHECK-LABEL: @strtoll_test(
+; CHECK-NEXT:    ret i64 4994967295
+;
+; CHECK-NEXT
+  %call = call i64 @strtoll(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i32 0, i32 0), i8** null, i32 10) #5
+  ret i64 %call
+}

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+@.str = private unnamed_addr constant [3 x i8] c"12\00", align 1
+@.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
+@.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1
+@.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1
+@.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1
+@.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
+@.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1
+@.str.7 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
+
+declare i32 @strtol(i8*, i8**, i32)
+declare i32 @atoi(i8*)
+declare i32 @atol(i8*)
+declare i32 @atoll(i8*)
+declare i32 @strtoll(i8*, i8**, i32)
+
+define i32 @strtol_dec() #0 {
+; CHECK-LABEL: @strtol_dec(
+; CHECK-NEXT:    ret i32 12
+;
+  %call = call i32 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 10) #2
+  ret i32 %call
+}
+
+define i32 @strtol_base_zero() #0 {
+; CHECK-LABEL: @strtol_base_zero(
+; CHECK-NEXT:    ret i32 12
+;
+  %call = call i32 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 0) #2
+  ret i32 %call
+}
+
+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 {
+; 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:    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
+  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
+  ret i32 %call
+}
+
+define i32 @strtol_not_const_str(i8* %s) #0 {
+; CHECK-LABEL: @strtol_not_const_str(
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtol(i8* nocapture [[S:%.*]], i8** null, i32 10)
+; 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:    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 @strtol(i8* nocapture getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8** null, i32 [[B:%.*]])
+; CHECK-NEXT:    ret i32 [[CALL]]
+;
+  %call = call i32 @strtol(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8** null, i32 %b) #2
+  ret i32 %call
+}
+
+define i32 @strtol_long_int() #0 {
+; CHECK-LABEL: @strtol_long_int(
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    ret i32 [[CALL]]
+;
+  %call = call i32 @strtol(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), i8** null, i32 10) #3
+  ret i32 %call
+}
+
+
+define i32 @strtol_big_overflow() #0 {
+; CHECK-LABEL: @strtol_big_overflow(
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strtol(i8* nocapture getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), i8** null, i32 10)
+; CHECK-NEXT:    ret i32 [[CALL]]
+;
+  %call = call i32 @strtol(i8* nocapture getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i32 0, i32 0), i8** null, i32 10) #2
+  ret i32 %call
+}
+
+define i32 @atol_test() #0 {
+; CHECK-LABEL: @atol_test(
+; CHECK-NEXT:    ret i32 499496729
+;
+; 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:    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
+}