[libc] Add explicit casts for string functions

[abrachet]

Summary

This fixes warnings from -Wimplicit-int-conversion

[michaelrj]

LGTM

[gchatelet]

LGTM thx

libc/src/string/memchr.cpp

 #include "src/__support/common.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 // TODO: Look at performance benefits of comparing words.
 LLVM_LIBC_FUNCTION(void *, memchr, (const void *src, int c, size_t n)) {
   return internal::find_first_character(
-      reinterpret_cast<const unsigned char *>(src), c, n);
+      reinterpret_cast<const unsigned char *>(src),
+      static_cast<unsigned char>(c), n);
 }
 
 } // namespace __llvm_libc

libc/src/string/memory_utils/elements_x86.h

template <typename Base> struct Vector : public Base {
   }
 };
 
 struct M128 {
   static constexpr size_t SIZE = 16;
   using T = char __attribute__((__vector_size__(SIZE)));
   static uint16_t mask(T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm_movemask_epi8(__llvm_libc::bit_cast<__m128i>(value));
+    return static_cast<uint16_t>(
+        _mm_movemask_epi8(__llvm_libc::bit_cast<__m128i>(value)));
   }
   static uint16_t not_equal_mask(T a, T b) { return mask(a != b); }
   static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return __llvm_libc::bit_cast<T>(
         _mm_loadu_si128(reinterpret_cast<__m128i_u const *>(ptr)));
   }
   static void store(char *ptr, T value) {

libc/src/string/memrchr.cpp

 //===-- Implementation of memrchr -----------------------------------------===//
 //
 // 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/string/memrchr.h"
 #include "src/__support/common.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memrchr, (const void *src, int c, size_t n)) {
   const unsigned char *str = reinterpret_cast<const unsigned char *>(src);
-  const unsigned char ch = c;
+  const unsigned char ch = static_cast<unsigned char>(c);
   for (; n != 0; --n) {
     const unsigned char *s = str + n - 1;
     if (*s == ch)
       return const_cast<unsigned char *>(s);
   }
   return nullptr;
 }
 
 } // namespace __llvm_libc

libc/src/string/strchr.cpp

 //===-- Implementation of strchr ------------------------------------------===//
 //
 // 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/string/strchr.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // TODO: Look at performance benefits of comparing words.
 LLVM_LIBC_FUNCTION(char *, strchr, (const char *src, int c)) {
-  const char ch = c;
+  const char ch = static_cast<char>(c);
   for (; *src && *src != ch; ++src)
     ;
   return *src == ch ? const_cast<char *>(src) : nullptr;
 }
 
 } // namespace __llvm_libc

libc/src/string/strrchr.cpp

 //===-- Implementation of strrchr------------------------------------------===//
 //
 // 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/string/strrchr.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strrchr, (const char *src, int c)) {
-  const char ch = c;
+  const char ch = static_cast<char>(c);
   char *last_occurrence = nullptr;
   for (; *src; ++src) {
     if (*src == ch)
       last_occurrence = const_cast<char *>(src);
   }
   return last_occurrence;
 }
 
 } // namespace __llvm_libc