[libc] Add strtol, strtoul, and strtoull

[michaelrj]

Summary

Updates the internal string conversion function so that it
uses the new Limits.h added in a previous commit for max and min values,
and has a templated type. This makes implementing the other strto*
functions very simple.

[sivachandra]

Can you add implementation of strtol and strtoul and tests for them in this same patch? They will help us catch problems in the corner cases if any (one of which I have commented about inline).

libc/src/__support/str_conv_utils.h

78–81

I am not sure this is doing what you want. Lets take the example of T being the type int. I think you want NEGATIVE_MAX to be INT_MAX + 1. But, the above code is effectively:

unsigned long long const NEGATIVE_MASK = INT_MIN;

Which makes NEGATIVE_MASK a number much larger than INT_MAX + 1. This should fix it:

unsigned long long const NEGATIVE_MAX =
    (__llvm_libc::cpp::NumericLimits<T>::min() != 0)
        ? static_cast<unsigned long long>(__llvm_libc::cpp::NumericLimits<T>::max()) + 1
        : __llvm_libc::cpp::NumericLimits<T>::max();

114–131

We should prefer T(...) or static_cast<T>(...) over c-style casts. Also, use the ternary operator instead of an if-else statement?

[michaelrj]

add strtol, strtoul, and strtoull, as well as address comments.

[sivachandra]

libc/src/__support/str_conv_utils.h

109–110

There is change in behavior from the earlier code. Even after detecting that the result is out of range we advance the pointer now, which was not the case previously because of the break statements. But I think this change is doing it right - it is reading out the full number even if it is out of range. So, may be add a test for it?

Also, can we reduce the loop body once overflow is detected? As in, before line 92, can we have something like:

if (result == ABS_MAX)
  continue;

124

When the sign is negative and result is ABS_MAX and the return type is a signed integer type, then I think we have to handle that specially. Consider this: T is long, result_sign is - and result is ABS_MAX which is effectively LONG_MAX + 1. Since LONG_MAX + 1 cannot be represent as a long type, the static_cast here becomes an implementation defined operation.

I think previously also it was implementation defined.

libc/test/src/stdlib/strtoll_test.cpp

170

Why did you change this to unsigned here and other similar places?

[michaelrj]

fix the static cast, add a test for long numbers, and a shortcut for the loop.

libc/src/__support/str_conv_utils.h

109–110

Ah, yes the change in behavior was intentional, I noticed that the str_end value was different between my implementation and the existing strtoll. I have added a test to check that in all of the strto* functions. I also added the loop shortcut.

124

You're right, I've added an extra case and a comment explaining it.

libc/test/src/stdlib/strtoll_test.cpp

170

I changed it because the compiler was giving warnings for comparing int base with the unsigned digits (e.g. first_digit < base) and so I made it unsigned, and decided to make it consistent across all of the strto* tests. It doesn't affect anything.

[sivachandra]

libc/src/__support/str_conv_utils.h

78

This can be constexpr.

94

Add a comment here explaining the early return; point out that we read out the full number even if it is out of range.

124

Can we may be handle the overflow case like this:

if (result == ABS_MAX) {
  if (result_sign == '+' || is_unsigned) 
     return __llvm_libc::cpp::NumericLimits<T>::max();
  else // T is signed and there is a negative overflow
     return __llvm_libc::cpp::NumericLimits<T>::min();
}

For better readability, before line 78 you can define the following and use it above and also on line 79.

constexpr bool is_unsigned = (__llvm_libc::cpp::NumericLimits<T>::min() == 0);

Along the same lines, you can probably also define:

const bool is_positive = (result_sign == '+');

libc/src/stdlib/CMakeLists.txt

93

Fix here and in many other files.

[michaelrj]

cleaned up over/underflow handling. Fixed an edge case with passing LLONG_MAX followed by other numbers to strtoll.

libc/src/__support/str_conv_utils.h

94

I did that, in addition I added setting errno, since it's possible to hit ABS_MAX exactly, and then have more numbers. With the code as it was previously that would not set ERANGE in that case. I've added a test to strtoll_test.cpp to handle that.

[sivachandra]

libc/src/__support/str_conv_utils.h

94

Good catch! You can probably move setting of errno from here (and below) to inside the conditional at line 120.

122

You don't need parenthesis around is_positive.

[michaelrj]

small tweaks, respond to comments.

libc/src/__support/str_conv_utils.h

94

Thank you, and we can't do that because that would set errno if the input is exactly the maximum as well as if it's greater than the maximum.

[sivachandra]

libc/src/__support/str_conv_utils.h

94

Ah, ok!

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.assert.__assert_fail
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.abort
     libc.src.stdlib.abs
     libc.src.stdlib.labs
     libc.src.stdlib.llabs
