ffi 1.15.4 → 1.16.3

data/ext/ffi_c/Type.c

@@ -14,7 +14,7 @@
  *     * Neither the name of the Ruby FFI project nor the
  *       names of its contributors may be used to endorse or promote products
  *       derived from this software without specific prior written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -33,36 +33,74 @@
 
 #include <sys/types.h>
 #include <ruby.h>
+#if HAVE_RB_EXT_RACTOR_SAFE
+#include <ruby/ractor.h>
+#endif
 #include <ffi.h>
 #include "rbffi.h"
 #include "compat.h"
 #include "Types.h"
 #include "Type.h"
 
+static size_t type_memsize(const void *);
 
 typedef struct BuiltinType_ {
     Type type;
-    char* name;
+    const char* name;
 } BuiltinType;
 
-static void builtin_type_free(BuiltinType *);
+static size_t builtin_type_memsize(const void *);
 
 VALUE rbffi_TypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
 static VALUE moduleNativeType = Qnil;
-static VALUE typeMap = Qnil, sizeMap = Qnil;
-static ID id_find_type = 0, id_type_size = 0, id_size = 0;
+static VALUE typeMap = Qnil;
+static ID id_type_size = 0, id_size = 0;
+#if HAVE_RB_EXT_RACTOR_SAFE
+static rb_ractor_local_key_t custom_typedefs_key;
+#endif
+
+const rb_data_type_t rbffi_type_data_type = { /* extern */
+  .wrap_struct_name = "FFI::Type",
+  .function = {
+      .dmark = NULL,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = type_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 | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+static const rb_data_type_t builtin_type_data_type = {
+  .wrap_struct_name = "FFI::Type::Builtin",
+  .function = {
+      .dmark = NULL,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = builtin_type_memsize,
+  },
+  .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 size_t
+type_memsize(const void *data)
+{
+    return sizeof(Type);
+}
 
 static VALUE
 type_allocate(VALUE klass)
 {
     Type* type;
-    VALUE obj = Data_Make_Struct(klass, Type, NULL, -1, type);
+    VALUE obj = TypedData_Make_Struct(klass, Type, &rbffi_type_data_type, type);
 
     type->nativeType = -1;
     type->ffiType = &ffi_type_void;
-    
+
     return obj;
 }
 
@@ -78,18 +116,20 @@ type_initialize(VALUE self, VALUE value)
     Type* type;
     Type* other;
 
-    Data_Get_Struct(self, Type, type);
+    TypedData_Get_Struct(self, Type, &rbffi_type_data_type, type);
 
     if (FIXNUM_P(value)) {
         type->nativeType = FIX2INT(value);
     } else if (rb_obj_is_kind_of(value, rbffi_TypeClass)) {
-        Data_Get_Struct(value, Type, other);
+        TypedData_Get_Struct(value, Type, &rbffi_type_data_type, other);
         type->nativeType = other->nativeType;
         type->ffiType = other->ffiType;
     } else {
         rb_raise(rb_eArgError, "wrong type");
     }
-    
+
+    rb_obj_freeze(self);
+
     return self;
 }
 
@@ -103,7 +143,7 @@ type_size(VALUE self)
 {
     Type *type;
 
-    Data_Get_Struct(self, Type, type);
+    TypedData_Get_Struct(self, Type, &rbffi_type_data_type, type);
 
     return INT2FIX(type->ffiType->size);
 }
@@ -118,7 +158,7 @@ type_alignment(VALUE self)
 {
     Type *type;
 
-    Data_Get_Struct(self, Type, type);
+    TypedData_Get_Struct(self, Type, &rbffi_type_data_type, type);
 
     return INT2FIX(type->ffiType->alignment);
 }
@@ -134,9 +174,9 @@ type_inspect(VALUE self)
     char buf[100];
     Type *type;
 
-    Data_Get_Struct(self, Type, type);
+    TypedData_Get_Struct(self, Type, &rbffi_type_data_type, type);
 
-    snprintf(buf, sizeof(buf), "#<%s:%p size=%d alignment=%d>",
+    snprintf(buf, sizeof(buf), "#<%s::%p size=%d alignment=%d>",
             rb_obj_classname(self), type, (int) type->ffiType->size, (int) type->ffiType->alignment);
 
     return rb_str_new2(buf);
@@ -148,20 +188,21 @@ builtin_type_new(VALUE klass, int nativeType, ffi_type* ffiType, const char* nam
     BuiltinType* type;
     VALUE obj = Qnil;
 
-    obj = Data_Make_Struct(klass, BuiltinType, NULL, builtin_type_free, type);
-    
-    type->name = strdup(name);
+    obj = TypedData_Make_Struct(klass, BuiltinType, &builtin_type_data_type, type);
+
+    type->name = name;
     type->type.nativeType = nativeType;
     type->type.ffiType = ffiType;
 
+    rb_obj_freeze(obj);
+
     return obj;
 }
 
-static void
-builtin_type_free(BuiltinType *type)
+static size_t
+builtin_type_memsize(const void *data)
 {
-    free(type->name);
-    xfree(type);
+    return sizeof(BuiltinType) + sizeof(ffi_type);
 }
 
 /*
@@ -175,8 +216,8 @@ builtin_type_inspect(VALUE self)
     char buf[100];
     BuiltinType *type;
 
-    Data_Get_Struct(self, BuiltinType, type);
-    snprintf(buf, sizeof(buf), "#<%s:%s size=%d alignment=%d>",
+    TypedData_Get_Struct(self, BuiltinType, &builtin_type_data_type, type);
+    snprintf(buf, sizeof(buf), "#<%s::%s size=%d alignment=%d>",
             rb_obj_classname(self), type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
 
     return rb_str_new2(buf);
@@ -186,21 +227,21 @@ int
 rbffi_type_size(VALUE type)
 {
     int t = TYPE(type);
-    
+
     if (t == T_FIXNUM || t == T_BIGNUM) {
         return NUM2INT(type);
-    
+
     } else if (t == T_SYMBOL) {
         /*
-         * Try looking up directly in the type and size maps
+         * Try looking up directly in the type map
          */
         VALUE nType;
         if ((nType = rb_hash_lookup(typeMap, type)) != Qnil) {
             if (rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
                 Type* type;
-                Data_Get_Struct(nType, Type, type);
+                TypedData_Get_Struct(nType, Type, &rbffi_type_data_type, type);
                 return (int) type->ffiType->size;
-            
+
             } else if (rb_respond_to(nType, id_size)) {
                 return NUM2INT(rb_funcall2(nType, id_size, 0, NULL));
             }
@@ -208,26 +249,51 @@ rbffi_type_size(VALUE type)
 
         /* Not found - call up to the ruby version to resolve */
         return NUM2INT(rb_funcall2(rbffi_FFIModule, id_type_size, 1, &type));
-    
+
     } else {
         return NUM2INT(rb_funcall2(type, id_size, 0, NULL));
     }
 }
 
+static VALUE
+custom_typedefs(VALUE self)
+{
+#if HAVE_RB_EXT_RACTOR_SAFE
+    VALUE hash = rb_ractor_local_storage_value(custom_typedefs_key);
+    if (hash == Qnil) {
+        hash = rb_hash_new();
+        rb_ractor_local_storage_value_set(custom_typedefs_key, hash);
+    }
+#else
+    static VALUE hash = Qundef;
+    if (hash == Qundef) {
+        rb_global_variable(&hash);
+        hash = rb_hash_new();
+    }
+#endif
+    return hash;
+}
+
 VALUE
 rbffi_Type_Lookup(VALUE name)
 {
     int t = TYPE(name);
     if (t == T_SYMBOL || t == T_STRING) {
         /*
-         * Try looking up directly in the type Map
+         * Try looking up directly in the type map
          */
         VALUE nType;
+        VALUE cust = custom_typedefs(Qnil);
+
+        if ((nType = rb_hash_lookup(cust, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+            return nType;
+        }
+
         if ((nType = rb_hash_lookup(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
             return nType;
         }
     } else if (rb_obj_is_kind_of(name, rbffi_TypeClass)) {
-    
+
         return name;
     }
 
@@ -251,13 +317,15 @@ rbffi_Type_Init(VALUE moduleFFI)
      * Document-constant: FFI::TypeDefs
      */
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
-    rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
     rb_global_variable(&typeMap);
-    rb_global_variable(&sizeMap);
-    id_find_type = rb_intern("find_type");
     id_type_size = rb_intern("type_size");
     id_size = rb_intern("size");
 
+#if HAVE_RB_EXT_RACTOR_SAFE
+    custom_typedefs_key = rb_ractor_local_storage_value_newkey();
+#endif
+    rb_define_module_function(moduleFFI, "custom_typedefs", custom_typedefs, 0);
+
     /*
      * Document-class: FFI::Type::Builtin
      * Class for Built-in types.
@@ -297,7 +365,7 @@ rbffi_Type_Init(VALUE moduleFFI)
      * * BUFFER_OUT
      * * VARARGS (function takes a variable number of arguments)
      *
-     * All these constants are exported to {FFI} module prefixed with "TYPE_". 
+     * All these constants are exported to {FFI} module prefixed with "TYPE_".
      * They are objets from {FFI::Type::Builtin} class.
      */
     moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
@@ -318,7 +386,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     /* Make Type::Builtin non-allocatable */
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
     rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
-    
+
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
 

data/ext/ffi_c/Type.h

@@ -44,7 +44,7 @@ extern "C" {
 typedef struct Type_ Type;
 
 #include "Types.h"
-    
+
 struct Type_ {
     NativeType nativeType;
     ffi_type* ffiType;
@@ -53,6 +53,8 @@ struct Type_ {
 extern VALUE rbffi_TypeClass;
 extern VALUE rbffi_Type_Lookup(VALUE type);
 
+extern const rb_data_type_t rbffi_type_data_type;
+
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/Types.c

@@ -97,7 +97,7 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
             AbstractMemory* mem;
             VALUE rbMemory = rbffi_MemoryPointer_NewInstance(1, sbv->base.ffiType->size, false);
 
-            Data_Get_Struct(rbMemory, AbstractMemory, mem);
+            TypedData_Get_Struct(rbMemory, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
             memcpy(mem->address, ptr, sbv->base.ffiType->size);
             RB_GC_GUARD(rbMemory);
             RB_GC_GUARD(rbType);

data/ext/ffi_c/Variadic.c

@@ -36,6 +36,9 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <ruby.h>
+#if HAVE_RB_EXT_RACTOR_SAFE
+#include <ruby/ractor.h>
+#endif
 
 #include <ffi.h>
 #include "rbffi.h"
@@ -62,35 +65,65 @@ typedef struct VariadicInvoker_ {
     bool blocking;
 } VariadicInvoker;
 
-
 static VALUE variadic_allocate(VALUE klass);
 static VALUE variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes,
         VALUE rbReturnType, VALUE options);
-static void variadic_mark(VariadicInvoker *);
+static void variadic_mark(void *);
+static void variadic_compact(void *);
+static size_t variadic_memsize(const void *);
 
 static VALUE classVariadicInvoker = Qnil;
 
+static const rb_data_type_t variadic_data_type = {
+  .wrap_struct_name = "FFI::VariadicInvoker",
+  .function = {
+      .dmark = variadic_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = variadic_memsize,
+      ffi_compact_callback( variadic_compact )
+  },
+  // 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
 variadic_allocate(VALUE klass)
 {
     VariadicInvoker *invoker;
-    VALUE obj = Data_Make_Struct(klass, VariadicInvoker, variadic_mark, -1, invoker);
+    VALUE obj = TypedData_Make_Struct(klass, VariadicInvoker, &variadic_data_type, invoker);
 
-    invoker->rbAddress = Qnil;
-    invoker->rbEnums = Qnil;
-    invoker->rbReturnType = Qnil;
+    RB_OBJ_WRITE(obj, &invoker->rbAddress, Qnil);
+    RB_OBJ_WRITE(obj, &invoker->rbEnums, Qnil);
+    RB_OBJ_WRITE(obj, &invoker->rbReturnType, Qnil);
     invoker->blocking = false;
 
     return obj;
 }
 
 static void
-variadic_mark(VariadicInvoker *invoker)
+variadic_mark(void *data)
+{
+    VariadicInvoker *invoker = (VariadicInvoker *)data;
+    rb_gc_mark_movable(invoker->rbEnums);
+    rb_gc_mark_movable(invoker->rbAddress);
+    rb_gc_mark_movable(invoker->rbReturnType);
+}
+
+static void
+variadic_compact(void *data)
 {
-    rb_gc_mark(invoker->rbEnums);
-    rb_gc_mark(invoker->rbAddress);
-    rb_gc_mark(invoker->rbReturnType);
+    VariadicInvoker *invoker = (VariadicInvoker *)data;
+    ffi_gc_location(invoker->rbEnums);
+    ffi_gc_location(invoker->rbAddress);
+    ffi_gc_location(invoker->rbReturnType);
+}
+
+static size_t
+variadic_memsize(const void *data)
+{
+    return sizeof(VariadicInvoker);
 }
 
 static VALUE
@@ -108,10 +141,10 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     Check_Type(options, T_HASH);
     convention = rb_hash_aref(options, ID2SYM(rb_intern("convention")));
 
-    Data_Get_Struct(self, VariadicInvoker, invoker);
-    invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums")));
-    invoker->rbAddress = rbFunction;
-    invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
+    RB_OBJ_WRITE(self, &invoker->rbEnums, rb_hash_aref(options, ID2SYM(rb_intern("enums"))));
+    RB_OBJ_WRITE(self, &invoker->rbAddress, rbFunction);
+    invoker->function = rbffi_AbstractMemory_Cast(rbFunction, &rbffi_pointer_data_type)->address;
     invoker->blocking = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("blocking"))));
 
 #if defined(X86_WIN32)
@@ -122,13 +155,13 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     invoker->abi = FFI_DEFAULT_ABI;
 #endif
 
-    invoker->rbReturnType = rbffi_Type_Lookup(rbReturnType);
+    RB_OBJ_WRITE(self, &invoker->rbReturnType, rbffi_Type_Lookup(rbReturnType));
     if (!RTEST(invoker->rbReturnType)) {
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
     }
 
-    Data_Get_Struct(rbReturnType, Type, invoker->returnType);
+    TypedData_Get_Struct(rbReturnType, Type, &rbffi_type_data_type, invoker->returnType);
 
     invoker->paramCount = -1;
 
@@ -142,7 +175,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
             VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL);
             rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName));
         }
-        Data_Get_Struct(rbType, Type, type);
+        TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, type);
         if (type->nativeType != NATIVE_VARARGS) {
             rb_ary_push(fixed, entry);
         }
@@ -150,7 +183,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     /*
      * @fixed and @type_map are used by the parameter mangling ruby code
      */
-    rb_iv_set(self, "@fixed", fixed);
+    rb_iv_set(self, "@fixed", rb_obj_freeze(fixed));
     rb_iv_set(self, "@type_map", rb_hash_aref(options, ID2SYM(rb_intern("type_map"))));
 
     return retval;
@@ -176,7 +209,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     Check_Type(parameterTypes, T_ARRAY);
     Check_Type(parameterValues, T_ARRAY);
 
-    Data_Get_Struct(self, VariadicInvoker, invoker);
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
     paramCount = (int) RARRAY_LEN(parameterTypes);
     paramTypes = ALLOCA_N(Type *, paramCount);
     ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
@@ -192,25 +225,25 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
         if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
             rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
         }
-        Data_Get_Struct(rbType, Type, paramTypes[i]);
+        TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
 
         switch (paramTypes[i]->nativeType) {
             case NATIVE_INT8:
             case NATIVE_INT16:
             case NATIVE_INT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("INT32"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
                 break;
             case NATIVE_UINT8:
             case NATIVE_UINT16:
             case NATIVE_UINT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("UINT32"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
                 break;
 
             case NATIVE_FLOAT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("DOUBLE"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
                 break;
 
             case NATIVE_FUNCTION:
@@ -288,6 +321,14 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval);
 }
 
+static VALUE
+variadic_return_type(VALUE self)
+{
+    VariadicInvoker* invoker;
+
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
+    return invoker->rbReturnType;
+}
 
 void
 rbffi_Variadic_Init(VALUE moduleFFI)
@@ -299,5 +340,6 @@ rbffi_Variadic_Init(VALUE moduleFFI)
 
     rb_define_method(classVariadicInvoker, "initialize", variadic_initialize, 4);
     rb_define_method(classVariadicInvoker, "invoke", variadic_invoke, 2);
+    rb_define_method(classVariadicInvoker, "return_type", variadic_return_type, 0);
 }
 

data/ext/ffi_c/compat.h

@@ -32,26 +32,6 @@
 
 #include <ruby.h>
 
-#ifndef RARRAY_LEN
-#  define RARRAY_LEN(ary) RARRAY(ary)->len
-#endif
-
-#ifndef RARRAY_PTR
-#  define RARRAY_PTR(ary) RARRAY(ary)->ptr
-#endif
-
-#ifndef RSTRING_LEN
-#  define RSTRING_LEN(s) RSTRING(s)->len
-#endif
-
-#ifndef RSTRING_PTR
-#  define RSTRING_PTR(s) RSTRING(s)->ptr
-#endif
-
-#ifndef NUM2ULL
-#  define NUM2ULL(x) rb_num2ull((VALUE)x)
-#endif
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
@@ -75,8 +55,28 @@
 #  define MIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
-#ifndef RB_GC_GUARD
-#  define RB_GC_GUARD(x) (x)
+
+
+/* For compatibility with ruby < 2.7 */
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define ffi_compact_callback(x) .dcompact = (x),
+#define ffi_gc_location(x) x = rb_gc_location(x)
+#else
+#define rb_gc_mark_movable(x) rb_gc_mark(x)
+#define ffi_compact_callback(x)
+#define ffi_gc_location(x)
+#endif
+
+
+/* For compatibility with ruby < 3.0 */
+#ifndef RUBY_TYPED_FROZEN_SHAREABLE
+#define FFI_RUBY_TYPED_FROZEN_SHAREABLE 0
+#else
+#define FFI_RUBY_TYPED_FROZEN_SHAREABLE RUBY_TYPED_FROZEN_SHAREABLE
+#endif
+
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#define rb_ractor_make_shareable(self) rb_obj_freeze(self);
 #endif
 
 #endif /* RBFFI_COMPAT_H */

data/ext/ffi_c/extconf.rb

@@ -33,7 +33,11 @@ if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   $CFLAGS.gsub!(/[\s+]-ansi/, '')
   $CFLAGS.gsub!(/[\s+]-std=[^\s]+/, '')
   # solaris 10 needs -c99 for <stdbool.h>
-  $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
+  $CFLAGS << " -g -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
+  if enable_config("debug")
+    $CPPFLAGS += " #{RbConfig::CONFIG["debugflags"]}"
+    $LDFLAGS += " #{RbConfig::CONFIG["debugflags"]}"
+  end
 
   # Check whether we use system libffi
   system_libffi = enable_config('system-libffi', :try)
@@ -57,10 +61,13 @@ if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
     append_ldflags "-Wl,--exclude-libs,ALL"
   end
 
+  have_func 'rb_gc_mark_movable' # since ruby-2.7
+
   # Some linux archs need explicit linking to pthread, see https://github.com/ffi/ffi/issues/893
   append_ldflags "-pthread"
 
   ffi_alloc_default = RbConfig::CONFIG['host_os'] =~ /darwin/i && RbConfig::CONFIG['host'] =~ /arm|aarch64/i
+  ffi_alloc_default = ffi_alloc_default || RbConfig::CONFIG['host'] =~ /hppa/i
   if enable_config('libffi-alloc', ffi_alloc_default)
     $defs << "-DUSE_FFI_ALLOC"
   end
@@ -72,7 +79,17 @@ if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
 
   unless system_libffi
     File.open("Makefile", "a") do |mf|
-      mf.puts "LIBFFI_HOST=--host=#{RbConfig::CONFIG['host_alias']}" if RbConfig::CONFIG.has_key?("host_alias")
+      if enable_config("debug")
+        mf.puts "LIBFFI_DEBUG=--enable-debug CPPFLAGS='#{RbConfig::CONFIG["debugflags"]}' LDFLAGS='#{RbConfig::CONFIG["debugflags"]}'"
+      end
+
+      if RbConfig::CONFIG['host_alias'] == "i386-w64-mingw32"
+        host = "i686-w64-mingw32" # Work around host name without matching compiler name in rake-compiler-dock-1.3.0 on platform x86-mingw32
+      elsif RbConfig::CONFIG.has_key?("host_alias")
+        host = RbConfig::CONFIG['host_alias']
+      end
+      mf.puts "LIBFFI_HOST=--host=#{host}" if host
+
       if RbConfig::CONFIG['host_os'] =~ /darwin/i
         if RbConfig::CONFIG['host'] =~ /arm|aarch64/i
           mf.puts "LIBFFI_HOST=--host=aarch64-apple-#{RbConfig::CONFIG['host_os']}"

data/ext/ffi_c/ffi.c

@@ -60,6 +60,10 @@ static VALUE moduleFFI = Qnil;
 void
 Init_ffi_c(void)
 {
+    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+        rb_ext_ractor_safe(1);
+    #endif
+
     /*
      * Document-module: FFI
      *

data/ext/ffi_c/libffi/.appveyor/site.exp

@@ -0,0 +1,16 @@
+# Copyright (C) 2021  Anthony Green
+
+lappend boards_dir $::env(SITEDIR)
+
+verbose "Global Config File: target_triplet is $target_triplet" 1
+global target_list
+
+case "$target_triplet" in {
+    { "aarch*cygwin*" } {
+	set target_list "unix-noexec"
+    }
+    { "arm*cygwin*" } {
+	set target_list "unix-noexec"
+    }
+}
+

data/ext/ffi_c/libffi/.appveyor/unix-noexec.exp

@@ -0,0 +1,7 @@
+load_generic_config "remote"
+
+proc noexec_load { dest prog args } {
+  return "unsupported"  
+}
+
+set_board_info protocol "noexec"