Compiler Explorer

Source code

#include <immintrin.h>

#include <bit>
#include <cstddef>
#include <cstdint>
#include <type_traits>

#define LIKELY(x) __builtin_expect(!!(x), 1)
#define UNLIKELY(x) __builtin_expect(!!(x), 0)

enum class byte : unsigned char {};

template <bool flag = false>
static void deferred_static_assert(const char *msg) {
  static_assert(flag, "compilation error");
  (void)msg;
}

static constexpr bool is_power2_or_zero(size_t value) {
  return (value & (value - 1U)) == 0;
}

static constexpr bool is_power2(size_t value) {
  return value && is_power2_or_zero(value);
}

static constexpr size_t log2(size_t value) {
  return (value == 0 || value == 1) ? 0 : 1 + log2(value / 2);
}

static constexpr size_t le_power2(size_t value) {
  return value == 0 ? value : 1ULL << log2(value);
}

static constexpr size_t ge_power2(size_t value) {
  return is_power2_or_zero(value) ? value : 1ULL << (log2(value) + 1);
}

template <size_t alignment>
uintptr_t distance_to_align_down(const void *ptr) {
  static_assert(is_power2(alignment), "alignment must be a power of 2");
  return reinterpret_cast<uintptr_t>(ptr) & (alignment - 1U);
}

template <size_t alignment>
uintptr_t distance_to_align_up(const void *ptr) {
  static_assert(is_power2(alignment), "alignment must be a power of 2");

return -reinterpret_cast<uintptr_t>(ptr) & (alignment - 1U);
}

template <size_t alignment>
uintptr_t distance_to_next_aligned(const void *ptr) {
  return alignment - distance_to_align_down<alignment>(ptr);
}

template <size_t alignment, typename T>
static T *assume_aligned(T *ptr) {
  return reinterpret_cast<T *>(__builtin_assume_aligned(ptr, alignment));
}

template <size_t Size>
inline void memcpy_inline(void *__restrict dst, const void *__restrict src) {
  __builtin_memcpy_inline(dst, src, Size);
}

using Ptr = std::byte *;
using CPtr = const std::byte *;

template <typename T>
struct StrictIntegralType {
  static_assert(std::is_integral_v<T>);

template <typename U, std::enable_if_t<std::is_same_v<U, T>, bool> = 0>
  StrictIntegralType(U value) : value(value) {}

explicit operator bool() const { return value; }

StrictIntegralType operator|(const StrictIntegralType &Rhs) const {
    static_assert(!std::is_signed_v<T>);
    return value | Rhs.value;
  }

explicit operator int() const { return std::bit_cast<int>(value); }

inline static constexpr StrictIntegralType ZERO() { return {T(0)}; }

private:
  T value;
};

using MemcmpReturnType = StrictIntegralType<int32_t>;
using BcmpReturnType = StrictIntegralType<uint32_t>;

template <typename T>
inline T load(CPtr ptr) {
  T Out;
  memcpy_inline<sizeof(T)>(&Out, ptr);
  return Out;
}

template <typename T>
inline void store(Ptr ptr, T value) {
  memcpy_inline<sizeof(T)>(ptr, &value);
}

template <typename T1, typename T2>
inline void adjust(ptrdiff_t offset, T1 *__restrict &p1, T2 *__restrict &p2,
                   size_t &count) {
  p1 += offset;
  p2 += offset;
  count -= offset;
}

template <size_t SIZE>
struct AlignHelper {
  AlignHelper(CPtr ptr) : offset_(distance_to_next_aligned<SIZE>(ptr)) {}

inline bool not_aligned() const { return offset_ != SIZE; }
  inline uintptr_t offset() const { return offset_; }

private:
  uintptr_t offset_;
};

static_assert(((18446744073709551615UL) == 4294967295U) ||
                  ((18446744073709551615UL) == 18446744073709551615UL),
              "We currently only support 32- or 64-bit platforms");

