ffi 1.15.4 → 1.16.3

data/ext/ffi_c/FunctionInfo.c

@@ -51,8 +51,24 @@
 
 static VALUE fntype_allocate(VALUE klass);
 static VALUE fntype_initialize(int argc, VALUE* argv, VALUE self);
-static void fntype_mark(FunctionType*);
-static void fntype_free(FunctionType *);
+static void fntype_mark(void *);
+static void fntype_compact(void *);
+static void fntype_free(void *);
+static size_t fntype_memsize(const void *);
+
+const rb_data_type_t rbffi_fntype_data_type = { /* extern */
+    .wrap_struct_name = "FFI::FunctionType",
+    .function = {
+        .dmark = fntype_mark,
+        .dfree = fntype_free,
+        .dsize = fntype_memsize,
+        ffi_compact_callback( fntype_compact )
+    },
+    .parent = &rbffi_type_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
 
 VALUE rbffi_FunctionTypeClass = Qnil;
 
@@ -60,13 +76,13 @@ static VALUE
 fntype_allocate(VALUE klass)
 {
     FunctionType* fnInfo;
-    VALUE obj = Data_Make_Struct(klass, FunctionType, fntype_mark, fntype_free, fnInfo);
+    VALUE obj = TypedData_Make_Struct(klass, FunctionType, &rbffi_fntype_data_type, fnInfo);
 
     fnInfo->type.ffiType = &ffi_type_pointer;
     fnInfo->type.nativeType = NATIVE_FUNCTION;
-    fnInfo->rbReturnType = Qnil;
-    fnInfo->rbParameterTypes = Qnil;
-    fnInfo->rbEnums = Qnil;
+    RB_OBJ_WRITE(obj, &fnInfo->rbReturnType, Qnil);
+    RB_OBJ_WRITE(obj, &fnInfo->rbParameterTypes, Qnil);
+    RB_OBJ_WRITE(obj, &fnInfo->rbEnums, Qnil);
     fnInfo->invoke = rbffi_CallFunction;
     fnInfo->closurePool = NULL;
 
@@ -74,19 +90,39 @@ fntype_allocate(VALUE klass)
 }
 
 static void
-fntype_mark(FunctionType* fnInfo)
+fntype_mark(void *data)
 {
-    rb_gc_mark(fnInfo->rbReturnType);
-    rb_gc_mark(fnInfo->rbParameterTypes);
-    rb_gc_mark(fnInfo->rbEnums);
+    FunctionType *fnInfo = (FunctionType *)data;
+    rb_gc_mark_movable(fnInfo->rbReturnType);
+    rb_gc_mark_movable(fnInfo->rbParameterTypes);
+    rb_gc_mark_movable(fnInfo->rbEnums);
     if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
-        rb_gc_mark_locations(&fnInfo->callbackParameters[0], &fnInfo->callbackParameters[fnInfo->callbackCount]);
+        size_t index;
+        for (index = 0; index < fnInfo->callbackCount; index++) {
+            rb_gc_mark_movable(fnInfo->callbackParameters[index]);
+        }
+    }
+}
+
+static void
+fntype_compact(void *data)
+{
+    FunctionType *fnInfo = (FunctionType *)data;
+    ffi_gc_location(fnInfo->rbReturnType);
+    ffi_gc_location(fnInfo->rbParameterTypes);
+    ffi_gc_location(fnInfo->rbEnums);
+    if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
+        size_t index;
+        for (index = 0; index < fnInfo->callbackCount; index++) {
+            ffi_gc_location(fnInfo->callbackParameters[index]);
+        }
     }
 }
 
 static void
-fntype_free(FunctionType* fnInfo)
+fntype_free(void *data)
 {
+    FunctionType *fnInfo = (FunctionType *)data;
     xfree(fnInfo->parameterTypes);
     xfree(fnInfo->ffiParameterTypes);
     xfree(fnInfo->nativeParameterTypes);
@@ -97,6 +133,23 @@ fntype_free(FunctionType* fnInfo)
     xfree(fnInfo);
 }
 
