[libc] clean up ctype negative handling

[michaelrj]

Summary

The ctype functions will sometimes be passed negative numbers, such as
EOF. Some of the previous implementations didn't handle these properly.
Additionally, the tests did not check any negative numbers. These
problems have been fixed.

This patch fixes https://github.com/llvm/llvm-project/issues/62000

[rillig]

The implementation of the <ctype.h> functions only needs to accept EOF or a value representable as unsigned char. Testing the functions with other negative numbers may invoke undefined behavior, as the implementation need not handle these numbers. Therefore, the words "such as" from the commit message sound misleading to me.

libc/src/ctype/isblank.cpp

 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // TODO: Currently restricted to default locale.
 // These should be extended using locale information.
 LLVM_LIBC_FUNCTION(int, isblank, (int c)) {
-  const unsigned char ch = static_cast<unsigned char>(c);
-  return static_cast<int>(ch == ' ' || ch == '\t');
+  return static_cast<int>(c == ' ' || c == '\t');
 }
 
 } // namespace __llvm_libc

libc/src/ctype/iscntrl.cpp

 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // TODO: Currently restricted to default locale.
 // These should be extended using locale information.
 LLVM_LIBC_FUNCTION(int, iscntrl, (int c)) {
-  const unsigned char ch = static_cast<unsigned char>(c);
+  const unsigned ch = static_cast<unsigned>(c);
   return static_cast<int>(ch < 0x20 || ch == 0x7f);
 }
 
 } // namespace __llvm_libc

libc/test/src/ctype/CMakeLists.txt

 add_libc_testsuite(libc_ctype_unittests)
 
 add_libc_unittest(
-  isalnum
+  isalnum_test
   SUITE
     libc_ctype_unittests
   SRCS
     isalnum_test.cpp
   DEPENDS
     libc.src.ctype.isalnum
 )
 
 add_libc_unittest(
-  isalpha
+  isalpha_test
   SUITE
     libc_ctype_unittests
   SRCS
     isalpha_test.cpp
   DEPENDS
     libc.src.ctype.isalpha
 )
 
 add_libc_unittest(
-  isascii
+  isascii_test
   SUITE
     libc_ctype_unittests
   SRCS
     isascii_test.cpp
   DEPENDS
     libc.src.ctype.isascii
 )
 
 add_libc_unittest(
-  isblank
+  isblank_test
   SUITE
     libc_ctype_unittests
   SRCS
     isblank_test.cpp
   DEPENDS
     libc.src.ctype.isblank
 )
 
 add_libc_unittest(
-  iscntrl
+  iscntrl_test
   SUITE
     libc_ctype_unittests
   SRCS
     iscntrl_test.cpp
   DEPENDS
     libc.src.ctype.iscntrl
 )
 
 add_libc_unittest(
-  isdigit
+  isdigit_test
   SUITE
     libc_ctype_unittests
   SRCS
     isdigit_test.cpp
   DEPENDS
     libc.src.ctype.isdigit
 )
 
 add_libc_unittest(
-  isgraph
+  isgraph_test
   SUITE
     libc_ctype_unittests
   SRCS
     isgraph_test.cpp
   DEPENDS
     libc.src.ctype.isgraph
 )
 
 add_libc_unittest(
-  islower
+  islower_test
   SUITE
     libc_ctype_unittests
   SRCS
     islower_test.cpp
   DEPENDS
     libc.src.ctype.islower
 )
 
 add_libc_unittest(
-  isprint
+  isprint_test
   SUITE
     libc_ctype_unittests
   SRCS
     isprint_test.cpp
   DEPENDS
     libc.src.ctype.isprint
 )
 
 add_libc_unittest(
-  ispunct
+  ispunct_test
   SUITE
     libc_ctype_unittests
   SRCS
     ispunct_test.cpp
   DEPENDS
     libc.src.ctype.ispunct
 )
 
 add_libc_unittest(
-  isspace
+  isspace_test
   SUITE
     libc_ctype_unittests
   SRCS
     isspace_test.cpp
   DEPENDS
     libc.src.ctype.isspace
 )
 
 add_libc_unittest(
-  isupper
+  isupper_test
   SUITE
     libc_ctype_unittests
   SRCS
     isupper_test.cpp
   DEPENDS
     libc.src.ctype.isupper
 )
 
 add_libc_unittest(
-  isxdigit
+  isxdigit_test
   SUITE
     libc_ctype_unittests
   SRCS
     isxdigit_test.cpp
   DEPENDS
     libc.src.ctype.isxdigit
 )
 
 add_libc_unittest(
-  toascii
+  toascii_test
   SUITE
     libc_ctype_unittests
   SRCS
     toascii_test.cpp
   DEPENDS
     libc.src.ctype.toascii
 )
 
 add_libc_unittest(
-  tolower
+  tolower_test
   SUITE
     libc_ctype_unittests
   SRCS
     tolower_test.cpp
   DEPENDS
     libc.src.ctype.tolower
 )
 
 add_libc_unittest(
-  toupper
+  toupper_test
   SUITE
     libc_ctype_unittests
   SRCS
     toupper_test.cpp
   DEPENDS
     libc.src.ctype.toupper
 )

