[libc] Add riscv64 config.

[sivachandra]

Summary

Memory functions get the basic implementation. They can be tuned
as a follow up.

libc/cmake/modules/LLVMLibCArchitectures.cmake

elseif(target_arch MATCHES "^arm")
     # `arm` here.
     set(target_arch "arm")
   elseif(target_arch MATCHES "^aarch64")
     set(target_arch "aarch64")
   elseif(target_arch MATCHES "(x86_64)|(AMD64|amd64)|(^i.86$)")
     set(target_arch "x86_64")
   elseif(target_arch MATCHES "^(powerpc|ppc)")
     set(target_arch "power")
+  elseif(target_arch MATCHES "^riscv64")
+    set(target_arch "riscv64")
   else()
     return()
   endif()
 
   set(${arch_var} ${target_arch} PARENT_SCOPE)
   list(GET triple_comps ${system_index} target_sys)
 
   # Correcting OS name for Apple's systems.

 # the libc CMake infrastructure. Also, this is where we also check if the target
 # architecture is currently supported.
 if(LIBC_TARGET_ARCHITECTURE STREQUAL "arm")
   set(LIBC_TARGET_ARCHITECTURE_IS_ARM TRUE)
 elseif(LIBC_TARGET_ARCHITECTURE STREQUAL "aarch64")
   set(LIBC_TARGET_ARCHITECTURE_IS_AARCH64 TRUE)
 elseif(LIBC_TARGET_ARCHITECTURE STREQUAL "x86_64")
   set(LIBC_TARGET_ARCHITECTURE_IS_X86 TRUE)
+elseif(LIBC_TARGET_ARCHITECTURE STREQUAL "riscv64")
+  set(LIBC_TARGET_ARCHITECTURE_IS_RISCV64 TRUE)
 else()
   message(FATAL_ERROR
           "Unsupported libc target architecture ${LIBC_TARGET_ARCHITECTURE}")
 endif()
 
 if(LIBC_TARGET_OS STREQUAL "baremetal")
   set(LIBC_TARGET_OS_IS_BAREMETAL TRUE)
 elseif(LIBC_TARGET_OS STREQUAL "linux")

libc/config/linux/riscv64/entrypoints.txt

+set(TARGET_LIBC_ENTRYPOINTS
+    # ctype.h entrypoints
+    libc.src.ctype.isalnum
+    libc.src.ctype.isalpha
+    libc.src.ctype.isascii
+    libc.src.ctype.isblank
+    libc.src.ctype.iscntrl
+    libc.src.ctype.isdigit
+    libc.src.ctype.isgraph
+    libc.src.ctype.islower
+    libc.src.ctype.isprint
+    libc.src.ctype.ispunct
+    libc.src.ctype.isspace
+    libc.src.ctype.isupper
+    libc.src.ctype.isxdigit
+    libc.src.ctype.toascii
+    libc.src.ctype.tolower
+    libc.src.ctype.toupper
+
+    # errno.h entrypoints
+    libc.src.errno.errno
+
+    # string.h entrypoints
+    libc.src.string.bcmp
+    libc.src.string.bcopy
+    libc.src.string.bzero
+    libc.src.string.memccpy
+    libc.src.string.memchr
+    libc.src.string.memcmp
+    libc.src.string.memcpy
+    libc.src.string.memmove
+    libc.src.string.mempcpy
+    libc.src.string.memrchr
+    libc.src.string.memset
+    libc.src.string.stpcpy
+    libc.src.string.stpncpy
+    libc.src.string.strcasecmp
+    libc.src.string.strcasestr
+    libc.src.string.strcat
+    libc.src.string.strchr
+    libc.src.string.strcmp
+    libc.src.string.strcpy
+    libc.src.string.strcspn
+    libc.src.string.strlcat
+    libc.src.string.strlcpy
+    libc.src.string.strlen
+    libc.src.string.strncasecmp
+    libc.src.string.strncat
+    libc.src.string.strncmp
+    libc.src.string.strncpy
+    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.imaxabs
+    libc.src.inttypes.imaxdiv
+    libc.src.inttypes.strtoimax
+    libc.src.inttypes.strtoumax
+ 
+    # stdlib.h entrypoints
+    libc.src.stdlib.abs
+    libc.src.stdlib.atoi
+    libc.src.stdlib.atof
+    libc.src.stdlib.atol
+    libc.src.stdlib.atoll
+    libc.src.stdlib.bsearch
+    libc.src.stdlib.div
+    libc.src.stdlib.labs
+    libc.src.stdlib.ldiv
+    libc.src.stdlib.llabs
+    libc.src.stdlib.lldiv
+    libc.src.stdlib.qsort
+    libc.src.stdlib.strtod
+    libc.src.stdlib.strtof
+    libc.src.stdlib.strtol
+    libc.src.stdlib.strtold
+    libc.src.stdlib.strtoll
+    libc.src.stdlib.strtoul
+    libc.src.stdlib.strtoull
+)
+
+set(TARGET_LIBM_ENTRYPOINTS
+    # math.h entrypoints
+    libc.src.math.fabs
+    libc.src.math.fabsf
+    libc.src.math.fabsl
+    libc.src.math.fdim
+    libc.src.math.fdimf
+    libc.src.math.fdiml
+    libc.src.math.fmax
+    libc.src.math.fmaxf
+    libc.src.math.fmaxl
+    libc.src.math.fmin
+    libc.src.math.fminf
+    libc.src.math.fminl
+)
+
+set(TARGET_LLVMLIBC_ENTRYPOINTS
+  ${TARGET_LIBC_ENTRYPOINTS}
+  ${TARGET_LIBM_ENTRYPOINTS}
+)

