Revert mimalloc v3 (dev3) upgrade (#29353)

## Summary
- Reverts e0cc98d ("We cannot use MI_OSX_ZONE")
- Reverts ccbaed9 ("deps: bump mimalloc to dev3 (bun-dev3-v2)",
#29251)

We are seeing regressions with the mimalloc v3 upgrade, so this rolls
back to the previous pin (`1beadf9651a7bfdec6b5367c380ecc3fe1c40d1a`)
and restores the matching `MimallocArena` / `mimalloc.zig` bindings,
build script, static-initializer counts, aarch64 baseline allowlist, and
`process.versions` snapshot. The `heapStats({dump})` mimalloc
integration and its test are removed as they depend on dev3-only APIs.

The only manual conflict resolution was in
`test/js/node/process/process.test.js`, where the boringssl/libarchive
version lines adjacent to the mimalloc line had since changed; those
were kept at their current `main` values.

## Test plan
- [ ] CI builds green on all platforms
- [ ] `test/js/bun/perf/static-initializers.test.ts` passes (initializer
count back to 1/2)
- [ ] `test/js/node/process/process.test.js` `process.versions` passes
- [ ] `scripts/verify-baseline-static` aarch64 allowlist check passes

Author: dylan-conway

scripts/build/deps/mimalloc.ts

@@ -5,7 +5,7 @@
 
 import type { Dependency, NestedCmakeBuild, Provides } from "../source.ts";
 
-const MIMALLOC_COMMIT = "9a5e1f52cdf4662f9590b69de104a4469140796f";
+const MIMALLOC_COMMIT = "1beadf9651a7bfdec6b5367c380ecc3fe1c40d1a";
 
 export const mimalloc: Dependency = {
   name: "mimalloc",
@@ -68,7 +68,6 @@ export const mimalloc: Dependency = {
       // so UBSan doesn't false-positive on mimalloc's type punning.
       args.MI_DEBUG_UBSAN = "ON";
     } else if (cfg.darwin) {
-      // We cannot use MI_OSX_ZONE because it breaks NAPI addons.
       args.MI_OVERRIDE = "OFF";
       args.MI_OSX_ZONE = "OFF";
       args.MI_OSX_INTERPOSE = "OFF";
@@ -92,10 +91,10 @@ export const mimalloc: Dependency = {
       args.MI_TRACK_VALGRIND = "ON";
     }
 
-    // dev3 grew MI_OPT_ARCH which sets -march=armv8.1-a on arm64 — that
-    // SIGILLs on ARMv8.0 CPUs. Explicitly disable it; our global
-    // -march=armv8-a+crc (via CMAKE_CXX_FLAGS) is sufficient.
-    args.MI_NO_OPT_ARCH = "ON";
+    // If mimalloc gets bumped to a version with MI_OPT_ARCH: pass
+    // MI_NO_OPT_ARCH=ON to stop it setting -march=armv8.1-a on arm64
+    // (SIGILLs on ARMv8.0 CPUs). Current pin has no arch-detection logic
+    // so our global -march=armv8-a+crc (via CMAKE_CXX_FLAGS) is sufficient.
 
     // ─── Windows: silence the vendored-C-as-C++ warning flood ───
     // MI_USE_CXX=ON means .c files compile as C++. clang-cl then complains
@@ -122,7 +121,7 @@ export const mimalloc: Dependency = {
     // to override this, so we have to mirror its naming logic.
     let libname: string;
     if (cfg.windows) {
-      libname = cfg.debug ? "mimalloc-debug" : "mimalloc";
+      libname = cfg.debug ? "mimalloc-static-debug" : "mimalloc-static";
     } else if (cfg.debug) {
       libname = cfg.asan ? "mimalloc-asan-debug" : "mimalloc-debug";
     } else {

scripts/verify-baseline-static/allowlist-aarch64.txt

@@ -94,7 +94,6 @@ __aarch64_ldclr1_acq_rel  [LSE]
 __aarch64_ldclr2_acq_rel  [LSE]
 __aarch64_ldclr4_acq_rel  [LSE]
 __aarch64_ldclr8_acq_rel  [LSE]
-__aarch64_ldclr8_relax    [LSE]
 __aarch64_ldeor1_acq_rel  [LSE]
 __aarch64_ldeor2_acq_rel  [LSE]
 __aarch64_ldeor4_acq_rel  [LSE]
@@ -103,7 +102,6 @@ __aarch64_ldset1_acq_rel  [LSE]
 __aarch64_ldset2_acq_rel  [LSE]
 __aarch64_ldset4_acq_rel  [LSE]
 __aarch64_ldset8_acq_rel  [LSE]
-__aarch64_ldset8_relax    [LSE]
 __aarch64_swp1_acq        [LSE]
 __aarch64_swp1_acq_rel    [LSE]
 __aarch64_swp1_relax      [LSE]
@@ -112,8 +110,6 @@ __aarch64_swp4_acq        [LSE]
 __aarch64_swp4_acq_rel    [LSE]
 __aarch64_swp4_rel        [LSE]
 __aarch64_swp8_acq_rel    [LSE]
-__aarch64_swp8_rel        [LSE]
-__aarch64_swp8_relax      [LSE]
 
 
 # ----------------------------------------------------------------------------

src/allocators/MimallocArena.zig

@@ -8,8 +8,9 @@ const Self = @This();
 ///
 /// This type is a `GenericAllocator`; see `src/allocators.zig`.
 pub const Default = struct {
-    pub fn allocator(_: Default) std.mem.Allocator {
-        return .{ .ptr = undefined, .vtable = &global_mimalloc_vtable };
+    pub fn allocator(self: Default) std.mem.Allocator {
+        _ = self;
+        return Borrowed.getDefault().allocator();
     }
 };
 
@@ -22,20 +23,11 @@ pub const Borrowed = struct {
     #heap: BorrowedHeap,
 
     pub fn allocator(self: Borrowed) std.mem.Allocator {
-        return .{ .ptr = self.#heap, .vtable = &heap_allocator_vtable };
+        return .{ .ptr = self.#heap, .vtable = &c_allocator_vtable };
     }
 
-    /// Prefer `Default.allocator()` / `getThreadLocalDefault()` for a thread-safe
-    /// global allocator. This returns the process-wide main heap so that
-    /// `gc()` / `ownsPtr()` on the result remain meaningful.
     pub fn getDefault() Borrowed {
-        const heap = mimalloc.mi_heap_main();
-        if (comptime !safety_checks) return .{ .#heap = heap };
-        const S = struct {
-            threadlocal var dbg: ?DebugHeap = null;
-        };
-        if (S.dbg == null) S.dbg = .{ .inner = heap, .thread_lock = .initLocked() };
-        return .{ .#heap = &S.dbg.? };
+        return .{ .#heap = getThreadHeap() };
     }
 
     pub fn gc(self: Borrowed) void {
@@ -50,7 +42,7 @@ pub const Borrowed = struct {
     }
 
     pub fn ownsPtr(self: Borrowed, ptr: *const anyopaque) bool {
-        return mimalloc.mi_heap_contains(self.getMimallocHeap(), ptr);
+        return mimalloc.mi_heap_check_owned(self.getMimallocHeap(), ptr);
     }
 
     fn fromOpaque(ptr: *anyopaque) Borrowed {
@@ -89,8 +81,8 @@ pub const Borrowed = struct {
 
     pub fn downcast(std_alloc: std.mem.Allocator) Borrowed {
         bun.assertf(
-            std_alloc.vtable == &heap_allocator_vtable,
-            "not an owned MimallocArena heap (vtable is {*})",
+            isInstance(std_alloc),
+            "not a MimallocArena (vtable is {*})",
             .{std_alloc.vtable},
         );
         return .fromOpaque(std_alloc.ptr);
@@ -106,6 +98,19 @@ const DebugHeap = struct {
     pub const deinit = void;
 };
 
+threadlocal var thread_heap: if (safety_checks) ?DebugHeap else void = if (safety_checks) null;
+
+fn getThreadHeap() BorrowedHeap {
+    if (comptime !safety_checks) return mimalloc.mi_heap_get_default();
+    if (thread_heap == null) {
+        thread_heap = .{
+            .inner = mimalloc.mi_heap_get_default(),
+            .thread_lock = .initLocked(),
+        };
+    }
+    return &thread_heap.?;
+}
+
 const log = bun.Output.scoped(.mimalloc, .hidden);
 
 pub fn allocator(self: Self) std.mem.Allocator {
@@ -116,11 +121,13 @@ pub fn borrow(self: Self) Borrowed {
     return .{ .#heap = if (comptime safety_checks) self.#heap.get() else self.#heap };
 }
 
-/// In v3, `mi_malloc`/`mi_free` are already thread-local-fast — there is no
-/// per-thread default heap to cache. Route through the global vtable.
+/// Internally, mimalloc calls mi_heap_get_default()
+/// to get the default heap.
+/// It uses pthread_getspecific to do that.
+/// We can save those extra calls if we just do it once in here
 pub fn getThreadLocalDefault() std.mem.Allocator {
     if (bun.Environment.enable_asan) return bun.default_allocator;
-    return .{ .ptr = undefined, .vtable = &global_mimalloc_vtable };
+    return Borrowed.getDefault().allocator();
 }
 
 pub fn backingAllocator(_: Self) std.mem.Allocator {
@@ -244,43 +251,17 @@ fn vtable_remap(ptr: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize
     return @ptrCast(value);
 }
 
-fn global_vtable_alloc(_: *anyopaque, len: usize, alignment: Alignment, _: usize) ?[*]u8 {
-    log("Malloc: {d}\n", .{len});
-    const ptr: ?*anyopaque = if (mimalloc.mustUseAlignedAlloc(alignment))
-        mimalloc.mi_malloc_aligned(len, alignment.toByteUnits())
-    else
-        mimalloc.mi_malloc(len);
-    return if (ptr) |p| @ptrCast(p) else null;
-}
-
-fn global_vtable_resize(_: *anyopaque, buf: []u8, _: Alignment, new_len: usize, _: usize) bool {
-    return mimalloc.mi_expand(buf.ptr, new_len) != null;
-}
-
-fn global_vtable_remap(_: *anyopaque, buf: []u8, alignment: Alignment, new_len: usize, _: usize) ?[*]u8 {
-    return @ptrCast(mimalloc.mi_realloc_aligned(buf.ptr, new_len, alignment.toByteUnits()));
-}
-
 pub fn isInstance(alloc: std.mem.Allocator) bool {
-    return alloc.vtable == &heap_allocator_vtable or alloc.vtable == &global_mimalloc_vtable;
+    return alloc.vtable == &c_allocator_vtable;
 }
 
-/// VTable for owned heaps created with `mi_heap_new`.
-const heap_allocator_vtable = std.mem.Allocator.VTable{
+const c_allocator_vtable = std.mem.Allocator.VTable{
     .alloc = vtable_alloc,
     .resize = vtable_resize,
     .remap = vtable_remap,
     .free = vtable_free,
 };
 
-/// VTable for the process-wide default allocator (`mi_malloc`/`mi_free`).
-const global_mimalloc_vtable = std.mem.Allocator.VTable{
-    .alloc = global_vtable_alloc,
-    .resize = global_vtable_resize,
-    .remap = global_vtable_remap,
-    .free = vtable_free,
-};
-
 const std = @import("std");
 const Alignment = std.mem.Alignment;
 

src/allocators/mimalloc.zig

@@ -60,15 +60,16 @@ pub const Heap = opaque {
         return mi_heap_realloc(self, p, newsize);
     }
 
-    pub fn isOwned(self: *Heap, p: ?*const anyopaque) bool {
-        return mi_heap_contains(self, p);
+    pub fn isOwned(self: *Heap, p: ?*anyopaque) bool {
+        return mi_heap_check_owned(self, p);
     }
 };
 pub extern fn mi_heap_new() ?*Heap;
 pub extern fn mi_heap_delete(heap: *Heap) void;
 pub extern fn mi_heap_destroy(heap: *Heap) void;
-pub extern fn mi_heap_main() *Heap;
-pub extern fn mi_heap_contains(heap: *const Heap, p: ?*const anyopaque) bool;
+pub extern fn mi_heap_set_default(heap: *Heap) *Heap;
+pub extern fn mi_heap_get_default() *Heap;
+pub extern fn mi_heap_get_backing() *Heap;
 pub extern fn mi_heap_collect(heap: *Heap, force: bool) void;
 pub extern fn mi_heap_malloc(heap: *Heap, size: usize) ?*anyopaque;
 pub extern fn mi_heap_zalloc(heap: *Heap, size: usize) ?*anyopaque;
@@ -101,6 +102,8 @@ pub extern fn mi_heap_rezalloc_aligned(heap: *Heap, p: ?*anyopaque, newsize: usi
 pub extern fn mi_heap_rezalloc_aligned_at(heap: *Heap, p: ?*anyopaque, newsize: usize, alignment: usize, offset: usize) ?*anyopaque;
 pub extern fn mi_heap_recalloc_aligned(heap: *Heap, p: ?*anyopaque, newcount: usize, size: usize, alignment: usize) ?*anyopaque;
 pub extern fn mi_heap_recalloc_aligned_at(heap: *Heap, p: ?*anyopaque, newcount: usize, size: usize, alignment: usize, offset: usize) ?*anyopaque;
+pub extern fn mi_heap_contains_block(heap: *Heap, p: *const anyopaque) bool;
+pub extern fn mi_heap_check_owned(heap: *Heap, p: *const anyopaque) bool;
 pub extern fn mi_check_owned(p: ?*const anyopaque) bool;
 pub const struct_mi_heap_area_s = extern struct {
     blocks: ?*anyopaque,
@@ -109,7 +112,6 @@ pub const struct_mi_heap_area_s = extern struct {
     used: usize,
     block_size: usize,
     full_block_size: usize,
-    reserved1: ?*anyopaque,
 };
 pub const mi_heap_area_t = struct_mi_heap_area_s;
 pub const mi_block_visit_fun = *const fn (?*const Heap, [*c]const mi_heap_area_t, ?*anyopaque, usize, ?*anyopaque) callconv(.c) bool;

src/bun.js/modules/BunJSCModule.h

@@ -46,8 +46,6 @@
 #include "JSDOMConvertBase.h"
 #include "ZigSourceProvider.h"
 #include "mimalloc.h"
-extern "C" char* mi_stats_get_json(size_t, char*);
-extern "C" char* mi_heap_dump_json(bool include_blocks, bool hash_addresses);
 
 #include <JavaScriptCore/ControlFlowProfiler.h>
 
@@ -221,7 +219,7 @@ createMemoryFootprintStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 
 JSC_DECLARE_HOST_FUNCTION(functionMemoryUsageStatistics);
 JSC_DEFINE_HOST_FUNCTION(functionMemoryUsageStatistics,
-    (JSGlobalObject * globalObject, CallFrame* callFrame))
+    (JSGlobalObject * globalObject, CallFrame*))
 {
 
     auto& vm = JSC::getVM(globalObject);
@@ -358,34 +356,6 @@ JSC_DEFINE_HOST_FUNCTION(functionMemoryUsageStatistics,
 #endif
 #endif
 
-    mi_collect(false);
-    if (char* json = mi_stats_get_json(0, nullptr)) {
-        JSValue parsed = JSONParse(globalObject, String::fromUTF8(json));
-        mi_free(json);
-        object->putDirect(vm, Identifier::fromString(vm, "mimalloc"_s),
-            parsed.isEmpty() ? jsNull() : parsed);
-    }
-
-    // heapStats({ dump: true | "blocks" }) -> per-heap/per-page (and per-block) live snapshot.
-    JSValue arg0 = callFrame->argument(0);
-    if (arg0.isObject()) {
-        JSValue dump = arg0.getObject()->get(globalObject, Identifier::fromString(vm, "dump"_s));
-        if (dump.toBoolean(globalObject)) {
-            const bool includeBlocks = dump.isString() && dump.toWTFString(globalObject) == "blocks"_s;
-#if BUN_DEBUG
-            const bool hashAddresses = false;
-#else
-            const bool hashAddresses = true;
-#endif
-            if (char* json = mi_heap_dump_json(includeBlocks, hashAddresses)) {
-                JSValue parsed = JSONParse(globalObject, String::fromUTF8(json));
-                mi_free(json);
-                object->putDirect(vm, Identifier::fromString(vm, "mimallocDump"_s),
-                    parsed.isEmpty() ? jsNull() : parsed);
-            }
-        }
-    }
-
     return JSValue::encode(object);
 }
 

test/js/bun/jsc/heapStats-mimalloc.test.ts

@@ -59,12 +59,15 @@ describe("static initializers", () => {
       .map(a => a.trim())
       .filter(line => line.includes("running initializer") && line.includes(bunExe()));
 
-    // mimalloc v3 with MI_OSX_ZONE=ON contributes three: __GLOBAL__sub_I_static.c,
-    // mi_process_attach, and _mi_macos_override_malloc (the zone-swap constructor).
-    // On x86_64 there is also ___cpu_indicator_init from CPU feature detection.
+    // On both architectures, we have one initializer "__GLOBAL__sub_I_static.c".
+    // On arm64, mimalloc v3 adds one more static initializer (total: 2).
+    // On x86_64, we also have:
+    // - one from ___cpu_indicator_init due to our CPU feature detection
+    // - one from mimalloc v3
+    // (total: 3)
     expect(
       bunInitializers.length,
       `Do not add static initializers to Bun. Static initializers are called when Bun starts up, regardless of whether you use the variables or not. This makes Bun slower.`,
-    ).toBe(process.arch === "arm64" ? 3 : 4);
+    ).toBe(process.arch === "arm64" ? 1 : 2);
   });
 });

test/js/bun/perf/static-initializers.test.ts

@@ -275,7 +275,7 @@ it("process.versions", () => {
   const expectedVersions = {
     boringssl: "0c5fce43b7ed5eb6001487ee48ac65766f5ddcd1",
     libarchive: "ded82291ab41d5e355831b96b0e1ff49e24d8939",
-    mimalloc: "9a5e1f52cdf4662f9590b69de104a4469140796f",
+    mimalloc: "1beadf9651a7bfdec6b5367c380ecc3fe1c40d1a",
     picohttpparser: "066d2b1e9ab820703db0837a7255d92d30f0c9f5",
     zlib: "886098f3f339617b4243b286f5ed364b9989e245",
     tinycc: "12882eee073cfe5c7621bcfadf679e1372d4537b",