+static size_t
+fntype_memsize(const void *data)
+{
+    const FunctionType *fnInfo = (const FunctionType *)data;
+
+    size_t memsize = sizeof(FunctionType);
+    memsize += fnInfo->callbackCount * sizeof(VALUE);
+
+    memsize += fnInfo->parameterCount * (
+        sizeof(*fnInfo->parameterTypes)
+        + sizeof(ffi_type *)
+        + sizeof(*fnInfo->nativeParameterTypes)
+    );
+
+    return memsize;
+}
+
 /*
  * call-seq: initialize(return_type, param_types, options={})
  * @param [Type, Symbol] return_type return type for the function
@@ -129,13 +182,13 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
     Check_Type(rbParamTypes, T_ARRAY);
 
-    Data_Get_Struct(self, FunctionType, fnInfo);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, fnInfo);
     fnInfo->parameterCount = (int) RARRAY_LEN(rbParamTypes);
     fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes));
     fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *));
     fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes));
-    fnInfo->rbParameterTypes = rb_ary_new2(fnInfo->parameterCount);
-    fnInfo->rbEnums = rbEnums;
+    RB_OBJ_WRITE(self, &fnInfo->rbParameterTypes, rb_ary_new2(fnInfo->parameterCount));
+    RB_OBJ_WRITE(self, &fnInfo->rbEnums, rbEnums);
     fnInfo->blocking = RTEST(rbBlocking);
     fnInfo->hasStruct = false;
 
@@ -150,7 +203,8 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
         if (rb_obj_is_kind_of(type, rbffi_FunctionTypeClass)) {
             REALLOC_N(fnInfo->callbackParameters, VALUE, fnInfo->callbackCount + 1);
-            fnInfo->callbackParameters[fnInfo->callbackCount++] = type;
+            RB_OBJ_WRITE(self, &fnInfo->callbackParameters[fnInfo->callbackCount], type);
+            fnInfo->callbackCount++;
         }
 
         if (rb_obj_is_kind_of(type, rbffi_StructByValueClass)) {
@@ -158,12 +212,12 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
         }
 
         rb_ary_push(fnInfo->rbParameterTypes, type);
-        Data_Get_Struct(type, Type, fnInfo->parameterTypes[i]);
+        TypedData_Get_Struct(type, Type, &rbffi_type_data_type, fnInfo->parameterTypes[i]);
         fnInfo->ffiParameterTypes[i] = fnInfo->parameterTypes[i]->ffiType;
         fnInfo->nativeParameterTypes[i] = fnInfo->parameterTypes[i]->nativeType;
     }
 
-    fnInfo->rbReturnType = rbffi_Type_Lookup(rbReturnType);
+    RB_OBJ_WRITE(self, &fnInfo->rbReturnType, rbffi_Type_Lookup(rbReturnType));
     if (!RTEST(fnInfo->rbReturnType)) {
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
@@ -173,7 +227,7 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
         fnInfo->hasStruct = true;
     }
 
-    Data_Get_Struct(fnInfo->rbReturnType, Type, fnInfo->returnType);
+    TypedData_Get_Struct(fnInfo->rbReturnType, Type, &rbffi_type_data_type, fnInfo->returnType);
     fnInfo->ffiReturnType = fnInfo->returnType->ffiType;
 
 #if defined(X86_WIN32)
@@ -199,20 +253,22 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
     fnInfo->invoke = rbffi_GetInvoker(fnInfo);
 
+    rb_obj_freeze(fnInfo->rbParameterTypes);
+    rb_obj_freeze(self);
     return self;
 }
 
 /*
- * call-seq: result_type
+ * call-seq: return_type
  * @return [Type]
  * Get the return type of the function type
  */
 static VALUE
-fntype_result_type(VALUE self)
+fntype_return_type(VALUE self)
 {
     FunctionType* ft;
 
-    Data_Get_Struct(self, FunctionType, ft);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
 
     return ft->rbReturnType;
 }