+    libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
+    libc.src.stdlib.strtoul
+    libc.src.stdlib.strtoull
 
     # signal.h entrypoints
     libc.src.signal.raise
     libc.src.signal.sigaction
     libc.src.signal.sigdelset
     libc.src.signal.sigaddset
     libc.src.signal.sigemptyset
     libc.src.signal.sigprocmask

libc/spec/spec.td

class RestrictedPtrType<Type type> : Type {
   Type PointeeType = type;
 }
 
 // Builtin types.
 def VarArgType : Type {}
 def VoidType : NamedType<"void">;
 def IntType : NamedType<"int">;
 def LongType : NamedType<"long">;
+def UnsignedLongType : NamedType<"unsigned long">;
 def LongLongType : NamedType<"long long">;
+def UnsignedLongLongType : NamedType<"unsigned long long">;
 def FloatType : NamedType<"float">;
 def DoubleType : NamedType<"double">;
 def LongDoubleType : NamedType<"long double">;
 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
 def ConstVoidPtr : ConstType<VoidPtr>;

libc/spec/stdc.td

HeaderSpec StdLib = HeaderSpec<
       [], // Macros
       [], // Types
       [], // Enumerations
       [
           FunctionSpec<"abort", RetValSpec<NoReturn>, [ArgSpec<VoidType>]>,
           FunctionSpec<"abs", RetValSpec<IntType>, [ArgSpec<IntType>]>,
           FunctionSpec<"labs", RetValSpec<LongType>, [ArgSpec<LongType>]>,
           FunctionSpec<"llabs", RetValSpec<LongLongType>, [ArgSpec<LongLongType>]>,
+          FunctionSpec<"strtol", RetValSpec<LongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"strtoll", RetValSpec<LongLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
+          FunctionSpec<"strtoul", RetValSpec<UnsignedLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
+          FunctionSpec<"strtoull", RetValSpec<UnsignedLongLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"_Exit", RetValSpec<NoReturn>, [ArgSpec<IntType>]>,
       ]
   >;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"errno">,

libc/src/__support/CMakeLists.txt

 add_header_library(
   str_conv_utils
   HDRS
     str_conv_utils.h
   DEPENDS
     .ctype_utils
     libc.include.errno
     libc.src.errno.__errno_location
+    libc.utils.CPP.standalone_cpp
 )
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h
 )
 
 add_subdirectory(FPUtil)

libc/src/__support/str_conv_utils.h

 //===-- Stdlib utils --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBC_SRC_STDLIB_STDLIB_UTILS_H
 #define LIBC_SRC_STDLIB_STDLIB_UTILS_H
 
 #include "src/__support/ctype_utils.h"
+#include "utils/CPP/Limits.h"
 #include <errno.h>
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
 // character (as determined by isspace())
if (**src == '0') {
     return 8;
   }
   return 10;
 }
 
 // Takes a pointer to a string, a pointer to a string pointer, and the base to
 // convert to. This function is used as the backend for all of the string to int
 // functions.
-static inline long long strtoll(const char *__restrict src,
-                                char **__restrict str_end, int base) {
+template <class T>
+static inline T strtointeger(const char *__restrict src,
   unsigned long long result = 0;
 
   if (base < 0 || base == 1 || base > 36) {
     errno = EINVAL; // NOLINT
     return 0;
   }
 
   src = first_non_whitespace(src);
 
   char result_sign = '+';
   if (*src == '+' || *src == '-') {
     result_sign = *src;
     ++src;
   }
 
   if (base == 0) {
     base = infer_base(&src);
   } else if (base == 16 && *src == '0' && (*(src + 1) | 32) == 'x') {
     src = src + 2;
   }
 
+  unsigned long long const NEGATIVE_MAX =
+      (__llvm_libc::cpp::NumericLimits<T>::min() != 0)
+          ? static_cast<unsigned long long>(
+                __llvm_libc::cpp::NumericLimits<T>::max()) +
+                1
+          : __llvm_libc::cpp::NumericLimits<T>::max();
   unsigned long long const ABS_MAX =
-      (result_sign == '+' ? LLONG_MAX
-                          : static_cast<unsigned long long>(LLONG_MAX) + 1);
+      (result_sign == '+' ? __llvm_libc::cpp::NumericLimits<T>::max()
+                          : NEGATIVE_MAX);
   unsigned long long const ABS_MAX_DIV_BY_BASE = ABS_MAX / base;
   while (isalnum(*src)) {
     int cur_digit = b36_char_to_int(*src);
     if (cur_digit >= base)
       break;
+
+    ++src;
+
+    if (result == ABS_MAX)
+      continue;
+
     if (result > ABS_MAX_DIV_BY_BASE) {
       result = ABS_MAX;
       errno = ERANGE; // NOLINT
-      break;
-    }
+    } else {
       result = result * base;
+    }
     if (result > ABS_MAX - cur_digit) {
       result = ABS_MAX;
       errno = ERANGE; // NOLINT
-      break;
-    }
+    } else {
       result = result + cur_digit;
-
-    ++src;
+    }
   }
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(src);
-  if (result_sign == '+')
-    return result;
-  else
-    return -result;
+
+  // This is to handle overflowing negative numbers for unsigned T.
+  // For example if result overflows and becomes ULLONG_MAX and then is negated
+  // then it becomes 1. This doesn't match the intended outcome, which is
+  // ULLONG_MAX for large negative numbers.
+  if (result == ABS_MAX && __llvm_libc::cpp::NumericLimits<T>::min() == 0) {
+    return static_cast<T>(result);
+  }
+
+  // This is because NEGATIVE_MAX for signed numbers is greater than the maximum
+  // positive value that can be stored. In that case if result was cast to T,
+  // the result would be defined by the implementation. This avoids that.
+  if (result == NEGATIVE_MAX && result_sign == '-') {
+    return __llvm_libc::cpp::NumericLimits<T>::min();
+  }
+
+  return (result_sign == '+') ? static_cast<T>(result)
+                              : -static_cast<T>(result);
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_STDLIB_STDLIB_UTILS_H

