ffi 1.13.1 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c1ae7c590f7dd4d8d821c6faf31c66499a90c421ff25fe14ce4465cc058b83f
-  data.tar.gz: e4c16035d46e13e752e215fdc87511c214db31cec9084cca3c2141a9d83469c7
+  metadata.gz: 2c0a1872f48b6db1c64ae5390e0e76455fa27ae7016e5a0426753e4973b53751
+  data.tar.gz: 2e9a65f7e151185182a42848eebbd0709fee683d3513e096c7552a669a5326a6
 SHA512:
-  metadata.gz: a4064371f99217b7b449c46915e4505b54a61785ec27a2b5cd51d798cc929ff58bef33ad9064ab93ca85ad2c5d5c07d515edb0ac5d673a468fb17abf18565627
-  data.tar.gz: a545c796f0b36fb7cac6ac06a73094274d077e0e0f54f55f67c129e6bff27b7679886a3adc87e9b3c173f975864dc78ac3d6277d8a8d1352f974b697ace0f8b4
+  metadata.gz: 9c78c1d0e46f1bcc9e0ff29dafadb660970ff86f54fb5326dc63e81eecee307e9e22e187c07dc2f9982ffff7c3a3c913caaeb2136683f5990466d452b87ec23c
+  data.tar.gz: a5c06fa33eb31dd59f26ee10796609bfee821d076107e5f6ac2ab131f39fbb4979d00f84d98e1e556268ee55f310f8bbda1c770d0af5b98d72b314c1fdd9b0a1

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+1.14.0 / 2020-12-18
+-------------------
+
+Added:
+* Add types.conf for x86_64-msys, x86_64-haiku, aarch64-openbsd and aarch64-darwin (alias arm64-darwin)
+* Add method AbstractMemory#size_limit? . #829
+* Add new extconf option --enable-libffi-alloc which is enabled per default on Apple M1 (arm64-darwin).
+
+Changed:
+* Do NULL pointer check only when array length > 0 . #305
+* Raise an error on an unknown order argument. #830
+* Change FFI::Pointer#write_string to terminate with a NUL byte like other string methods. #805
+* Update bundled libffi to latest master.
+
+Removed:
+* Remove win32/stdint.h and stdbool.h because of copyright issue.  #693
+
+Fixed:
+* Fix possible UTF-8 load error in loader script interpretation. #792
+* Fix segfault on non-array argument to #write_array_of_*
+* Fix memory leak in MethodHandle . #815
+* Fix possible segfault in combination with fiddle or other libffi using gems . #835
+* Fix possibility to use ffi ruby gem with JRuby-9.3 . #763
+
+
 1.13.1 / 2020-06-09
 -------------------
 

data/README.md

@@ -1,4 +1,4 @@
-# Ruby-FFI https://github.com/ffi/ffi/wiki [![Build Status](https://travis-ci.org/ffi/ffi.svg?branch=master)](https://travis-ci.org/ffi/ffi) [![Build status Windows](https://ci.appveyor.com/api/projects/status/r8wxn1sd4s794gg1/branch/master?svg=true)](https://ci.appveyor.com/project/larskanis/ffi-aofqa/branch/master)
+# Ruby-FFI https://github.com/ffi/ffi/wiki [![Build Status](https://travis-ci.com/ffi/ffi.svg?branch=master)](https://travis-ci.com/ffi/ffi) [![Build status Windows](https://ci.appveyor.com/api/projects/status/r8wxn1sd4s794gg1/branch/master?svg=true)](https://ci.appveyor.com/project/larskanis/ffi-aofqa/branch/master)
 
 ## Description
 
@@ -66,10 +66,18 @@ From rubygems:
 or from the git repository on github:
 
     git clone git://github.com/ffi/ffi.git
-    git submodule update --init --recursive
     cd ffi
+    git submodule update --init --recursive
+    bundle install
     rake install
 