template <typename T>
struct is_scalar : std::false_type {};
template <>
struct is_scalar<uint8_t> : std::true_type {};
template <>
struct is_scalar<uint16_t> : std::true_type {};
template <>
struct is_scalar<uint32_t> : std::true_type {};
template <>
struct is_scalar<uint64_t> : std::true_type {};
template <typename T>
constexpr bool is_scalar_v = is_scalar<T>::value;

template <typename T>
struct is_vector : std::false_type {};
template <typename T>
constexpr bool is_vector_v = is_vector<T>::value;

template <typename T>
constexpr bool is_element_type_v = is_scalar_v<T> || is_vector_v<T>;

template <typename T>
inline static T load(CPtr ptr, size_t offset) {
  return load<T>(ptr + offset);
}

template <typename T>
inline static T load_be(CPtr ptr, size_t offset) {
  if constexpr (std::is_same_v<T, uint8_t>) {
    return load<T>(ptr, offset);
  } else if constexpr (std::is_same_v<T, uint16_t>) {
    return __builtin_bswap16(load<T>(ptr, offset));
  } else if constexpr (std::is_same_v<T, uint32_t>) {
    return __builtin_bswap32(load<T>(ptr, offset));
  } else if constexpr (std::is_same_v<T, uint64_t>) {
    return __builtin_bswap64(load<T>(ptr, offset));
  }
}

template <typename T>
static bool eq(CPtr p1, CPtr p2, size_t offset);

template <typename T>
static uint32_t neq(CPtr p1, CPtr p2, size_t offset);

template <typename T>
static MemcmpReturnType cmp(CPtr p1, CPtr p2, size_t offset);

template <typename T>
static MemcmpReturnType cmp_neq(CPtr p1, CPtr p2, size_t offset);

template <typename T>
struct cmp_is_expensive;
template <>
struct cmp_is_expensive<uint8_t> : public std::false_type {};
template <>
struct cmp_is_expensive<uint16_t> : public std::false_type {};
template <>
struct cmp_is_expensive<uint32_t> : public std::false_type {};
template <>
struct cmp_is_expensive<uint64_t> : public std::true_type {};

template <typename T>
struct Memcmp {
  static_assert(is_element_type_v<T>);
  static constexpr size_t SIZE = sizeof(T);

private:
  inline static MemcmpReturnType block_offset(CPtr p1, CPtr p2, size_t offset) {
    if constexpr (cmp_is_expensive<T>::value) {
      if (!eq<T>(p1, p2, offset)) return cmp_neq<T>(p1, p2, offset);
      return MemcmpReturnType::ZERO();
    } else {
      return cmp<T>(p1, p2, offset);
    }
  }

public:
  inline static MemcmpReturnType block(CPtr p1, CPtr p2) {
    return block_offset(p1, p2, 0);
  }

inline static MemcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
    if constexpr (cmp_is_expensive<T>::value) {
      if (!eq<T>(p1, p2, 0)) return cmp_neq<T>(p1, p2, 0);
    } else {
      if (const auto value = cmp<T>(p1, p2, 0)) return value;
    }
    return block_offset(p1, p2, count - SIZE);
  }

inline static MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
    if constexpr (SIZE > 1) {
      const size_t limit = count - SIZE;

for (size_t offset = 0; offset < limit; offset += SIZE) {
        if (!eq<T>(p1, p2, offset)) {
          if constexpr (cmp_is_expensive<T>::value) {
            return cmp_neq<T>(p1, p2, offset);
          } else {
            return cmp<T>(p1, p2, offset);
          }
        }
      }
      return block_offset(p1, p2, limit);
    } else {
      for (size_t offset = 0; offset < count; offset += SIZE)
        if (auto value = cmp<T>(p1, p2, offset)) return value;
      return MemcmpReturnType::ZERO();
    }
  }

inline static MemcmpReturnType loop_and_tail_align_above(size_t threshold,
                                                           CPtr p1, CPtr p2,
                                                           size_t count) {
    const AlignHelper<sizeof(T)> helper(p1);
    if (UNLIKELY(count >= threshold) && helper.not_aligned()) {
      if (auto value = block(p1, p2)) return value;
      adjust(helper.offset(), p1, p2, count);
    }
    return loop_and_tail(p1, p2, count);
  }
};