libc/test/src/ctype/isalnum_test.cpp

 //===-- Unittests for isalnum----------------------------------------------===//
 //
 // 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/ctype/isalnum.h"
 
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsAlNum, DefaultLocale) {
   // Loops through all characters, verifying that numbers and letters
   // return non-zero integer and everything else returns a zero.
-  for (int c = 0; c < 255; ++c) {
+  for (int c = -255; c < 255; ++c) {
     if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') ||
         ('0' <= c && c <= '9'))
       EXPECT_NE(__llvm_libc::isalnum(c), 0);
     else
       EXPECT_EQ(__llvm_libc::isalnum(c), 0);
   }
 }

libc/test/src/ctype/isalpha_test.cpp

 //===-- Unittests for isalpha----------------------------------------------===//
 //
 // 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/ctype/isalpha.h"
 
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsAlpha, DefaultLocale) {
   // Loops through all characters, verifying that letters return a
   // non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z'))
       EXPECT_NE(__llvm_libc::isalpha(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isalpha(ch), 0);
   }
 }

libc/test/src/ctype/isascii_test.cpp

 //===-- Unittests for isascii----------------------------------------------===//
 //
 // 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 "test/UnitTest/Test.h"
 
 #include "src/ctype/isascii.h"
 
 TEST(LlvmLibcIsAscii, DefaultLocale) {
   // Loops through all characters, verifying that ascii characters
   //    (which are all 7 bit unsigned integers)
   // return a non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
-    if (ch <= 0x7f)
+  for (int ch = -255; ch < 255; ++ch) {
+    if (0 <= ch && ch <= 0x7f)
       EXPECT_NE(__llvm_libc::isascii(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isascii(ch), 0);
   }
 }

libc/test/src/ctype/isblank_test.cpp

 //===-- Unittests for isblank----------------------------------------------===//
 //
 // 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/ctype/isblank.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsBlank, DefaultLocale) {
   // Loops through all characters, verifying that space and horizontal tab
   // return a non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (ch == ' ' || ch == '\t')
       EXPECT_NE(__llvm_libc::isblank(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isblank(ch), 0);
   }
 }

libc/test/src/ctype/iscntrl_test.cpp

 //===-- Unittests for iscntrl----------------------------------------------===//
 //
 // 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/ctype/iscntrl.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsCntrl, DefaultLocale) {
   // Loops through all characters, verifying that control characters
   // return a non-zero integer, all others return zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if ((0 <= ch && ch <= 0x1f /*US*/) || ch == 0x7f /*DEL*/)
       EXPECT_NE(__llvm_libc::iscntrl(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::iscntrl(ch), 0);
   }
 }

libc/test/src/ctype/isdigit_test.cpp

 //===-- Unittests for isdigit----------------------------------------------===//
 //
 // 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/ctype/isdigit.h"
 
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsDigit, DefaultLocale) {
   // Loops through all characters, verifying that numbers return a
   // non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if ('0' <= ch && ch <= '9')
       EXPECT_NE(__llvm_libc::isdigit(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isdigit(ch), 0);
   }
 }

libc/test/src/ctype/isgraph_test.cpp

 //===-- Unittests for isgraph----------------------------------------------===//
 //
 // 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/ctype/isgraph.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsGraph, DefaultLocale) {
   // Loops through all characters, verifying that graphical characters
   // return a non-zero integer, everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if ('!' <= ch && ch <= '~') // A-Z, a-z, 0-9, punctuation.
       EXPECT_NE(__llvm_libc::isgraph(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isgraph(ch), 0);
   }
 }

