react-native-quick-crypto 1.0.19 → 1.1.1

package/deps/simdutf/src/ppc64/ppc64_convert_utf32_to_utf8.cpp

@@ -0,0 +1,166 @@
+struct utf32_to_utf8_t {
+  error_code err;
+  const char32_t *input;
+  char *output;
+};
+
+template <ErrorReporting er>
+utf32_to_utf8_t ppc64_convert_utf32_to_utf8(const char32_t *buf, size_t len,
+                                            char *utf8_output) {
+  const char32_t *end = buf + len;
+
+  const auto v_f800 = vector_u16::splat(0xf800);
+  const auto v_d800 = vector_u16::splat(0xd800);
+
+  const auto v_ffff0000 = vector_u32::splat(0xffff0000);
+  const auto v_00000000 = vector_u32::zero();
+  auto forbidden_bytemask = simd16<bool>();
+  const size_t safety_margin =
+      12; // to avoid overruns, see issue
+          // https://github.com/simdutf/simdutf/issues/92
+
+  while (end - buf >=
+         std::ptrdiff_t(
+             16 + safety_margin)) { // buf is a char32_t pointer, each char32_t
+                                    // has 4 bytes or 32 bits, thus buf + 16 *
+                                    // char_32t = 512 bits = 64 bytes
+    // We load two 16 bytes registers for a total of 32 bytes or 16 characters.
+    // These two values can hold only 8 UTF32 chars
+    auto in0 = vector_u32::load(buf);
+    auto in1 = vector_u32::load(buf + vector_u32::ELEMENTS);
+
+    // Pack 32-bit UTF-32 code units to 16-bit UTF-16 code units with unsigned
+    // saturation
+    auto in = vector_u32::pack(in0, in1);
+
+    // Try to apply UTF-16 => UTF-8 from ./ppc64_convert_utf16_to_utf8.cpp
+
+    // Check for ASCII fast path
+
+    // ASCII fast path!!!!
+    // We eagerly load another 32 bytes, hoping that they will be ASCII too.
+    // The intuition is that we try to collect 16 ASCII characters which
+    // requires a total of 64 bytes of input. If we fail, we just pass thirdin
+    // and fourthin as our new inputs.
+    if (in.is_ascii()) { // if the first two blocks are ASCII
+      const auto in2 = vector_u32::load(buf + 2 * vector_u32::ELEMENTS);
+      const auto in3 = vector_u32::load(buf + 3 * vector_u32::ELEMENTS);
+
+      const auto next = vector_u32::pack(in2, in3);
+      if (next.is_ascii()) {
+        // 1. pack the bytes
+        const auto utf8_packed = vector_u16::pack(in, next);
+        // 2. store (16 bytes)
+        utf8_packed.store(utf8_output);
+        // 3. adjust pointers
+        buf += 16;
+        utf8_output += 16;
+        continue; // we are done for this round!
+      }
+
+      // `next` is not ASCII, write `in` and carry on with next
+
+      // 1. pack the bytes
+      const auto utf8_packed = vector_u16::pack(in, in);
+      utf8_packed.store(utf8_output);
+      // 3. adjust pointers
+      buf += 8;
+      utf8_output += 8;
+
+      // Proceed with next input
+      in = next;
+      in0 = in2;
+      in1 = in3;
+    }
+
+    // no bits set above 7th bit
+    const auto one_byte_bytemask = in < uint16_t(1 << 7);
+    const uint16_t one_byte_bitmask = one_byte_bytemask.to_bitmask();
+
+    // no bits set above 11th bit
+    const auto one_or_two_bytes_bytemask = in < uint16_t(1 << 11);
+    const uint16_t one_or_two_bytes_bitmask =
+        one_or_two_bytes_bytemask.to_bitmask();
+
+    if (one_or_two_bytes_bitmask == 0xffff) {
+      write_v_u16_11bits_to_utf8(
+          in, utf8_output, as_vector_u8(one_byte_bytemask), one_byte_bitmask);
+      buf += 8;
+      continue;
+    }
+
+    // Check for overflow in packing
+    const auto saturation_bytemask = ((in0 | in1) & v_ffff0000) == v_00000000;
+    const uint16_t saturation_bitmask = saturation_bytemask.to_bitmask();
+    if (saturation_bitmask == 0xffff) {
+      switch (er) {
+      case ErrorReporting::precise: {
+        const auto forbidden = (in & v_f800) == v_d800;
+        if (forbidden.any()) {
+          // We return no error code, instead we force the scalar procedure
+          // to rescan the portion of input where we've just found an error.
+          return utf32_to_utf8_t{error_code::SUCCESS, buf, utf8_output};
+        }
+      } break;
+      case ErrorReporting::at_the_end:
+        forbidden_bytemask |= (in & v_f800) == v_d800;
+        break;
+      case ErrorReporting::none:
+        break;
+      }
+
+      ppc64_convert_utf16_to_1_2_3_bytes_of_utf8(
+          in, one_byte_bitmask, one_or_two_bytes_bytemask,
+          one_or_two_bytes_bitmask, utf8_output);
+      buf += 8;
+    } else {
+      // case: at least one 32-bit word produce a surrogate pair in UTF-16 <=>
+      // will produce four UTF-8 bytes Let us do a scalar fallback. It may seem
+      // wasteful to use scalar code, but being efficient with SIMD in the
+      // presence of surrogate pairs may require non-trivial tables.
+      size_t forward = 15;
+      size_t k = 0;
+      if (size_t(end - buf) < forward + 1) {
+        forward = size_t(end - buf - 1);
+      }
+      for (; k < forward; k++) {
+        uint32_t word = buf[k];
+        if ((word & 0xFFFFFF80) == 0) {
+          *utf8_output++ = char(word);
+        } else if ((word & 0xFFFFF800) == 0) {
+          *utf8_output++ = char((word >> 6) | 0b11000000);
+          *utf8_output++ = char((word & 0b111111) | 0b10000000);
+        } else if ((word & 0xFFFF0000) == 0) {
+          if (er != ErrorReporting::none and
+              (word >= 0xD800 && word <= 0xDFFF)) {
+            return utf32_to_utf8_t{error_code::SURROGATE, buf + k, utf8_output};
+          }
+          *utf8_output++ = char((word >> 12) | 0b11100000);
+          *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+          *utf8_output++ = char((word & 0b111111) | 0b10000000);
+        } else {
+          if (er != ErrorReporting::none and (word > 0x10FFFF)) {
+            return utf32_to_utf8_t{error_code::TOO_LARGE, buf + k, utf8_output};
+          }
+          *utf8_output++ = char((word >> 18) | 0b11110000);
+          *utf8_output++ = char(((word >> 12) & 0b111111) | 0b10000000);
+          *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+          *utf8_output++ = char((word & 0b111111) | 0b10000000);
+        }
+      }
+      buf += k;
+    }
+  } // while
+
+  if (er == ErrorReporting::at_the_end) {
+    if (forbidden_bytemask.any()) {
+      return utf32_to_utf8_t{error_code::SURROGATE, buf, utf8_output};
+    }
+  }
+
+  return utf32_to_utf8_t{
+      error_code::SUCCESS,
+      buf,
+      utf8_output,
+  };
+}

