ICU: per-item zstd decompression hook for compressed libicudata

src/jsc/bindings/bun_icu_decompress.cpp

@@ -0,0 +1,115 @@
+// Per-item zstd decompression hook for ICU common data.
+//
+// oven-sh/WebKit's ICU build (icu/udata-decompress-hook.patch) inserts a weak
+// call to bun_icu_maybe_decompress between TOC lookup and checkDataItem.
+// Display-name items (curr/ lang/ region/ unit/ zone/, non-en) are stored as
+// raw zstd frames; everything else keeps its 0xda27 header and passes through
+// after one u32 compare. Decompressed buffers are cached for the process
+// lifetime, keyed by their .rodata address.
+//
+// The dict symbols are emitted by the repacked libicudata.a; declaring them
+// weak here lets this file link against a prebuilt that predates the repack
+// (the hook is then never called, since no item is compressed).
+
+#include "root.h"
+
+// The repacked libicudata.a (and the patched udata.cpp that calls this hook)
+// are produced by oven-sh/WebKit's Dockerfile / Dockerfile.musl only. On every
+// other platform ICU is unmodified, so there is nothing to decompress and the
+// weak externs below have no definer — gate the whole implementation to keep
+// non-ELF weak-symbol semantics out of the picture.
+#if OS(LINUX)
+
+#include "MimallocWTFMalloc.h"
+
+#include <wtf/HashMap.h>
+#include <wtf/Lock.h>
+#include <wtf/NeverDestroyed.h>
+
+#define ZSTD_STATIC_LINKING_ONLY
+#include <zstd.h>
+
+static_assert(ZSTD_MAGICNUMBER == 0xFD2FB528);
+// Raw ICU items have bytes[2..3] == {0xda, 0x27} (ucmndata.h MAGIC1/MAGIC2),
+// so their first u32 is 0x27da'hhhh — cannot collide with zstd's magic.
+
+extern "C" __attribute__((weak)) const unsigned char bun_icu_zstd_dict[];
+extern "C" __attribute__((weak)) const unsigned int bun_icu_zstd_dict_size;
+
+namespace Bun {
+
+class ICUDecompressor {
+public:
+    static ICUDecompressor& get()
+    {
+        static LazyNeverDestroyed<ICUDecompressor> instance;
+        static std::once_flag once;
+        std::call_once(once, [] { instance.construct(); });
+        return instance.get();
+    }
+
+    const void* decompress(const void* p, int32_t* length)
+    {
+        Locker locker { m_lock };
+
+        if (auto it = m_cache.find(p); it != m_cache.end()) {
+            *length = static_cast<int32_t>(ZSTD_getFrameContentSize(p, frameBound(*length)));
+            return it->value;
+        }
+
+        size_t clen = ZSTD_findFrameCompressedSize(p, frameBound(*length));
+        if (ZSTD_isError(clen))
+            return p;
+        auto dlen = ZSTD_getFrameContentSize(p, clen);
+        if (dlen == ZSTD_CONTENTSIZE_UNKNOWN || dlen == ZSTD_CONTENTSIZE_ERROR)
+            return p;
+
+        void* buf = MimallocMalloc::tryAlignedMalloc(static_cast<size_t>(dlen), 16);
+        if (!buf)
+            return p;
+        size_t r = m_ddict
+            ? ZSTD_decompress_usingDDict(m_dctx, buf, static_cast<size_t>(dlen), p, clen, m_ddict)
+            : ZSTD_decompressDCtx(m_dctx, buf, static_cast<size_t>(dlen), p, clen);
+        if (ZSTD_isError(r)) {
+            MimallocMalloc::free(buf);
+            return p;
+        }
+
+        m_cache.add(p, buf);
+        *length = static_cast<int32_t>(dlen);
+        return buf;
+    }
+
+private:
+    ICUDecompressor()
+        : m_dctx(ZSTD_createDCtx())
+        , m_ddict(&bun_icu_zstd_dict_size && bun_icu_zstd_dict_size
+                  ? ZSTD_createDDict_byReference(bun_icu_zstd_dict, bun_icu_zstd_dict_size)
+                  : nullptr)
+    {
+    }
+
+    static size_t frameBound(int32_t tocLength) { return tocLength > 0 ? static_cast<size_t>(tocLength) : (1u << 20); }
+
+    friend class WTF::LazyNeverDestroyed<ICUDecompressor>;
+
+    WTF::Lock m_lock;
+    WTF::HashMap<const void*, void*> m_cache WTF_GUARDED_BY_LOCK(m_lock);
+    ZSTD_DCtx* const m_dctx;
+    ZSTD_DDict* const m_ddict;
+};
+
+} // namespace Bun
+
+extern "C" const void* bun_icu_maybe_decompress(const void* p, int32_t* length)
+{
+    if (!p)
+        return p;
+    uint32_t magic;
+    std::memcpy(&magic, p, sizeof(magic));
+    if (magic != ZSTD_MAGICNUMBER) [[likely]]
+        return p;
+    return Bun::ICUDecompressor::get().decompress(p, length);
+}
+
+#endif // OS(LINUX)