template <typename T, typename... TS>
struct MemcmpSequence {
  static constexpr size_t SIZE = (sizeof(T) + ... + sizeof(TS));
  inline static MemcmpReturnType block(CPtr p1, CPtr p2) {
    if constexpr (cmp_is_expensive<T>::value) {
      if (!eq<T>(p1, p2, 0)) return cmp_neq<T>(p1, p2, 0);
    } else {
      if (auto value = cmp<T>(p1, p2, 0)) return value;
    }
    if constexpr (sizeof...(TS) > 0)
      return MemcmpSequence<TS...>::block(p1 + sizeof(T), p2 + sizeof(T));
    else
      return MemcmpReturnType::ZERO();
  }
};

template <typename T>
struct Bcmp {
  static_assert(is_element_type_v<T>);
  static constexpr size_t SIZE = sizeof(T);

inline static BcmpReturnType block(CPtr p1, CPtr p2) {
    return neq<T>(p1, p2, 0);
  }

inline static BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
    const size_t tail_offset = count - SIZE;
    return neq<T>(p1, p2, tail_offset);
  }

inline static BcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
    if (const auto value = neq<T>(p1, p2, 0)) return value;
    return tail(p1, p2, count);
  }

inline static BcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
    if constexpr (SIZE > 1) {
      const size_t limit = count - SIZE;

for (size_t offset = 0; offset < limit; offset += SIZE)
        if (const auto value = neq<T>(p1, p2, offset)) return value;
      return tail(p1, p2, count);
    } else {
      for (size_t offset = 0; offset < count; offset += SIZE)
        if (const auto value = neq<T>(p1, p2, offset)) return value;
      return BcmpReturnType::ZERO();
    }
  }

inline static BcmpReturnType loop_and_tail_align_above(size_t threshold,
                                                         CPtr p1, CPtr p2,
                                                         size_t count) {
    static_assert(SIZE > 1,
                  "No need to align when processing one byte at a time");
    const AlignHelper<sizeof(T)> helper(p1);
    if (UNLIKELY(count >= threshold) && helper.not_aligned()) {
      if (auto value = block(p1, p2)) return value;
      adjust(helper.offset(), p1, p2, count);
    }
    return loop_and_tail(p1, p2, count);
  }
};

template <typename T, typename... TS>
struct BcmpSequence {
  static constexpr size_t SIZE = (sizeof(T) + ... + sizeof(TS));
  inline static BcmpReturnType block(CPtr p1, CPtr p2) {
    if (auto value = neq<T>(p1, p2, 0)) return value;
    if constexpr (sizeof...(TS) > 0)
      return BcmpSequence<TS...>::block(p1 + sizeof(T), p2 + sizeof(T));
    else
      return BcmpReturnType::ZERO();
  }
};

///////////////////////////////////////////////////////////////////////////////
// Specializations for uint8_t
template <>
inline bool eq<uint8_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint8_t>(p1, offset) == load<uint8_t>(p2, offset);
}
template <>
inline uint32_t neq<uint8_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint8_t>(p1, offset) ^ load<uint8_t>(p2, offset);
}
template <>
inline MemcmpReturnType cmp<uint8_t>(CPtr p1, CPtr p2, size_t offset) {
  return static_cast<int32_t>(load<uint8_t>(p1, offset)) -
         static_cast<int32_t>(load<uint8_t>(p2, offset));
}
template <>
inline MemcmpReturnType cmp_neq<uint8_t>(CPtr p1, CPtr p2, size_t offset);

