[llvm-branch-commits] [libc] Make find_first_character_impl return const void* (PR #244468)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Thu Nov 19 17:06:50 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-libc

Author: Aiden Grossman (boomanaiden154)

<details>
<summary>Changes</summary>

This means we only have to const_cast in one place instead of in all the
implementations and I find const_cast annoying.

Assisted-By: LLM


---
Full diff: https://github.com/llvm/llvm-project/pull/244468.diff


5 Files Affected:

- (modified) libc/src/string/memory_utils/generic/inline_strlen.h (+3-3) 
- (modified) libc/src/string/memory_utils/x86_64/inline_strlen.h (+7-7) 
- (modified) libc/src/string/string_length.h (+7-7) 
- (modified) libc/src/string/string_utils.h (+1-1) 
- (modified) libc/test/src/strings/wide_read_memory_test.cpp (+4-4) 


``````````diff
diff --git a/libc/src/string/memory_utils/generic/inline_strlen.h b/libc/src/string/memory_utils/generic/inline_strlen.h
index 9df55b16ba940c..3e67f8373451a5 100644
--- a/libc/src/string/memory_utils/generic/inline_strlen.h
+++ b/libc/src/string/memory_utils/generic/inline_strlen.h
@@ -47,15 +47,15 @@ LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE size_t string_length(const char *src) {
   }
 }
 