package/deps/simdutf/src/ppc64/ppc64_convert_utf8_to_latin1.cpp

@@ -0,0 +1,69 @@
+// depends on "tables/utf8_to_utf16_tables.h"
+
+// Convert up to 12 bytes from utf8 to latin1 using a mask indicating the
+// end of the code points. Only the least significant 12 bits of the mask
+// are accessed.
+// It returns how many bytes were consumed (up to 12).
+size_t convert_masked_utf8_to_latin1(const char *input,
+                                     uint64_t utf8_end_of_code_point_mask,
+                                     char *&latin1_output) {
+  // we use an approach where we try to process up to 12 input bytes.
+  // Why 12 input bytes and not 16? Because we are concerned with the size of
+  // the lookup tables. Also 12 is nicely divisible by two and three.
+  //
+  //
+  // Optimization note: our main path below is load-latency dependent. Thus it
+  // is maybe beneficial to have fast paths that depend on branch prediction but
+  // have less latency. This results in more instructions but, potentially, also
+  // higher speeds.
+  //
+  const auto in = vector_u8::load(input);
+  const uint16_t input_utf8_end_of_code_point_mask =
+      utf8_end_of_code_point_mask &
+      0xfff; // we are only processing 12 bytes in case it is not all ASCII
+  if (utf8_end_of_code_point_mask == 0xfff) {
+    // We process the data in chunks of 12 bytes.
+    in.store(latin1_output);
+    latin1_output += 12; // We wrote 12 characters.
+    return 12;           // We consumed 12 bytes.
+  }
+  /// We do not have a fast path available, so we fallback.
+  const uint8_t idx =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][0];
+  const uint8_t consumed =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][1];
+  // this indicates an invalid input:
+  if (idx >= 64) {
+    return consumed;
+  }
+  // Here we should have (idx < 64), if not, there is a bug in the validation or
+  // elsewhere. SIX (6) input code-code units this is a relatively easy scenario
+  // we process SIX (6) input code-code units. The max length in bytes of six
+  // code code units spanning between 1 and 2 bytes each is 12 bytes. On
+  // processors where pdep/pext is fast, we might be able to use a small lookup
+  // table.
+
+  const auto reshuffle = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+  const auto perm8 = reshuffle.lookup_32(in, vector_u8::zero());
+#if SIMDUTF_IS_BIG_ENDIAN
+  const auto perm16 = as_vector_u16(perm8).swap_bytes();
+#else
+  const auto perm16 = as_vector_u16(perm8);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+  const auto ascii = perm16 & uint16_t(0x7f);
+  const auto highbyte = perm16 & uint16_t(0x1f00);
+  const auto composed = ascii | highbyte.shr<2>();
+
+  const auto latin1_packed = vector_u16::pack(composed, composed);
+#if defined(__clang__)
+  __attribute__((aligned(16))) char buf[16];
+  latin1_packed.store(buf);
+  memcpy(latin1_output, buf, 6);
+#else
+  // writing 8 bytes even though we only care about the first 6 bytes.
+  const auto tmp = vec_u64_t(latin1_packed.value);
+  memcpy(latin1_output, &tmp[0], 8);
+#endif
+  latin1_output += 6; // We wrote 6 bytes.
+  return consumed;
+}

