working through

simdutf · lemire · Apr 1, 2024 · Mar 20, 2024 · Mar 20, 2024 · Mar 22, 2024
commit 4aa837d44b1126a32badaa9fc7971afbe23c46a6
diff --git a/scripts/base64/neon_decode.py b/scripts/base64/neon_decode.py
@@ -0,0 +1,33 @@
+t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+spaces=' \t\n\r'
+lut_lo = [0x3a, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x61, 0xe1, 0xb4, 0xf4, 0xe5, 0xf4, 0xb4]
+lut_hi = [0x11, 0x20, 0x42, 0x80, 0x8,  0x4,  0x8,  0x4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20]
+roll = [0x0, 0x10, 0x13, 0x4, 0xbf, 0xbf, 0xb9, 0xb9, 0x0, 0x0,  0x0,  0x0, 0x0,  0x0,  0x0,  0x0]
+def decode(s):
+    low = s & 0xf
+    high = s >> 4
+    m = lut_lo[low] & lut_hi[high]
+    if(m > 0x3):
+        return (m, None)
+    if s == 0x2f:
+        off = roll[high - 1]
+    else:
+        off = roll[high]
+    return (m,(s + off)&0xff)
+
+for i in range(256):
+    m,d = decode(i)
+    if d is None:
+        assert t.find(chr(i)) == -1
+        assert spaces.find(chr(i)) == -1
+        continue
+    if m == 0:
+        assert d >= 0
+        # we must have a base64 element
+        v = t.find(chr(i))
+        #print(i, chr(i), v, d)
+        assert v == d
+    else:
+        # we must have a space
+        v = spaces.find(chr(i))
+        assert v >= 0
diff --git a/src/arm64/arm_base64.cpp b/src/arm64/arm_base64.cpp
@@ -36,8 +36,15 @@ size_t encode_base64(char *dst, const char *src, size_t srclen, base64_options o
       '5', 'K', 'a', 'q', '6', 'L', 'b', 'r', '7', 'M', 'c', 's', '8',
       'N', 'd', 't', '9', 'O', 'e', 'u', '+', 'P', 'f', 'v', '/',
   };
+  constexpr static uint8_t source_table_url[64] = {
+      'A', 'Q', 'g', 'w', 'B', 'R', 'h', 'x', 'C', 'S', 'i', 'y', 'D',
+      'T', 'j', 'z', 'E', 'U', 'k', '0', 'F', 'V', 'l', '1', 'G', 'W',
+      'm', '2', 'H', 'X', 'n', '3', 'I', 'Y', 'o', '4', 'J', 'Z', 'p',
+      '5', 'K', 'a', 'q', '6', 'L', 'b', 'r', '7', 'M', 'c', 's', '8',
+      'N', 'd', 't', '9', 'O', 'e', 'u', '-', 'P', 'f', 'v', '_',
+  };
   const uint8x16_t v3f = vdupq_n_u8(0x3f);