///////////////////////////////////////////////////////////////////////////////
// Specializations for uint16_t
template <>
inline bool eq<uint16_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint16_t>(p1, offset) == load<uint16_t>(p2, offset);
}
template <>
inline uint32_t neq<uint16_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint16_t>(p1, offset) ^ load<uint16_t>(p2, offset);
}
template <>
inline MemcmpReturnType cmp<uint16_t>(CPtr p1, CPtr p2, size_t offset) {
  return static_cast<int32_t>(load_be<uint16_t>(p1, offset)) -
         static_cast<int32_t>(load_be<uint16_t>(p2, offset));
}
template <>
inline MemcmpReturnType cmp_neq<uint16_t>(CPtr p1, CPtr p2, size_t offset);

///////////////////////////////////////////////////////////////////////////////
// Specializations for uint32_t
template <>
inline bool eq<uint32_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint32_t>(p1, offset) == load<uint32_t>(p2, offset);
}
template <>
inline uint32_t neq<uint32_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint32_t>(p1, offset) ^ load<uint32_t>(p2, offset);
}
template <>
inline MemcmpReturnType cmp<uint32_t>(CPtr p1, CPtr p2, size_t offset) {
  // We perform the difference as an uint64_t.
  const int64_t diff = static_cast<int64_t>(load_be<uint32_t>(p1, offset)) -
                       static_cast<int64_t>(load_be<uint32_t>(p2, offset));
  // And reduce the uint64_t into an uint32_t.
  // TODO: provide a detailed explanation.
  return static_cast<int32_t>((diff >> 1) | (diff & 0xFFFF));
}
template <>
inline MemcmpReturnType cmp_neq<uint32_t>(CPtr p1, CPtr p2, size_t offset);

///////////////////////////////////////////////////////////////////////////////
// Specializations for uint64_t
template <>
inline bool eq<uint64_t>(CPtr p1, CPtr p2, size_t offset) {
  return load<uint64_t>(p1, offset) == load<uint64_t>(p2, offset);
}
template <>
inline uint32_t neq<uint64_t>(CPtr p1, CPtr p2, size_t offset) {
  return !eq<uint64_t>(p1, p2, offset);
}
template <>
inline MemcmpReturnType cmp<uint64_t>(CPtr p1, CPtr p2, size_t offset);
template <>
inline MemcmpReturnType cmp_neq<uint64_t>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load_be<uint64_t>(p1, offset);
  const auto b = load_be<uint64_t>(p2, offset);
  return a < b ? -1 : 1;
}

///////////////////////////////////////////////////////////////////////////////
// Specializations for __m128i
#if defined(__SSE4_1__)
template <>
struct is_vector<__m128i> : std::true_type {};
template <>
struct cmp_is_expensive<__m128i> : std::true_type {};
inline __m128i bytewise_max(__m128i a, __m128i b) { return _mm_max_epu8(a, b); }
inline __m128i bytewise_reverse(__m128i value) {
  return _mm_shuffle_epi8(value, _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7,  //
                                              8, 9, 10, 11, 12, 13, 14, 15));
}
inline uint16_t big_endian_cmp_mask(__m128i max, __m128i value) {
  return _mm_movemask_epi8(bytewise_reverse(_mm_cmpeq_epi8(max, value)));
}
template <>
inline bool eq<__m128i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m128i>(p1, offset);
  const auto b = load<__m128i>(p2, offset);
  const auto xored = _mm_xor_si128(a, b);
  return _mm_testz_si128(xored, xored) == 1;  // 1 iff xored == 0
}
template <>
inline uint32_t neq<__m128i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m128i>(p1, offset);
  const auto b = load<__m128i>(p2, offset);
  const auto xored = _mm_xor_si128(a, b);
  return _mm_testz_si128(xored, xored) == 0;  // 0 iff xored != 0
}
template <>
inline MemcmpReturnType cmp_neq<__m128i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m128i>(p1, offset);
  const auto b = load<__m128i>(p2, offset);
  const auto vmax = bytewise_max(a, b);
  const auto le = big_endian_cmp_mask(vmax, b);
  const auto ge = big_endian_cmp_mask(vmax, a);
  static_assert(std::is_same_v<std::remove_cv_t<decltype(le)>, uint16_t>);
  return static_cast<int32_t>(ge) - static_cast<int32_t>(le);
}
#endif  // __SSE4_1__

