[libc] add strtoll function and backend

[michaelrj]

Summary

This change adds the stroll function, but most of the implementation is
in the new file str_conv_utils.h since many of the other integer
conversion functions are implemented through what are effectively calls
to strtoll.

[sivachandra]

Just one major comment about errno but the rest are mostly nits and bikeshed comments.

libc/src/__support/CMakeLists.txt

16

Bikeshed: The name stdlib_utils sounds very general and can end up with more than one topic. May be call it str_conv_utils to keep it focused.

20

For targets in the same directory, you use .ctype_utils.

libc/src/__support/stdlib_utils.h

12 ↗

(On Diff #365316)

We don't include LLVM libc's errno now. Just do #include <errno.h> and refer to errno directly in code. Lint rules will catch if the header file is not from LLVM libc. For there reference to errno in code, you might need a NOLINT comment.

If you do the standard build, as in not the full build, my feeling is this will not build.

39 ↗

(On Diff #365316)

May be s/base_from_num_start/infer_base ?

41 ↗

(On Diff #365316)

Nit: Format it with parenthesis: ++(*src)?

55 ↗

(On Diff #365316)

Since this is in an internal namespace, you can name it strtoll.

78 ↗

(On Diff #365316)

Nit: What does the CUR prefix indicate? It seems to indicate the current value of some variable being updated in a loop. But it is actually a const.

libc/test/src/stdlib/strtoll_test.cpp

54

Why not LLONG_MAX?

59

LLONG_MIN here?

[sivachandra]

Question: Do you intend to use internal::strtoll to implement atoi and friends? If yes, then may be the internal strtoll function should also take an additional arg for errno?

[michaelrj]

Addressed comments, renamed the backend file and function.

libc/src/__support/stdlib_utils.h

12 ↗

(On Diff #365316)

I have switched it, but all of the stdlib functions are inside of an if(LLVM_LIBC_FuLL_BUILD) in entrypoints.txt, so if full build is off then it won't even try to build this.

78 ↗

(On Diff #365316)

In this case it's to distinguish it from LLONG_MAX, since this is the current maximum value we can store (either LLONG_MAX or -LLONG_MIN). I'm not sure what other prefix to use to indicate that this is a local variable, but a const one.

103 ↗

(On Diff #365316)

This line gives me compiler warnings due to casting from a const char* to a char* but the specification says that str_end is not const. Is there a better way to do this or alternately a way to suppress the compiler warnings?

libc/test/src/stdlib/strtoll_test.cpp

54

I was trying to avoid including <limits.h>, but on reflection having the variables match across the files is more important than that.

[michaelrj]

I was planning on using internal::strtoll to implement atoi and friends, but I'm not sure what the additional errno argument you mentioned would do. The existing implementation of atoi gives errors in the same manner as strtoll, e.g. setting errno to ERANGE when passed a string that decodes to a number greater than 2^63.

[sivachandra]

In D107792#2937562, @michaelrj wrote:

I was planning on using internal::strtoll to implement atoi and friends, but I'm not sure what the additional errno argument you mentioned would do. The existing implementation of atoi gives errors in the same manner as strtoll, e.g. setting errno to ERANGE when passed a string that decodes to a number greater than 2^63.

If I am reading the C standard and the POSIX standard correctly, atoi and friends do not modify errno. So, what I was trying to point out is that you might want to pass an additional int & argument for errno which you will use in strtoll and friends but not in atoi and friends.

libc/src/__support/stdlib_utils.h

12 ↗

(On Diff #365316)

Ah, as a follow up, we should revisit this and may be move some of the functions outside the conditional.

78 ↗

(On Diff #365316)

Call it ABS_MAX may be?

103 ↗

(On Diff #365316)

*str_end = const_cast<char *>(src); ?

[michaelrj]

The relevant line from the specification is "The functions atof, atoi, atol, and atoll need not affect the value of the integer expression errno on an error. If the value of the result cannot be represented, the behavior is undefined." From what I can tell that means that we aren't required to set the errno at any time, since if you pass it an out of range number then that is undefined behavior. However, implementations in other libcs do set errno to ERANGE when atoi is passed a number that is greater than 2^63.
Since this follows the specification, matches expected behavior from other libcs, and simplifies implementation, I think this is the best way forward.

libc/src/__support/stdlib_utils.h

103 ↗

(On Diff #365316)

ah yes, that fixed it. Thank you.

[michaelrj]

address comments

[sivachandra]

In D107792#2937738, @michaelrj wrote:

The relevant line from the specification is "The functions atof, atoi, atol, and atoll need not affect the value of the integer expression errno on an error. If the value of the result cannot be represented, the behavior is undefined." From what I can tell that means that we aren't required to set the errno at any time, since if you pass it an out of range number then that is undefined behavior. However, implementations in other libcs do set errno to ERANGE when atoi is passed a number that is greater than 2^63.
Since this follows the specification, matches expected behavior from other libcs, and simplifies implementation, I think this is the best way forward.

Ah! Not the first time cppreference.com is incomplete: https://en.cppreference.com/w/c/string/byte/atoi
Also, not all libcs set errno in atoi and friends. For example: https://git.musl-libc.org/cgit/musl/tree/src/stdlib/atoi.c.

[michaelrj]

Ah, that makes sense. I was only testing with my system's default glibc. I will land this patch after I do a pull and run the tests on my machine.

[michaelrj]

add strtoll to the spec in stdc.td, as well as add CharPtrPtr to the types defined in spec.td

[sivachandra]

libc/src/__support/str_conv_utils.h

13

You don't need this. In the code below, use errno directly. llvmlibc_errno.h is not available in the default build.

[michaelrj]

switch over from using the internal errno to using the public errno.
This required changing all the tests, since ErrnoSetterMatcher.h uses only the internal errno.

[michaelrj]

libc/src/__support/str_conv_utils.h

13

Done, but I had to change all the tests to match.

[michaelrj]

fix type for strtoll being char**, it is now char **restrict

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.strtoll
 
     # 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

 // _Noreturn is really not a type, but it is convenient to treat it as a type.
 def NoReturn : NamedType<"_Noreturn void">;
 
 //types moved from stdc.td
 def VoidRestrictedPtr : RestrictedPtrType<VoidType>;
 def ConstVoidRestrictedPtr : ConstType<VoidRestrictedPtr>;
 
 def CharPtr : PtrType<CharType>;
+def CharPtrPtr : PtrType<CharPtr>;
 def ConstCharPtr : ConstType<CharPtr>;
 def CharRestrictedPtr : RestrictedPtrType<CharType>;
 def ConstCharRestrictedPtr : ConstType<CharRestrictedPtr>;
 
 def OnceFlagType : NamedType<"once_flag">;
 def OnceFlagTypePtr : PtrType<OnceFlagType>;
 // TODO(sivachandra): Remove this non-standard type when a formal
 // way to describe callable types is available.

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<"strtoll", RetValSpec<LongLongType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharPtrPtr>, ArgSpec<IntType>]>,
           FunctionSpec<"_Exit", RetValSpec<NoReturn>, [ArgSpec<IntType>]>,
       ]
   >;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"errno">,

libc/src/__support/CMakeLists.txt

 add_header_library(
   common
   HDRS
     common.h
     endian.h
     sanitizer.h
 )
 
 add_header_library(
   ctype_utils
   HDRS
     ctype_utils.h
 )
 
 add_header_library(
+  str_conv_utils
+  HDRS
+    str_conv_utils.h
+  DEPENDS
+    .ctype_utils
+    libc.include.errno
+    libc.src.errno.__errno_location
+)
+
+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 "src/errno/llvmlibc_errno.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())
+static inline const char *first_non_whitespace(const char *__restrict src) {
+  while (internal::isspace(*src)) {
+    ++src;
+  }
+  return src;
+}
+
+static inline int b36_char_to_int(char input) {
+  if (isdigit(input))
+    return input - '0';
+  if (isalpha(input))
+    return (input | 32) + 10 - 'a';
+  return 0;
+}
+
+// Takes the address of the string pointer and parses the base from the start of
+// it. This will advance the string pointer.
+static inline int infer_base(const char *__restrict *__restrict src) {
+  if (**src == '0') {
+    ++(*src);
+    if ((**src | 32) == 'x') {
+      ++(*src);
+      return 16;
+    }
+    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) {
+  unsigned long long result = 0;
+
+  if (base < 0 || base == 1 || base > 36) {
+    llvmlibc_errno = EINVAL;
+    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 ABS_MAX =
+      (result_sign == '+' ? LLONG_MAX
+                          : static_cast<unsigned long long>(LLONG_MAX) + 1);
+  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;
+    if (result > ABS_MAX_DIV_BY_BASE) {
+      result = ABS_MAX;
+      llvmlibc_errno = ERANGE;
+      break;
+    }
+    result = result * base;
+    if (result > ABS_MAX - cur_digit) {
+      result = ABS_MAX;
+      llvmlibc_errno = ERANGE;
+      break;
+    }
+    result = result + cur_digit;
+
+    ++src;
+  }
+
+  if (str_end != nullptr)
+    *str_end = const_cast<char *>(src);
+  if (result_sign == '+')
+    return result;
+  else
+    return -result;
+}
+
+} // namespace internal
+} // namespace __llvm_libc
+
+#endif // LIBC_SRC_STDLIB_STDLIB_UTILS_H

libc/src/stdlib/CMakeLists.txt

add_entrypoint_object(
   llabs
   SRCS
     llabs.cpp
   HDRS
     llabs.h
   DEPENDS
     libc.src.__support.integer_operations
 )
+
+add_entrypoint_object(
+  strtoll
+  SRCS
+    strtoll.cpp
+  HDRS
+    strtoll.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)

libc/src/stdlib/strtoll.h

+//===-- Implementation header for strtoll -----------------------*- 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_STRTOLL_H
+#define LLVM_LIBC_SRC_STDLIB_STRTOLL_H
+
+namespace __llvm_libc {
+
+long long strtoll(const char *__restrict str, char **__restrict str_end,
+                  int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDLIB_STRTOLL_H

libc/src/stdlib/strtoll.cpp

+//===-- Implementation of strtoll -----------------------------------------===//
+//
+// 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/__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);
+}
+
+} // namespace __llvm_libc

libc/test/src/stdlib/CMakeLists.txt

add_libc_unittest(
   llabs_test
   SUITE
     libc_stdlib_unittests
   SRCS
     llabs_test.cpp
   DEPENDS
     libc.src.stdlib.llabs
 )
+
+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
+)

libc/test/src/stdlib/strtoll_test.cpp

+//===-- Unittests for strtoll ---------------------------------------------===//
+//
+// 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 "test/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+
+using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+
+TEST(LlvmLibcStrToLLTest, InvalidBase) {
+  const char *ten = "10";
+  ASSERT_THAT(__llvm_libc::strtoll(ten, nullptr, -1), Fails(EINVAL, 0));
+}
+
+TEST(LlvmLibcStrToLLTest, CleanBaseTenDecode) {
+  char *str_end = nullptr;
+
+  const char *ten = "10";
+  ASSERT_THAT(__llvm_libc::strtoll(ten, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - ten, 2l);
+  ASSERT_THAT(__llvm_libc::strtoll(ten, nullptr, 10), Succeeds(10));
+
+  const char *hundred = "100";
+  ASSERT_THAT(__llvm_libc::strtoll(hundred, &str_end, 10), Succeeds(100));
+  EXPECT_EQ(str_end - hundred, 3l);
+
+  const char *negative = "-100";
+  ASSERT_THAT(__llvm_libc::strtoll(negative, &str_end, 10), Succeeds(-100));
+  EXPECT_EQ(str_end - negative, 4l);
+
+  const char *big_number = "123456789012345";
+  ASSERT_THAT(__llvm_libc::strtoll(big_number, &str_end, 10),
+              Succeeds(123456789012345));
+  EXPECT_EQ(str_end - big_number, 15l);
+
+  const char *big_negative_number = "-123456789012345";
+  ASSERT_THAT(__llvm_libc::strtoll(big_negative_number, &str_end, 10),
+              Succeeds(-123456789012345));
+  EXPECT_EQ(str_end - big_negative_number, 16l);
+
+  const char *too_big_number = "123456789012345678901";
+  ASSERT_THAT(__llvm_libc::strtoll(too_big_number, &str_end, 10),
+              Fails(ERANGE, LLONG_MAX));
+  EXPECT_EQ(str_end - too_big_number, 19l);
+
+  const char *too_big_negative_number = "-123456789012345678901";
+  ASSERT_THAT(__llvm_libc::strtoll(too_big_negative_number, &str_end, 10),
+              Fails(ERANGE, LLONG_MIN));
+  EXPECT_EQ(str_end - too_big_negative_number, 20l);
+}
+
+TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
+  char *str_end = nullptr;
+
+  const char *spaces_before = "     10";
+  ASSERT_THAT(__llvm_libc::strtoll(spaces_before, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - spaces_before, 7l);
+
+  const char *spaces_after = "10      ";
+  ASSERT_THAT(__llvm_libc::strtoll(spaces_after, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - spaces_after, 2l);
+
+  const char *word_before = "word10";
+  ASSERT_THAT(__llvm_libc::strtoll(word_before, &str_end, 10), Succeeds(0));
+  EXPECT_EQ(str_end - word_before, 0l);
+
+  const char *word_after = "10word";
+  ASSERT_THAT(__llvm_libc::strtoll(word_after, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - word_after, 2l);
+
+  const char *two_numbers = "10 999";
+  ASSERT_THAT(__llvm_libc::strtoll(two_numbers, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - two_numbers, 2l);
+
+  const char *two_signs = "--10 999";
+  ASSERT_THAT(__llvm_libc::strtoll(two_signs, &str_end, 10), Succeeds(0));
+  EXPECT_EQ(str_end - two_signs, 1l);
+
+  const char *sign_before = "+2=4";
+  ASSERT_THAT(__llvm_libc::strtoll(sign_before, &str_end, 10), Succeeds(2));
+  EXPECT_EQ(str_end - sign_before, 2l);
+
+  const char *sign_after = "2+2=4";
+  ASSERT_THAT(__llvm_libc::strtoll(sign_after, &str_end, 10), Succeeds(2));
+  EXPECT_EQ(str_end - sign_after, 1l);
+
+  const char *tab_before = "\t10";
+  ASSERT_THAT(__llvm_libc::strtoll(tab_before, &str_end, 10), Succeeds(10));
+  EXPECT_EQ(str_end - tab_before, 3l);
+
+  const char *all_together = "\t  -12345and+67890";
+  ASSERT_THAT(__llvm_libc::strtoll(all_together, &str_end, 10),
+              Succeeds(-12345));
+  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) {
+  char small_string[4] = {'\0', '\0', '\0', '\0'};
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
+      small_string[0] = int_to_b36_char(first_digit);
+      if (first_digit < base) {
+        ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                    Succeeds(first_digit));
+      } else {
+        ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                    Succeeds(0));
+      }
+    }
+  }
+
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
+      small_string[0] = int_to_b36_char(first_digit);
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
+        small_string[1] = int_to_b36_char(second_digit);
+        if (first_digit < base && second_digit < base) {
+          ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                      Succeeds(second_digit + (first_digit * base)));
+        } else if (first_digit < base) {
+          ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                      Succeeds(first_digit));
+        } else {
+          ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                      Succeeds(0));
+        }
+      }
+    }
+  }
+
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
+      small_string[0] = int_to_b36_char(first_digit);
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
+        small_string[1] = int_to_b36_char(second_digit);
+        for (int 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) {
+            ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                        Succeeds(third_digit + (second_digit * base) +
+                                 (first_digit * base * base)));
+          } else if (first_digit < base && second_digit < base) {
+            ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                        Succeeds(second_digit + (first_digit * base)));
+          } 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) {
+                ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                            Succeeds(third_digit));
+              } else {
+                ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                            Succeeds(0));
+              }
+            } else {
+              ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                          Succeeds(first_digit));
+            }
+          } else {
+            ASSERT_THAT(__llvm_libc::strtoll(small_string, nullptr, base),
+                        Succeeds(0));
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(LlvmLibcStrToLLTest, CleanBaseSixteenDecode) {
+  char *str_end = nullptr;
+
+  const char *no_prefix = "123abc";
+  ASSERT_THAT(__llvm_libc::strtoll(no_prefix, &str_end, 16),
+              Succeeds(0x123abc));
+  EXPECT_EQ(str_end - no_prefix, 6l);
+
+  const char *yes_prefix = "0x456def";
+  ASSERT_THAT(__llvm_libc::strtoll(yes_prefix, &str_end, 16),
+              Succeeds(0x456def));
+  EXPECT_EQ(str_end - yes_prefix, 8l);
+}
+
+TEST(LlvmLibcStrToLLTest, AutomaticBaseSelection) {
+  char *str_end = nullptr;
+
+  const char *base_ten = "12345";
+  ASSERT_THAT(__llvm_libc::strtoll(base_ten, &str_end, 0), Succeeds(12345));
+  EXPECT_EQ(str_end - base_ten, 5l);
+
+  const char *base_sixteen_no_prefix = "123abc";
+  ASSERT_THAT(__llvm_libc::strtoll(base_sixteen_no_prefix, &str_end, 0),
+              Succeeds(123));
+  EXPECT_EQ(str_end - base_sixteen_no_prefix, 3l);
+
+  const char *base_sixteen_with_prefix = "0x456def";
+  ASSERT_THAT(__llvm_libc::strtoll(base_sixteen_with_prefix, &str_end, 0),
+              Succeeds(0x456def));
+  EXPECT_EQ(str_end - base_sixteen_with_prefix, 8l);
+
+  const char *base_eight_with_prefix = "012345";
+  ASSERT_THAT(__llvm_libc::strtoll(base_eight_with_prefix, &str_end, 0),
+              Succeeds(012345));
+  EXPECT_EQ(str_end - base_eight_with_prefix, 6l);
+}