@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/deps/simdutf/src/ppc64/ppc64_base64_internal_tests.cpp

@@ -0,0 +1,401 @@
+namespace base64tests {
+const char *base64_std =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const char *base64_url =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const char *accepted_whitespaces = "\x20\x09\x0a\x0c\x0d";
+} // namespace base64tests
+
+simdutf_maybe_unused static void
+base64_encoding_translate_6bit_values(const simdutf::implementation &) {
+  using simdutf::ppc64::encoding_translate_6bit_values;
+  using simdutf::ppc64::vector_u8;
+
+  for (uint8_t value = 0; value < 64; value++) {
+    const auto in = vector_u8::splat(value);
+    const auto got = encoding_translate_6bit_values<false>(in);
+    const auto want = vector_u8::splat(base64tests::base64_std[value]);
+
+    const auto eq = (got == want);
+    if (not eq.all()) {
+      printf("value = 0x%02x (%c)\n", value, value);
+      printf("want  = ");
+      want.dump();
+      printf("got   = ");
+      got.dump();
+      abort();
+    }
+  }
+
+  for (uint8_t value = 0; value < 64; value++) {
+    const auto in = vector_u8::splat(value);
+    const auto got = encoding_translate_6bit_values<true>(in);
+    const auto want = vector_u8::splat(base64tests::base64_url[value]);
+
+    const auto eq = (got == want);
+    if (not eq.all()) {
+      printf("value = 0x%02x (%c)\n", value, value);
+      printf("want  = ");
+      want.dump();
+      printf("got   = ");
+      got.dump();
+      abort();
+    }
+  }
+}
+
+simdutf_maybe_unused static void
+base64_encoding_expand_6bit_fields(const simdutf::implementation &) {
+  using simdutf::ppc64::encoding_expand_6bit_fields;
+  using simdutf::ppc64::vector_u8;
+
+  for (size_t position = 0; position < 5; position++) {
+    for (uint32_t value = 0; value < 0xffffff; value++) {
+      const uint8_t a = uint8_t(value >> (3 * 6)) & 0x3f;
+      const uint8_t b = uint8_t(value >> (2 * 6)) & 0x3f;
+      const uint8_t c = uint8_t(value >> (1 * 6)) & 0x3f;
+      const uint8_t d = uint8_t(value >> (0 * 6)) & 0x3f;
+
+      auto input = vector_u8::zero();
+      input.value[position * 3 + 0] = uint8_t(value >> (2 * 8));
+      input.value[position * 3 + 1] = uint8_t(value >> (1 * 8));
+      input.value[position * 3 + 2] = uint8_t(value >> (0 * 8));
+
+      const auto expanded = encoding_expand_6bit_fields(input);
+
+      // test
+      const size_t a_idx = position * 4 + 0;
+      const size_t b_idx = position * 4 + 1;
+      const size_t c_idx = position * 4 + 2;
+      const size_t d_idx = position * 4 + 3;
+
+      for (size_t i = 0; i < 5; i++) {
+        uint8_t want = 0;
+        if (i == a_idx) {
+          want = a;
+        } else if (i == b_idx) {
+          want = b;
+        } else if (i == c_idx) {
+          want = c;
+        } else if (i == d_idx) {
+          want = d;
+        }
+
+        const uint8_t got = expanded.value[i];
+        if (got != want) {
+          printf("value = 0x%02x\n", uint8_t(value));
+          printf("pos   = %lu\n", position);
+          printf("want  = %02x\n", want);
+          printf("got   = %02x\n", got);
+          printf("expanded = ");
+          expanded.dump();
+          abort();
+        }
+      }
+    }
+  }
+}
+
+simdutf_maybe_unused static void
+base64_decoding_valid(const simdutf::implementation &) {
+  using simdutf::ppc64::block64;
+  using simdutf::ppc64::vector_u8;
+  using simdutf::ppc64::with_base64_std;
+  using simdutf::ppc64::with_base64_url;
+  using simdutf::ppc64::with_ignore_errors;
+
+  for (uint8_t i = 0; i < 64; i++) {
+    auto ascii = vector_u8::splat(base64tests::base64_std[i]);
+    uint16_t error = 0;
+    const auto mask =
+        block64::to_base64_mask<with_base64_std, with_ignore_errors>(ascii,
+                                                                     error);
+
+    const auto err =
+        (mask != 0) || (error != 0) || (ascii != vector_u8::splat(i)).any();
+
+    if (err) {
+      printf("mask  = %02x\n", mask);
+      printf("error = %02x\n", error);
+      printf("want  = 0x%02x\n", i);
+      printf("got   = ");
+      ascii.dump();
+      abort();
+    }
+  }
+
+  for (uint8_t i = 0; i < 64; i++) {
+    auto ascii = vector_u8::splat(base64tests::base64_url[i]);
+    uint16_t error = 0;
+    const auto mask =
+        block64::to_base64_mask<with_base64_url, with_ignore_errors>(ascii,
+                                                                     error);
+
+    const auto err =
+        (mask != 0) || (error != 0) || (ascii != vector_u8::splat(i)).any();
+
+    if (err) {
+      printf("mask  = %02x\n", mask);
+      printf("error = %02x\n", error);
+      printf("want  = 0x%02x\n", i);
+      printf("got   = ");
+      ascii.dump();
+      abort();
+    }
+  }
+}
+
+template <bool base64_url>
+static void unittest_decoding_invalid_ignore_errors(const char *base64) {
+  using simdutf::ppc64::block64;
+  using simdutf::ppc64::vector_u8;
+  using simdutf::ppc64::with_ignore_errors;
+
+  const char *accepted_whitespaces = " \t\n\r\v";
+
+  constexpr uint8_t invalid = 0xff;
+  constexpr uint8_t whitespace = 0x80;
+
+  uint8_t map[256];
+  for (size_t i = 0; i < 256; i++) {
+    map[i] = invalid;
+  }
+
+  for (uint8_t i = 0; i < 64; i++) {
+    map[uint8_t(base64[i])] = i;
+  }
+
+  for (size_t i = 0; i < 5; i++) {
+    const uint8_t idx = uint8_t(accepted_whitespaces[i]);
+    map[idx] = whitespace;
+  }
+
+  for (size_t i = 0; i < 256; i++) {
+    const auto b = uint8_t(i);
+    auto ascii = vector_u8::splat(b);
+    uint16_t error = 0;
+    const auto mask =
+        block64::to_base64_mask<base64_url, with_ignore_errors>(ascii, error);
+
+    if (map[i] == invalid or map[i] == whitespace) {
+      if (mask != 0xffff or error != 0x0000) {
+        printf("value = %u (0x%02x)\n", b, b);
+        printf("mask  = %04x\n", mask);
+        printf("error = %04x\n", error);
+        ascii.dump();
+        printf("%s:%d\n", __FILE__, __LINE__);
+        exit(1);
+      }
+    } else {
+      if (mask != 0x0000 or error != 0x0000) {
+        printf("value = %u (0x%02x)\n", b, b);
+        printf("mask  = %04x\n", mask);
+        printf("error = %04x\n", error);
+        ascii.dump();
+        printf("%s:%d\n", __FILE__, __LINE__);
+        exit(1);
+      }
+    }
+  }
+}
+
+template <bool base64_url>
+static void unittest_decoding_invalid_strict_errors(const char *base64) {
+  using simdutf::ppc64::block64;
+  using simdutf::ppc64::vector_u8;
+  using simdutf::ppc64::with_strict_checking;
+
+  constexpr uint8_t invalid = 0xff;
+  constexpr uint8_t whitespace = 0x80;
+
+  uint8_t map[256];
+  for (size_t i = 0; i < 256; i++) {
+    map[i] = invalid;
+  }
+
+  for (uint8_t i = 0; i < 64; i++) {
+    map[uint8_t(base64[i])] = i;
+  }
+
+  for (size_t i = 0; i < 5; i++) {
+    const uint8_t idx = uint8_t(base64tests::accepted_whitespaces[i]);
+    map[idx] = whitespace;
+  }
+
+  for (size_t i = 0; i < 256; i++) {
+    const uint8_t b = uint8_t(i);
+    auto ascii = vector_u8::splat(b);
+    uint16_t error = 0;
+    const auto mask =
+        block64::to_base64_mask<base64_url, with_strict_checking>(ascii, error);
+
+    if (map[i] == invalid) {
+      if (mask != 0xffff or error != 0xffff) {
+        printf("value = %u (0x%02x)\n", b, b);
+        printf("mask  = %04x\n", mask);
+        printf("error = %04x\n", error);
+        ascii.dump();
+        printf("%s:%d\n", __FILE__, __LINE__);
+        exit(1);
+      }
+    } else if (map[i] == whitespace) {
+      if (mask != 0xffff or error != 0x0000) {
+        printf("value = %lu (0x%02lx)\n", i, i);
+        printf("mask  = %04x\n", mask);
+        printf("error = %04x\n", error);
+        ascii.dump();
+        printf("%s:%d\n", __FILE__, __LINE__);
+        exit(1);
+      }
+    } else {
+      if (mask != 0x0000 or error != 0x0000) {
+        printf("value = %lu (0x%02lx)\n", i, i);
+        printf("mask  = %04x\n", mask);
+        printf("error = %04x\n", error);
+        ascii.dump();
+        printf("%s:%d\n", __FILE__, __LINE__);
+        exit(1);
+      }
+    }
+  }
+}
+
+simdutf_maybe_unused static void
+base64_decoding_invalid_ignore_errors(const simdutf::implementation &) {
+  using simdutf::ppc64::with_base64_std;
+
+  unittest_decoding_invalid_ignore_errors<with_base64_std>(
+      base64tests::base64_std);
+}
+
+simdutf_maybe_unused static void
+base64url_decoding_invalid_ignore_errors(const simdutf::implementation &) {
+  using simdutf::ppc64::with_base64_url;
+
+  unittest_decoding_invalid_ignore_errors<with_base64_url>(
+      base64tests::base64_url);
+}
+
+simdutf_maybe_unused static void
+base64_decoding_invalid_strict_errors(const simdutf::implementation &) {
+  using simdutf::ppc64::with_base64_std;
+
+  unittest_decoding_invalid_strict_errors<with_base64_std>(
+      base64tests::base64_std);
+}
+
+simdutf_maybe_unused static void
+base64url_decoding_invalid_strict_errors(const simdutf::implementation &) {
+  using simdutf::ppc64::with_base64_url;
+
+  unittest_decoding_invalid_strict_errors<with_base64_url>(
+      base64tests::base64_url);
+}
+
+simdutf_maybe_unused static void
+base64_decoding_pack(const simdutf::implementation &) {
+  using simdutf::ppc64::decoding_pack;
+  using simdutf::ppc64::vector_u8;
+
+  for (size_t position = 0; position < 4; position++) {
+    for (uint32_t value = 0; value < 0xffffff; value++) {
+      const uint8_t a = uint8_t(value >> (0 * 6)) & 0x3f;
+      const uint8_t b = uint8_t(value >> (1 * 6)) & 0x3f;
+      const uint8_t c = uint8_t(value >> (2 * 6)) & 0x3f;
+      const uint8_t d = uint8_t(value >> (3 * 6)) & 0x3f;
+
+      auto input = vector_u8::zero();
+      input.value[position * 4 + 0] = a;
+      input.value[position * 4 + 1] = b;
+      input.value[position * 4 + 2] = c;
+      input.value[position * 4 + 3] = d;
+
+      const uint8_t b0 = uint8_t((a << 2) | (b >> 4));
+      const uint8_t b1 = uint8_t((b << 4) | (c >> 2));
+      const uint8_t b2 = uint8_t(d | (c << 6));
+
+      const auto packed = decoding_pack(input);
+
+      // test
+      const size_t b0_idx = position * 3 + 0;
+      const size_t b1_idx = position * 3 + 1;
+      const size_t b2_idx = position * 3 + 2;
+
+      for (size_t i = 0; i < 3; i++) {
+        uint8_t want = 0;
+        if (i == b0_idx) {
+          want = b0;
+        } else if (i == b1_idx) {
+          want = b1;
+        } else if (i == b2_idx) {
+          want = b2;
+        }
+
+        const uint8_t got = packed.value[i];
+        if (got != want) {
+          printf("pos   = %lu\n", position);
+          printf("want  = %02x\n", want);
+          printf("got   = %02x\n", got);
+          printf("expanded = ");
+          packed.dump();
+          printf("file %s:%d, function %s\n", __FILE__, __LINE__, __func__);
+          abort();
+        }
+      }
+    }
+  }
+}
+
+simdutf_maybe_unused static int
+scalar_compress(const simdutf::ppc64::vector_u8 data, uint16_t nmask,
+                char *output) {
+  char tmp[16];
+  data.store(tmp);
+
+  int j = 0;
+  for (int i = 0; i < 16; i++) {
+    if ((nmask & 0x1) == 0) {
+      output[j++] = tmp[i];
+    }
+
+    nmask >>= 1;
+  }
+
+  return j;
+}
+
+simdutf_maybe_unused static void
+base64_compress(const simdutf::implementation &) {
+  using simdutf::ppc64::compress;
+  using simdutf::ppc64::vector_u8;
+
+  char want[16];
+  char got[16];
+
+  const auto data = vector_u8('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+                              'K', 'L', 'M', 'N', 'O', 'P');
+  for (uint32_t mask = 0; mask <= 0xffff; mask++) {
+    memset(want, 0, 16);
+    memset(got, 0, 16);
+    const uint16_t nmask = uint16_t(~mask);
+
+    const int count = scalar_compress(data, nmask, want);
+    compress(data, nmask, got);
+
+    if (memcmp(want, got, count) != 0) {
+      printf("want = ");
+      for (int i = 0; i < count; i++) {
+        putchar(want[i]);
+      }
+      putchar('\n');
+
+      printf("got  = ");
+      for (int i = 0; i < count; i++) {
+        putchar(got[i]);
+      }
+      putchar('\n');
+
+      exit(1);
+    }
+  }
+}

package/harmony/quick_crypto/deps/simdutf/src/ppc64/ppc64_convert_latin1_to_utf16.cpp

@@ -0,0 +1,12 @@
+template <endianness big_endian>
+size_t ppc64_convert_latin1_to_utf16(const char *latin1_input, size_t len,
+                                     char16_t *utf16_output) {
+  const size_t rounded_len = align_down<vector_u8::ELEMENTS>(len);
+
+  for (size_t i = 0; i < rounded_len; i += vector_u8::ELEMENTS) {
+    const auto in = vector_u8::load(&latin1_input[i]);
+    in.store_bytes_as_utf16<big_endian>(&utf16_output[i]);
+  }
+
+  return rounded_len;
+}

package/harmony/quick_crypto/deps/simdutf/src/ppc64/ppc64_convert_latin1_to_utf32.cpp

@@ -0,0 +1,12 @@
+std::pair<const char *, char32_t *>
+ppc64_convert_latin1_to_utf32(const char *buf, size_t len,
+                              char32_t *utf32_output) {
+  const size_t rounded_len = align_down<vector_u8::ELEMENTS>(len);
+
+  for (size_t i = 0; i < rounded_len; i += vector_u8::ELEMENTS) {
+    const auto in = vector_u8::load(&buf[i]);
+    in.store_bytes_as_utf32(&utf32_output[i]);
+  }
+
+  return std::make_pair(buf + rounded_len, utf32_output + rounded_len);
+}

package/harmony/quick_crypto/deps/simdutf/src/ppc64/ppc64_convert_latin1_to_utf8.cpp

@@ -0,0 +1,149 @@
+/*
+ * reads a vector of uint16 values
+ * bits after 11th are ignored
+ * first 11 bits are encoded into utf8
+ * !important! utf8_output must have at least 16 writable bytes
+ */
+simdutf_really_inline void
+write_v_u16_11bits_to_utf8(const vector_u16 v_u16, char *&utf8_output,
+                           const vector_u8 one_byte_bytemask,
+                           const uint16_t one_byte_bitmask) {
+
+  // 0b1100_0000_1000_0000
+  const auto v_c080 = vector_u16(0xc080);
+  // 0b0011_1111_0000_0000
+  const auto v_1f00 = vector_u16(0x1f00);
+  // 0b0000_0000_0011_1111
+  const auto v_003f = vector_u16(0x003f);
+
+  // 1. prepare 2-byte values
+  // input 16-bit word : [0000|0aaa|aabb|bbbb] x 8
+  // expected output   : [110a|aaaa|10bb|bbbb] x 8
+
+  // t0 = [0000|0000|00bb|bbbb]
+  const auto t0 = v_u16 & v_003f;
+  // t1 = [000a|aaaa|bbbb|bb00]
+  const auto t1 = v_u16.shl<2>();
+  // t2 = [000a|aaaa|00bb|bbbb]
+  const auto t2 = select(v_1f00, t1, t0);
+  // t3 = [110a|aaaa|10bb|bbbb]
+  const auto t3 = t2 | v_c080;
+
+  // 2. merge ASCII and 2-byte codewords
+  const auto utf8_unpacked1 =
+      select(one_byte_bytemask, as_vector_u8(v_u16), as_vector_u8(t3));
+
+#if SIMDUTF_IS_BIG_ENDIAN
+  const auto tmp = as_vector_u16(utf8_unpacked1).swap_bytes();
+#else
+  const auto tmp = as_vector_u16(utf8_unpacked1);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+  const auto utf8_unpacked = as_vector_u8(tmp);
+
+  // 3. prepare bitmask for 8-bit lookup
+  //    one_byte_bitmask = hhggffeeddccbbaa -- the bits are doubled (h - MSB, a
+  //    - LSB)
+  const uint16_t m0 = one_byte_bitmask & 0x5555;      // m0 = 0h0g0f0e0d0c0b0a
+  const uint16_t m1 = static_cast<uint16_t>(m0 >> 7); // m1 = 00000000h0g0f0e0
+  const uint8_t m2 = static_cast<uint8_t>((m0 | m1) & 0xff); // m2 = hdgcfbea
+  // 4. pack the bytes
+  const uint8_t *row =
+      &simdutf::tables::utf16_to_utf8::pack_1_2_utf8_bytes[m2][0];
+  const auto shuffle = vector_u8::load(row + 1);
+  const auto utf8_packed = shuffle.lookup_16(utf8_unpacked);
+
+  // 5. store bytes
+  utf8_packed.store(utf8_output);
+
+  // 6. adjust pointers
+  utf8_output += row[0];
+}
+
+inline void write_v_u16_11bits_to_utf8(const vector_u16 v_u16,
+                                       char *&utf8_output,
+                                       const vector_u16 v_0000,
+                                       const vector_u16 v_ff80) {
+  // no bits set above 7th bit
+  const auto one_byte_bytemask = (v_u16 & v_ff80) == v_0000;
+  const uint16_t one_byte_bitmask = one_byte_bytemask.to_bitmask();
+
+  write_v_u16_11bits_to_utf8(v_u16, utf8_output,
+                             as_vector_u8(one_byte_bytemask), one_byte_bitmask);
+}
+
+std::pair<const char *const, char *const>
+ppc64_convert_latin1_to_utf8(const char *latin_input,
+                             const size_t latin_input_length,
+                             char *utf8_output) {
+  const char *end = latin_input + latin_input_length;
+
+  const auto v_0000 = vector_u16::zero();
+  const auto v_00 = vector_u8::zero();
+
+  // 0b1111_1111_1000_0000
+  const auto v_ff80 = vector_u16(0xff80);
+
+#if SIMDUTF_IS_BIG_ENDIAN
+  const auto latin_1_half_into_u16_byte_mask =
+      vector_u8(16, 0, 16, 1, 16, 2, 16, 3, 16, 4, 16, 5, 16, 6, 16, 7);
+  const auto latin_2_half_into_u16_byte_mask =
+      vector_u8(16, 8, 16, 9, 16, 10, 16, 11, 16, 12, 16, 13, 16, 14, 16, 15);
+#else
+  const auto latin_1_half_into_u16_byte_mask =
+      vector_u8(0, 16, 1, 16, 2, 16, 3, 16, 4, 16, 5, 16, 6, 16, 7, 16);
+  const auto latin_2_half_into_u16_byte_mask =
+      vector_u8(8, 16, 9, 16, 10, 16, 11, 16, 12, 16, 13, 16, 14, 16, 15, 16);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+
+  // each latin1 takes 1-2 utf8 bytes
+  // slow path writes useful 8-15 bytes twice (eagerly writes 16 bytes and then
+  // adjust the pointer) so the last write can exceed the utf8_output size by
+  // 8-1 bytes by reserving 8 extra input bytes, we expect the output to have
+  // 8-16 bytes free
+  while (end - latin_input >= 16 + 8) {
+    // Load 16 Latin1 characters (16 bytes) into a 128-bit register
+    const auto v_latin = vector_u8::load(latin_input);
+
+    if (v_latin.is_ascii()) { // ASCII fast path!!!!
+      v_latin.store(utf8_output);
+      latin_input += 16;
+      utf8_output += 16;
+      continue;
+    }
+
+    // assuming a/b are bytes and A/B are uint16 of the same value
+    // aaaa_aaaa_bbbb_bbbb -> AAAA_AAAA
+    const vector_u16 v_u16_latin_1_half =
+        as_vector_u16(latin_1_half_into_u16_byte_mask.lookup_32(v_latin, v_00));
+
+    // aaaa_aaaa_bbbb_bbbb -> BBBB_BBBB
+    const vector_u16 v_u16_latin_2_half =
+        as_vector_u16(latin_2_half_into_u16_byte_mask.lookup_32(v_latin, v_00));
+
+    write_v_u16_11bits_to_utf8(v_u16_latin_1_half, utf8_output, v_0000, v_ff80);
+    write_v_u16_11bits_to_utf8(v_u16_latin_2_half, utf8_output, v_0000, v_ff80);
+    latin_input += 16;
+  }
+
+  if (end - latin_input >= 16) {
+    // Load 16 Latin1 characters (16 bytes) into a 128-bit register
+    const auto v_latin = vector_u8::load(latin_input);
+
+    if (v_latin.is_ascii()) { // ASCII fast path!!!!
+      v_latin.store(utf8_output);
+      latin_input += 16;
+      utf8_output += 16;
+    } else {
+      // assuming a/b are bytes and A/B are uint16 of the same value
+      // aaaa_aaaa_bbbb_bbbb -> AAAA_AAAA
+      const auto v_u16_latin_1_half = as_vector_u16(
+          latin_1_half_into_u16_byte_mask.lookup_32(v_latin, v_00));
+
+      write_v_u16_11bits_to_utf8(v_u16_latin_1_half, utf8_output, v_0000,
+                                 v_ff80);
+      latin_input += 8;
+    }
+  }
+
+  return std::make_pair(latin_input, utf8_output);
+}

package/harmony/quick_crypto/deps/simdutf/src/ppc64/ppc64_convert_utf16_to_latin1.cpp

@@ -0,0 +1,67 @@
+struct utf16_to_latin1_t {
+  error_code err;
+  const char16_t *input;
+  char *output;
+};
+
+template <endianness big_endian>
+utf16_to_latin1_t ppc64_convert_utf16_to_latin1(const char16_t *buf, size_t len,
+                                                char *latin1_output) {
+  const char16_t *end = buf + len;
+  while (end - buf >= 8) {
+    // Load 8 x UTF-16 characters
+    auto in = vector_u8::load(buf);
+
+    // Move low bytes of UTF-16 chars to lower half of `in`
+    // and upper bytes to upper half of `in`.
+    if simdutf_constexpr (!match_system(big_endian)) {
+      const auto perm =
+          vector_u8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
+      in = perm.lookup_16(in);
+    } else {
+      const auto perm =
+          vector_u8(1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 14);
+      in = perm.lookup_16(in);
+    }
+
+    // AltiVec-specific
+#if defined(__clang__)
+    __attribute__((aligned(16))) uint64_t tmp[8];
+    in.store(tmp);
+  #if SIMDUTF_IS_BIG_ENDIAN
+    memcpy(latin1_output, &tmp[0], 8);
+    const uint64_t upper = tmp[1];
+  #else
+    memcpy(latin1_output, &tmp[1], 8);
+    const uint64_t upper = tmp[0];
+  #endif // SIMDUTF_IS_BIG_ENDIAN
+#else
+    const auto tmp = vec_u64_t(in.value);
+  #if SIMDUTF_IS_BIG_ENDIAN
+    memcpy(latin1_output, &tmp[0], 8);
+    const uint64_t upper = tmp[1];
+  #else
+    memcpy(latin1_output, &tmp[1], 8);
+    const uint64_t upper = tmp[0];
+  #endif // SIMDUTF_IS_BIG_ENDIAN
+#endif   // defined(__clang__)
+    // AltiVec
+
+    if (simdutf_unlikely(upper)) {
+      uint8_t bytes[8];
+      memcpy(bytes, &upper, 8);
+      for (size_t k = 0; k < 8; k++) {
+        if (bytes[k] != 0) {
+          return utf16_to_latin1_t{error_code::TOO_LARGE, buf + k,
+                                   latin1_output};
+        }
+      }
+    } else {
+      // Adjust pointers for next iteration
+      buf += 8;
+      latin1_output += 8;
+    }
+  } // while
+
+  return utf16_to_latin1_t{error_code::SUCCESS, buf, latin1_output};
+}