libc/config/linux/riscv64/headers.txt

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

libc/src/string/memory_utils/bcmp_implementations.h

 }
 #endif // defined(LIBC_TARGET_ARCH_IS_AARCH64)
 
 LIBC_INLINE BcmpReturnType inline_bcmp(CPtr p1, CPtr p2, size_t count) {
 #if defined(LIBC_TARGET_ARCH_IS_X86)
   return inline_bcmp_x86(p1, p2, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   return inline_bcmp_aarch64(p1, p2, count);
-#elif defined(LIBC_TARGET_ARCH_IS_ARM)
-  return inline_bcmp_embedded_tiny(p1, p2, count);
-#elif defined(LIBC_TARGET_ARCH_IS_GPU)
-  return inline_bcmp_embedded_tiny(p1, p2, count);
 #else
-#error "Unsupported platform"
+  return inline_bcmp_embedded_tiny(p1, p2, count);
 #endif
 }
 
 LIBC_INLINE int inline_bcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_bcmp(reinterpret_cast<CPtr>(p1),
                                       reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcmp_implementations.h

#if defined(LIBC_TARGET_ARCH_IS_X86)
   else
     return inline_memcmp_generic_gt16(p1, p2, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   if constexpr (aarch64::kNeon)
     return inline_memcmp_aarch64_neon_gt16(p1, p2, count);
   else
     return inline_memcmp_generic_gt16(p1, p2, count);
 #endif
-#elif defined(LIBC_TARGET_ARCH_IS_ARM)
-  return inline_memcmp_embedded_tiny(p1, p2, count);
-#elif defined(LIBC_TARGET_ARCH_IS_GPU)
-  return inline_memcmp_embedded_tiny(p1, p2, count);
 #else
-#error "Unsupported platform"
+  return inline_memcmp_embedded_tiny(p1, p2, count);
 #endif
 }
 
 LIBC_INLINE int inline_memcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_memcmp(reinterpret_cast<CPtr>(p1),
                                         reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcpy_implementations.h

inline_memcpy_embedded_tiny(Ptr __restrict dst, CPtr __restrict src,
   LIBC_LOOP_NOUNROLL
   for (size_t offset = 0; offset < count; ++offset)
     builtin::Memcpy<1>::block(dst + offset, src + offset);
 }
 
 LIBC_INLINE void inline_memcpy(Ptr __restrict dst, CPtr __restrict src,
                                size_t count) {
   using namespace __llvm_libc::builtin;
-#if defined(LIBC_COPT_MEMCPY_USE_EMBEDDED_TINY) ||                             \
-    defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
+#if defined(LIBC_COPT_MEMCPY_USE_EMBEDDED_TINY)
   return inline_memcpy_embedded_tiny(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_X86)
   return inline_memcpy_x86_maybe_interpose_repmovsb(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   return inline_memcpy_aarch64(dst, src, count);
 #else
-#error "Unsupported platform"
+  return inline_memcpy_embedded_tiny(dst, src, count);
 #endif
 }
 
 LIBC_INLINE void inline_memcpy(void *__restrict dst, const void *__restrict src,
                                size_t count) {
   inline_memcpy(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.h

if (dst < src) {
     generic::Memmove<32, kMaxSize>::align_forward<Arg::Src>(dst, src, count);
     return generic::Memmove<64, kMaxSize>::loop_and_tail_forward(dst, src,
                                                                  count);
   } else {
     generic::Memmove<32, kMaxSize>::align_backward<Arg::Src>(dst, src, count);
     return generic::Memmove<64, kMaxSize>::loop_and_tail_backward(dst, src,
                                                                   count);
   }
-#elif defined(LIBC_TARGET_ARCH_IS_ARM)
-  return inline_memmove_embedded_tiny(dst, src, count);
-#elif defined(LIBC_TARGET_ARCH_IS_GPU)
-  return inline_memmove_embedded_tiny(dst, src, count);
 #else
-#error "Unsupported platform"
+  return inline_memmove_embedded_tiny(dst, src, count);
 #endif
 }
 
 LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
   inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src),
                  count);
 }
 
 } // namespace __llvm_libc
 
 #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/memset_implementations.h

#if defined(LIBC_TARGET_ARCH_IS_X86)
   static constexpr size_t kMaxSize = x86::kAvx512F ? 64
                                      : x86::kAvx   ? 32
                                      : x86::kSse2  ? 16
                                                    : 8;
   return inline_memset_x86<kMaxSize>(dst, value, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   static constexpr size_t kMaxSize = aarch64::kNeon ? 16 : 8;
   return inline_memset_aarch64<kMaxSize>(dst, value, count);
-#elif defined(LIBC_TARGET_ARCH_IS_ARM)
-  return inline_memset_embedded_tiny(dst, value, count);
-#elif defined(LIBC_TARGET_ARCH_IS_GPU)
-  return inline_memset_embedded_tiny(dst, value, count);
 #else
-#error "Unsupported platform"
+  return inline_memset_embedded_tiny(dst, value, count);
 #endif
 }
 
 LIBC_INLINE static void inline_memset(void *dst, uint8_t value, size_t count) {
   inline_memset(reinterpret_cast<Ptr>(dst), value, count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H