[libc] add inttypes header

[michaelrj]

Summary

Add inttypes.h to llvm libc. As its first functions strtoimax and
strtoumax are included.

[sivachandra]

OK after adding new line at the end of some of the files.

[michaelrj]

add newline at the end of files

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.string.strnlen
     libc.src.string.strpbrk
     libc.src.string.strrchr
     libc.src.string.strspn
     libc.src.string.strstr
     libc.src.string.strtok
     libc.src.string.strtok_r
 
+    # inttypes.h entrypoints
+    libc.src.inttypes.strtoimax
+    libc.src.inttypes.strtoumax
+
     # stdlib.h entrypoints
     libc.src.stdlib.atoi
     libc.src.stdlib.atol
     libc.src.stdlib.atoll
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull

libc/config/linux/aarch64/headers.txt

 set(TARGET_PUBLIC_HEADERS
     libc.include.ctype
     libc.include.errno
     libc.include.fenv
+    libc.include.inttypes
     libc.include.math
     libc.include.stdlib
     libc.include.string
 )

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.string.strnlen
     libc.src.string.strpbrk
     libc.src.string.strrchr
     libc.src.string.strspn
     libc.src.string.strstr
     libc.src.string.strtok
     libc.src.string.strtok_r
 
+    # inttypes.h entrypoints
+    libc.src.inttypes.strtoimax
+    libc.src.inttypes.strtoumax
+
     # stdlib.h entrypoints
     libc.src.stdlib.atoi
     libc.src.stdlib.atol
     libc.src.stdlib.atoll
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull

libc/config/linux/x86_64/headers.txt

 set(TARGET_PUBLIC_HEADERS
     libc.include.assert_h
     libc.include.ctype
     libc.include.errno
+    libc.include.inttypes
     libc.include.math
     libc.include.signal
     libc.include.stdio
     libc.include.stdlib
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.include.threads
     libc.include.time
     libc.include.unistd
 )

libc/config/windows/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.string.strnlen
     libc.src.string.strpbrk
     libc.src.string.strrchr
     libc.src.string.strspn
     libc.src.string.strstr
     libc.src.string.strtok
     libc.src.string.strtok_r
 
+    # inttypes.h entrypoints
+    libc.src.inttypes.strtoimax
+    libc.src.inttypes.strtoumax
+
     # stdlib.h entrypoints
     libc.src.stdlib.atoi
     libc.src.stdlib.atol
     libc.src.stdlib.atoll
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull

libc/include/CMakeLists.txt

add_gen_header(
   fenv
   DEF_FILE fenv.h.def
   GEN_HDR fenv.h
   DEPENDS
     .llvm_libc_common_h
 )
 
 add_gen_header(
+  inttypes
+  DEF_FILE inttypes.h.def
+  GEN_HDR inttypes.h
+  DEPENDS
+    .llvm_libc_common_h
+)
+
+add_gen_header(
   math
   DEF_FILE math.h.def
   GEN_HDR math.h
   DEPENDS
     .llvm_libc_common_h
     .stdc_types
 )
 

libc/include/inttypes.h.def

+//===-- C standard library header inttypes.h ------------------------------===//
+//
+// 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_INTTYPES_H
+#define LLVM_LIBC_INTTYPES_H
+
+#include <__llvm-libc-common.h>
+#include <stdint.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_INTTYPES_H

libc/spec/spec.td

 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
 def ConstVoidPtr : ConstType<VoidPtr>;
 def SizeTType : NamedType<"size_t">;
 def LongDoublePtr : PtrType<LongDoubleType>;
 
+def IntMaxTType : NamedType<"intmax_t">;
+def UIntMaxTType : NamedType<"uintmax_t">;
+
 // _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>;

libc/spec/stdc.td

HeaderSpec StdLib = HeaderSpec<
           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 IntTypes = HeaderSpec<
+      "inttypes.h",
+      [], // Macros
+      [], // Types
+      [], // Enumerations
+      [
+          FunctionSpec<"imaxabs", RetValSpec<IntMaxTType>, [ArgSpec<IntMaxTType>]>,
+          FunctionSpec<"imaxdiv", RetValSpec<IntMaxTType>, [ArgSpec<IntMaxTType>, ArgSpec<IntMaxTType>]>,
+          FunctionSpec<"strtoimax", RetValSpec<IntMaxTType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
+          FunctionSpec<"strtoumax", RetValSpec<UIntMaxTType>, [ArgSpec<ConstCharRestrictedPtr>, ArgSpec<CharRestrictedPtrPtr>, ArgSpec<IntType>]>,
+      ]
+  >;
+
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"errno">,
         Macro<"EDOM">,
         Macro<"EILSEQ">,
         Macro<"ERANGE">,
       ]
