ffi 1.12.2 → 1.14.2

data/ext/ffi_c/Buffer.c

@@ -28,13 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -114,7 +109,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
         }
 
         /* ensure the memory is aligned on at least a 8 byte boundary */
-        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     
         if (p->memory.size > 0 && (nargs < 3 || RTEST(rbClear))) {
             memset(p->memory.address, 0, p->memory.size);
@@ -154,7 +149,7 @@ buffer_initialize_copy(VALUE self, VALUE other)
         return Qnil;
     }
     
-    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     

data/ext/ffi_c/Call.c

@@ -34,13 +34,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 #include <ruby/thread.h>
@@ -339,13 +334,7 @@ static void *
 call_blocking_function(void* data)
 {
     rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
-#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
-    b->frame->has_gvl = false;
-#endif
     ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
-#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
-    b->frame->has_gvl = true;
-#endif
 
     return NULL;
 }
@@ -353,7 +342,7 @@ call_blocking_function(void* data)
 VALUE
 rbffi_do_blocking_call(VALUE data)
 {
-    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (void *) -1, NULL);
+    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (rb_unblock_function_t *) -1, NULL);
 
     return Qnil;
 }

data/ext/ffi_c/ClosurePool.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/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #if defined(__CYGWIN__) || !defined(_WIN32)
 #  include <unistd.h>
 #else
@@ -51,9 +46,6 @@
 #include <errno.h>
 #include <ruby.h>
 
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
 #include <ffi.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -66,13 +58,9 @@
 
 #include "ClosurePool.h"
 
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
-#ifdef _WIN32
-  typedef char* caddr_t;
-#endif
 
 typedef struct Memory {
     void* code;
@@ -96,7 +84,7 @@ static bool freePage(void *);
 static bool protectPage(void *);
 
 ClosurePool*
-rbffi_ClosurePool_New(int closureSize, 
+rbffi_ClosurePool_New(int closureSize,
         bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
         void* ctx)
 {
@@ -107,7 +95,7 @@ rbffi_ClosurePool_New(int closureSize,
     pool->ctx = ctx;
     pool->prep = prep;
     pool->refcnt = 1;
-    
+
     return pool;
 }
 
@@ -115,10 +103,14 @@ void
 cleanup_closure_pool(ClosurePool* pool)
 {
     Memory* memory;
-    
+
     for (memory = pool->blocks; memory != NULL; ) {
         Memory* next = memory->next;
+#if !USE_FFI_ALLOC
         freePage(memory->code);
+#else
+        ffi_closure_free(memory->code);
+#endif
         free(memory->data);
         free(memory);
         memory = next;
@@ -137,12 +129,14 @@ rbffi_ClosurePool_Free(ClosurePool* pool)
     }
 }
 
+#if !USE_FFI_ALLOC
+
 Closure*
 rbffi_Closure_Alloc(ClosurePool* pool)
 {
     Closure *list = NULL;
     Memory* block = NULL;
-    caddr_t code = NULL;
+    void *code = NULL;
     char errmsg[256];
     int nclosures;
     long trampolineSize;
@@ -152,7 +146,7 @@ rbffi_Closure_Alloc(ClosurePool* pool)
         Closure* closure = pool->list;
         pool->list = pool->list->next;
         pool->refcnt++;
-    
+
         return closure;
     }
 
@@ -161,17 +155,18 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     block = calloc(1, sizeof(*block));
     list = calloc(nclosures, sizeof(*list));
     code = allocatePage();
-    
+
     if (block == NULL || list == NULL || code == NULL) {
         snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
         goto error;
     }
-    
+
     for (i = 0; i < nclosures; ++i) {
         Closure* closure = &list[i];
         closure->next = &list[i + 1];
         closure->pool = pool;
-        closure->code = (code + (i * trampolineSize));
+        closure->code = ((char *)code + (i * trampolineSize));
+        closure->pcl  = closure->code;
 
         if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
             goto error;
@@ -202,12 +197,63 @@ error:
     if (code != NULL) {
         freePage(code);
     }
-    
+
 
     rb_raise(rb_eRuntimeError, "%s", errmsg);
     return NULL;
 }
 
+#else
+
+Closure*
+rbffi_Closure_Alloc(ClosurePool* pool)
+{
+    Closure *closure = NULL;
+    Memory* block = NULL;
+    void *code = NULL;
+    void *pcl = NULL;
+    char errmsg[256];
+
+    block = calloc(1, sizeof(*block));
+    closure = calloc(1, sizeof(*closure));
+    pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+
+    if (block == NULL || closure == NULL || pcl == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
+        goto error;
+    }
+
+    closure->pool = pool;
+    closure->code = code;
+    closure->pcl = pcl;
+
+    if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
+        goto error;
+    }
+
+    /* Track the allocated page + Closure memory area */
+    block->data = closure;
+    block->code = pcl;
+    pool->blocks = block;
+
+    /* Thread the new block onto the free list, apart from the first one. */
+    pool->refcnt++;
+
+    return closure;
+
+error:
+    free(block);
+    free(closure);
+    if (pcl != NULL) {
+        ffi_closure_free(pcl);
+    }
+
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+    return NULL;
+}
+
+#endif /* !USE_FFI_ALLOC */
+
 void
 rbffi_Closure_Free(Closure* closure)
 {
@@ -243,14 +289,16 @@ getPageSize()
 #endif
 }
 
+#if !USE_FFI_ALLOC
+
 static void*
 allocatePage(void)
 {
 #if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
     return VirtualAlloc(NULL, pageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #else
-    caddr_t page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
-    return (page != (caddr_t) -1) ? page : NULL;
+    void *page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    return (page != (void *) -1) ? page : NULL;
 #endif
 }
 
@@ -275,6 +323,8 @@ protectPage(void* page)
 #endif
 }
 
+#endif /* !USE_FFI_ALLOC */
+
 void
 rbffi_ClosurePool_Init(VALUE module)
 {

data/ext/ffi_c/ClosurePool.h

@@ -35,7 +35,9 @@ typedef struct Closure_ Closure;
 struct Closure_ {
     void* info;      /* opaque handle for storing closure-instance specific data */
     void* function;  /* closure-instance specific function, called by custom trampoline */
-    void* code;      /* The native trampoline code location */
+    void* code;      /* Executable address for the native trampoline code location */
+    void* pcl;       /* Writeable address for the native trampoline code location */
+
     struct ClosurePool_* pool;
     Closure* next;
 };

data/ext/ffi_c/DynamicLibrary.c

@@ -29,9 +29,7 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-#  include <stdint.h>
-#endif
+#include <stdint.h>
 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
 # include <winsock2.h>
 # define _WINSOCKAPI_
@@ -41,9 +39,6 @@
 # include <dlfcn.h>
 #endif
 #include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
 
 #include <ffi.h>
 

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>
 
@@ -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,8 +272,10 @@ 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);
     }
 
@@ -476,8 +453,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);
@@ -721,7 +698,7 @@ invoke_callback(VALUE 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_str_new2(*(char **) parameters[i]) : Qnil;
@@ -793,6 +770,9 @@ invoke_callback(VALUE 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;
@@ -864,9 +844,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/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)