+### Install options:
+
+* `--enable-system-libffi` : Force usage of system libffi
+* `--disable-system-libffi` : Force usage of builtin libffi
+* `--enable-libffi-alloc` : Force closure allocation by libffi
+* `--disable-libffi-alloc` : Force closure allocation by builtin method
+
 ## License
 
 The ffi library is covered by the BSD license, also see the LICENSE file.

data/ext/ffi_c/AbstractMemory.c

@@ -32,12 +32,9 @@
 #include <sys/types.h>
 #ifndef _MSC_VER
 # include <sys/param.h>
-# 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>
@@ -135,11 +132,13 @@ static VALUE memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary); \
 static VALUE \
 memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
 { \
-    long count = RARRAY_LEN(ary); \
+    long count; \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
     long i; \
-    checkWrite(memory); \
+    Check_Type(ary, T_ARRAY); \
+    count = RARRAY_LEN(ary); \
+    if (likely(count > 0)) checkWrite(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
         type tmp = (type) VAL(toNative(RARRAY_PTR(ary)[i]), swap); \
@@ -162,7 +161,7 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     AbstractMemory* memory = MEMORY(self); \
     VALUE retVal = rb_ary_new2(count); \
     long i; \
-    checkRead(memory); \
+    if (likely(count > 0)) checkRead(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; ++i) { \
         type tmp; \
@@ -209,13 +208,13 @@ SWAPU16(uint16_t x)
         ((x >> 40) & 0x000000000000ff00ULL) | \
         ((x >> 56) & 0x00000000000000ffULL))
 
-static inline int32_t 
+static inline int32_t
 SWAPS32(int32_t x)
 {
     return bswap32(x);
 }
 
-static inline uint32_t 
+static inline uint32_t
 SWAPU32(uint32_t x)
 {
     return bswap32(x);
@@ -450,7 +449,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
         int i;
 
         checkBounds(ptr, off, count * sizeof (char*));
-        
+
         for (i = 0; i < count; ++i) {
             const char* strptr = *((const char**) (ptr->address + off) + i);
             rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_str_new2(strptr)));
@@ -477,7 +476,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
  * @param [Numeric] count number of strings to get. If nil, return all strings
  * @return [Array<String>]
  */
-static VALUE 
+static VALUE
 memory_read_array_of_string(int argc, VALUE* argv, VALUE self)
 {
     VALUE* rargv = ALLOCA_N(VALUE, argc + 1);
@@ -500,7 +499,7 @@ memory_read_array_of_string(int argc, VALUE* argv, VALUE self)
  * @raise {SecurityError} when writing unsafe string to memory
  * @raise {IndexError} if +offset+ is too great
  * @raise {NullPointerError} if memory not initialized
- * Put a string in memory.
+ * Put a string in memory. Writes a final \0 byte.
  */
 static VALUE
 memory_put_string(VALUE self, VALUE offset, VALUE str)
@@ -535,13 +534,13 @@ memory_get_bytes(VALUE self, VALUE offset, VALUE length)
 {
     AbstractMemory* ptr = MEMORY(self);
     long off, len;
-    
+
     off = NUM2LONG(offset);
     len = NUM2LONG(length);
 
     checkRead(ptr);
     checkBounds(ptr, off, len);
-    
+
     return rb_str_new((char *) ptr->address + off, len);
 }
 
@@ -595,7 +594,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
  * equivalent to :
  *  memory.get_bytes(0, length)
  */
-static VALUE 
+static VALUE
 memory_read_bytes(VALUE self, VALUE length)
 {
     return memory_get_bytes(self, INT2FIX(0), length);
@@ -610,7 +609,7 @@ memory_read_bytes(VALUE self, VALUE length)
  * equivalent to :
  *  memory.put_bytes(0, str, index, length)
  */
-static VALUE 
+static VALUE
 memory_write_bytes(int argc, VALUE* argv, VALUE self)
 {
     VALUE* wargv = ALLOCA_N(VALUE, argc + 1);
@@ -643,7 +642,7 @@ memory_type_size(VALUE self)
  * Document-method: []
  * call-seq: memory[idx]
  * @param [Numeric] idx index to access in memory
- * @return 
+ * @return
  * Memory read accessor.
  */
 static VALUE
@@ -748,9 +747,9 @@ MemoryOps rbffi_AbstractMemoryOps = {
 void
 rbffi_AbstractMemory_Init(VALUE moduleFFI)
 {
-    /* 
+    /*
      * Document-class: FFI::AbstractMemory
-     * 
+     *
      * {AbstractMemory} is the base class for many memory management classes such as {Buffer}.
      *
      * This class has a lot of methods to work with integers :
@@ -778,8 +777,8 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
      */
     VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
     rbffi_AbstractMemoryClass = classMemory;
-    /* 
-     * Document-variable: FFI::AbstractMemory 
+    /*
+     * Document-variable: FFI::AbstractMemory
      */
     rb_global_variable(&rbffi_AbstractMemoryClass);
     rb_define_alloc_func(classMemory, memory_allocate);
@@ -807,13 +806,13 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "read_array_of_" #type, memory_read_array_of_##type, 1); \
     rb_define_method(classMemory, "write_array_of_u" #type, memory_write_array_of_u##type, 1); \
     rb_define_method(classMemory, "read_array_of_u" #type, memory_read_array_of_u##type, 1);
-    
+
     INT(int8);
     INT(int16);
     INT(int32);
     INT(int64);
     INT(long);
-    
+
 #define ALIAS(name, old) \
     rb_define_alias(classMemory, "put_" #name, "put_" #old); \
     rb_define_alias(classMemory, "get_" #name, "get_" #old); \
@@ -831,12 +830,12 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_alias(classMemory, "read_array_of_" #name, "read_array_of_" #old); \
     rb_define_alias(classMemory, "write_array_of_u" #name, "write_array_of_u" #old); \
     rb_define_alias(classMemory, "read_array_of_u" #name, "read_array_of_u" #old);
-    
+
     ALIAS(char, int8);
     ALIAS(short, int16);
     ALIAS(int, int32);
     ALIAS(long_long, int64);
-    
+
     /*
      * Document-method: put_float32
      * call-seq: memory.put_float32offset, value)

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"

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>

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,7 +58,6 @@
 
 #include "ClosurePool.h"
 
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
@@ -115,7 +106,11 @@ cleanup_closure_pool(ClosurePool* pool)
 
     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;
@@ -134,6 +129,8 @@ rbffi_ClosurePool_Free(ClosurePool* pool)
     }
 }
 
+#if !USE_FFI_ALLOC
+
 Closure*
 rbffi_Closure_Alloc(ClosurePool* pool)
 {
@@ -169,6 +166,7 @@ rbffi_Closure_Alloc(ClosurePool* pool)
         closure->next = &list[i + 1];
         closure->pool = pool;
         closure->code = ((char *)code + (i * trampolineSize));
+        closure->pcl  = closure->code;
 
         if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
             goto error;
@@ -205,6 +203,57 @@ error:
     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)
 {
@@ -240,6 +289,8 @@ getPageSize()
 #endif
 }
 
+#if !USE_FFI_ALLOC
+
 static void*
 allocatePage(void)
 {
@@ -272,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>
 
@@ -256,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;
@@ -279,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);
     }
 
@@ -849,7 +844,7 @@ callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errm
     FunctionType* fnInfo = (FunctionType *) ctx;
     ffi_status ffiStatus;
 
-    ffiStatus = ffi_prep_closure_loc(code, &fnInfo->ffi_cif, callback_invoke, closure, code);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &fnInfo->ffi_cif, callback_invoke, closure, code);
     if (ffiStatus != FFI_OK) {
         snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;