libc/src/stdlib/CMakeLists.txt

SRCS
     llabs.cpp
   HDRS
     llabs.h
   DEPENDS
     libc.src.__support.integer_operations
 )
 
 add_entrypoint_object(
+  strtol
+  SRCS
+    strtol.cpp
+  HDRS
+    strtol.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
   strtoll
   SRCS
     strtoll.cpp
   HDRS
     strtoll.h
   DEPENDS
     libc.src.__support.str_conv_utils
 )
+
+add_entrypoint_object(
+  strtoul
+  SRCS
+    strtoul.cpp
+  HDRS
+    strtoul.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
+  strtoull
+  SRCS
+    strtoull.cpp
+  HDRS
+    strtoull.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
 No newline at end of file

libc/src/stdlib/strtol.h

+//===-- Implementation header for strtol ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDLIB_STRTOL_H
+#define LLVM_LIBC_SRC_STDLIB_STRTOL_H
+
+namespace __llvm_libc {
+
+long strtol(const char *__restrict str, char **__restrict str_end, int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_STRTOL_H

libc/src/stdlib/strtol.cpp

-//===-- Implementation of strtoll -----------------------------------------===//
+//===-- Implementation of strtol ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtol.h"
 #include "src/__support/common.h"
 #include "src/__support/str_conv_utils.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(long long, strtoll,
+LLVM_LIBC_FUNCTION(long, strtol,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtoll(str, str_end, base);
+  return internal::strtointeger<long>(str, str_end, base);
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoll.cpp

 #include "src/__support/common.h"
 #include "src/__support/str_conv_utils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, strtoll,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtoll(str, str_end, base);
+  return internal::strtointeger<long long>(str, str_end, base);
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoul.h

+//===-- Implementation header for strtoul -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDLIB_STRTOUL_H
+#define LLVM_LIBC_SRC_STDLIB_STRTOUL_H
+
+namespace __llvm_libc {
+
+unsigned long strtoul(const char *__restrict str, char **__restrict str_end,
+                      int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_STRTOUL_H

libc/src/stdlib/strtoul.cpp

-//===-- Implementation of strtoll -----------------------------------------===//
+//===-- Implementation of strtoul -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtoul.h"
 #include "src/__support/common.h"
 #include "src/__support/str_conv_utils.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(long long, strtoll,
+LLVM_LIBC_FUNCTION(unsigned long, strtoul,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtoll(str, str_end, base);
+  return internal::strtointeger<unsigned long>(str, str_end, base);
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoull.h

+//===-- Implementation header for strtoull ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDLIB_STRTOULL_H
+#define LLVM_LIBC_SRC_STDLIB_STRTOULL_H
+
+namespace __llvm_libc {
+
+unsigned long long strtoull(const char *__restrict str,
+                            char **__restrict str_end, int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_STRTOULL_H

libc/src/stdlib/strtoull.cpp

-//===-- Implementation of strtoll -----------------------------------------===//
+//===-- Implementation of strtoull ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtoull.h"
 #include "src/__support/common.h"
 #include "src/__support/str_conv_utils.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(long long, strtoll,
+LLVM_LIBC_FUNCTION(unsigned long long, strtoull,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
-  return internal::strtoll(str, str_end, base);
+  return internal::strtointeger<unsigned long long>(str, str_end, base);
 }
 
 } // namespace __llvm_libc

libc/test/src/stdlib/CMakeLists.txt

SUITE
     libc_stdlib_unittests
   SRCS
     llabs_test.cpp
   DEPENDS
     libc.src.stdlib.llabs
 )
 
 add_libc_unittest(
+  strtol_test
+  SUITE
+    libc_stdlib_unittests
+  SRCS
+    strtol_test.cpp
+  DEPENDS
+    libc.src.stdlib.strtol
+)
+
+add_libc_unittest(
   strtoll_test
   SUITE
     libc_stdlib_unittests
   SRCS
     strtoll_test.cpp
   DEPENDS
     libc.src.stdlib.strtoll
-    libc.include.errno
-    libc.test.errno_setter_matcher
 )
+
+add_libc_unittest(
+  strtoul_test
+  SUITE
+    libc_stdlib_unittests
+  SRCS
+    strtoul_test.cpp
+  DEPENDS
+    libc.src.stdlib.strtoul
+)
+
+add_libc_unittest(
+  strtoull_test
+  SUITE
+    libc_stdlib_unittests
+  SRCS
+    strtoull_test.cpp
+  DEPENDS
+    libc.src.stdlib.strtoull
+)
 No newline at end of file

libc/test/src/stdlib/strtol_test.cpp

-//===-- Unittests for strtoll ---------------------------------------------===//
+//===-- Unittests for strtol ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtol.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <limits.h>
 
-TEST(LlvmLibcStrToLLTest, InvalidBase) {
+TEST(LlvmLibcStrToLTest, InvalidBase) {
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, -1), 0ll);
+  ASSERT_EQ(__llvm_libc::strtol(ten, nullptr, -1), 0l);
   ASSERT_EQ(errno, EINVAL);
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseTenDecode) {
+TEST(LlvmLibcStrToLTest, CleanBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(ten, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - ten, 2l);
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(ten, nullptr, 10), 10l);
   ASSERT_EQ(errno, 0);
 
   const char *hundred = "100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(hundred, &str_end, 10), 100ll);
+  ASSERT_EQ(__llvm_libc::strtol(hundred, &str_end, 10), 100l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - hundred, 3l);
 
   const char *negative = "-100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(negative, &str_end, 10), -100ll);
+  ASSERT_EQ(__llvm_libc::strtol(negative, &str_end, 10), -100l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - negative, 4l);
 
   const char *big_number = "123456789012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_number, &str_end, 10), 123456789012345ll);
+  ASSERT_EQ(__llvm_libc::strtol(big_number, &str_end, 10), 123456789012345l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - big_number, 15l);
 
   const char *big_negative_number = "-123456789012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_negative_number, &str_end, 10),
-            -123456789012345ll);
+  ASSERT_EQ(__llvm_libc::strtol(big_negative_number, &str_end, 10),
+            -123456789012345l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - big_negative_number, 16l);
 
   const char *too_big_number = "123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_number, &str_end, 10), LLONG_MAX);
+  ASSERT_EQ(__llvm_libc::strtol(too_big_number, &str_end, 10), LONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_number, 19l);
+  EXPECT_EQ(str_end - too_big_number, 21l);
 
   const char *too_big_negative_number = "-123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_negative_number, &str_end, 10),
-            LLONG_MIN);
+  ASSERT_EQ(__llvm_libc::strtol(too_big_negative_number, &str_end, 10),
+            LONG_MIN);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_negative_number, 20l);
+  EXPECT_EQ(str_end - too_big_negative_number, 22l);
+
+  const char *long_number_range_test =
+      "10000000000000000000000000000000000000000000000000";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtol(long_number_range_test, &str_end, 10),
+            LONG_MAX);
+  ASSERT_EQ(errno, ERANGE);
+  EXPECT_EQ(str_end - long_number_range_test, 50l);
 }
 
-TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
+TEST(LlvmLibcStrToLTest, MessyBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *spaces_before = "     10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(spaces_before, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_before, 7l);
 
   const char *spaces_after = "10      ";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(spaces_after, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_after, 2l);
 
   const char *word_before = "word10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_before, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtol(word_before, &str_end, 10), 0l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_before, 0l);
 
   const char *word_after = "10word";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(word_after, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_after, 2l);
 
   const char *two_numbers = "10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_numbers, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(two_numbers, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_numbers, 2l);
 
   const char *two_signs = "--10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_signs, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtol(two_signs, &str_end, 10), 0l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_signs, 1l);
 
   const char *sign_before = "+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_before, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtol(sign_before, &str_end, 10), 2l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_before, 2l);
 
   const char *sign_after = "2+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_after, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtol(sign_after, &str_end, 10), 2l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_after, 1l);
 
   const char *tab_before = "\t10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(tab_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtol(tab_before, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - tab_before, 3l);
 
   const char *all_together = "\t  -12345and+67890";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(all_together, &str_end, 10), -12345ll);
+  ASSERT_EQ(__llvm_libc::strtol(all_together, &str_end, 10), -12345l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, 9l);
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
     return '0' + input;
   return 'A' + input - 10;
 }
 
-TEST(LlvmLibcStrToLLTest, DecodeInOtherBases) {
+TEST(LlvmLibcStrToLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+        ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                   first_digit);
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+        ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                     second_digit + (first_digit * base));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                     first_digit);
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+          ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (long long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (long third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                       third_digit + (second_digit * base) +
                           (first_digit * base * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                       second_digit + (first_digit * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+                ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                           third_digit);
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                          0ll);
+                ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
-              ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+              ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
                         first_digit);
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+            ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
             ASSERT_EQ(errno, 0);
           }
         }
       }
     }
   }
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseSixteenDecode) {
+TEST(LlvmLibcStrToLTest, CleanBaseSixteenDecode) {
   char *str_end = nullptr;
 
   const char *no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(no_prefix, &str_end, 16), 0x123abcll);
+  ASSERT_EQ(__llvm_libc::strtol(no_prefix, &str_end, 16), 0x123abcl);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - no_prefix, 6l);
 
   const char *yes_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(yes_prefix, &str_end, 16), 0x456defll);
