ffi 1.11.1 → 1.15.5

data/ext/ffi_c/Function.c

@@ -37,15 +37,8 @@
 #endif
 
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# if !defined(INT8_MIN)
-#  include "win32/stdint.h"
-# endif
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ruby/thread.h>
 
@@ -88,8 +81,8 @@ static VALUE function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc);
 static void callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
 static bool callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
 static void* callback_with_gvl(void* data);
-static VALUE invoke_callback(void* data);
-static VALUE save_callback_exception(void* data, VALUE exc);
+static VALUE invoke_callback(VALUE data);
+static VALUE save_callback_exception(VALUE data, VALUE exc);
 
 #define DEFER_ASYNC_CALLBACK 1
 
@@ -99,26 +92,8 @@ static VALUE async_cb_event(void *);
 static VALUE async_cb_call(void *);
 #endif
 
-#ifdef HAVE_RUBY_THREAD_HAS_GVL_P
 extern int ruby_thread_has_gvl_p(void);
-#define rbffi_thread_has_gvl_p(frame) ruby_thread_has_gvl_p()
-#else
-static int rbffi_thread_has_gvl_p(rbffi_frame_t *frame)
-{
-    return frame != NULL && frame->has_gvl;
-}
-#endif
-
-#ifdef HAVE_RUBY_NATIVE_THREAD_P
 extern int ruby_native_thread_p(void);
-#define rbffi_native_thread_p(frame) ruby_native_thread_p()
-#else
-static int rbffi_native_thread_p(rbffi_frame_t *frame)
-{
-    return frame != NULL;
-}
-#endif
-
 
 VALUE rbffi_FunctionClass = Qnil;
 
