0x82, 0x20, 0x40, 0x02, // sub %g1, %g2, %g1 0xff, 0x18, 0x60, 0x00, // ldd [ %l1 ], %d62 0xc2, 0x58, 0x60, 0x08, // ldx [ %g1 + 8 ], %g1 0x81, 0xc0, 0x40, 0x00, // jmp %g1 0x01, 0x00, 0x00, 0x00 // nop ]! } $else $if big_endian { [ u8(0x7C), 0x08, 0x02, 0xA6, // mflr %r0 0x48, 0x00, 0x00, 0x05, // bl here 0x7D, 0xC8, 0x02, 0xA6, // here: mflr %r14 0x39, 0xCE, 0xC0, 0x08, // addi %r14, %r14, -16376 0xC9, 0xCE, 0x00, 0x00, // lfd %f14, 0(%r14) // userdata 0xE9, 0xCE, 0x00, 0x08, // ld %r14, 8(%r14) // func descriptor ptr 0xE9, 0x8E, 0x00, 0x00, // ld %r12, 0(%r14) // code addr from descriptor 0xE8, 0x4E, 0x00, 0x08, // ld %r2, 8(%r14) // TOC from descriptor 0x7C, 0x08, 0x03, 0xA6, // mtlr %r0 0x7D, 0x89, 0x03, 0xA6, // mtctr %r12 0x4E, 0x80, 0x04, 0x20, // bctr ]! } $else { [u8(0)]! } // NOTE: Keep the first branch as the longest byte sequence. In translated/bootstrap C mode // (`vc/v.c`), V emits a fixed C array whose size is inferred from the first branch. const closure_get_data_bytes = $if !ppc64le && !amd64 && !i386 && !arm64 && !arm32 && !rv64 && !rv32 && !s390x && !loongarch64 { // ppc (32-bit PowerPC) - expressed as negation of all other arches for bootstrap compat [ u8(0x94), 0x21, 0xff, 0xf0, // stwu %r1, -16(%r1) 0xd9, 0xc1, 0x00, 0x08, // stfd %f14, 8(%r1) 0x80, 0x61, 0x00, 0x08, // lwz %r3, 8(%r1) 0x38, 0x21, 0x00, 0x10, // addi %r1, %r1, 16 0x4e, 0x80, 0x00, 0x20, // blr ]! } $else $if arm32 { [ u8(0x90), 0x0A, 0x17, 0xEE, // vmov r0, s15 0x04, 0x00, 0x10, 0xE5, // ldr r0, [r0, #-4] 0x1E, 0xFF, 0x2F, 0xE1 // bx lr ]! } $else $if amd64 { [ u8(0x66), 0x4C, 0x0F, 0x7E, 0xF8, // movq rax, xmm15 0xC3 // ret ]! } $else $if i386 { [ u8(0x66), 0x0F, 0x7E, 0xF8, // movd eax, xmm7 0x8B, 0x80, 0xFB, 0xBF, 0xFF, 0xFF, // mov eax, DWORD PTR [eax - 0x4005] 0xc3 // ret ]! } $else $if arm64 { [ u8(0x20), 0x02, 0x66, 0x9E, // fmov x0, d17 0xC0, 0x03, 0x5F, 0xD6 // ret ]! } $else $if rv64 { [ u8(0x53), 0x05, 0x03, 0xE2, // fmv.x.d a0, ft6 0x67, 0x80, 0x00, 0x00, // ret ]! } $else $if rv32 { [ u8(0x53), 0x05, 0x0B, 0xE0, // fmv.x.w a0, fs6 0x67, 0x80, 0x00, 0x00 // ret ]! } $else $if s390x { [ u8(0xB3), 0xCD, 0x00, 0x2F, // lgdr %r2, %f15 0x07, 0xFE, // br %r14 ]! } $else $if ppc64le { [ u8(0x66), 0x00, 0xc3, 0x7d, // mfvsrd %r3, %f14 0x20, 0x00, 0x80, 0x4e, // blr ]! } $else $if loongarch64 { [ u8(0x04), 0xB9, 0x14, 0x01, // movfr2gr.d a0, f8 0x20, 0x00, 0x00, 0x4C, // ret ]! } $else $if sparc64 { [ u8(0x91), 0xb0, 0x22, 0x1f, // movdtox %f62, %o0 0x81, 0xc3, 0xe0, 0x08, // retl 0x01, 0x00, 0x00, 0x00 // nop ]! } $else $if big_endian { [ u8(0x7d), 0xc3, 0x00, 0x66, // mfvsrd %r3, %f14 0x4e, 0x80, 0x00, 0x20 // blr ]! } $else { [u8(0)]! } // vfmt on // equal to `max(2*sizeof(void*), sizeof(__closure_thunk))`, rounded up to the next multiple of `sizeof(void*)` // NOTE: This is a workaround for `-usecache` bug, as it can't include `fn get_closure_size()` needed by `const closure_size` in `build-module` mode. const closure_size_1 = if 2 * u32(sizeof(voidptr)) > u32(closure_thunk.len) { 2 * u32(sizeof(voidptr)) } else { u32(closure_thunk.len) + u32(sizeof(voidptr)) - 1 } const closure_size = int(closure_size_1 & ~(u32(sizeof(voidptr)) - 1)) @[inline] fn closure_exec_ptr(closure voidptr) voidptr { if is_ppc64() { return unsafe { &u8(closure) + assumed_page_size } } return closure } @[inline] fn closure_return_ptr(exec_ptr voidptr) voidptr { if is_ppc64() { return unsafe { &u8(exec_ptr) - assumed_page_size } } return exec_ptr } @[inline] fn closure_slot_meta(exec_ptr voidptr) &voidptr { return unsafe { &voidptr(&u8(exec_ptr) - assumed_page_size) } } fn closure_register_page(exec_page_start voidptr) { unsafe { node := &ClosurePage(malloc(sizeof(ClosurePage))) *node = ClosurePage{ next: g_closure.pages exec_page_start: exec_page_start } g_closure.pages = node } } fn closure_is_managed(exec_ptr voidptr) bool { if isnil(exec_ptr) { return false } exec_addr := unsafe { usize(exec_ptr) } mut page := g_closure.pages for page != unsafe { nil } { page_addr := unsafe { usize(page.exec_page_start) } if exec_addr >= page_addr && exec_addr < page_addr + usize(g_closure.v_page_size) { slot_offset := exec_addr - page_addr return slot_offset >= usize(closure_size) && slot_offset % usize(closure_size) == 0 } page = page.next } return false } // closure_alloc allocates executable memory pages for closures(INTERNAL COMPILER USE ONLY). fn closure_alloc() { p := closure_alloc_platform() if isnil(p) { return } // Setup executable and guard pages x := unsafe { p + g_closure.v_page_size } // End of guard page mut remaining := g_closure.v_page_size / closure_size // Calculate slot count closure_register_page(x) g_closure.closure_ptr = x // Current allocation pointer g_closure.closure_cap = remaining // Remaining slot count // Fill page with closure templates for remaining > 0 { unsafe { vmemcpy(x, &closure_thunk[0], closure_thunk.len) } // Copy template remaining-- unsafe { x += closure_size // Move to next slot } } closure_memory_protect_platform(g_closure.closure_ptr, g_closure.v_page_size, .read_exec) } // closure_init initializes global closure subsystem(INTERNAL COMPILER USE ONLY). fn closure_init() { // Determine system page size mut page_size := get_page_size_platform() g_closure.v_page_size = page_size // Store calculated size // Initialize thread-safety lock closure_mtx_lock_init_platform() // Initial memory allocation closure_alloc() // Install closure handler template unsafe { // Temporarily enable write access to executable memory closure_memory_protect_platform(g_closure.closure_ptr, page_size, .read_write) // Copy closure entry stub code vmemcpy(g_closure.closure_ptr, &closure_get_data_bytes[0], closure_get_data_bytes.len) // Re-normalize execution protection closure_memory_protect_platform(g_closure.closure_ptr, page_size, .read_exec) } // Setup global closure handler pointer if is_ppc64() { mut desc := unsafe { &voidptr(&u8(g_closure.closure_ptr) - assumed_page_size) } unsafe { desc[0] = g_closure.closure_ptr desc[1] = nil } g_closure.closure_get_data = unsafe { ClosureGetDataFn(desc) } } else { g_closure.closure_get_data = g_closure.closure_ptr } // Advance allocation pointer past header unsafe { g_closure.closure_ptr = &u8(g_closure.closure_ptr) + closure_size } g_closure.closure_cap-- // Account for header slot } // closure_create creates closure objects at compile-time(INTERNAL COMPILER USE ONLY). @[direct_array_access] fn closure_create(func voidptr, data voidptr) voidptr { closure_mtx_lock_platform() mut curr_closure := g_closure.free_closure_ptr if !isnil(curr_closure) { unsafe { mut p := closure_slot_meta(curr_closure) g_closure.free_closure_ptr = p[0] } } else { // Handle memory exhaustion if g_closure.closure_cap == 0 { closure_alloc() // Allocate new memory page } g_closure.closure_cap-- // Decrement slot counter // Claim current closure slot curr_closure = g_closure.closure_ptr unsafe { // Move to next available slot g_closure.closure_ptr = &u8(g_closure.closure_ptr) + closure_size } } unsafe { // Write closure metadata (data + function pointer) mut p := closure_slot_meta(curr_closure) if is_ppc64() { // ELFv1: guard page layout per slot: // [0] desc[0] = thunk code address <- returned as ELFv1 function pointer // [1] desc[1] = nil (TOC unused; thunk loads real TOC from func descriptor) // [2] userdata // [3] func (V function descriptor pointer into .opd) p[0] = curr_closure p[1] = nil p[2] = data p[3] = func } else { p[0] = data // Stored closure context p[1] = func // Target function to execute } } closure_mtx_unlock_platform() // Return executable closure object return closure_return_ptr(curr_closure) } // closure_data returns the userdata pointer associated with a closure object. @[direct_array_access] fn closure_data(closure voidptr) voidptr { unsafe { mut p := closure_slot_meta(closure_exec_ptr(closure)) $if ppc64 { return p[2] } $else { return p[0] } } } // closure_try_destroy frees a managed closure slot and its context when the closure is known to be temporary. @[direct_array_access] fn closure_try_destroy(closure voidptr) { if isnil(closure) { return } exec_ptr := closure_exec_ptr(closure) closure_mtx_lock_platform() if !closure_is_managed(exec_ptr) { closure_mtx_unlock_platform() return } unsafe { mut p := closure_slot_meta(exec_ptr) mut data := nil if is_ppc64() { data = p[2] } else { data = p[0] } if !isnil(data) { free(data) } p[0] = g_closure.free_closure_ptr if is_ppc64() { p[1] = nil p[2] = nil p[3] = nil } else { p[1] = nil } g_closure.free_closure_ptr = exec_ptr } closure_mtx_unlock_platform() }