+  ASSERT_EQ(__llvm_libc::strtol(yes_prefix, &str_end, 16), 0x456defl);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - yes_prefix, 8l);
 }
 
-TEST(LlvmLibcStrToLLTest, AutomaticBaseSelection) {
+TEST(LlvmLibcStrToLTest, AutomaticBaseSelection) {
   char *str_end = nullptr;
 
   const char *base_ten = "12345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_ten, &str_end, 0), 12345ll);
+  ASSERT_EQ(__llvm_libc::strtol(base_ten, &str_end, 0), 12345l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_ten, 5l);
 
   const char *base_sixteen_no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_no_prefix, &str_end, 0), 123ll);
+  ASSERT_EQ(__llvm_libc::strtol(base_sixteen_no_prefix, &str_end, 0), 123l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_no_prefix, 3l);
 
   const char *base_sixteen_with_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_with_prefix, &str_end, 0),
-            0x456defll);
+  ASSERT_EQ(__llvm_libc::strtol(base_sixteen_with_prefix, &str_end, 0),
+            0x456defl);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_with_prefix, 8l);
 
   const char *base_eight_with_prefix = "012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_eight_with_prefix, &str_end, 0),
-            012345ll);
+  ASSERT_EQ(__llvm_libc::strtol(base_eight_with_prefix, &str_end, 0), 012345l);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_eight_with_prefix, 6l);
 }

