feat: Persistent and Global (#154)

Author: toyobayashi

.gitignore

@@ -12,3 +12,4 @@ out
 /script/emnapi.zip
 /script/*.cmake
 *.tgz
+temp

packages/emnapi/include/node/emnapi.h

@@ -81,6 +81,17 @@ napi_status emnapi_get_memory_address(napi_env env,
                                       emnapi_ownership* ownership,
                                       bool* runtime_allocated);
 
+EMNAPI_EXTERN void emnapi_debug(
+  const char* file,
+  int lineno,
+  const char* str,
+  void* value,
+  int type
+);
+
+#define DEBUGGER_LOG(str, value, type) \
+  emnapi_debug(__FILE__, __LINE__, str, value, type)
+
 EXTERN_C_END
 
 #endif

packages/emnapi/src/emnapi.ts

@@ -4,6 +4,24 @@ import { from64, makeSetValue, makeGetValue } from 'emscripten:parse-tools'
 import { type MemoryViewDescriptor, type ArrayBufferPointer, emnapiExternalMemory } from './memory'
 import { napi_add_finalizer } from './wrap'
 import { $CHECK_ARG, $PREAMBLE, $CHECK_ENV, $GET_RETURN_STATUS } from './macro'
+import { emnapiString } from './string'
+
+/**
+ * @__sig vpippi
+ */
+export function emnapi_debug (file: number, lineno: number, str: number, ptr: Ptr, type: number) {
+  from64('str')
+  from64('file')
+  const string = str ? emnapiString.UTF8ToString(str, -1) : ''
+  const message = `[emnapi_debug] ${emnapiString.UTF8ToString(file, -1)}:${lineno} ${string} ${ptr}`
+  const logArgs: any[] = [message]
+  if (ptr) {
+    logArgs.push(type === 1 ? emnapiCtx.getRef(ptr)?.persistent : emnapiCtx.jsValueFromNapiValue(ptr))
+  }
+  console.log(...logArgs)
+  // eslint-disable-next-line no-debugger
+  debugger
+}
 
 /**
  * @__sig ipippppp

packages/emnapi/src/v8/internal.cc

@@ -6,6 +6,10 @@ namespace v8 {
 extern "C" {
   V8_EXTERN internal::Address _v8_globalize_reference(
     internal::Isolate* isolate, internal::Address value);
+  V8_EXTERN internal::Address _v8_copy_global_reference(internal::Address from);
+  V8_EXTERN internal::Address _v8_local_from_global_reference(internal::Address ref);
+  V8_EXTERN void _v8_move_global_reference(internal::Address from,
+                                           internal::Address to);
   V8_EXTERN void _v8_dispose_global(internal::Address global_handle);
   V8_EXTERN void _v8_make_weak(internal::Address location,
                                void* data,
@@ -64,6 +68,24 @@ void DisposeGlobal(internal::Address* global_handle) {
   delete global_handle;
 }
 
+internal::Address* CopyGlobalReference(internal::Address* from) {
+  internal::Address ref_id = _v8_copy_global_reference(*from);
+  return new internal::Address(ref_id);
+}
+
+internal::Address LocalFromGlobalReference(internal::Address global_handle) {
+  return _v8_local_from_global_reference(global_handle);
+}
+
+void MoveGlobalReference(internal::Address** from, internal::Address** to) {
+  if (*from == *to) {
+    return;
+  }
+  *to = *from;
+  *from = nullptr;
+  // _v8_move_global_reference(**from, **to);
+}
+
 namespace {
 static void WeakCallback(WeakCallbackInfo<void>::Callback weak_callback,
                          void* data,

packages/emnapi/src/v8/internal.ts

@@ -1,5 +1,16 @@
 import { from64, makeDynCall } from 'emscripten:parse-tools'
 
+/**
+ * @__deps $emnapiCtx
+ * @__sig pp
+ */
+export function _v8_local_from_global_reference (ref: Ptr): Ptr {
+  const reference = emnapiCtx.getRef(ref)
+  if (reference === undefined) return 1
+  const id = reference.get(emnapiCtx)
+  return id || 1
+}
+
 /**
  * @__deps $emnapiCtx
  * @__sig ppp
@@ -10,6 +21,27 @@ export function _v8_globalize_reference (isolate: Ptr, value: Ptr): Ptr {
   return emnapiCtx.createReference(undefined, jsValue, 1, ReferenceOwnership.kUserland as any).id
 }
 
+/**
+ * @__deps $emnapiCtx
+ * @__sig pp
+ */
+export function _v8_copy_global_reference (from: Ptr): Ptr {
+  const ref = emnapiCtx.getRef(from)
+  if (ref === undefined) return 0
+  return ref.copy().id
+}
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig vpp
+ */
+export function _v8_move_global_reference (from: Ptr, to: Ptr): void {
+  const refFrom = emnapiCtx.getRef(from)
+  const refTo = emnapiCtx.getRef(to)
+  if (refFrom === undefined || refTo === undefined) return
+  refFrom.move(refTo)
+}
+
 /**
  * @__deps $emnapiCtx
  * @__sig vp

packages/runtime/src/Context.ts

@@ -212,7 +212,7 @@ export class Context {
     ownership: ReferenceOwnership
   ): Reference {
     return Reference.create(
-      this.getCurrentScope(),
+      this,
       envObject,
       handle_id,
       initialRefcount,
@@ -228,7 +228,7 @@ export class Context {
     data: void_p
   ): Reference {
     return ReferenceWithData.create(
-      this.getCurrentScope(),
+      this,
       envObject,
       handle_id,
       initialRefcount,
@@ -247,7 +247,7 @@ export class Context {
     finalize_hint: void_p = 0
   ): Reference {
     return ReferenceWithFinalizer.create(
-      this.getCurrentScope(),
+      this,
       envObject,
       handle_id,
       initialRefcount,
@@ -495,6 +495,10 @@ export class Context {
     return this.handleStore.deepDeref(napiValue)
   }
 
+  public deleteHandle (napiValue: number | bigint): void {
+    this.handleStore.dealloc(napiValue)
+  }
+
   public isExternal (value: unknown): boolean {
     return isExternal(value)
   }

packages/runtime/src/Finalizer.ts

@@ -12,6 +12,29 @@ export class Finalizer {
     this._makeDynCall_vppp = envObject.makeDynCall_vppp
   }
 
+  public copy (): Finalizer {
+    const newFina: Finalizer = Object.create(Finalizer.prototype)
+    newFina.envObject = this.envObject
+    newFina._makeDynCall_vppp = this._makeDynCall_vppp
+    newFina._finalizeCallback = this._finalizeCallback
+    newFina._finalizeData = this._finalizeData
+    newFina._finalizeHint = this._finalizeHint
+    return newFina
+  }
+
+  public move (target: Finalizer): void {
+    target._finalizeCallback = this._finalizeCallback
+    target._finalizeData = this._finalizeData
+    target._finalizeHint = this._finalizeHint
+    target.envObject = this.envObject
+    target._makeDynCall_vppp = this._makeDynCall_vppp
+
+    this._finalizeCallback = 0
+    this._finalizeData = 0
+    this._finalizeHint = 0
+    this.dispose()
+  }
+
   public callback (): napi_finalize { return this._finalizeCallback }
   public data (): void_p { return this._finalizeData }
   public hint (): void_p { return this._finalizeHint }

packages/runtime/src/RefTracker.ts

@@ -7,8 +7,8 @@ export class RefTracker extends Disposable {
   /** @virtual */
   public finalize (): void {}
 
-  private _next: RefTracker | null = null
-  private _prev: RefTracker | null = null
+  protected _next: RefTracker | null = null
+  protected _prev: RefTracker | null = null
 
   public link (list: RefTracker): void {
     this._prev = list