[libc][NFC] make atoi undefined cases match std

[michaelrj]

Summary

The standard describes atoi as:

"equivalent to atoi: (int)strtol(nptr, (char **)NULL, 10)"

Previously, our behavior was slightly different on numbers larger than
INT_MAX, but this patch changes it to just do the cast instead. Both of
these are valid since the standard says

"If the value of the result cannot be represented, the
behavior is undefined."

But matching existing behavior makes differential fuzzing easier.

[sivachandra]

libc/test/src/stdlib/AtoiTest.h

68

Nit: Make this conditional more explicit:

cpp::is_same_v<ReturnT, int> && sizeof(ReturnT) < sizeof(long)

69

Nit: I think this assume int to be 4 bytes wide so add: static_assert(sizeof(int) == 4).

[michaelrj]

address comments and rebase before landing

libc/src/stdlib/atoi.cpp

 //===-- Implementation of atoi --------------------------------------------===//
 //
 // 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/atoi.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, atoi, (const char *str)) {
-  auto result = internal::strtointeger<int>(str, 10);
+  // This is done because the standard specifies that atoi is identical to
+  // (int)(strtol).
+  auto result = internal::strtointeger<long>(str, 10);
   if (result.has_error())
     errno = result.error;
 
-  return result;
+  return static_cast<int>(result);
 }
 
 } // namespace __llvm_libc

libc/test/src/stdlib/AtoiTest.h

 //===-- A template class for testing ato* functions -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/type_traits.h"
 #include "utils/UnitTest/Test.h"
 
 #include <limits.h>
 
+using __llvm_libc::cpp::is_same_v;
+
 template <typename ReturnT> struct AtoTest : public __llvm_libc::testing::Test {
   using FunctionT = ReturnT (*)(const char *);
 
   void validNumbers(FunctionT func) {
     const char *zero = "0";
     ASSERT_EQ(func(zero), static_cast<ReturnT>(0));
 
     const char *ten = "10";
void validNumbers(FunctionT func) {
 
     if constexpr (sizeof(ReturnT) >= 8) {
       const char *biggest_long_long = "9223372036854775807";
       ASSERT_EQ(func(biggest_long_long), static_cast<ReturnT>(LLONG_MAX));
 
       const char *smallest_long_long = "-9223372036854775808";
       ASSERT_EQ(func(smallest_long_long), static_cast<ReturnT>(LLONG_MIN));
     }
+
+    // If this is atoi and the size of int is less than the size of long, then
+    // we parse as long and cast to int to match existing behavior. This only
+    // matters for cases where the result would be outside of the int range, and
+    // those cases are undefined, so we can choose whatever output value we
+    // want. In this case we have chosen to cast since that matches existing
+    // implementations and makes differential fuzzing easier, but no user should
+    // rely on this behavior.
+    if constexpr (is_same_v<ReturnT, int> && sizeof(ReturnT) < sizeof(long)) {
+
+      static_assert(sizeof(int) == 4);
+
+      const char *bigger_than_biggest_int = "2147483649";
+      ASSERT_EQ(func(bigger_than_biggest_int),
+                static_cast<ReturnT>(2147483649));
+
+      const char *smaller_than_smallest_int = "-2147483649";
+      ASSERT_EQ(func(smaller_than_smallest_int),
+                static_cast<ReturnT>(-2147483649));
+    }
   }
 
   void nonBaseTenWholeNumbers(FunctionT func) {
     const char *hexadecimal = "0x10";
     ASSERT_EQ(func(hexadecimal), static_cast<ReturnT>(0));
 
     const char *octal = "010";
     ASSERT_EQ(func(octal), static_cast<ReturnT>(10));