libc/test/src/stdlib/strtoll_test.cpp

TEST(LlvmLibcStrToLLTest, CleanBaseTenDecode) {
 
   const char *big_negative_number = "-123456789012345";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoll(big_negative_number, &str_end, 10),
             -123456789012345ll);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - big_negative_number, 16l);
 
+  const char *long_long_max_number = "9223372036854775807";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoll(long_long_max_number, &str_end, 10),
+            9223372036854775807ll);
+  ASSERT_EQ(errno, 0);
+  EXPECT_EQ(str_end - long_long_max_number, 19l);
+
+  const char *long_long_min_number = "-9223372036854775808";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoll(long_long_min_number, &str_end, 10),
+            -9223372036854775807ll - 1ll);
+  ASSERT_EQ(errno, 0);
+  EXPECT_EQ(str_end - long_long_min_number, 20l);
+
   const char *too_big_number = "123456789012345678901";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoll(too_big_number, &str_end, 10), LLONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_number, 19l);
+  EXPECT_EQ(str_end - too_big_number, 21l);
 
   const char *too_big_negative_number = "-123456789012345678901";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoll(too_big_negative_number, &str_end, 10),
             LLONG_MIN);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_negative_number, 20l);
+  EXPECT_EQ(str_end - too_big_negative_number, 22l);
+
+  const char *long_number_range_test =
+      "10000000000000000000000000000000000000000000000000";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoll(long_number_range_test, &str_end, 10),
+            LLONG_MAX);
+  ASSERT_EQ(errno, ERANGE);
+  EXPECT_EQ(str_end - long_number_range_test, 50l);
 }
 
 TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *spaces_before = "     10";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoll(spaces_before, &str_end, 10), 10ll);
