如何为v8::Persistent<v8::Function>创建C++包装器并转为void(__cdecl*)函数？

Hey there! Let's walk through exactly how to wrap your v8::Persistent<v8::Function> into a C-style void(__cdecl*)() function pointer. The key here is using a wrapper function as an intermediary—since V8's JS function references can't be directly cast to C function pointers (they operate on totally different execution models), we need a bridge that speaks both V8's API and C's calling convention.

Why a wrapper is necessary #

First, let's clarify: a v8::Persistent<v8::Function> is a persistent reference to a JavaScript function managed by the V8 engine. Calling it requires using V8's native API (like v8::Function::Call()), which has nothing to do with C's function call mechanics. The wrapper acts as a middleman: it adheres to the __cdecl calling convention, and internally uses V8's API to invoke the stored JS function.

Basic implementation (single-threaded/simple use case) #

If you're working in a single-threaded environment or can safely use a global variable, this straightforward approach works:

Step 1: Declare a global Persistent reference #

We'll use this to hold onto the JS function across calls to the wrapper:

#include <v8.h>

// Global storage for the JS function reference (safe only in single-threaded scenarios)
v8::Persistent<v8::Function> g_stored_js_function;

Step 2: Write the C-style wrapper function #

This function matches the void(__cdecl*)() signature, and handles invoking the JS function via V8:

// Wrapper function that follows __cdecl calling convention
void __cdecl js_function_wrapper() {
    // Grab the active V8 Isolate and Context (ensure these are valid when the wrapper is called!)
    v8::Isolate* isolate = v8::Isolate::GetCurrent();
    v8::HandleScope scope(isolate); // Manages local V8 handles
    v8::Local<v8::Context> active_context = isolate->GetCurrentContext();

    // Convert the Persistent reference to a Local reference (required for V8 API calls)
    v8::Local<v8::Function> js_func = v8::Local<v8::Function>::New(isolate, g_stored_js_function);

    // Invoke the JS function (example: no arguments, using the global object as 'this')
    // To pass arguments, add a Local<Value> array as the 4th parameter
    v8::MaybeLocal<v8::Value> result = js_func->Call(
        active_context,
        active_context->Global(),
        0, // Number of arguments
        nullptr // Argument array
    );

    // Optional: Handle the return value if needed
    if (!result.IsEmpty()) {
        // Do something with result.ToLocalChecked()
    }
}

Step 3: Get the function pointer #

Now you can assign the wrapper's address to your target function pointer type:

// Cast the wrapper to the desired __cdecl function pointer type
void(__cdecl* c_style_func_ptr)() = &js_function_wrapper;

Step 4: Initialize the Persistent reference #

Somewhere in your V8 setup code, store the JS function in the global Persistent:

// Assume 'js_function' is a Local<v8::Function> obtained from your JS context
g_stored_js_function.Reset(isolate, js_function);

// Optional: Set a weak callback to clean up the Persistent when the JS function is GC'd
g_stored_js_function.SetWeak(
    nullptr,
    [](const v8::WeakCallbackInfo<void>& info) {
        auto* persistent_func = static_cast<v8::Persistent<v8::Function>*>(info.GetParameter());
        persistent_func->Reset();
    },
    v8::WeakCallbackType::kParameter
);

Safer implementation (multi-threaded/avoid globals) #

Global variables are risky in multi-threaded code. Instead, we can bundle the V8 context and Persistent function into a struct, and pass that struct to the wrapper (note: this requires adjusting the function pointer signature to accept a void* parameter; if you absolutely need a parameterless function, you'll need platform-specific thunking, which is more complex).

Step 1: Define a wrapper context struct #

struct WrapperContext {
    v8::Isolate* isolate;
    v8::Persistent<v8::Function> js_function;
};

Step 2: Write the context-aware wrapper #

void __cdecl js_function_wrapper_with_context(void* context_ptr) {
    WrapperContext* ctx = static_cast<WrapperContext*>(context_ptr);
    v8::Isolate* isolate = ctx->isolate;
    v8::HandleScope scope(isolate);
    v8::Local<v8::Context> active_context = isolate->GetCurrentContext();

    v8::Local<v8::Function> js_func = v8::Local<v8::Function>::New(isolate, ctx->js_function);
    js_func->Call(active_context, active_context->Global(), 0, nullptr);
}

Step 3: Use the wrapper #

// Create and initialize the context
WrapperContext* ctx = new WrapperContext();
ctx->isolate = v8::Isolate::GetCurrent();
ctx->js_function.Reset(ctx->isolate, js_function); // 'js_function' is your Local<Function>

// Now the function pointer accepts a void* parameter
void(__cdecl* c_style_func_ptr)(void*) = &js_function_wrapper_with_context;

// Call the wrapper with the context
c_style_func_ptr(ctx);

Critical things to remember #

• Valid Isolate/Context: The wrapper must be called while a V8 Isolate and Context are active. If calling from a non-V8 thread, you need to call isolate->Enter() first and ensure the Context is properly entered.
• Persistent Lifecycle: Always call Reset() on the Persistent reference when you're done with it to avoid memory leaks. The weak callback helps automate this when the JS function is garbage collected.
• Calling Convention: Double-check that your wrapper uses __cdecl correctly—compilers vary (e.g., GCC uses __attribute__((cdecl))).
• Thread Safety: V8 Isolates are thread-bound. You can't call a wrapper tied to one Isolate from a different thread without proper synchronization or a dedicated Isolate per thread.

内容的提问来源于stack exchange，提问作者Alex