///////////////////////////////////////////////////////////////////////////////
// Specializations for __m256i
#if defined(__AVX__)
template <>
struct is_vector<__m256i> : std::true_type {};
template <>
struct cmp_is_expensive<__m256i> : std::true_type {};
template <>
inline bool eq<__m256i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m256i>(p1, offset);
  const auto b = load<__m256i>(p2, offset);
  const auto xored = _mm256_castps_si256(
      _mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
  return _mm256_testz_si256(xored, xored) == 1;  // 1 iff xored == 0
}
template <>
inline uint32_t neq<__m256i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m256i>(p1, offset);
  const auto b = load<__m256i>(p2, offset);
  const auto xored = _mm256_castps_si256(
      _mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));
  return _mm256_testz_si256(xored, xored) == 0;  // 0 iff xored != 0
}
#endif  // __AVX__

#if defined(__AVX2__)
inline __m256i bytewise_max(__m256i a, __m256i b) {
  return _mm256_max_epu8(a, b);
}
inline __m256i bytewise_reverse(__m256i value) {
  return _mm256_shuffle_epi8(value,
                             _mm256_set_epi8(0, 1, 2, 3, 4, 5, 6, 7,          //
                                             8, 9, 10, 11, 12, 13, 14, 15,    //
                                             16, 17, 18, 19, 20, 21, 22, 23,  //
                                             24, 25, 26, 27, 28, 29, 30, 31));
}
inline uint32_t big_endian_cmp_mask(__m256i max, __m256i value) {
  return _mm256_movemask_epi8(bytewise_reverse(_mm256_cmpeq_epi8(max, value)));
}
template <>
inline MemcmpReturnType cmp_neq<__m256i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m256i>(p1, offset);
  const auto b = load<__m256i>(p2, offset);
  const auto vmax = bytewise_max(a, b);
  const auto le = big_endian_cmp_mask(vmax, b);
  const auto ge = big_endian_cmp_mask(vmax, a);
  static_assert(std::is_same_v<std::remove_cv_t<decltype(le)>, uint32_t>);
  const int64_t diff = static_cast<int64_t>(ge) - static_cast<int64_t>(le);
  return static_cast<int32_t>((diff >> 1) | (diff & 0xFFFF));
}
#endif  // __AVX2__

///////////////////////////////////////////////////////////////////////////////
// Specializations for __m512i
#if defined(__AVX512BW__)
template <>
struct is_vector<__m512i> : std::true_type {};
template <>
struct cmp_is_expensive<__m512i> : std::true_type {};
inline __m512i bytewise_max(__m512i a, __m512i b) {
  return _mm512_max_epu8(a, b);
}
inline __m512i bytewise_reverse(__m512i value) {
  return _mm512_shuffle_epi8(value,
                             _mm512_set_epi8(0, 1, 2, 3, 4, 5, 6, 7,          //
                                             8, 9, 10, 11, 12, 13, 14, 15,    //
                                             16, 17, 18, 19, 20, 21, 22, 23,  //
                                             24, 25, 26, 27, 28, 29, 30, 31,  //
                                             32, 33, 34, 35, 36, 37, 38, 39,  //
                                             40, 41, 42, 43, 44, 45, 46, 47,  //
                                             48, 49, 50, 51, 52, 53, 54, 55,  //
                                             56, 57, 58, 59, 60, 61, 62, 63));
}
inline uint64_t big_endian_cmp_mask(__m512i max, __m512i value) {
  return _mm512_cmpeq_epi8_mask(bytewise_reverse(max), bytewise_reverse(value));
}
template <>
inline bool eq<__m512i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m512i>(p1, offset);
  const auto b = load<__m512i>(p2, offset);
  return _mm512_cmpneq_epi8_mask(a, b) == 0;
}
template <>
inline uint32_t neq<__m512i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m512i>(p1, offset);
  const auto b = load<__m512i>(p2, offset);
  const uint64_t xored = _mm512_cmpneq_epi8_mask(a, b);
  return (xored >> 32) | (xored & 0xFFFFFFFF);
}
template <>
inline MemcmpReturnType cmp_neq<__m512i>(CPtr p1, CPtr p2, size_t offset) {
  const auto a = load<__m512i>(p1, offset);
  const auto b = load<__m512i>(p2, offset);
  const auto vmax = bytewise_max(a, b);
  const auto le = big_endian_cmp_mask(vmax, b);
  const auto ge = big_endian_cmp_mask(vmax, a);
  static_assert(std::is_same_v<std::remove_cv_t<decltype(le)>, uint64_t>);
  return ge < le ? -1 : 1;
}
#endif  // __AVX512BW__