@@ -227,7 +283,7 @@ fntype_param_types(VALUE self)
 {
     FunctionType* ft;
 
-    Data_Get_Struct(self, FunctionType, ft);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
 
     return rb_ary_dup(ft->rbParameterTypes);
 }
@@ -259,7 +315,7 @@ rbffi_FunctionInfo_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate);
     rb_define_method(rbffi_FunctionTypeClass, "initialize", fntype_initialize, -1);
-    rb_define_method(rbffi_FunctionTypeClass, "result_type", fntype_result_type, 0);
+    rb_define_method(rbffi_FunctionTypeClass, "return_type", fntype_return_type, 0);
     rb_define_method(rbffi_FunctionTypeClass, "param_types", fntype_param_types, 0);
 
 }

data/ext/ffi_c/LastError.c

@@ -91,30 +91,49 @@ thread_data_free(void *ptr)
 }
 
 #else
+static size_t
+thread_data_memsize(const void *data) {
+    return sizeof(ThreadData);
+}
+
+static const rb_data_type_t thread_data_data_type = {
+    .wrap_struct_name = "FFI::ThreadData",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = thread_data_memsize,
+    },
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static ID id_thread_data;
 
 static ThreadData*
 thread_data_init(void)
 {
-    ThreadData* td;
+    ThreadData *td;
     VALUE obj;
 
-    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
+    obj = TypedData_Make_Struct(rb_cObject, ThreadData, &thread_data_data_type, td);
     rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);
 
     return td;
 }
 
 static inline ThreadData*
