koffi 2.12.2 → 2.12.4

package/src/core/base/base.cc

@@ -20,6 +20,8 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 
 #include "base.hh"
+#include "crc.inc"
+#include "unicode.inc"
 
 #if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h")
     #include "vendor/dragonbox/include/dragonbox/dragonbox.h"
@@ -1854,6 +1856,35 @@ void FmtLowerAscii::Format(FunctionRef<void(Span<const char>)> append) const
     }
 }
 
+void FmtEscape::Format(FunctionRef<void(Span<const char>)> append) const
+{
+    static const char literals[] = "0123456789ABCDEF";
+
+    for (char c: str) {
+        if (c >= 32 && (unsigned int)c < 128) {
+            append(c);
+        } else {
+            switch (c) {
+                case '\t': { append('\t'); } break;
+                case '\r': { append("\r"); } break;
+                case '\n': { append("\n"); } break;
+
+                default: {
+                    char encoded[4];
+
+                    encoded[0] = '\\';
+                    encoded[1] = 'x';
+                    encoded[2] = literals[((uint8_t)c >> 4) & 0xF];
+                    encoded[3] = literals[((uint8_t)c >> 0) & 0xF];
+
+                    Span<const char> buf = MakeSpan(encoded, 4);
+                    append(buf);
+                } break;
+            }
+        }
+    }
+}
+
 void FmtUrlSafe::Format(FunctionRef<void(Span<const char>)> append) const
 {
     static const char literals[] = "0123456789ABCDEF";
@@ -4473,14 +4504,44 @@ bool SpliceFile(int src_fd, const char *src_filename, int64_t src_offset,
     int64_t max = size;
     progress(0, max);
 
-#if defined(__linux__) || defined(__FreeBSD__)
     // Try copy_file_range() if available
+#if defined(SYS_copy_file_range)
     {
         bool first = true;
 
         while (size) {
+            // glibc < 2.27 doesn't define copy_file_range
+
             size_t count = (size_t)std::min(size, (int64_t)Mebibytes(64));
-            ssize_t ret = copy_file_range(src_fd, (off_t *)&src_offset, dest_fd, (off_t *)&dest_offset, count, 0);
+            ssize_t ret = syscall(SYS_copy_file_range, src_fd, (off_t *)&src_offset, dest_fd, (off_t *)&dest_offset, count, 0u);
+
+            if (ret < 0) {
+                if (first && errno == EXDEV)
+                    goto xdev;
+                if (errno == EINTR)
+                    continue;
+
+                LogError("Failed to copy '%1' to '%2': %3", src_filename, dest_filename, strerror(errno));
+                return false;
+            }
+
+            first = false;
+            size -= ret;
+
+            progress(max - size, max);
+        }
+
+        return true;
+    }
+
+xdev:
+#elif defined(__FreeBSD__)
+    {
+        bool first = true;
+
+        while (size) {
+            size_t count = (size_t)std::min(size, (int64_t)Mebibytes(64));
+            ssize_t ret = copy_file_range(src_fd, (off_t *)&src_offset, dest_fd, (off_t *)&dest_offset, count, 0u);
 
             if (ret < 0) {
                 if (first && errno == EXDEV)
@@ -5963,16 +6024,12 @@ const char *GetTemporaryDirectory()
 
 #endif
 
-const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
-                           HeapArray<const char *> *out_possibilities)
+const char *FindConfigFile(const char *directory, Span<const char *const> names,
+                           Allocator *alloc, HeapArray<const char *> *out_possibilities)
 {
-    decltype(GetUserConfigPath) *funcs[] = {
-        [](const char *name, Allocator *alloc) {
-            Span<const char> dir = GetApplicationDirectory();
+    RG_ASSERT(!directory || directory[0]);
 
-            const char *filename = Fmt(alloc, "%1%/%2", dir, name).ptr;
-            return filename;
-        },
+    decltype(GetUserConfigPath) *funcs[] = {
         GetUserConfigPath,
 #if !defined(_WIN32)
         GetSystemConfigPath
@@ -5981,19 +6038,46 @@ const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
 
     const char *filename = nullptr;
 
-    for (const auto &func: funcs) {
+    // Try application directory
+    for (const char *name: names) {
+        Span<const char> dir = GetApplicationDirectory();
+        const char *path = Fmt(alloc, "%1%/%2", dir, name).ptr;
+
+        if (!filename && TestFile(path, FileType::File)) {
+            filename = path;
+        }
+        if (out_possibilities) {
+            out_possibilities->Append(path);
+        }
+    }
+
+    LocalArray<const char *, 8> tests;
+    {
+        RG_ASSERT(names.len <= tests.Available());
+
         for (const char *name: names) {
-            const char *path = func(name, alloc);
+            if (directory) {
+                const char *test = Fmt(alloc, "%1%/%2", directory, name).ptr;
+                tests.Append(test);
+            } else {
+                tests.Append(name);
+            }
+        }
+    }
+
+    // Try standard paths
+    for (const auto &func: funcs) {
+        for (const char *test: tests) {
+            const char *path = func(test, alloc);
 
             if (!path)
                 continue;
 
-            if (TestFile(path, FileType::File)) {
+            if (!filename && TestFile(path, FileType::File)) {
                 filename = path;
             }
             if (out_possibilities) {
                 out_possibilities->Append(path);
-                break;
             }
         }
     }
@@ -7555,6 +7639,8 @@ bool StreamReader::Rewind()
     }
 
     source.eof = false;
+    raw_len = -1;
+    raw_read = 0;
     eof = false;
 
     return true;
@@ -7992,6 +8078,59 @@ bool StreamWriter::Open(const std::function<bool(Span<const uint8_t>)> &func, co
     return true;
 }
 
+bool StreamWriter::Rewind()
+{
+    if (error) [[unlikely]]
+        return false;
+
+    if (encoder) [[unlikely]] {
+        LogError("Cannot rewind stream with encoder");
+        return false;
+    }
+
+    switch (dest.type) {
+        case DestinationType::Memory: { dest.u.mem.memory->RemoveFrom(dest.u.mem.start); } break;
+
+        case DestinationType::LineFile:
+        case DestinationType::BufferedFile:
+        case DestinationType::DirectFile: {
+            if (lseek(dest.u.file.fd, 0, SEEK_SET) < 0) {
+                LogError("Failed to rewind '%1': %2", filename, strerror(errno));
+                error = true;
+                return false;
+            }
+
+#if defined(_WIN32)
+            HANDLE h = (HANDLE)_get_osfhandle(dest.u.file.fd);
+
+            if (!SetEndOfFile(h)) {
+                LogError("Failed to truncate '%1': %2", filename, GetWin32ErrorString());
+                error = true;
+                return false;
+            }
+#else
+            if (ftruncate(dest.u.file.fd, 0) < 0) {
+                LogError("Failed to truncate '%1': %2", filename, strerror(errno));
+                error = true;
+                return false;
+            }
+#endif
+
+            dest.u.file.buf_used = 0;
+        } break;
+
+        case DestinationType::Function: {
+            LogError("Cannot rewind stream '%1'", filename);
+            error = true;
+            return false;
+        } break;
+    }
+
+    raw_written = 0;
+
+    return true;
+}
+
 bool StreamWriter::Flush()
 {
 #if !defined(__wasm__)
@@ -9027,8 +9166,10 @@ bool ConsolePrompter::Read(Span<const char> *out_str)
     }
 }
 
-bool ConsolePrompter::ReadYN(bool *out_value)
+Size ConsolePrompter::ReadEnum(Span<const PromptChoice> choices, Size value)
 {
+    RG_ASSERT(value < choices.len);
+
 #if !defined(_WIN32) && !defined(__wasm__)
     struct sigaction old_sa;
     IgnoreSigWinch(&old_sa);
@@ -9041,9 +9182,9 @@ bool ConsolePrompter::ReadYN(bool *out_value)
             DisableRawMode();
         };
 
-        return ReadRawYN(out_value);
+        return ReadRawEnum(choices, value);
     } else {
-        return ReadBufferedYN(out_value);
+        return ReadBufferedEnum(choices);
     }
 }
 
@@ -9070,8 +9211,8 @@ bool ConsolePrompter::ReadRaw(Span<const char> *out_str)
     StdErr->Flush();
 
     prompt_columns = ComputeWidth(prompt);
-
     str_offset = str.len;
+
     RenderRaw();
 
     int32_t uc;
@@ -9294,18 +9435,13 @@ bool ConsolePrompter::ReadRaw(Span<const char> *out_str)
     return true;
 }
 
-bool ConsolePrompter::ReadRawYN(bool *out_value)
+Size ConsolePrompter::ReadRawEnum(Span<const PromptChoice> choices, Size value)
 {
-    const char *yn = "[Y/N]";
-
     StdErr->Flush();
 
-    prompt_columns = ComputeWidth(prompt) + ComputeWidth(yn) + 1;
-
-    str.RemoveFrom(0);
-    str_offset = 0;
+    prompt_columns = 0;
+    FormatChoices(choices, value);
     RenderRaw();
-    Print(StdErr, "%!D..%1%!0 ", yn);
 
     int32_t uc;
     while ((uc = ReadChar()) >= 0) {
@@ -9316,36 +9452,86 @@ bool ConsolePrompter::ReadRawYN(bool *out_value)
         }
 
         switch (uc) {
-            case 0x3: { // Ctrl-C
-                StdErr->Write("\r\n");
-                StdErr->Flush();
+            case 0x1B: {
+                LocalArray<char, 16> buf;
 
-                return false;
-            } break;
-            case 0x4: { // Ctrl-D
-                return false;
+                const auto match_escape = [&](const char *seq) {
+                    RG_ASSERT(strlen(seq) < RG_SIZE(buf.data));
+
+                    for (Size i = 0; seq[i]; i++) {
+                        if (i >= buf.len) {
+                            uc = ReadChar();
+
+                            if (uc >= 128) {
+                                // Got some kind of non-ASCII character, make sure nothing else matches
+                                buf.Append(0);
+                                return false;
+                            }
+
+                            buf.Append((char)uc);
+                        }
+                        if (buf[i] != seq[i])
+                            return false;
+                    }
+
+                    return true;
+                };
+
+                if (match_escape("[A")) { // Up
+                    fake_input = "\x10";
+                } else if (match_escape("[B")) { // Down
+                    fake_input = "\x0E";
+                }
             } break;
 
-            case 'Y':
-            case 'y': {
-                StdErr->Write("Y\n");
+            case 0x3:   // Ctrl-C
+            case 0x4: { // Ctrl-D
+                if (rows > y) {
+                    Print(StdErr, "\x1B[%1B", rows - y);
+                }
+                StdErr->Write("\r");
                 StdErr->Flush();
 
-                *out_value = true;
-                return true;
+                return -1;
+            } break;
+
+            case 0xE: { // Down
+                if (value + 1 < choices.len) {
+                    FormatChoices(choices, ++value);
+                    RenderRaw();
+                }
+            } break;
+            case 0x10: { // Up
+                if (value > 0) {
+                    FormatChoices(choices, --value);
+                    RenderRaw();
+                }
             } break;
-            case 'N':
-            case 'n': {
-                StdErr->Write("N\n");
+
+            default: {
+                const auto it = std::find_if(choices.begin(), choices.end(),
+                                             [&](const PromptChoice &choice) { return choice.c == uc; });
+                if (it == choices.end())
+                    break;
+                value = it - choices.begin();
+            } [[fallthrough]];
+
+            case '\r':
+            case '\n': {
+                str.RemoveFrom(0);
+                str.Append(choices[value].str);
+                str_offset = str.len;
+                RenderRaw();
+
+                StdErr->Write("\r\n");
                 StdErr->Flush();
 
-                *out_value = false;
-                return true;
+                return value;
             } break;
         }
     }
 
-    return false;
+    return -1;
 }
 
 bool ConsolePrompter::ReadBuffered(Span<const char> *out_str)
@@ -9374,41 +9560,43 @@ bool ConsolePrompter::ReadBuffered(Span<const char> *out_str)
     return false;
 }
 
-bool ConsolePrompter::ReadBufferedYN(bool *out_value)
+Size ConsolePrompter::ReadBufferedEnum(Span<const PromptChoice> choices)
 {
-    const char *yn = "[Yes/No]";
+    static const Span<const char> prefix = "Input your choice: ";
 
-    prompt_columns = ComputeWidth(prompt) + ComputeWidth(yn) + 1;
+    prompt_columns = 0;
+    FormatChoices(choices, 0);
+    RenderBuffered();
 
-    while (!StdIn->IsEOF()) {
-        str.RemoveFrom(0);
-        str_offset = 0;
-        RenderBuffered();
-        Print(StdErr, "%1 ", yn);
+    Print(StdErr, "\n%1", prefix);
+    StdErr->Flush();
 
-        for (;;) {
-            uint8_t c = 0;
-            if (StdIn->Read(1, &c) < 0)
-                return false;
+    do {
+        uint8_t c = 0;
+        if (StdIn->Read(1, &c) < 0)
+            return -1;
 
-            if (c == '\n') {
-                if (TestStrI(str, "y") || TestStrI(str, "yes")) {
-                    *out_value = true;
-                    return true;
-                } else if (TestStrI(str, "n") || TestStrI(str, "no")) {
-                    *out_value = false;
-                    return true;
-                } else {
-                    break;
-                }
-            } else if (c >= 32 || c == '\t') {
-                str.Append((char)c);
+        if (c == '\n') {
+            Span<const char> end = TrimStr(SplitStrReverse(str, '\n'));
+
+            if (end.len == 1) {
+                const auto it = std::find_if(choices.begin(), choices.end(),
+                                             [&](const PromptChoice &choice) { return choice.c == end[0]; });
+                if (it != choices.end())
+                    return it - choices.ptr;
             }
+
+            str.RemoveFrom(end.ptr - str.ptr);
+
+            StdErr->Write(prefix);
+            StdErr->Flush();
+        } else if (c >= 32 || c == '\t') {
+            str.Append((char)c);
         }
-    }
+    } while (!StdIn->IsEOF());
 
     // EOF
-    return false;
+    return -1;
 }
 
 void ConsolePrompter::ChangeEntry(Size new_idx)
@@ -9492,6 +9680,27 @@ void ConsolePrompter::Delete(Size start, Size end)
     }
 }
 
+void ConsolePrompter::FormatChoices(Span<const PromptChoice> choices, Size value)
+{
+    int align = 0;
+
+    for (const PromptChoice &choice: choices) {
+        align = std::max(align, (int)strlen(choice.str));
+    }
+
+    str.RemoveFrom(0);
+    str.Append('\n');
+    for (Size i = 0; i < choices.len; i++) {
+        const PromptChoice &choice = choices[i];
+
+        Fmt(&str, "  [%1] %2  ", choice.c, FmtArg(choice.str).Pad(align));
+        if (i == value) {
+            str_offset = str.len;
+        }
+        str.Append('\n');
+    }
+}
+
 void ConsolePrompter::RenderRaw()
 {
     columns = GetConsoleSize().x;
@@ -9524,7 +9733,7 @@ void ConsolePrompter::RenderRaw()
             int width = mask ? mask_columns : ComputeWidth(str.Take(i, bytes));
 
             if (x2 + width >= columns || str[i] == '\n') {
-                FmtArg prefix = FmtArg(str[i] == '\n' ? '.' : ' ').Repeat(prompt_columns - 1);
+                FmtArg prefix = FmtArg(' ').Repeat(prompt_columns - 1);
                 Print(StdErr, "\x1B[0K\r\n%!D.+%1%!0 %!..+", prefix);
 
                 x2 = prompt_columns;
@@ -9568,8 +9777,10 @@ void ConsolePrompter::RenderBuffered()
     Print(StdErr, "%1%2", prompt, line);
     while (remain.len) {
         line = SplitStr(remain, '\n', &remain);
-        Print(StdErr, "\n%1 %2", FmtArg('.').Repeat(prompt_columns - 1), line);
+        Print(StdErr, "\n%1%2", FmtArg(' ').Repeat(prompt_columns), line);
     }
+
+    StdErr->Flush();
 }
 
 Vec2<int> ConsolePrompter::GetConsoleSize()
@@ -9732,12 +9943,18 @@ error:
 
 int ConsolePrompter::ComputeWidth(Span<const char> str)
 {
+    Size i = 0;
     int width = 0;
 
-    for (char c: str) {
-        // XXX: For now we assume all codepoints take a single column,
-        // we need to use something like wcwidth() instead.
-        width += ((uint8_t)c >= 32 && !((c & 0xC0) == 0x80));
+    while (i < str.len) {
+        int32_t uc;
+        Size bytes = DecodeUtf8(str, i, &uc);
+
+        if (!bytes) [[unlikely]]
+            return false;
+
+        i += bytes;
+        width += ComputeCharacterWidth(uc);
     }
 
     return width;
@@ -9769,12 +9986,42 @@ const char *Prompt(const char *prompt, const char *default_value, const char *ma
     return str;
 }
 
-bool PromptYN(const char *prompt, bool *out_value)
+Size PromptEnum(const char *prompt, Span<const PromptChoice> choices, Size value)
 {
+#if defined(RG_DEBUG)
+    {
+        HashSet<char> keys;
+
+        for (const PromptChoice &choice: choices) {
+            keys.Set(choice.c);
+        }
+
+        bool duplicates = (keys.table.count < choices.len);
+        RG_ASSERT(!duplicates);
+    }
+#endif
+
     ConsolePrompter prompter;
     prompter.prompt = prompt;
 
-    return prompter.ReadYN(out_value);
+    return prompter.ReadEnum(choices, value);
+}
+
+Size PromptEnum(const char *prompt, Span<const char *const> strings, Size value)
+{
+    static const char literals[] = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    RG_ASSERT(strings.len <= RG_LEN(literals));
+
+    HeapArray<PromptChoice> choices;
+
+    for (Size i = 0; i < strings.len; i++) {
+        const char *str = strings[i];
+        PromptChoice choice = { literals[i], str };
+
+        choices.Append(choice);
+    }
+
+    return PromptEnum(prompt, choices, value);
 }
 
 // ------------------------------------------------------------------------
@@ -9856,4 +10103,194 @@ bool CanCompressFile(const char *filename)
     return true;
 }
 
+// ------------------------------------------------------------------------
+// Unicode
+// ------------------------------------------------------------------------
+
+static bool TestUnicodeTable(Span<const int32_t> table, int32_t uc)
+{
+    RG_ASSERT(table.len > 0);
+    RG_ASSERT(table.len % 2 == 0);
+
+    auto it = std::upper_bound(table.begin(), table.end(), uc,
+                               [](int32_t uc, int32_t x) { return uc < x; });
+    Size idx = it - table.ptr;
+
+    // Each pair of value in table represents a valid interval
+    return idx & 0x1;
+}
+
+int ComputeCharacterWidth(int32_t uc)
+{
+    if (uc < 32)
+        return 0;
+
+    if (TestUnicodeTable(WcWidthNull, uc))
+        return 0;
+    if (TestUnicodeTable(WcWidthWide, uc))
+        return 2;
+
+    return 1;
+}
+
+bool IsXidStart(int32_t uc)
+{
+    if (IsAsciiAlpha(uc))
+        return true;
+    if (uc == '_')
+        return true;
+    if (TestUnicodeTable(XidStartTable, uc))
+        return true;
+
+    return false;
+}
+
+bool IsXidContinue(int32_t uc)
+{
+    if (IsAsciiAlphaOrDigit(uc))
+        return true;
+    if (uc == '_')
+        return true;
+    if (TestUnicodeTable(XidContinueTable, uc))
+        return true;
+
+    return false;
+}
+
+// ------------------------------------------------------------------------
+// CRC
+// ------------------------------------------------------------------------
+
+uint32_t CRC32(uint32_t state, Span<const uint8_t> buf)
+{
+    state = ~state;
+
+    Size right = buf.len & (RG_SIZE_MAX - 3);
+
+    for (Size i = 0; i < right; i += 4) {
+        state = (state >> 8) ^ Crc32Table[(state ^ buf[i + 0]) & 0xFF];
+        state = (state >> 8) ^ Crc32Table[(state ^ buf[i + 1]) & 0xFF];
+        state = (state >> 8) ^ Crc32Table[(state ^ buf[i + 2]) & 0xFF];
+        state = (state >> 8) ^ Crc32Table[(state ^ buf[i + 3]) & 0xFF];
+    }
+    for (Size i = right; i < buf.len; i++) {
+        state = (state >> 8) ^ Crc32Table[(state ^ buf[i]) & 0xFF];
+    }
+
+    return ~state;
+}
+
+uint32_t CRC32C(uint32_t state, Span<const uint8_t> buf)
+{
+    state = ~state;
+
+    Size right = buf.len & (RG_SIZE_MAX - 3);
+
+    for (Size i = 0; i < right; i += 4) {
+        state = (state >> 8) ^ Crc32CTable[(state ^ buf[i + 0]) & 0xFF];
+        state = (state >> 8) ^ Crc32CTable[(state ^ buf[i + 1]) & 0xFF];
+        state = (state >> 8) ^ Crc32CTable[(state ^ buf[i + 2]) & 0xFF];
+        state = (state >> 8) ^ Crc32CTable[(state ^ buf[i + 3]) & 0xFF];
+    }
+    for (Size i = right; i < buf.len; i++) {
+        state = (state >> 8) ^ Crc32CTable[(state ^ buf[i]) & 0xFF];
+    }
+
+    return ~state;
+}
+
+static uint64_t XzUpdate1(uint64_t state, uint8_t byte)
+{
+    uint64_t ret = (state >> 8) ^ Crc64XzTable0[byte ^ (uint8_t)state];
+    return ret;
+}
+
+static uint64_t XzUpdate16(uint64_t state, const uint8_t *bytes)
+{
+    uint64_t ret = Crc64XzTable0[bytes[15]] ^
+                   Crc64XzTable1[bytes[14]] ^
+                   Crc64XzTable2[bytes[13]] ^
+                   Crc64XzTable3[bytes[12]] ^
+                   Crc64XzTable4[bytes[11]] ^
+                   Crc64XzTable5[bytes[10]] ^
+                   Crc64XzTable6[bytes[9]] ^
+                   Crc64XzTable7[bytes[8]] ^
+                   Crc64XzTable8[bytes[7] ^ (uint8_t)(state >> 56)] ^
+                   Crc64XzTable9[bytes[6] ^ (uint8_t)(state >> 48)] ^
+                   Crc64XzTable10[bytes[5] ^ (uint8_t)(state >> 40)] ^
+                   Crc64XzTable11[bytes[4] ^ (uint8_t)(state >> 32)] ^
+                   Crc64XzTable12[bytes[3] ^ (uint8_t)(state >> 24)] ^
+                   Crc64XzTable13[bytes[2] ^ (uint8_t)(state >> 16)] ^
+                   Crc64XzTable14[bytes[1] ^ (uint8_t)(state >> 8)] ^
+                   Crc64XzTable15[bytes[0] ^ (uint8_t)(state >> 0)];
+    return ret;
+}
+
+uint64_t CRC64xz(uint64_t state, Span<const uint8_t> buf)
+{
+    state = ~state;
+
+    Size left = std::min(buf.len, (Size)(AlignUp(buf.ptr, 16) - buf.ptr));
+    Size right = std::max(left, (Size)(AlignDown(buf.end(), 16) - buf.ptr));
+
+    for (Size i = 0; i < left; i++) {
+        state = XzUpdate1(state, buf[i]);
+    }
+    for (Size i = left; i < right; i += 16) {
+        state = XzUpdate16(state, buf.ptr + i);
+    }
+    for (Size i = right; i < buf.len; i++) {
+        state = XzUpdate1(state, buf[i]);
+    }
+
+    return ~state;
+}
+
+static uint64_t NvmeUpdate1(uint64_t state, uint8_t byte)
+{
+    uint64_t ret = (state >> 8) ^ Crc64NvmeTable0[byte ^ (uint8_t)state];
+    return ret;
+}
+
+static uint64_t NvmeUpdate16(uint64_t state, const uint8_t *bytes)
+{
+    uint64_t ret = Crc64NvmeTable0[bytes[15]] ^
+                   Crc64NvmeTable1[bytes[14]] ^
+                   Crc64NvmeTable2[bytes[13]] ^
+                   Crc64NvmeTable3[bytes[12]] ^
+                   Crc64NvmeTable4[bytes[11]] ^
+                   Crc64NvmeTable5[bytes[10]] ^
+                   Crc64NvmeTable6[bytes[9]] ^
+                   Crc64NvmeTable7[bytes[8]] ^
+                   Crc64NvmeTable8[bytes[7] ^ (uint8_t)(state >> 56)] ^
+                   Crc64NvmeTable9[bytes[6] ^ (uint8_t)(state >> 48)] ^
+                   Crc64NvmeTable10[bytes[5] ^ (uint8_t)(state >> 40)] ^
+                   Crc64NvmeTable11[bytes[4] ^ (uint8_t)(state >> 32)] ^
+                   Crc64NvmeTable12[bytes[3] ^ (uint8_t)(state >> 24)] ^
+                   Crc64NvmeTable13[bytes[2] ^ (uint8_t)(state >> 16)] ^
+                   Crc64NvmeTable14[bytes[1] ^ (uint8_t)(state >> 8)] ^
+                   Crc64NvmeTable15[bytes[0] ^ (uint8_t)(state >> 0)];
+    return ret;
+}
+
+uint64_t CRC64nvme(uint64_t state, Span<const uint8_t> buf)
+{
+    state = ~state;
+
+    Size left = std::min(buf.len, (Size)(AlignUp(buf.ptr, 16) - buf.ptr));
+    Size right = std::max(left, (Size)(AlignDown(buf.end(), 16) - buf.ptr));
+
+    for (Size i = 0; i < left; i++) {
+        state = NvmeUpdate1(state, buf[i]);
+    }
+    for (Size i = left; i < right; i += 16) {
+        state = NvmeUpdate16(state, buf.ptr + i);
+    }
+    for (Size i = right; i < buf.len; i++) {
+        state = NvmeUpdate1(state, buf[i]);
+    }
+
+    return ~state;
+}
+
 }