[[maybe_unused]] inline MemcmpReturnType inline_memcmp_generic_gt16(
    CPtr p1, CPtr p2, size_t count) {
  return Memcmp<uint64_t>::loop_and_tail_align_above(384, p1, p2, count);
}

#if defined(__SSE4_1__)
[[maybe_unused]] inline MemcmpReturnType inline_memcmp_x86_sse41_gt16(
    CPtr p1, CPtr p2, size_t count) {
  return Memcmp<__m128i>::loop_and_tail_align_above(384, p1, p2, count);
}
#endif  // __SSE4_1__

#if defined(__AVX2__)
[[maybe_unused]] inline MemcmpReturnType inline_memcmp_x86_avx2_gt16(
    CPtr p1, CPtr p2, size_t count) {
  if (count <= 32) return Memcmp<__m128i>::head_tail(p1, p2, count);
  if (count <= 64) return Memcmp<__m256i>::head_tail(p1, p2, count);
  return Memcmp<__m256i>::loop_and_tail_align_above(384, p1, p2, count);
}
#endif  // __AVX2__

#if defined(__AVX512BW__)
[[maybe_unused]] inline MemcmpReturnType inline_memcmp_x86_avx512bw_gt16(
    CPtr p1, CPtr p2, size_t count) {
  if (count <= 32) return Memcmp<__m128i>::head_tail(p1, p2, count);
  if (count <= 64) return Memcmp<__m256i>::head_tail(p1, p2, count);
  if (count <= 128) return Memcmp<__m512i>::head_tail(p1, p2, count);
  return Memcmp<__m512i>::loop_and_tail_align_above(384, p1, p2, count);
}
#endif  // __AVX512BW__

inline MemcmpReturnType inline_memcmp_x86(CPtr p1, CPtr p2, size_t count) {
  if (count == 0)  //
    return MemcmpReturnType::ZERO();
  if (count == 1)  //
    return Memcmp<uint8_t>::block(p1, p2);
  if (count == 2)  //
    return Memcmp<uint16_t>::block(p1, p2);
  if (count == 3)  //
    return MemcmpSequence<uint16_t, uint8_t>::block(p1, p2);
  if (count == 4)  //
    return Memcmp<uint32_t>::block(p1, p2);
  if (count == 5)  //
    return MemcmpSequence<uint32_t, uint8_t>::block(p1, p2);
  if (count == 6)  //
    return MemcmpSequence<uint32_t, uint16_t>::block(p1, p2);
  if (count == 7)  //
    return MemcmpSequence<uint32_t, uint16_t, uint8_t>::block(p1, p2);
  if (count == 8)  //
    return Memcmp<uint64_t>::block(p1, p2);
  if (count <= 16)  //
    return Memcmp<uint64_t>::head_tail(p1, p2, count);
#if defined(__AVX512BW__)
  return inline_memcmp_x86_avx512bw_gt16(p1, p2, count);
#elif defined(__AVX2__)
  return inline_memcmp_x86_avx2_gt16(p1, p2, count);
#elif defined(__SSE4_1__)
  return inline_memcmp_x86_sse41_gt16(p1, p2, count);
#else
  return inline_memcmp_generic_gt16(p1, p2, count);
#endif
}

__attribute__((flatten)) extern "C" int32_t memcmp(CPtr p1, CPtr p2,
                                                   size_t count) {
  return (int32_t)inline_memcmp_x86(p1, p2, count);
}