if (input < 0 || input > 36)
     return '0';
   if (input < 10)
     return '0' + input;
   return 'A' + input - 10;
 }
 
 TEST(LlvmLibcStrToLLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (int base = 2; base <= 36; ++base) {
+  for (unsigned int base = 2; base <= 36; ++base) {
     for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
                   first_digit);
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
+  for (unsigned int base = 2; base <= 36; ++base) {
     for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
                     second_digit + (first_digit * base));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
                     first_digit);
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
+  for (unsigned int base = 2; base <= 36; ++base) {
     for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         for (long long third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {

libc/test/src/stdlib/strtoul_test.cpp

-//===-- Unittests for strtoll ---------------------------------------------===//
+//===-- Unittests for strtoul ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtoul.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <limits.h>
 
-TEST(LlvmLibcStrToLLTest, InvalidBase) {
+TEST(LlvmLibcStrToULTest, InvalidBase) {
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, -1), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoul(ten, nullptr, -1), 0ul);
   ASSERT_EQ(errno, EINVAL);
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseTenDecode) {
+TEST(LlvmLibcStrToULTest, CleanBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(ten, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - ten, 2l);
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(ten, nullptr, 10), 10ul);
   ASSERT_EQ(errno, 0);
 
   const char *hundred = "100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(hundred, &str_end, 10), 100ll);
+  ASSERT_EQ(__llvm_libc::strtoul(hundred, &str_end, 10), 100ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - hundred, 3l);
 
   const char *negative = "-100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(negative, &str_end, 10), -100ll);
+  ASSERT_EQ(__llvm_libc::strtoul(negative, &str_end, 10), -(100ul));
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - negative, 4l);
 
   const char *big_number = "123456789012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_number, &str_end, 10), 123456789012345ll);
+  ASSERT_EQ(__llvm_libc::strtoul(big_number, &str_end, 10), 123456789012345ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - big_number, 15l);
 
-  const char *big_negative_number = "-123456789012345";
-  errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_negative_number, &str_end, 10),
-            -123456789012345ll);
-  ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - big_negative_number, 16l);
-
   const char *too_big_number = "123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_number, &str_end, 10), LLONG_MAX);
+  ASSERT_EQ(__llvm_libc::strtoul(too_big_number, &str_end, 10), ULONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_number, 19l);
+  EXPECT_EQ(str_end - too_big_number, 21l);
 
   const char *too_big_negative_number = "-123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_negative_number, &str_end, 10),
-            LLONG_MIN);
+  ASSERT_EQ(__llvm_libc::strtoul(too_big_negative_number, &str_end, 10),
+            ULONG_MAX);
+  ASSERT_EQ(errno, ERANGE);
+  EXPECT_EQ(str_end - too_big_negative_number, 22l);
+
+  const char *long_number_range_test =
+      "10000000000000000000000000000000000000000000000000";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoul(long_number_range_test, &str_end, 10),
+            ULONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_negative_number, 20l);
+  EXPECT_EQ(str_end - long_number_range_test, 50l);
 }
 
-TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
+TEST(LlvmLibcStrToULTest, MessyBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *spaces_before = "     10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(spaces_before, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_before, 7l);
 
   const char *spaces_after = "10      ";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(spaces_after, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_after, 2l);
 
   const char *word_before = "word10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_before, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoul(word_before, &str_end, 10), 0ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_before, 0l);
 
   const char *word_after = "10word";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(word_after, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_after, 2l);
 
   const char *two_numbers = "10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_numbers, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(two_numbers, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_numbers, 2l);
 
   const char *two_signs = "--10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_signs, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoul(two_signs, &str_end, 10), 0ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_signs, 1l);
 
   const char *sign_before = "+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_before, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtoul(sign_before, &str_end, 10), 2ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_before, 2l);
 
   const char *sign_after = "2+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_after, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtoul(sign_after, &str_end, 10), 2ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_after, 1l);
 
   const char *tab_before = "\t10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(tab_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoul(tab_before, &str_end, 10), 10ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - tab_before, 3l);
 
   const char *all_together = "\t  -12345and+67890";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(all_together, &str_end, 10), -12345ll);
+  ASSERT_EQ(__llvm_libc::strtoul(all_together, &str_end, 10), -(12345ul));
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, 9l);
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
     return '0' + input;
   return 'A' + input - 10;
 }
 
-TEST(LlvmLibcStrToLLTest, DecodeInOtherBases) {
+TEST(LlvmLibcStrToULTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+        ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                   first_digit);
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+        ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base), 0ul);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (unsigned long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                     second_digit + (first_digit * base));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                     first_digit);
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+          ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base), 0ul);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (unsigned long second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (long long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (unsigned long third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                       third_digit + (second_digit * base) +
                           (first_digit * base * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                       second_digit + (first_digit * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+                ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                           third_digit);
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                          0ll);
+                ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
+                          0ul);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
-              ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+              ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                         first_digit);
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+            ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base), 0ul);
             ASSERT_EQ(errno, 0);
           }
         }
       }
     }
   }
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseSixteenDecode) {
+TEST(LlvmLibcStrToULTest, CleanBaseSixteenDecode) {
   char *str_end = nullptr;
 
   const char *no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(no_prefix, &str_end, 16), 0x123abcll);
+  ASSERT_EQ(__llvm_libc::strtoul(no_prefix, &str_end, 16), 0x123abcul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - no_prefix, 6l);
 
   const char *yes_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(yes_prefix, &str_end, 16), 0x456defll);