@@ -274,11 +249,11 @@ VALUE
 rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
 {
     VALUE callback, cbref, cbTable;
-    Function* fp;
 
     cbref = RTEST(rb_ivar_defined(proc, id_cb_ref)) ? rb_ivar_get(proc, id_cb_ref) : Qnil;
     /* If the first callback reference has the same function function signature, use it */
     if (cbref != Qnil && CLASS_OF(cbref) == rbffi_FunctionClass) {
+        Function* fp;
         Data_Get_Struct(cbref, Function, fp);
         if (fp->rbFunctionInfo == rbFunctionInfo) {
             return cbref;
@@ -297,14 +272,27 @@ rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
         rb_ivar_set(proc, id_cb_ref, callback);
     } else {
         /* The proc instance has been used as more than one type of callback, store extras in a hash */
-        cbTable = rb_hash_new();
-        rb_ivar_set(proc, id_cbtable, cbTable);
+        if(cbTable == Qnil) {
+          cbTable = rb_hash_new();
+          rb_ivar_set(proc, id_cbtable, cbTable);
+        }
         rb_hash_aset(cbTable, rbFunctionInfo, callback);
     }
 
     return callback;
 }
 
+#if !defined(_WIN32) && defined(DEFER_ASYNC_CALLBACK)
+static void
+after_fork_callback(void)
+{
+    /* Ensure that a new dispatcher thread is started in a forked process */
+    async_cb_thread = Qnil;
+    pthread_mutex_init(&async_cb_mutex, NULL);
+    pthread_cond_init(&async_cb_cond, NULL);
+}
+#endif
+
 static VALUE
 function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 {
@@ -332,7 +320,16 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 
 #if defined(DEFER_ASYNC_CALLBACK)
         if (async_cb_thread == Qnil) {
+
+#if !defined(_WIN32)
+            if( pthread_atfork(NULL, NULL, after_fork_callback) ){
+                rb_warn("FFI: unable to register fork callback");
+            }
+#endif
+
             async_cb_thread = rb_thread_create(async_cb_event, NULL);
+            /* Name thread, for better debugging */
+            rb_funcall(async_cb_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Dispatcher"));
         }
 #endif
 
@@ -476,8 +473,8 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 
     if (cb.frame != NULL) cb.frame->exc = Qnil;
 
-    if (rbffi_native_thread_p(cb.frame)) {
-      if(rbffi_thread_has_gvl_p(cb.frame)) {
+    if (ruby_native_thread_p()) {
+      if(ruby_thread_has_gvl_p()) {
         callback_with_gvl(&cb);
       } else {
         rb_thread_call_with_gvl(callback_with_gvl, &cb);
@@ -548,7 +545,9 @@ async_cb_event(void* unused)
         rb_thread_call_without_gvl(async_cb_wait, &w, async_cb_stop, &w);
         if (w.cb != NULL) {
             /* Start up a new ruby thread to run the ruby callback */
-            rb_thread_create(async_cb_call, w.cb);
+            VALUE new_thread = rb_thread_create(async_cb_call, w.cb);
+            /* Name thread, for better debugging */
+            rb_funcall(new_thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Runner"));
         }
     }
 
@@ -658,7 +657,7 @@ callback_with_gvl(void* data)
 }
 
 static VALUE
-invoke_callback(void* data)
+invoke_callback(VALUE data)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
 
@@ -721,10 +720,10 @@ invoke_callback(void* data)
                 param = rb_float_new(*(double *) parameters[i]);
                 break;
             case NATIVE_LONGDOUBLE:
-	      param = rbffi_longdouble_new(*(long double *) parameters[i]);
+                param = rbffi_longdouble_new(*(long double *) parameters[i]);
                 break;
             case NATIVE_STRING:
-                param = (*(void **) parameters[i] != NULL) ? rb_tainted_str_new2(*(char **) parameters[i]) : Qnil;
+                param = (*(void **) parameters[i] != NULL) ? rb_str_new2(*(char **) parameters[i]) : Qnil;
                 break;
             case NATIVE_POINTER:
                 param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
@@ -734,7 +733,6 @@ invoke_callback(void* data)
                 break;
 
             case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
             case NATIVE_STRUCT:
                 param = rbffi_NativeValue_ToRuby(paramType, rbParamType, parameters[i]);
                 break;
@@ -793,6 +791,9 @@ invoke_callback(void* data)
         case NATIVE_FLOAT64:
             *((double *) retval) = NUM2DBL(rbReturnValue);
             break;
+        case NATIVE_LONGDOUBLE:
+            *((long double *) retval) = rbffi_num2longdouble(rbReturnValue);
+            break;
         case NATIVE_POINTER:
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
@@ -807,7 +808,6 @@ invoke_callback(void* data)
             break;
 
         case NATIVE_FUNCTION:
-        case NATIVE_CALLBACK:
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
 
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
@@ -848,7 +848,7 @@ invoke_callback(void* data)
 }
 
 static VALUE
-save_callback_exception(void* data, VALUE exc)
+save_callback_exception(VALUE data, VALUE exc)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
 
@@ -864,9 +864,9 @@ callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errm
     FunctionType* fnInfo = (FunctionType *) ctx;
     ffi_status ffiStatus;
 
-    ffiStatus = ffi_prep_closure(code, &fnInfo->ffi_cif, callback_invoke, closure);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &fnInfo->ffi_cif, callback_invoke, closure, code);
     if (ffiStatus != FFI_OK) {
-        snprintf(errmsg, errmsgsize, "ffi_prep_closure failed.  status=%#x", ffiStatus);
+        snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;
     }
 

data/ext/ffi_c/Function.h

@@ -34,11 +34,7 @@
 extern "C" {
 #endif
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #include <ffi.h>
 

data/ext/ffi_c/FunctionInfo.c

@@ -33,12 +33,8 @@
 #include <sys/types.h>
 #include <stdio.h>
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 
 #include <errno.h>
 #include <ruby.h>
@@ -172,7 +168,7 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
     }
-    
+
     if (rb_obj_is_kind_of(fnInfo->rbReturnType, rbffi_StructByValueClass)) {
         fnInfo->hasStruct = true;
     }
@@ -180,7 +176,6 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
     Data_Get_Struct(fnInfo->rbReturnType, Type, fnInfo->returnType);
     fnInfo->ffiReturnType = fnInfo->returnType->ffiType;
 
-
 #if defined(X86_WIN32)
     rbConventionStr = (rbConvention != Qnil) ? rb_funcall2(rbConvention, rb_intern("to_s"), 0, NULL) : Qnil;
     fnInfo->abi = (rbConventionStr != Qnil && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)

data/ext/ffi_c/LastError.c

@@ -33,12 +33,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 

data/ext/ffi_c/LongDouble.c

@@ -3,15 +3,15 @@
 #include <stdarg.h>
 #include <float.h>
 
-#if defined (__CYGWIN__) || defined(__INTERIX)
+#if defined (__CYGWIN__) || defined(__INTERIX) || defined(_MSC_VER)
 # define strtold(str, endptr)    ((long double) strtod((str), (endptr)))
 #endif /* defined (__CYGWIN__) */
 
 static VALUE rb_cBigDecimal = Qnil;
 static VALUE bigdecimal_load(VALUE unused);
-static VALUE bigdecimal_failed(VALUE value);
+static VALUE bigdecimal_failed(VALUE value, VALUE exc);
 
-VALUE 
+VALUE
 rbffi_longdouble_new(long double ld)
 {
     if (!RTEST(rb_cBigDecimal)) {
@@ -21,27 +21,29 @@ rbffi_longdouble_new(long double ld)
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject) {
         char buf[128];
-        return rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
+        return rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
     }
 
     /* Fall through to handling as a float */
     return rb_float_new(ld);
 }
 
-long double 
+long double
 rbffi_num2longdouble(VALUE value)
 {
     if (TYPE(value) == T_FLOAT) {
         return rb_num2dbl(value);
     }
-    
+
     if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
         rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
     }
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
         VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
-        return strtold(RSTRING_PTR(s), NULL);
+        long double ret = strtold(RSTRING_PTR(s), NULL);
+        RB_GC_GUARD(s);
+        return ret;
     }
 
     /* Fall through to handling as a float */
@@ -49,15 +51,15 @@ rbffi_num2longdouble(VALUE value)
 }
 
 
-static VALUE 
+static VALUE
 bigdecimal_load(VALUE unused)
 {
     rb_require("bigdecimal");
     return rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 }
 
-static VALUE 
-bigdecimal_failed(VALUE value)
+static VALUE
+bigdecimal_failed(VALUE value, VALUE exc)
 {
     return value;
 }

data/ext/ffi_c/LongDouble.h

@@ -36,10 +36,6 @@
 extern "C" {
 #endif
 
-#ifdef _MSC_VER
-#define strtold strtod
-#endif
-
 extern VALUE rbffi_longdouble_new(long double ld);
 extern long double rbffi_num2longdouble(VALUE value);
 

data/ext/ffi_c/MemoryPointer.c

@@ -28,13 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdbool.h>
-# include <stdint.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdbool.h>
+#include <stdint.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -112,7 +107,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     p->memory.typeSize = (int) size;
     p->memory.size = msize;
     /* ensure the memory is aligned on at least a 8 byte boundary */
-    p->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);;
+    p->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7ULL);
     p->allocated = true;
 
     if (clear && p->memory.size > 0) {

data/ext/ffi_c/MemoryPointer.h

@@ -31,11 +31,7 @@
 #ifndef RBFFI_MEMORYPOINTER_H
 #define	RBFFI_MEMORYPOINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 #include <ruby.h>
 
 #ifdef	__cplusplus

data/ext/ffi_c/MethodHandle.c

@@ -34,13 +34,8 @@
 # include <sys/mman.h>
 #endif
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #ifndef _WIN32
 # include <unistd.h>
 #endif
@@ -68,9 +63,6 @@
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
-#ifdef _WIN32
-  typedef char* caddr_t;
-#endif
 
 #ifdef USE_RAW
 #  define METHOD_CLOSURE ffi_raw_closure
@@ -120,23 +112,19 @@ rbffi_MethodHandle_Free(MethodHandle* handle)
 {
     if (handle != NULL) {
         rbffi_Closure_Free(handle->closure);
+        xfree(handle);
     }
 }
 
-void*
-rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
+rbffi_function_anyargs rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
 {
-    return handle->closure->code;
+    return (rbffi_function_anyargs) handle->closure->code;
 }
 
 #ifndef CUSTOM_TRAMPOLINE
 static void attached_method_invoke(ffi_cif* cif, void* retval, METHOD_PARAMS parameters, void* user_data);
 
-static ffi_type* methodHandleParamTypes[] = {
-    &ffi_type_sint,
-    &ffi_type_pointer,
-    &ffi_type_ulong,
-};
+static ffi_type* methodHandleParamTypes[3];
 
 static ffi_cif mh_cif;
 
@@ -148,10 +136,10 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 #if defined(USE_RAW)
     ffiStatus = ffi_prep_raw_closure(code, &mh_cif, attached_method_invoke, closure);
 #else
-    ffiStatus = ffi_prep_closure(code, &mh_cif, attached_method_invoke, closure);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &mh_cif, attached_method_invoke, closure, code);
 #endif
     if (ffiStatus != FFI_OK) {
-        snprintf(errmsg, errmsgsize, "ffi_prep_closure failed.  status=%#x", ffiStatus);
+        snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;
     }
 
@@ -237,7 +225,7 @@ custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 
 #elif defined(__i386__) && 0
 
-static VALUE custom_trampoline(caddr_t args, Closure*);
+static VALUE custom_trampoline(void *args, Closure*);
 #define TRAMPOLINE_CTX_MAGIC (0xfee1dead)
 #define TRAMPOLINE_FUN_MAGIC (0xbeefcafe)
 
@@ -269,7 +257,7 @@ __asm__(
 );
 
 static VALUE
-custom_trampoline(caddr_t args, Closure* handle)
+custom_trampoline(void *args, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
     return (*fnInfo->invoke)(*(int *) args, *(VALUE **) (args + 4), handle->function, fnInfo);
@@ -286,10 +274,10 @@ static long trampoline_ctx_offset, trampoline_func_offset;
 static long
 trampoline_offset(int off, const long value)
 {
-    caddr_t ptr;
-    for (ptr = (caddr_t) &ffi_trampoline + off; ptr < (caddr_t) &ffi_trampoline_end; ++ptr) {
+    char *ptr;
+    for (ptr = (char *) &ffi_trampoline + off; ptr < (char *) &ffi_trampoline_end; ++ptr) {
         if (*(long *) ptr == value) {
-            return ptr - (caddr_t) &ffi_trampoline;
+            return ptr - (char *) &ffi_trampoline;
         }
     }
 
@@ -315,12 +303,10 @@ trampoline_offsets(long* ctxOffset, long* fnOffset)
 static bool
 prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize)
 {
-    caddr_t ptr = (caddr_t) code;
-
-    memcpy(ptr, &ffi_trampoline, trampoline_size());
+    memcpy(code, (void*) &ffi_trampoline, trampoline_size());
     /* Patch the context and function addresses into the stub code */
-    *(intptr_t *)(ptr + trampoline_ctx_offset) = (intptr_t) closure;
-    *(intptr_t *)(ptr + trampoline_func_offset) = (intptr_t) custom_trampoline;
+    *(intptr_t *)((char*)code + trampoline_ctx_offset) = (intptr_t) closure;
+    *(intptr_t *)((char*)code + trampoline_func_offset) = (intptr_t) custom_trampoline;
 
     return true;
 }
@@ -328,7 +314,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 static long
 trampoline_size(void)
 {
-    return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
+    return (char *) &ffi_trampoline_end - (char *) &ffi_trampoline;
 }
 
 #endif /* CUSTOM_TRAMPOLINE */
@@ -348,6 +334,10 @@ rbffi_MethodHandle_Init(VALUE module)
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
+    methodHandleParamTypes[0] = &ffi_type_sint;
+    methodHandleParamTypes[1] = &ffi_type_pointer;
+    methodHandleParamTypes[2] = &ffi_type_ulong;
+
     ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {

data/ext/ffi_c/MethodHandle.h

@@ -37,14 +37,15 @@ extern "C" {
 #include <ruby.h>
 #include "Function.h"
 
-    
+
 typedef struct MethodHandlePool MethodHandlePool;
 typedef struct MethodHandle MethodHandle;
+typedef VALUE (*rbffi_function_anyargs)(int argc, VALUE* argv, VALUE self);
 
 
 MethodHandle* rbffi_MethodHandle_Alloc(FunctionType* fnInfo, void* function);
 void rbffi_MethodHandle_Free(MethodHandle* handle);
-void* rbffi_MethodHandle_CodeAddress(MethodHandle* handle);
+rbffi_function_anyargs rbffi_MethodHandle_CodeAddress(MethodHandle* handle);
 void rbffi_MethodHandle_Init(VALUE module);
 
 #ifdef	__cplusplus

data/ext/ffi_c/Platform.c

@@ -31,19 +31,14 @@
 # include <sys/param.h>
 #endif
 # include <sys/types.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
 #include "rbffi_endian.h"
 #include "Platform.h"
 
-#if defined(__GNU__) || defined(__GLIBC__)
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
 # include <gnu/lib-names.h>
 #endif
 
@@ -64,6 +59,7 @@ export_primitive_types(VALUE module)
     S(LONG, long);
     S(FLOAT, float);
     S(DOUBLE, double);
+    S(LONG_DOUBLE, long double);
     S(ADDRESS, void*);
 #undef S
 }
@@ -75,7 +71,7 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
-#if defined(__GNU__) || defined(__GLIBC__)
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
     rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
 #endif
     export_primitive_types(PlatformModule);