Use explicit type for size_t on musl

[lyssdod]

Summary

This fixes build on musl for 12.0.0 release

[lyssdod]

Fixed includes order

[pcc]

I suspect the real issue is that we're missing #include <stddef.h> at the top of this file. What happens if you add that and don't std qualify everything?

compiler-rt/lib/fuzzer/FuzzerInterceptors.cpp

 // Intercept certain libc functions to aid fuzzing.
 // Linked only when other RTs that define their own interceptors are not linked.
 //===----------------------------------------------------------------------===//
-
+#include <cstddef>
 #include "FuzzerPlatform.h"
 
 #if LIBFUZZER_LINUX

 }
 
 static int internal_strcmp_strncmp(const char *s1, const char *s2, bool strncmp,
-                                   size_t n) {
-  size_t i = 0;
+                                   std::size_t n) {
+  std::size_t i = 0;
   while (true) {
     if (strncmp) {
       if (i == n)

   return 0;
 }
 
-static int internal_strncmp(const char *s1, const char *s2, size_t n) {
+static int internal_strncmp(const char *s1, const char *s2, std::size_t n) {
   return internal_strcmp_strncmp(s1, s2, true, n);
 }
 

   return internal_strcmp_strncmp(s1, s2, false, 0);
 }
 
-static int internal_memcmp(const void *s1, const void *s2, size_t n) {
+static int internal_memcmp(const void *s1, const void *s2, std::size_t n) {
   const uint8_t *t1 = static_cast<const uint8_t *>(s1);
   const uint8_t *t2 = static_cast<const uint8_t *>(s2);
-  for (size_t i = 0; i < n; ++i, ++t1, ++t2)
+  for (std::size_t i = 0; i < n; ++i, ++t1, ++t2)
     if (*t1 != *t2)
       return *t1 < *t2 ? -1 : 1;
   return 0;
 }
 
-static size_t internal_strlen(const char *s) {
-  size_t i = 0;
+static std::size_t internal_strlen(const char *s) {
+  std::size_t i = 0;
   while (s[i])
     i++;
   return i;

 
 static char *internal_strstr(const char *haystack, const char *needle) {
   // This is O(N^2), but we are not using it in hot places.
-  size_t len1 = internal_strlen(haystack);
-  size_t len2 = internal_strlen(needle);
+  std::size_t len1 = internal_strlen(haystack);
+  std::size_t len2 = internal_strlen(needle);
   if (len1 < len2)
     return nullptr;
-  for (size_t pos = 0; pos <= len1 - len2; pos++) {
+  for (std::size_t pos = 0; pos <= len1 - len2; pos++) {
     if (internal_memcmp(haystack + pos, needle, len2) == 0)
       return const_cast<char *>(haystack) + pos;
   }

 // Weak hooks forward-declared to avoid dependency on
 // <sanitizer/common_interface_defs.h>.
 void __sanitizer_weak_hook_memcmp(void *called_pc, const void *s1,
-                                  const void *s2, size_t n, int result);
+                                  const void *s2, std::size_t n, int result);
 void __sanitizer_weak_hook_strncmp(void *called_pc, const char *s1,
-                                   const char *s2, size_t n, int result);
+                                   const char *s2, std::size_t n, int result);
 void __sanitizer_weak_hook_strncasecmp(void *called_pc, const char *s1,
-                                       const char *s2, size_t n, int result);
+                                       const char *s2, std::size_t n, int result);
 void __sanitizer_weak_hook_strcmp(void *called_pc, const char *s1,
                                   const char *s2, int result);
 void __sanitizer_weak_hook_strcasecmp(void *called_pc, const char *s1,

                                   const char *s2, char *result);
 void __sanitizer_weak_hook_strcasestr(void *called_pc, const char *s1,
                                       const char *s2, char *result);
-void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1,
-                                  const void *s2, size_t len2, void *result);
+void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, std::size_t len1,
+                                  const void *s2, std::size_t len2, void *result);
 
-DEFINE_REAL(int, bcmp, const void *, const void *, size_t)
-DEFINE_REAL(int, memcmp, const void *, const void *, size_t)
-DEFINE_REAL(int, strncmp, const char *, const char *, size_t)
+DEFINE_REAL(int, bcmp, const void *, const void *, std::size_t)
+DEFINE_REAL(int, memcmp, const void *, const void *, std::size_t)
+DEFINE_REAL(int, strncmp, const char *, const char *, std::size_t)
 DEFINE_REAL(int, strcmp, const char *, const char *)
-DEFINE_REAL(int, strncasecmp, const char *, const char *, size_t)
+DEFINE_REAL(int, strncasecmp, const char *, const char *, std::size_t)
 DEFINE_REAL(int, strcasecmp, const char *, const char *)
 DEFINE_REAL(char *, strstr, const char *, const char *)
 DEFINE_REAL(char *, strcasestr, const char *, const char *)
-DEFINE_REAL(void *, memmem, const void *, size_t, const void *, size_t)
+DEFINE_REAL(void *, memmem, const void *, std::size_t, const void *, std::size_t)
 
-ATTRIBUTE_INTERFACE int bcmp(const char *s1, const char *s2, size_t n) {
+ATTRIBUTE_INTERFACE int bcmp(const char *s1, const char *s2, std::size_t n) {
   if (!FuzzerInited)
     return internal_memcmp(s1, s2, n);
   int result = REAL(bcmp)(s1, s2, n);

   return result;
 }
 
-ATTRIBUTE_INTERFACE int memcmp(const void *s1, const void *s2, size_t n) {
+ATTRIBUTE_INTERFACE int memcmp(const void *s1, const void *s2, std::size_t n) {
   if (!FuzzerInited)
     return internal_memcmp(s1, s2, n);
   int result = REAL(memcmp)(s1, s2, n);

   return result;
 }
 
-ATTRIBUTE_INTERFACE int strncmp(const char *s1, const char *s2, size_t n) {
+ATTRIBUTE_INTERFACE int strncmp(const char *s1, const char *s2, std::size_t n) {
   if (!FuzzerInited)
     return internal_strncmp(s1, s2, n);
   int result = REAL(strncmp)(s1, s2, n);

   return result;
 }
 
-ATTRIBUTE_INTERFACE int strncasecmp(const char *s1, const char *s2, size_t n) {
+ATTRIBUTE_INTERFACE int strncasecmp(const char *s1, const char *s2, std::size_t n) {
   ensureFuzzerInited();
   int result = REAL(strncasecmp)(s1, s2, n);
   __sanitizer_weak_hook_strncasecmp(GET_CALLER_PC(), s1, s2, n, result);

 }
 
 ATTRIBUTE_INTERFACE
-void *memmem(const void *s1, size_t len1, const void *s2, size_t len2) {
+void *memmem(const void *s1, std::size_t len1, const void *s2, std::size_t len2) {
   ensureFuzzerInited();
   void *result = REAL(memmem)(s1, len1, s2, len2);
   __sanitizer_weak_hook_memmem(GET_CALLER_PC(), s1, len1, s2, len2, result);