+  ASSERT_EQ(__llvm_libc::strtoul(yes_prefix, &str_end, 16), 0x456deful);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - yes_prefix, 8l);
 }
 
-TEST(LlvmLibcStrToLLTest, AutomaticBaseSelection) {
+TEST(LlvmLibcStrToULTest, AutomaticBaseSelection) {
   char *str_end = nullptr;
 
   const char *base_ten = "12345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_ten, &str_end, 0), 12345ll);
+  ASSERT_EQ(__llvm_libc::strtoul(base_ten, &str_end, 0), 12345ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_ten, 5l);
 
   const char *base_sixteen_no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_no_prefix, &str_end, 0), 123ll);
+  ASSERT_EQ(__llvm_libc::strtoul(base_sixteen_no_prefix, &str_end, 0), 123ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_no_prefix, 3l);
 
   const char *base_sixteen_with_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_with_prefix, &str_end, 0),
-            0x456defll);
+  ASSERT_EQ(__llvm_libc::strtoul(base_sixteen_with_prefix, &str_end, 0),
+            0x456deful);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_with_prefix, 8l);
 
   const char *base_eight_with_prefix = "012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_eight_with_prefix, &str_end, 0),
-            012345ll);
+  ASSERT_EQ(__llvm_libc::strtoul(base_eight_with_prefix, &str_end, 0),
+            012345ul);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_eight_with_prefix, 6l);
 }

libc/test/src/stdlib/strtoull_test.cpp

-//===-- Unittests for strtoll ---------------------------------------------===//
+//===-- Unittests for strtoull --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/strtoll.h"
+#include "src/stdlib/strtoull.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <errno.h>
 #include <limits.h>
 
-TEST(LlvmLibcStrToLLTest, InvalidBase) {
+TEST(LlvmLibcStrToULLTest, InvalidBase) {
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, -1), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoull(ten, nullptr, -1), 0ull);
   ASSERT_EQ(errno, EINVAL);
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseTenDecode) {
+TEST(LlvmLibcStrToULLTest, CleanBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *ten = "10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(ten, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - ten, 2l);
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(ten, nullptr, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(ten, nullptr, 10), 10ull);
   ASSERT_EQ(errno, 0);
 
   const char *hundred = "100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(hundred, &str_end, 10), 100ll);
+  ASSERT_EQ(__llvm_libc::strtoull(hundred, &str_end, 10), 100ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - hundred, 3l);
 
   const char *negative = "-100";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(negative, &str_end, 10), -100ll);
+  ASSERT_EQ(__llvm_libc::strtoull(negative, &str_end, 10), -(100ull));
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - negative, 4l);
 
   const char *big_number = "123456789012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_number, &str_end, 10), 123456789012345ll);
+  ASSERT_EQ(__llvm_libc::strtoull(big_number, &str_end, 10),
+            123456789012345ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - big_number, 15l);
 
-  const char *big_negative_number = "-123456789012345";
+  const char *unsigned_long_long_max_number = "18446744073709551615";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(big_negative_number, &str_end, 10),
-            -123456789012345ll);
+  ASSERT_EQ(__llvm_libc::strtoull(unsigned_long_long_max_number, &str_end, 10),
+            18446744073709551615ull);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - big_negative_number, 16l);
+  EXPECT_EQ(str_end - unsigned_long_long_max_number, 20l);
 
   const char *too_big_number = "123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_number, &str_end, 10), LLONG_MAX);
+  ASSERT_EQ(__llvm_libc::strtoull(too_big_number, &str_end, 10), ULLONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_number, 19l);
+  EXPECT_EQ(str_end - too_big_number, 21l);
 
   const char *too_big_negative_number = "-123456789012345678901";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(too_big_negative_number, &str_end, 10),
-            LLONG_MIN);
+  ASSERT_EQ(__llvm_libc::strtoull(too_big_negative_number, &str_end, 10),
+            ULLONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_negative_number, 20l);
+  EXPECT_EQ(str_end - too_big_negative_number, 22l);
+
+  const char *long_number_range_test =
+      "10000000000000000000000000000000000000000000000000";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoull(long_number_range_test, &str_end, 10),
+            ULLONG_MAX);
+  ASSERT_EQ(errno, ERANGE);
+  EXPECT_EQ(str_end - long_number_range_test, 50l);
 }
 
-TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
+TEST(LlvmLibcStrToULLTest, MessyBaseTenDecode) {
   char *str_end = nullptr;
 
   const char *spaces_before = "     10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(spaces_before, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_before, 7l);
 
   const char *spaces_after = "10      ";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(spaces_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(spaces_after, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - spaces_after, 2l);
 
   const char *word_before = "word10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_before, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoull(word_before, &str_end, 10), 0ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_before, 0l);
 
   const char *word_after = "10word";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(word_after, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(word_after, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - word_after, 2l);
 
   const char *two_numbers = "10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_numbers, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(two_numbers, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_numbers, 2l);
 
   const char *two_signs = "--10 999";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(two_signs, &str_end, 10), 0ll);
+  ASSERT_EQ(__llvm_libc::strtoull(two_signs, &str_end, 10), 0ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - two_signs, 1l);
 
   const char *sign_before = "+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_before, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtoull(sign_before, &str_end, 10), 2ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_before, 2l);
 
   const char *sign_after = "2+2=4";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(sign_after, &str_end, 10), 2ll);
+  ASSERT_EQ(__llvm_libc::strtoull(sign_after, &str_end, 10), 2ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - sign_after, 1l);
 
   const char *tab_before = "\t10";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(tab_before, &str_end, 10), 10ll);
+  ASSERT_EQ(__llvm_libc::strtoull(tab_before, &str_end, 10), 10ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - tab_before, 3l);
 
   const char *all_together = "\t  -12345and+67890";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(all_together, &str_end, 10), -12345ll);
+  ASSERT_EQ(__llvm_libc::strtoull(all_together, &str_end, 10), -(12345ull));
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, 9l);
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
     return '0' + input;
   return 'A' + input - 10;
 }
 
-TEST(LlvmLibcStrToLLTest, DecodeInOtherBases) {
+TEST(LlvmLibcStrToULLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+        ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                   first_digit);
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
-        ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+        ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (unsigned long long second_digit = 0; second_digit <= 36;
+           ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                     second_digit + (first_digit * base));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+          ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                     first_digit);
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+          ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (int base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (unsigned int base = 2; base <= 36; ++base) {
+    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (unsigned long long second_digit = 0; second_digit <= 36;
+           ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (long long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (unsigned long long third_digit = 0; third_digit <= 36;
+             ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                       third_digit + (second_digit * base) +
                           (first_digit * base * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+            ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                       second_digit + (first_digit * base));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+                ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                           third_digit);
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
-                ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                          0ll);
+                ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
+                          0ull);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
-              ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
+              ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                         first_digit);
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
+            ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
             ASSERT_EQ(errno, 0);
           }
         }
       }
     }
   }
 }
 
-TEST(LlvmLibcStrToLLTest, CleanBaseSixteenDecode) {
+TEST(LlvmLibcStrToULLTest, CleanBaseSixteenDecode) {
   char *str_end = nullptr;
 
   const char *no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(no_prefix, &str_end, 16), 0x123abcll);
+  ASSERT_EQ(__llvm_libc::strtoull(no_prefix, &str_end, 16), 0x123abcull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - no_prefix, 6l);
 
   const char *yes_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(yes_prefix, &str_end, 16), 0x456defll);
+  ASSERT_EQ(__llvm_libc::strtoull(yes_prefix, &str_end, 16), 0x456defull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - yes_prefix, 8l);
 }
 
-TEST(LlvmLibcStrToLLTest, AutomaticBaseSelection) {
+TEST(LlvmLibcStrToULLTest, AutomaticBaseSelection) {
   char *str_end = nullptr;
 
   const char *base_ten = "12345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_ten, &str_end, 0), 12345ll);
+  ASSERT_EQ(__llvm_libc::strtoull(base_ten, &str_end, 0), 12345ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_ten, 5l);
 
   const char *base_sixteen_no_prefix = "123abc";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_no_prefix, &str_end, 0), 123ll);
+  ASSERT_EQ(__llvm_libc::strtoull(base_sixteen_no_prefix, &str_end, 0), 123ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_no_prefix, 3l);
 
   const char *base_sixteen_with_prefix = "0x456def";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_sixteen_with_prefix, &str_end, 0),
-            0x456defll);
+  ASSERT_EQ(__llvm_libc::strtoull(base_sixteen_with_prefix, &str_end, 0),
+            0x456defull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_sixteen_with_prefix, 8l);
 
   const char *base_eight_with_prefix = "012345";
   errno = 0;
-  ASSERT_EQ(__llvm_libc::strtoll(base_eight_with_prefix, &str_end, 0),
-            012345ll);
+  ASSERT_EQ(__llvm_libc::strtoull(base_eight_with_prefix, &str_end, 0),
+            012345ull);
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - base_eight_with_prefix, 6l);
 }