let Headers = [
     Assert,
     CType,
     Errno,
     Fenv,
     Math,
     String,
     StdIO,
     StdLib,
+    IntTypes,
     Signal,
     Threads,
     Time,
   ];
 }

libc/src/CMakeLists.txt

 add_subdirectory(__support)
 
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(fenv)
+add_subdirectory(inttypes)
 add_subdirectory(math)
 add_subdirectory(string)
 add_subdirectory(stdlib)
 
 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 add_subdirectory(assert)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 # TODO: Add this target conditional to the target OS.
 add_subdirectory(sys)
 add_subdirectory(threads)
 add_subdirectory(time)
 add_subdirectory(unistd)

libc/src/inttypes/CMakeLists.txt

+add_entrypoint_object(
+  strtoimax
+  SRCS
+    strtoimax.cpp
+  HDRS
+    strtoimax.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)
+
+add_entrypoint_object(
+  strtoumax
+  SRCS
+    strtoumax.cpp
+  HDRS
+    strtoumax.h
+  DEPENDS
+    libc.src.__support.str_conv_utils
+)

libc/src/inttypes/strtoimax.h

+//===-- Implementation header for strtoimax ---------------------*- 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_INTTYPES_STRTOIMAX_H
+#define LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+
+intmax_t strtoimax(const char *__restrict str, char **__restrict str_end,
+                   int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H

libc/src/inttypes/strtoimax.cpp

+//===-- Implementation of strtoimax ---------------------------------------===//
+//
+// 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/inttypes/strtoimax.h"
+#include "src/__support/common.h"
+#include "src/__support/str_conv_utils.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(intmax_t, strtoimax,
+                   (const char *__restrict str, char **__restrict str_end,
+                    int base)) {
+  return internal::strtointeger<intmax_t>(str, str_end, base);
+}
+
+} // namespace __llvm_libc

libc/src/inttypes/strtoumax.h

+//===-- Implementation header for strtoumax ---------------------*- 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_INTTYPES_STRTOUMAX_H
+#define LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+
+uintmax_t strtoumax(const char *__restrict str, char **__restrict str_end,
+                    int base);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H

libc/src/inttypes/strtoumax.cpp

+//===-- Implementation of strtoumax ---------------------------------------===//
+//
+// 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/inttypes/strtoumax.h"
+#include "src/__support/common.h"
+#include "src/__support/str_conv_utils.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(uintmax_t, strtoumax,
+                   (const char *__restrict str, char **__restrict str_end,
+                    int base)) {
+  return internal::strtointeger<uintmax_t>(str, str_end, base);
+}
+
+} // namespace __llvm_libc

libc/test/src/CMakeLists.txt

function(add_fp_unittest name)
   endif()
   target_link_libraries(${fq_target_name} PRIVATE LibcFPTestHelpers)
 endfunction(add_fp_unittest)
 
 add_subdirectory(__support)
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(fenv)
+add_subdirectory(inttypes)
 add_subdirectory(math)
 add_subdirectory(string)
 add_subdirectory(stdlib)
 
 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 

libc/test/src/inttypes/CMakeLists.txt

+add_libc_testsuite(libc_inttypes_unittests)
+
+add_libc_unittest(
+  strtoimax_test
+  SUITE
+    libc_inttypes_unittests
+  SRCS
+    strtoimax_test.cpp
+  DEPENDS
+    libc.src.inttypes.strtoimax
+)
+
+add_libc_unittest(
+  strtoumax_test
+  SUITE
+    libc_inttypes_unittests
+  SRCS
+    strtoumax_test.cpp
+  DEPENDS
+    libc.src.inttypes.strtoumax
+)

libc/test/src/inttypes/strtoimax_test.cpp

+//===-- Unittests for strtoimax -------------------------------------------===//
+//
+// 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/inttypes/strtoimax.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+
+// strtoimax is equivalent to strtoll on all currently supported configurations.
+// Thus to avoid duplicating code there is just one test to make sure that
+// strtoimax works at all. For real tests see stdlib/strtoll_test.cpp.
+
+TEST(LlvmLibcStrToIMaxTest, SimpleCheck) {
+  const char *ten = "10";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoimax(ten, nullptr, 10), intmax_t(10));
+  ASSERT_EQ(errno, 0);
+}

libc/test/src/inttypes/strtoumax_test.cpp

+//===-- Unittests for strtoumax -------------------------------------------===//
+//
+// 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/inttypes/strtoumax.h"
+
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+
+// strtoumax is equivalent to strtoull on all currently supported
+// configurations. Thus to avoid duplicating code there is just one test to make
+// sure that strtoumax works at all. For real tests see
+// stdlib/strtoull_test.cpp.
+
+TEST(LlvmLibcStrToUMaxTest, SimpleCheck) {
+  const char *ten = "10";
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::strtoumax(ten, nullptr, 10), uintmax_t(10));
+  ASSERT_EQ(errno, 0);
+}