-LIBC_INLINE static void *calculate_find_first_character_return(
+LIBC_INLINE static const void *calculate_find_first_character_return(
     const char *src, cpp::simd_mask<char> c_mask, size_t n_left) {
   size_t c_offset = cpp::find_first_set(c_mask);
   if (n_left <= c_offset)
     return nullptr;
-  return const_cast<char *>(src) + c_offset;
+  return src + c_offset;
 }
 
-LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE static void *
+LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE static const void *
 find_first_character(const unsigned char *s, unsigned char c, size_t n) {
   // s doesn't have to be dereferenceable if there is nothing to search.
   if (n == 0)
diff --git a/libc/src/string/memory_utils/x86_64/inline_strlen.h b/libc/src/string/memory_utils/x86_64/inline_strlen.h
index 35508f6e7ed3d5..ee2c0ce3039998 100644
--- a/libc/src/string/memory_utils/x86_64/inline_strlen.h
+++ b/libc/src/string/memory_utils/x86_64/inline_strlen.h
@@ -46,18 +46,18 @@ string_length_vector(const char *src) {
 }
 
 template <typename Mask>
-LIBC_INLINE static void *
+LIBC_INLINE static const void *
 calculate_find_first_character_return(const unsigned char *src, Mask c_mask,
                                       size_t n_left) {
   size_t c_offset = cpp::countr_zero(c_mask);
   if (n_left <= c_offset)
     return nullptr;
-  return const_cast<unsigned char *>(src) + c_offset;
+  return src + c_offset;
 }
 
 template <typename Vector, typename Mask,
           Mask (*CompareAndMask)(const Vector *, char)>
-LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE static void *
+LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE static const void *
 find_first_character_vector(const unsigned char *s, unsigned char c, size_t n) {
   // s doesn't have to be dereferenceable if there is nothing to search.
   if (n == 0)
@@ -100,7 +100,7 @@ namespace sse2 {
                               compare_and_mask<__m128i, uint32_t>>(src);
 }
 
-[[maybe_unused]] LIBC_INLINE void *
+[[maybe_unused]] LIBC_INLINE const void *
 find_first_character(const unsigned char *s, unsigned char c, size_t n) {
   return find_first_character_vector<__m128i, uint32_t,
                                      compare_and_mask<__m128i, uint32_t>>(s, c,
@@ -125,7 +125,7 @@ namespace avx2 {
                               compare_and_mask<__m256i, uint32_t>>(src);
 }
 
-[[maybe_unused]] LIBC_INLINE void *
+[[maybe_unused]] LIBC_INLINE const void *
 find_first_character(const unsigned char *s, unsigned char c, size_t n) {
   return find_first_character_vector<__m256i, uint32_t,
                                      compare_and_mask<__m256i, uint32_t>>(s, c,
@@ -149,7 +149,7 @@ namespace avx512 {
                               compare_and_mask<__m512i, __mmask64>>(src);
 }
 
-[[maybe_unused]] LIBC_INLINE void *
+[[maybe_unused]] LIBC_INLINE const void *
 find_first_character(const unsigned char *s, unsigned char c, size_t n) {
   return find_first_character_vector<__m512i, __mmask64,
                                      compare_and_mask<__m512i, __mmask64>>(s, c,
@@ -173,7 +173,7 @@ find_first_character(const unsigned char *s, unsigned char c, size_t n) {
 #endif
 }
 
-[[maybe_unused]] LIBC_INLINE void *
+[[maybe_unused]] LIBC_INLINE const void *
 find_first_character(const unsigned char *s, unsigned char c, size_t n) {
 #if defined(__AVX512F__)
   return avx512::find_first_character(s, c, n);
diff --git a/libc/src/string/string_length.h b/libc/src/string/string_length.h
index 8e9aa6bb5bc6d2..21376e04b439c9 100644
--- a/libc/src/string/string_length.h
+++ b/libc/src/string/string_length.h
@@ -66,11 +66,11 @@ template <typename T> LIBC_INLINE size_t string_length_element(const T *src) {
   return length;
 }
 
-LIBC_INLINE void *find_first_character(const unsigned char *src,
-                                       unsigned char ch, size_t n) {
+LIBC_INLINE const void *find_first_character(const unsigned char *src,
+                                             unsigned char ch, size_t n) {
   for (; n && *src != ch; --n, ++src)
     ;
-  return n ? const_cast<unsigned char *>(src) : nullptr;
+  return n ? src : nullptr;
 }
 } // namespace element
 
@@ -139,7 +139,7 @@ LIBC_INLINE size_t string_length(const char *src) {
   return static_cast<size_t>(char_ptr - src);
 }
 
-LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE void *
+LIBC_NO_SANITIZE_OOB_ACCESS LIBC_INLINE const void *
 find_first_character(const unsigned char *src, unsigned char ch,
                      size_t max_strlen = cpp::numeric_limits<size_t>::max()) {
   using Word = unsigned int;
@@ -160,7 +160,7 @@ find_first_character(const unsigned char *src, unsigned char ch,
   for (; cur < n && reinterpret_cast<uintptr_t>(char_ptr) % sizeof(Word) != 0;
        ++cur, ++char_ptr) {
     if (*char_ptr == ch)
-      return const_cast<unsigned char *>(char_ptr);
+      return char_ptr;
   }
 
   const Word ch_mask = repeat_byte<Word>(ch);
@@ -178,9 +178,9 @@ find_first_character(const unsigned char *src, unsigned char ch,
   }
 
   if (cur >= n || *char_ptr != ch)
-    return static_cast<void *>(nullptr);
+    return nullptr;
 
-  return const_cast<unsigned char *>(char_ptr);
+  return char_ptr;
 }
 
 } // namespace word
diff --git a/libc/src/string/string_utils.h b/libc/src/string/string_utils.h
index 5e9e9ec20f77cd..641b4fa375e67f 100644
--- a/libc/src/string/string_utils.h
+++ b/libc/src/string/string_utils.h
@@ -127,7 +127,7 @@ LIBC_INLINE constexpr static char *strrchr_implementation(const char *src,
 // 'src'. If 'ch' is not found, returns nullptr.
 LIBC_INLINE void *find_first_character(const unsigned char *src,
                                        unsigned char ch, size_t max_strlen) {
-  return find_first_character_impl(src, ch, max_strlen);
+  return const_cast<void *>(find_first_character_impl(src, ch, max_strlen));
 }
 
 LIBC_INLINE size_t strnlen(const char *s, size_t max_len) {
diff --git a/libc/test/src/strings/wide_read_memory_test.cpp b/libc/test/src/strings/wide_read_memory_test.cpp
index 01c29f22bed5d0..64c0f86b716600 100644
--- a/libc/test/src/strings/wide_read_memory_test.cpp
+++ b/libc/test/src/strings/wide_read_memory_test.cpp
@@ -104,8 +104,8 @@ TEST_F(LlvmLibcWideAccessMemoryTest, FindFirstCharZeroLength) {
   // All implementations, since the configured one is usually not vectorized.
   // Other architectures should be added to this list when they get a
   // target-specific find_first_character implementation.
-  static constexpr void *(*kImpls[])(const unsigned char *, unsigned char,
-                                     size_t) = {
+  static constexpr const void *(*kImpls[])(const unsigned char *, unsigned char,
+                                           size_t) = {
       internal::element::find_first_character,
       internal::word::find_first_character,
 #if LIBC_HAS_VECTOR_TYPE
@@ -147,8 +147,8 @@ TEST_F(LlvmLibcWideAccessMemoryTest, FindFirstCharAfterRange) {
   // All implementations, since the configured one is usually not vectorized.
   // Other architectures should be added to this list when they get a
   // target-specific find_first_character implementation.
-  static constexpr void *(*kImpls[])(const unsigned char *, unsigned char,
-                                     size_t) = {
+  static constexpr const void *(*kImpls[])(const unsigned char *, unsigned char,
+                                           size_t) = {
       internal::element::find_first_character,
       internal::word::find_first_character,
 #if LIBC_HAS_VECTOR_TYPE

``````````

</details>


https://github.com/llvm/llvm-project/pull/244468


More information about the llvm-branch-commits mailing list