libc/test/src/ctype/islower_test.cpp

 //===-- Unittests for islower----------------------------------------------===//
 //
 // 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/ctype/islower.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsLower, DefaultLocale) {
   // Loops through all characters, verifying that lowercase letters
   // return a non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if ('a' <= ch && ch <= 'z')
       EXPECT_NE(__llvm_libc::islower(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::islower(ch), 0);
   }
 }

libc/test/src/ctype/isprint_test.cpp

 //===-- Unittests for isprint----------------------------------------------===//
 //
 // 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/ctype/isprint.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsPrint, DefaultLocale) {
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (' ' <= ch && ch <= '~') // A-Z, a-z, 0-9, punctuation, space.
       EXPECT_NE(__llvm_libc::isprint(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isprint(ch), 0);
   }
 }

libc/test/src/ctype/ispunct_test.cpp

 static inline int is_punctuation_character(int c) {
   return ('!' <= c && c <= '/') || (':' <= c && c <= '@') ||
          ('[' <= c && c <= '`') || ('{' <= c && c <= '~');
 }
 
 TEST(LlvmLibcIsPunct, DefaultLocale) {
   // Loops through all characters, verifying that punctuation characters
   // return a non-zero integer, and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (is_punctuation_character(ch))
       EXPECT_NE(__llvm_libc::ispunct(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::ispunct(ch), 0);
   }
 }

libc/test/src/ctype/isspace_test.cpp

TEST(LlvmLibcIsSpace, DefaultLocale) {
   // return true and everything else returns false.
   // Hexadecimal | Symbol
   // ---------------------------
   //    0x09     |   horizontal tab
   //    0x0a     |   line feed
   //    0x0b     |   vertical tab
   //    0x0d     |   carriage return
   //    0x20     |   space
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (ch == 0x20 || (0x09 <= ch && ch <= 0x0d))
       EXPECT_NE(__llvm_libc::isspace(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isspace(ch), 0);
   }
 }

libc/test/src/ctype/isupper_test.cpp

 //===-- Unittests for isupper----------------------------------------------===//
 //
 // 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/ctype/isupper.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsUpper, DefaultLocale) {
   // Loops through all characters, verifying that uppercase letters
   // return a non-zero integer and everything else returns zero.
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if ('A' <= ch && ch <= 'Z')
       EXPECT_NE(__llvm_libc::isupper(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isupper(ch), 0);
   }
 }

libc/test/src/ctype/isxdigit_test.cpp

 //===-- Unittests for isxdigit---------------------------------------------===//
 //
 // 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/ctype/isxdigit.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcIsXDigit, DefaultLocale) {
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     if (('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') ||
         ('A' <= ch && ch <= 'F'))
       EXPECT_NE(__llvm_libc::isxdigit(ch), 0);
     else
       EXPECT_EQ(__llvm_libc::isxdigit(ch), 0);
   }
 }

libc/test/src/ctype/toascii_test.cpp

 
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcToAscii, DefaultLocale) {
   // Loops through all characters, verifying that ascii characters
   //    (which are all 7 bit unsigned integers)
   // return themself, and that all other characters return themself
   // mod 128 (which is equivalent to & 0x7f)
-  for (int ch = 0; ch < 255; ++ch) {
-    if (ch <= 0x7f)
+  for (int ch = -255; ch < 255; ++ch) {
+    if (0 <= ch && ch <= 0x7f)
       EXPECT_EQ(__llvm_libc::toascii(ch), ch);
     else
       EXPECT_EQ(__llvm_libc::toascii(ch), ch & 0x7f);
   }
 }

libc/test/src/ctype/tolower_test.cpp

 //===-- Unittests for tolower----------------------------------------------===//
 //
 // 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/ctype/tolower.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcToLower, DefaultLocale) {
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     // This follows pattern 'A' + 32 = 'a'.
     if ('A' <= ch && ch <= 'Z')
       EXPECT_EQ(__llvm_libc::tolower(ch), ch + 32);
     else
       EXPECT_EQ(__llvm_libc::tolower(ch), ch);
   }
 }

libc/test/src/ctype/toupper_test.cpp

 //===-- Unittests for toupper----------------------------------------------===//
 //
 // 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/ctype/toupper.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcToUpper, DefaultLocale) {
-  for (int ch = 0; ch < 255; ++ch) {
+  for (int ch = -255; ch < 255; ++ch) {
     // This follows pattern 'a' - 32 = 'A'.
     if ('a' <= ch && ch <= 'z')
       EXPECT_EQ(__llvm_libc::toupper(ch), ch - 32);
     else
       EXPECT_EQ(__llvm_libc::toupper(ch), ch);
   }
 }