-thread_data_get()
+thread_data_get(void)
 {
     VALUE obj = rb_thread_local_aref(rb_thread_current(), id_thread_data);
 
-    if (obj != Qnil && TYPE(obj) == T_DATA) {
-        return (ThreadData *) DATA_PTR(obj);
+    if (NIL_P(obj)) {
+        return thread_data_init();
     }
 
-    return thread_data_init();
+    ThreadData *td;
+    TypedData_Get_Struct(obj, ThreadData, &thread_data_data_type, td);
+    return td;
 }
 
 #endif
@@ -154,7 +173,6 @@ get_last_winapi_error(VALUE self)
 static VALUE
 set_last_error(VALUE self, VALUE error)
 {
-
 #ifdef _WIN32
     SetLastError(NUM2INT(error));
 #else

data/ext/ffi_c/MappedType.c

@@ -31,6 +31,7 @@
 
 #include <ffi.h>
 #include "rbffi.h"
+#include "compat.h"
 
 #include "Type.h"
 #include "MappedType.h"
@@ -38,24 +39,41 @@
 
 static VALUE mapped_allocate(VALUE);
 static VALUE mapped_initialize(VALUE, VALUE);
-static void mapped_mark(MappedType *);
+static void mapped_mark(void *);
+static void mapped_compact(void *);
+static size_t mapped_memsize(const void *);
 static ID id_native_type, id_to_native, id_from_native;
 
 VALUE rbffi_MappedTypeClass = Qnil;
 
+static const rb_data_type_t mapped_type_data_type = {
+  .wrap_struct_name = "FFI::Type::Mapped",
+  .function = {
+      .dmark = mapped_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = mapped_memsize,
+      ffi_compact_callback( mapped_compact )
+  },
+  .parent = &rbffi_type_data_type,
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+
 static VALUE
 mapped_allocate(VALUE klass)
 {
     MappedType* m;
 
-    VALUE obj = Data_Make_Struct(klass, MappedType, mapped_mark, -1, m);
+    VALUE obj = TypedData_Make_Struct(klass, MappedType, &mapped_type_data_type, m);
 
-    m->rbConverter = Qnil;
-    m->rbType = Qnil;
+    RB_OBJ_WRITE(obj, &m->rbConverter, Qnil);
+    RB_OBJ_WRITE(obj, &m->rbType, Qnil);
     m->type = NULL;
     m->base.nativeType = NATIVE_MAPPED;
     m->base.ffiType = &ffi_type_void;
-    
+
     return obj;
 }
 
@@ -69,7 +87,7 @@ static VALUE
 mapped_initialize(VALUE self, VALUE rbConverter)
 {
     MappedType* m = NULL;
-    
+
     if (!rb_respond_to(rbConverter, id_native_type)) {
         rb_raise(rb_eNoMethodError, "native_type method not implemented");
     }
@@ -81,25 +99,42 @@ mapped_initialize(VALUE self, VALUE rbConverter)
     if (!rb_respond_to(rbConverter, id_from_native)) {
         rb_raise(rb_eNoMethodError, "from_native method not implemented");
     }
-    
-    Data_Get_Struct(self, MappedType, m);
-    m->rbType = rb_funcall2(rbConverter, id_native_type, 0, NULL);
+
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+    RB_OBJ_WRITE(self, &m->rbType, rb_funcall2(rbConverter, id_native_type, 0, NULL));
     if (!(rb_obj_is_kind_of(m->rbType, rbffi_TypeClass))) {
         rb_raise(rb_eTypeError, "native_type did not return instance of FFI::Type");
     }
 
-    m->rbConverter = rbConverter;
-    Data_Get_Struct(m->rbType, Type, m->type);
+    RB_OBJ_WRITE(self, &m->rbConverter, rbConverter);
+    TypedData_Get_Struct(m->rbType, Type, &rbffi_type_data_type, m->type);
     m->base.ffiType = m->type->ffiType;
-    
+
+    rb_obj_freeze(self);
+
     return self;
 }
 
 static void
-mapped_mark(MappedType* m)
+mapped_mark(void* data)
+{
+    MappedType* m = (MappedType*)data;
+    rb_gc_mark_movable(m->rbType);
+    rb_gc_mark_movable(m->rbConverter);
+}
+
+static void
+mapped_compact(void* data)
 {
-    rb_gc_mark(m->rbType);
-    rb_gc_mark(m->rbConverter);
+    MappedType* m = (MappedType*)data;
+    ffi_gc_location(m->rbType);
+    ffi_gc_location(m->rbConverter);
+}
+
+static size_t
+mapped_memsize(const void *data)
+{
+    return sizeof(MappedType);
 }
 
 /*
@@ -111,7 +146,7 @@ static VALUE
 mapped_native_type(VALUE self)
 {
     MappedType*m = NULL;
-    Data_Get_Struct(self, MappedType, m);
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
 
     return m->rbType;
 }
@@ -124,9 +159,8 @@ static VALUE
 mapped_to_native(int argc, VALUE* argv, VALUE self)
 {
     MappedType*m = NULL;
-    
-    Data_Get_Struct(self, MappedType, m);
-    
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+
     return rb_funcall2(m->rbConverter, id_to_native, argc, argv);
 }
 
@@ -138,20 +172,28 @@ static VALUE
 mapped_from_native(int argc, VALUE* argv, VALUE self)
 {
     MappedType*m = NULL;
-    
-    Data_Get_Struct(self, MappedType, m);
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
 
     return rb_funcall2(m->rbConverter, id_from_native, argc, argv);
 }
 
+static VALUE
+mapped_converter(VALUE self)
+{
+    MappedType*m = NULL;
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+
+    return m->rbConverter;
+}
+
 void
 rbffi_MappedType_Init(VALUE moduleFFI)
 {
-    /* 
+    /*
      * Document-class: FFI::Type::Mapped < FFI::Type
      */
     rbffi_MappedTypeClass = rb_define_class_under(rbffi_TypeClass, "Mapped", rbffi_TypeClass);
-    
+
     rb_global_variable(&rbffi_MappedTypeClass);
 
     id_native_type = rb_intern("native_type");
@@ -164,5 +206,6 @@ rbffi_MappedType_Init(VALUE moduleFFI)
     rb_define_method(rbffi_MappedTypeClass, "native_type", mapped_native_type, 0);
     rb_define_method(rbffi_MappedTypeClass, "to_native", mapped_to_native, -1);
     rb_define_method(rbffi_MappedTypeClass, "from_native", mapped_from_native, -1);
+    rb_define_method(rbffi_MappedTypeClass, "converter", mapped_converter, 0);
 }
 

data/ext/ffi_c/MappedType.h

@@ -43,14 +43,12 @@ typedef struct MappedType_ {
     Type* type;
     VALUE rbConverter;
     VALUE rbType;
-    
 } MappedType;
 
 void rbffi_MappedType_Init(VALUE moduleFFI);
 
 extern VALUE rbffi_MappedTypeClass;
 
-
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/MemoryPointer.c

@@ -39,13 +39,14 @@
 
 
 static VALUE memptr_allocate(VALUE klass);
-static void memptr_release(Pointer* ptr);
+static void memptr_release(void *data);
+static size_t memptr_memsize(const void *data);
 static VALUE memptr_malloc(VALUE self, long size, long count, bool clear);
 static VALUE memptr_free(VALUE self);
 
 VALUE rbffi_MemoryPointerClass;
 
-#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, rbffi_MemoryPointerClass))
+#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, &memory_pointer_data_type))
 
 VALUE
 rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
@@ -53,12 +54,25 @@ rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
     return memptr_malloc(memptr_allocate(rbffi_MemoryPointerClass), size, count, clear);
 }
 
+static const rb_data_type_t memory_pointer_data_type = {
+    .wrap_struct_name = "FFI::MemoryPointer",
+    .function = {
+        .dmark = NULL,
+        .dfree = memptr_release,
+        .dsize = memptr_memsize,
+    },
+    .parent = &rbffi_pointer_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
 static VALUE
 memptr_allocate(VALUE klass)
 {
     Pointer* p;
-    VALUE obj = Data_Make_Struct(klass, Pointer, NULL, memptr_release, p);
-    p->rbParent = Qnil;
+    VALUE obj = TypedData_Make_Struct(klass, Pointer, &memory_pointer_data_type, p);
+    RB_OBJ_WRITE(obj, &p->rbParent, Qnil);
     p->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
@@ -94,7 +108,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     Pointer* p;
     unsigned long msize;
 
-    Data_Get_Struct(self, Pointer, p);
+    TypedData_Get_Struct(self, Pointer, &memory_pointer_data_type, p);
 
     msize = size * count;
 
@@ -122,7 +136,8 @@ memptr_free(VALUE self)
 {
     Pointer* ptr;
 
-    Data_Get_Struct(self, Pointer, ptr);
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pointer, &memory_pointer_data_type, ptr);
 
     if (ptr->allocated) {
         if (ptr->storage != NULL) {
@@ -136,8 +151,9 @@ memptr_free(VALUE self)
 }
 
 static void
-memptr_release(Pointer* ptr)
+memptr_release(void *data)
 {
+    Pointer *ptr = (Pointer *)data;
     if (ptr->autorelease && ptr->allocated && ptr->storage != NULL) {
         xfree(ptr->storage);
         ptr->storage = NULL;
@@ -145,6 +161,17 @@ memptr_release(Pointer* ptr)
     xfree(ptr);
 }
 
+static size_t
+memptr_memsize(const void *data)
+{
+    const Pointer *ptr = (const Pointer *)data;
+    size_t memsize = sizeof(Pointer);
+    if (ptr->allocated) {
+        memsize += ptr->memory.size;
+    }
+    return memsize;
+}
+
 /*
  * call-seq: from_string(s)
  * @param [String] s string

data/ext/ffi_c/MethodHandle.c

@@ -77,7 +77,9 @@
 static bool prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
 static long trampoline_size(void);
 
-#if defined(__x86_64__) && (defined(__linux__) || defined(__APPLE__))
+#if defined(__x86_64__) && \
+    (defined(__linux__) || defined(__APPLE__)) && \
+    !USE_FFI_ALLOC
 # define CUSTOM_TRAMPOLINE 1
 #endif