-  const uint8x16x4_t table = vld4q_u8(source_table);
+  const uint8x16x4_t table = vld4q_u8((options&base64_url) ? source_table_url : source_table);
   size_t i = 0;
   for (; i + 16 * 3 <= srclen; i += 16 * 3) {
     const uint8x16x3_t in = vld3q_u8((const uint8_t *)src + i);
@@ -94,6 +101,7 @@ struct block64 {
   uint8x16_t chunks[4];
 };
 static_assert(sizeof(block64) == 64, "block64 is not 64 bytes");
+template <bool base64_url>
 uint64_t to_base64_mask(block64 *b, bool *error) {
   uint8x16_t v0f = vdupq_n_u8(0xf);
 
@@ -235,9 +243,9 @@ void base64_decode_block(char *out, const char *src) {
   vst3q_u8((uint8_t *)out, outvec);
 }
 
-template <typename char_type>
+template <bool base64_url, typename char_type>
 result compress_decode_base64(char *dst, const char_type *src, size_t srclen, base64_options options) {
-  const uint8_t *to_base64 = (options & base64_url) ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
+  const uint8_t *to_base64 = base64_url ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
   size_t equalsigns = 0;
   if (srclen > 0 && src[srclen - 1] == '=') {
     srclen--;
@@ -261,7 +269,7 @@ result compress_decode_base64(char *dst, const char_type *src, size_t srclen, ba
       load_block(&b, src);
       src += 64;
       bool error = false;
-      uint64_t badcharmask = to_base64_mask(&b, &error);
+      uint64_t badcharmask = to_base64_mask<base64_url>(&b, &error);
       if (error) {
         src -= 64;
 

diff --git a/src/arm64/implementation.cpp b/src/arm64/implementation.cpp
@@ -840,15 +840,15 @@ simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(con
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(const char16_t * input, size_t length) const noexcept {
   return scalar::base64::maximal_binary_length_from_base64(input, length);
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char16_t * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::base64_length_from_binary(size_t length) const noexcept {

diff --git a/src/haswell/avx2_base64.cpp b/src/haswell/avx2_base64.cpp
@@ -328,9 +328,9 @@ static inline void base64_decode_block_safe(char *out, block64 *b) {
   std::memcpy(out + 24, buffer, 24);
 }
 
-template <typename chartype>
+template <bool base64_url, typename chartype>
 result compress_decode_base64(char *dst, const chartype *src, size_t srclen, base64_options options) {
-  const uint8_t *to_base64 = (options & base64_url) ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
+  const uint8_t *to_base64 = base64_url ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
   size_t equalsigns = 0;
   if (srclen > 0 && src[srclen - 1] == '=') {
     srclen--;

diff --git a/src/haswell/implementation.cpp b/src/haswell/implementation.cpp
@@ -783,15 +783,15 @@ simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(con
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(const char16_t * input, size_t length) const noexcept {
   return scalar::base64::maximal_binary_length_from_base64(input, length);
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char16_t * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::base64_length_from_binary(size_t length) const noexcept {

diff --git a/src/icelake/icelake_base64.inl.cpp b/src/icelake/icelake_base64.inl.cpp
@@ -137,9 +137,9 @@ static inline void base64_decode_block(char *out, block64 *b) {
   base64_decode(out, b->chunks[0]);
 }
 
-template <typename chartype>
+template <bool base64_url, typename chartype>
 result compress_decode_base64(char *dst, const chartype *src, size_t srclen, base64_options options) {
-  const uint8_t *to_base64 = (options & base64_url) ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
+  const uint8_t *to_base64 = base64_url ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
   size_t equalsigns = 0;
   if (srclen > 0 && src[srclen - 1] == '=') {
     srclen--;

diff --git a/src/icelake/implementation.cpp b/src/icelake/implementation.cpp
@@ -1369,15 +1369,15 @@ simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(con
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(const char16_t * input, size_t length) const noexcept {
   return scalar::base64::maximal_binary_length_from_base64(input, length);
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char16_t * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 

diff --git a/src/westmere/implementation.cpp b/src/westmere/implementation.cpp
@@ -784,15 +784,15 @@ simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(con
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(const char16_t * input, size_t length, base64_options options) const noexcept {
   return scalar::base64::maximal_binary_length_from_base64(input, length, options);
 }
 
 simdutf_warn_unused result implementation::base64_to_binary(const char16_t * input, size_t length, char* output, base64_options options) const noexcept {
-  return compress_decode_base64(output, input, length, options);
+  return (options & base64_url) ? compress_decode_base64<true>(output, input, length, options) : compress_decode_base64<false>(output, input, length, options);
 }
 
 simdutf_warn_unused size_t implementation::base64_length_from_binary(size_t length) const noexcept {

diff --git a/src/westmere/sse_base64.cpp b/src/westmere/sse_base64.cpp
@@ -338,9 +338,9 @@ static inline void base64_decode_block_safe(char *out, block64 *b) {
   std::memcpy(out + 36, buffer, 12);
 }
 
-template <typename chartype>
+template <bool base64_url, typename chartype>
 result compress_decode_base64(char *dst, const chartype *src, size_t srclen, base64_options options) {
-  const uint8_t *to_base64 = (options & base64_url) ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
+  const uint8_t *to_base64 = base64_url ? tables::base64::to_base64_url_value : tables::base64::to_base64_value;
   size_t equalsigns = 0;
   if (srclen > 0 && src[srclen - 1] == '=') {
     srclen--;