package/deps/simdutf/src/ppc64/ppc64_convert_utf8_to_utf16.cpp

@@ -0,0 +1,211 @@
+// depends on "tables/utf8_to_utf16_tables.h"
+
+// Convert up to 12 bytes from utf8 to utf16 using a mask indicating the
+// end of the code points. Only the least significant 12 bits of the mask
+// are accessed.
+// It returns how many bytes were consumed (up to 12).
+template <endianness big_endian>
+size_t convert_masked_utf8_to_utf16(const char *input,
+                                    uint64_t utf8_end_of_code_point_mask,
+                                    char16_t *&utf16_output) {
+  // we use an approach where we try to process up to 12 input bytes.
+  // Why 12 input bytes and not 16? Because we are concerned with the size of
+  // the lookup tables. Also 12 is nicely divisible by two and three.
+  //
+  //
+  // Optimization note: our main path below is load-latency dependent. Thus it
+  // is maybe beneficial to have fast paths that depend on branch prediction but
+  // have less latency. This results in more instructions but, potentially, also
+  // higher speeds.
+  //
+  // We first try a few fast paths.
+  const auto in = vector_u8::load(input);
+  const uint16_t input_utf8_end_of_code_point_mask =
+      utf8_end_of_code_point_mask & 0xfff;
+  if (utf8_end_of_code_point_mask == 0xfff) {
+    // We process the data in chunks of 12 bytes.
+    // Note: using 16 bytes is unsafe, see issue_ossfuzz_71218
+    in.store_bytes_as_utf16<big_endian>(utf16_output);
+    utf16_output += 12; // We wrote 12 16-bit characters.
+    return 12;          // We consumed 12 bytes.
+  }
+  if (((utf8_end_of_code_point_mask & 0xFFFF) == 0xaaaa)) {
+    // We want to take 8 2-byte UTF-8 code units and turn them into 8 2-byte
+    // UTF-16 code units.
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto in16 = as_vector_u16(in);
+#else
+    const auto in16 = as_vector_u16(in).swap_bytes();
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto lo = in16 & uint16_t(0x007f);
+    const auto hi = in16.shr<2>();
+
+    auto composed = select(uint16_t(0x1f00 >> 2), hi, lo);
+    if simdutf_constexpr (!match_system(big_endian)) {
+      composed = composed.swap_bytes();
+    }
+
+    composed.store(utf16_output);
+    utf16_output += 8; // We wrote 16 bytes, 8 code points.
+    return 16;
+  }
+  if (input_utf8_end_of_code_point_mask == 0x924) {
+    // We want to take 4 3-byte UTF-8 code units and turn them into 4 2-byte
+    // UTF-16 code units. There is probably a more efficient sequence, but the
+    // following might do.
+
+    // AltiVec: it might be done better, for now SSE translation
+
+    const auto sh =
+        vector_u8(2, 1, 0, 16, 5, 4, 3, 16, 8, 7, 6, 16, 11, 10, 9, 16);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u32(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto b0 = perm & uint32_t(0x0000007f);
+    const auto b1 = select(uint32_t(0x00003f00 >> 2), perm.shr<2>(), b0);
+    const auto b2 = select(uint32_t(0x000f0000 >> 4), perm.shr<4>(), b1);
+    const auto composed = b2;
+    auto packed = vector_u32::pack(composed, composed);
+
+    if simdutf_constexpr (!match_system(big_endian)) {
+      packed = packed.swap_bytes();
+    }
+
+    packed.store(utf16_output);
+    utf16_output += 4;
+    return 12;
+  }
+  /// We do not have a fast path available, so we fallback.
+
+  const uint8_t idx =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][0];
+  const uint8_t consumed =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][1];
+
+  if (idx < 64) {
+    // SIX (6) input code-code units
+    // this is a relatively easy scenario
+    // we process SIX (6) input code-code units. The max length in bytes of six
+    // code code units spanning between 1 and 2 bytes each is 12 bytes. On
+    // processors where pdep/pext is fast, we might be able to use a small
+    // lookup table.
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u16(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u16(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto b0 = perm & uint16_t(0x007f);
+    const auto b1 = perm & uint16_t(0x1f00);
+
+    auto composed = b0 | b1.shr<2>();
+
+    if simdutf_constexpr (!match_system(big_endian)) {
+      composed = composed.swap_bytes();
+    }
+
+    composed.store(utf16_output);
+    utf16_output += 6; // We wrote 12 bytes, 6 code points.
+  } else if (idx < 145) {
+    // FOUR (4) input code-code units
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u32(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto b0 = perm & uint32_t(0x0000007f);
+    const auto b1 = perm & uint32_t(0x00003f00);
+    const auto b2 = perm & uint32_t(0x000f0000);
+
+    const auto composed = b0 | b1.shr<2>() | b2.shr<4>();
+
+    auto packed = vector_u32::pack(composed, composed);
+
+    if simdutf_constexpr (!match_system(big_endian)) {
+      packed = packed.swap_bytes();
+    }
+
+    packed.store(utf16_output);
+    utf16_output += 4;
+  } else if (idx < 209) {
+    // TWO (2) input code-code units
+    //////////////
+    // There might be garbage inputs where a leading byte mascarades as a
+    // four-byte leading byte (by being followed by 3 continuation byte), but is
+    // not greater than 0xf0. This could trigger a buffer overflow if we only
+    // counted leading bytes of the form 0xf0 as generating surrogate pairs,
+    // without further UTF-8 validation. Thus we must be careful to ensure that
+    // only leading bytes at least as large as 0xf0 generate surrogate pairs. We
+    // do as at the cost of an extra mask.
+    /////////////
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u32(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto ascii = perm & uint32_t(0x00000007f);
+    const auto middlebyte = perm & uint32_t(0x00003f00);
+    const auto middlebyte_shifted = middlebyte.shr<2>();
+
+    auto middlehighbyte = perm & uint32_t(0x003f0000);
+    // correct for spurious high bit
+
+    const auto correct = (perm & uint32_t(0x00400000)).shr<1>();
+    middlehighbyte = correct ^ middlehighbyte;
+    const auto middlehighbyte_shifted = middlehighbyte.shr<4>();
+    // We deliberately carry the leading four bits in highbyte if they are
+    // present, we remove them later when computing hightenbits.
+    const auto highbyte = perm & uint32_t(0xff000000);
+    const auto highbyte_shifted = highbyte.shr<6>();
+    // When we need to generate a surrogate pair (leading byte > 0xF0), then
+    // the corresponding 32-bit value in 'composed'  will be greater than
+    // > (0xff00000>>6) or > 0x3c00000. This can be used later to identify the
+    // location of the surrogate pairs.
+    const auto composed =
+        ascii | middlebyte_shifted | highbyte_shifted | middlehighbyte_shifted;
+
+    const auto composedminus = composed - uint32_t(0x10000);
+    const auto lowtenbits = composedminus & uint32_t(0x3ff);
+    // Notice the 0x3ff mask:
+    const auto hightenbits = composedminus.shr<10>() & uint32_t(0x3ff);
+    const auto lowtenbitsadd = lowtenbits + uint32_t(0xDC00);
+    const auto hightenbitsadd = hightenbits + uint32_t(0xD800);
+    const auto lowtenbitsaddshifted = lowtenbitsadd.shl<16>();
+    auto surrogates = hightenbitsadd | lowtenbitsaddshifted;
+
+    uint32_t basic_buffer[4];
+    composed.store(basic_buffer);
+    uint32_t surrogate_buffer[4];
+    surrogates.swap_bytes().store(surrogate_buffer);
+
+    for (size_t i = 0; i < 3; i++) {
+      if (basic_buffer[i] > 0x3c00000) {
+        const auto ch0 = uint16_t(surrogate_buffer[i] & 0xffff);
+        const auto ch1 = uint16_t(surrogate_buffer[i] >> 16);
+        if (match_system(big_endian)) {
+          utf16_output[1] = scalar::u16_swap_bytes(ch0);
+          utf16_output[0] = scalar::u16_swap_bytes(ch1);
+        } else {
+          utf16_output[1] = ch0;
+          utf16_output[0] = ch1;
+        }
+        utf16_output += 2;
+      } else {
+        const auto chr = uint16_t(basic_buffer[i]);
+        utf16_output[0] = scalar::utf16::swap_if_needed<big_endian>(chr);
+        utf16_output++;
+      }
+    }
+  } else {
+    // here we know that there is an error but we do not handle errors
+  }
+  return consumed;
+}

package/deps/simdutf/src/ppc64/ppc64_convert_utf8_to_utf32.cpp

@@ -0,0 +1,153 @@
+// depends on "tables/utf8_to_utf16_tables.h"
+
+// Convert up to 12 bytes from utf8 to utf32 using a mask indicating the
+// end of the code points. Only the least significant 12 bits of the mask
+// are accessed.
+// It returns how many bytes were consumed (up to 12).
+size_t convert_masked_utf8_to_utf32(const char *input,
+                                    uint64_t utf8_end_of_code_point_mask,
+                                    char32_t *&utf32_output) {
+  // we use an approach where we try to process up to 12 input bytes.
+  // Why 12 input bytes and not 16? Because we are concerned with the size of
+  // the lookup tables. Also 12 is nicely divisible by two and three.
+  //
+  //
+  // Optimization note: our main path below is load-latency dependent. Thus it
+  // is maybe beneficial to have fast paths that depend on branch prediction but
+  // have less latency. This results in more instructions but, potentially, also
+  // higher speeds.
+  //
+  // We first try a few fast paths.
+  const auto in = vector_u8::load(input);
+  const uint16_t input_utf8_end_of_code_point_mask =
+      utf8_end_of_code_point_mask & 0xfff;
+  if (utf8_end_of_code_point_mask == 0xfff) {
+    // We process the data in chunks of 12 bytes.
+    in.store_bytes_as_utf32(utf32_output);
+    utf32_output += 12; // We wrote 12 32-bit characters.
+    return 12;          // We consumed 12 bytes.
+  }
+  if (((utf8_end_of_code_point_mask & 0xffff) == 0xaaaa)) {
+    // We want to take 8 2-byte UTF-8 code units and turn them into 8 4-byte
+    // UTF-32 code units.
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm = as_vector_u16(in);
+#else
+    const auto perm = as_vector_u16(in).swap_bytes();
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    // in = [110aaaaa|10bbbbbb]
+    // t0 = [00000000|00bbbbbb]
+    const auto t0 = perm & uint16_t(0x007f);
+
+    // t1 = [00110aaa|aabbbbbb]
+    const auto t1 = perm.shr<2>();
+    const auto composed = select(uint16_t(0x1f00 >> 2), t1, t0);
+
+    const auto composed8 = as_vector_u8(composed);
+    composed8.store_words_as_utf32(utf32_output);
+
+    utf32_output += 8; // We wrote 32 bytes, 8 code points.
+    return 16;
+  }
+  if (input_utf8_end_of_code_point_mask == 0x924) {
+    // We want to take 4 3-byte UTF-8 code units and turn them into 4 4-byte
+    // UTF-32 code units.
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto sh =
+        vector_u8(-1, 0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11);
+#else
+    const auto sh =
+        vector_u8(2, 1, 0, -1, 5, 4, 3, -1, 8, 7, 6, -1, 11, 10, 9, -1);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+
+    // in = [1110aaaa|10bbbbbb|10cccccc]
+
+    // t0 = [00000000|00000000|00cccccc]
+    const auto t0 = perm & uint32_t(0x0000007f);
+
+    // t2 = [00000000|0000bbbb|bbcccccc]
+    const auto t1 = perm.shr<2>();
+    const auto t2 = select(uint32_t(0x00003f00 >> 2), t1, t0);
+
+    // t4 = [00000000|aaaabbbb|bbcccccc]
+    const auto t3 = perm.shr<4>();
+    const auto t4 = select(uint32_t(0x0f0000 >> 4), t3, t2);
+
+    t4.store(utf32_output);
+    utf32_output += 4;
+    return 12;
+  }
+  /// We do not have a fast path available, so we fallback.
+
+  const uint8_t idx =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][0];
+  const uint8_t consumed =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][1];
+  if (idx < 64) {
+    // SIX (6) input code-code units
+    // this is a relatively easy scenario
+    // we process SIX (6) input code-code units. The max length in bytes of six
+    // code code units spanning between 1 and 2 bytes each is 12 bytes. On
+    // processors where pdep/pext is fast, we might be able to use a small
+    // lookup table.
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u16(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u16(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto ascii = perm & uint16_t(0x7f);
+    const auto highbyte = perm & uint16_t(0x1f00);
+    const auto composed = ascii | highbyte.shr<2>();
+
+    as_vector_u8(composed).store_words_as_utf32(utf32_output);
+    utf32_output += 6; // We wrote 12 bytes, 6 code points.
+  } else if (idx < 145) {
+    // FOUR (4) input code-code units
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u32(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto ascii = perm & uint32_t(0x7f);
+    const auto middlebyte = perm & uint32_t(0x3f00);
+    const auto middlebyte_shifted = middlebyte.shr<2>();
+    const auto highbyte = perm & uint32_t(0x0f0000);
+    const auto highbyte_shifted = highbyte.shr<4>();
+    const auto composed = ascii | middlebyte_shifted | highbyte_shifted;
+
+    composed.store(utf32_output);
+    utf32_output += 4;
+  } else if (idx < 209) {
+    // TWO (2) input code-code units
+    const auto sh = vector_u8::load(&tables::utf8_to_utf16::shufutf8[idx]);
+#if SIMDUTF_IS_BIG_ENDIAN
+    const auto perm =
+        as_vector_u32(sh.lookup_32(in, vector_u8::zero())).swap_bytes();
+#else
+    const auto perm = as_vector_u32(sh.lookup_32(in, vector_u8::zero()));
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto ascii = perm & uint32_t(0x0000007f);
+    const auto middlebyte = perm & uint32_t(0x3f00);
+    const auto middlebyte_shifted = middlebyte.shr<2>();
+    auto middlehighbyte = perm & uint32_t(0x003f0000);
+    // correct for spurious high bit
+    const auto correct0 = perm & uint32_t(0x00400000);
+    const auto correct = correct0.shr<1>();
+    middlehighbyte = correct ^ middlehighbyte;
+    const auto middlehighbyte_shifted = middlehighbyte.shr<4>();
+    const auto highbyte = perm & uint32_t(0x07000000);
+    const auto highbyte_shifted = highbyte.shr<6>();
+    const auto composed =
+        ascii | middlebyte_shifted | highbyte_shifted | middlehighbyte_shifted;
+    composed.store(utf32_output);
+    utf32_output += 3;
+  } else {
+    // here we know that there is an error but we do not handle errors
+  }
+  return consumed;
+}