ffi 1.9.18 → 1.9.23

data/ext/ffi_c/MethodHandle.c

@@ -26,30 +26,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-#include <sys/param.h>
-#endif
-#include <sys/types.h>
-#ifndef _WIN32
-# 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
-#ifndef _WIN32
-# include <unistd.h>
-#endif
-#include <errno.h>
-#include <ruby.h>
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-# include <pthread.h>
-#endif
-
 #include <ffi.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -59,79 +35,16 @@
 #include "Type.h"
 #include "LastError.h"
 #include "Call.h"
-#include "ClosurePool.h"
+#include "Closure.h"
 #include "MethodHandle.h"
 
-
-#define MAX_METHOD_FIXED_ARITY (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
-#  define METHOD_PARAMS ffi_raw*
-#else
-#  define METHOD_CLOSURE ffi_closure
-#  define METHOD_PARAMS void**
-#endif
-
-
-
-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__))
-# define CUSTOM_TRAMPOLINE 1
-#endif
-
+#define METHOD_CLOSURE ffi_closure
+#define METHOD_PARAMS void**
 
 struct MethodHandle {
     Closure* closure;
 };
 
-static ClosurePool* defaultClosurePool;
-
-
-MethodHandle*
-rbffi_MethodHandle_Alloc(FunctionType* fnInfo, void* function)
-{
-    MethodHandle* handle;
-    Closure* closure = rbffi_Closure_Alloc(defaultClosurePool);
-    if (closure == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate closure from pool");
-        return NULL;
-    }
-
-    handle = xcalloc(1, sizeof(*handle));
-    handle->closure = closure;
-    closure->info = fnInfo;
-    closure->function = function;
-
-    return handle;
-}
-
-void
-rbffi_MethodHandle_Free(MethodHandle* handle)
-{
-    if (handle != NULL) {
-        rbffi_Closure_Free(handle->closure);
-    }
-}
-
-void*
-rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
-{
-    return 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,
@@ -140,219 +53,71 @@ static ffi_type* methodHandleParamTypes[] = {
 
 static ffi_cif mh_cif;
 
-static bool
-prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize)
-{
-    ffi_status ffiStatus;
-
-#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);
-#endif
-    if (ffiStatus != FFI_OK) {
-        snprintf(errmsg, errmsgsize, "ffi_prep_closure failed.  status=%#x", ffiStatus);
-        return false;
-    }
-
-    return true;
-}
-
-
-static long
-trampoline_size(void)
-{
-    return sizeof(METHOD_CLOSURE);
-}
-
-/*
- * attached_method_invoke is used functions with more than 6 parameters, or
- * with struct param or return values
- */
 static void
 attached_method_invoke(ffi_cif* cif, void* mretval, METHOD_PARAMS parameters, void* user_data)
 {
     Closure* handle =  (Closure *) user_data;
     FunctionType* fnInfo = (FunctionType *) handle->info;
 
-#ifdef USE_RAW
-    int argc = parameters[0].sint;
-    VALUE* argv = *(VALUE **) &parameters[1];
-#else
     int argc = *(int *) parameters[0];
     VALUE* argv = *(VALUE **) parameters[1];
-#endif
 
     *(VALUE *) mretval = (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
 }
 
-#endif
-
-
-
-#if defined(CUSTOM_TRAMPOLINE)
-#if defined(__x86_64__)
-
-static VALUE custom_trampoline(int argc, VALUE* argv, VALUE self, Closure*);
-
-#define TRAMPOLINE_CTX_MAGIC (0xfee1deadcafebabe)
-#define TRAMPOLINE_FUN_MAGIC (0xfeedfacebeeff00d)
-
-/*
- * This is a hand-coded trampoline to speedup entry from ruby to the FFI translation
- * layer for x86_64 arches.
- *
- * Since a ruby function has exactly 3 arguments, and the first 6 arguments are
- * passed in registers for x86_64, we can tack on a context pointer by simply
- * putting a value in %rcx, then jumping to the C trampoline code.
- *
- * This results in approx a 30% speedup for x86_64 FFI dispatch
- */
-__asm__(
-    ".text\n\t"
-    ".globl ffi_trampoline\n\t"
-    ".globl _ffi_trampoline\n\t"
-    "ffi_trampoline:\n\t"
-    "_ffi_trampoline:\n\t"
-    "movabsq $0xfee1deadcafebabe, %rcx\n\t"
-    "movabsq $0xfeedfacebeeff00d, %r11\n\t"
-    "jmpq *%r11\n\t"
-    ".globl ffi_trampoline_end\n\t"
-    "ffi_trampoline_end:\n\t"
-    ".globl _ffi_trampoline_end\n\t"
-    "_ffi_trampoline_end:\n\t"
-);
-
-static VALUE
-custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
-{
-    FunctionType* fnInfo = (FunctionType *) handle->info;
-    VALUE rbReturnValue;
-
-    RB_GC_GUARD(rbReturnValue) = (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
-    RB_GC_GUARD(self);
-
-    return rbReturnValue;
-}
-
-#elif defined(__i386__) && 0
-
-static VALUE custom_trampoline(caddr_t args, Closure*);
-#define TRAMPOLINE_CTX_MAGIC (0xfee1dead)
-#define TRAMPOLINE_FUN_MAGIC (0xbeefcafe)
-
-/*
- * This is a hand-coded trampoline to speed-up entry from ruby to the FFI translation
- * layer for i386 arches.
- *
- * This does not make a discernible difference vs a raw closure, so for now,
- * it is not enabled.
- */
-__asm__(
-    ".text\n\t"
-    ".globl ffi_trampoline\n\t"
-    ".globl _ffi_trampoline\n\t"
-    "ffi_trampoline:\n\t"
-    "_ffi_trampoline:\n\t"
-    "subl    $12, %esp\n\t"
-    "leal    16(%esp), %eax\n\t"
-    "movl    %eax, (%esp)\n\t"
-    "movl    $0xfee1dead, 4(%esp)\n\t"
-    "movl    $0xbeefcafe, %eax\n\t"
-    "call    *%eax\n\t"
-    "addl    $12, %esp\n\t"
-    "ret\n\t"
-    ".globl ffi_trampoline_end\n\t"
-    "ffi_trampoline_end:\n\t"
-    ".globl _ffi_trampoline_end\n\t"
-    "_ffi_trampoline_end:\n\t"
-);
-
-static VALUE
-custom_trampoline(caddr_t args, Closure* handle)
+MethodHandle*
+rbffi_MethodHandle_Alloc(FunctionType* fnInfo, void* function)
 {
-    FunctionType* fnInfo = (FunctionType *) handle->info;
-    return (*fnInfo->invoke)(*(int *) args, *(VALUE **) (args + 4), handle->function, fnInfo);
-}
-
-#endif /* __x86_64__ else __i386__ */
-
-extern void ffi_trampoline(int argc, VALUE* argv, VALUE self);
-extern void ffi_trampoline_end(void);
-static int trampoline_offsets(long *, long *);
-
-static long trampoline_ctx_offset, trampoline_func_offset;
+    ffi_status ffiStatus;
+    MethodHandle* handle;
+    Closure* closure;
 
-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) {
-        if (*(long *) ptr == value) {
-            return ptr - (caddr_t) &ffi_trampoline;
-        }
+    closure = rbffi_Closure_Alloc();
+    if (closure == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate closure from pool");
+        return NULL;
     }
+    closure->info = fnInfo;
+    closure->function = function;
 
-    return -1;
-}
-
-static int
-trampoline_offsets(long* ctxOffset, long* fnOffset)
-{
-    *ctxOffset = trampoline_offset(0, TRAMPOLINE_CTX_MAGIC);
-    if (*ctxOffset == -1) {
-        return -1;
+    ffiStatus = ffi_prep_closure_loc(closure->libffi_closure,
+        &mh_cif, /* method signature */
+        attached_method_invoke,
+        closure, /* user_data for attached_method_invoke */
+        closure->libffi_trampoline);
+    if (ffiStatus != FFI_OK) {
+        rb_raise(rb_eRuntimeError, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
+        return false;
     }
 
-    *fnOffset = trampoline_offset(0, TRAMPOLINE_FUN_MAGIC);
-    if (*fnOffset == -1) {
-        return -1;
-    }
+    handle = xcalloc(1, sizeof(*handle));
+    handle->closure = closure;
 
-    return 0;
+    return handle;
 }
 
-static bool
-prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize)
+void
+rbffi_MethodHandle_Free(MethodHandle* handle)
 {
-    caddr_t ptr = (caddr_t) code;
-
-    memcpy(ptr, &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;
-
-    return true;
+    if (handle != NULL) {
+        rbffi_Closure_Free(handle->closure);
+    }
 }
 
-static long
-trampoline_size(void)
+void*
+rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
 {
-    return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
+    return handle->closure->libffi_trampoline;
 }
 
-#endif /* CUSTOM_TRAMPOLINE */
-
-
 void
 rbffi_MethodHandle_Init(VALUE module)
 {
-#ifndef CUSTOM_TRAMPOLINE
     ffi_status ffiStatus;
-#endif
 
-    defaultClosurePool = rbffi_ClosurePool_New((int) trampoline_size(), prep_trampoline, NULL);
-
-#if defined(CUSTOM_TRAMPOLINE)
-    if (trampoline_offsets(&trampoline_ctx_offset, &trampoline_func_offset) != 0) {
-        rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
-    }
-#else
     ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {
         rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);
     }
-
-#endif
 }

data/ext/ffi_c/Platform.c

@@ -66,12 +66,20 @@ static VALUE PlatformModule = Qnil;
 #elif defined(__ppc__) || defined(__powerpc__) || defined(__powerpc)
 # define CPU "ppc"
 
-/* Need to check for __sparcv9 first, because __sparc will be defined either way. */
+/*
+ * Need to check for __sparcv9 first, because __sparc will be defined either way.
+ * Note that __sparcv9 seems to only be set for Solaris. On Linux, __sparc will
+ * be set, along with __arch64__ if a 64-bit platform.
+ */
 #elif defined(__sparcv9__) || defined(__sparcv9)
 # define CPU "sparcv9"
 
 #elif defined(__sparc__) || defined(__sparc)
-# define CPU "sparc"
+# if defined(__arch64__)
+#  define CPU "sparcv9"
+# else
+#  define CPU "sparc"
+# endif
 
 #elif defined(__arm__) || defined(__arm)
 # define CPU "arm"

data/ext/ffi_c/extconf.rb

@@ -11,15 +11,15 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   $CFLAGS.gsub!(/[\s+]-std=[^\s]+/, '')
   # solaris 10 needs -c99 for <stdbool.h>
   $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
-  
+
   if ENV['RUBY_CC_VERSION'].nil? && (pkg_config("libffi") ||
      have_header("ffi.h") ||
      find_header("ffi.h", "/usr/local/include", "/usr/include/ffi"))
 
-    # We need at least ffi_call and ffi_prep_closure
+    # We need at least ffi_call and ffi_closure_alloc
     libffi_ok = have_library("ffi", "ffi_call", [ "ffi.h" ]) ||
                 have_library("libffi", "ffi_call", [ "ffi.h" ])
-    libffi_ok &&= have_func("ffi_prep_closure")
+    libffi_ok &&= have_func("ffi_closure_alloc")
 
     # Check if the raw api is available.
     $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
@@ -29,8 +29,13 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   have_func('rb_thread_blocking_region')
   have_func('rb_thread_call_with_gvl')
   have_func('rb_thread_call_without_gvl')
-  have_func('ffi_prep_cif_var')
-  
+
+  if libffi_ok
+    have_func('ffi_prep_cif_var')
+  else
+    $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+  end
+
   $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
   $defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
   $defs << "-DRUBY_1_9" if RUBY_VERSION >= "1.9.0"

data/ext/ffi_c/ffi.c

@@ -46,7 +46,7 @@
 #include "Types.h"
 #include "LastError.h"
 #include "Function.h"
-#include "ClosurePool.h"
+#include "Closure.h"
 #include "MethodHandle.h"
 #include "Call.h"
 #include "ArrayType.h"
@@ -79,7 +79,7 @@ Init_ffi_c(void)
     rbffi_ArrayType_Init(moduleFFI);
     rbffi_LastError_Init(moduleFFI);
     rbffi_Call_Init(moduleFFI);
-    rbffi_ClosurePool_Init(moduleFFI);
+    rbffi_Closure_Init(moduleFFI);
     rbffi_MethodHandle_Init(moduleFFI);
     rbffi_Platform_Init(moduleFFI);
     rbffi_AbstractMemory_Init(moduleFFI);

data/ext/ffi_c/libffi/.appveyor.yml

@@ -0,0 +1,48 @@
+shallow_clone: true
+
+# We're currently only testing 64-bit libffi built with Microsoft's
+# tools.
+# This matrix should be expanded to include at least:
+#  32- and 64-bit gcc/cygwin
+#  32- and 64-bit gcc/mingw
+#  32- and 64-bit clang/mingw
+#  and perhaps more.
+
+image: Visual Studio 2013
+platform:
+  - x64
+
+environment:
+  global:
+    CYG_ROOT: C:/cygwin
+    CYG_CACHE: C:/cygwin/var/cache/setup
+    CYG_MIRROR: http://mirrors.kernel.org/sourceware/cygwin/
+  matrix:
+    - VSVER: 12
+
+install:
+  - ps: >-
+      If ($env:Platform -Match "x86") {
+          $env:VCVARS_PLATFORM="x86"
+          $env:BUILD="x86-pc-cygwin"
+          $env:HOST="x86-pc-windows"
+        } Else {
+          $env:VCVARS_PLATFORM="amd64"
+          $env:BUILD="x86_64-pc-cygwin"
+          $env:HOST="x86_64-pc-winnt"
+      }
+  - 'appveyor DownloadFile http://cygwin.com/setup-x86.exe -FileName setup.exe'
+  - 'setup.exe -qnNdO -R "%CYG_ROOT%" -s "%CYG_MIRROR%" -l "%CYG_CACHE%" -P dejagnu >NUL'
+  - '%CYG_ROOT%/bin/bash -lc "cygcheck -dc cygwin"'
+  - ps: $env:VSCOMNTOOLS=(Get-Content ("env:VS" + "$env:VSVER" + "0COMNTOOLS"))
+  - echo "Using Visual Studio %VSVER%.0 at %VSCOMNTOOLS%"
+  - call "%VSCOMNTOOLS%\..\..\VC\vcvarsall.bat" %VCVARS_PLATFORM%
+
+build_script:
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; ./autogen.sh;)"
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; ./configure CC='/cygdrive/c/projects/libffi/msvcc.sh -m64' CXX='/cygdrive/c/projects/libffi/msvcc.sh -m64' LD=link CPP='cl -nologo -EP' --build=$BUILD --host=$HOST; cp src/x86/ffitarget.h include; make;)"
+
+# FIXME: "make check" currently fails.  It just looks like msvcc needs
+# to learn about -L and -l options.  If you add "make check; cat `find
+# ./ -name libffi.log" to the end of that build command you'll see
+# what I mean.

data/ext/ffi_c/libffi/.gitignore

@@ -0,0 +1,36 @@
+.libs
+.deps
+*.o
+*.lo
+.dirstamp
+*.la
+Makefile
+Makefile.in
+aclocal.m4
+compile
+configure
+depcomp
+doc/libffi.info
+*~
+fficonfig.h.in
+fficonfig.h
+include/ffi.h
+include/ffitarget.h
+install-sh
+libffi.pc
+libtool
+libtool-ldflags
+ltmain.sh
+m4/libtool.m4
+m4/lt*.m4
+mdate-sh
+missing
+stamp-h1
+libffi*gz
+autom4te.cache
+libffi.xcodeproj/xcuserdata
+libffi.xcodeproj/project.xcworkspace
+build_*/
+darwin_*/
+src/arm/trampoline.S
+**/texinfo.tex

data/ext/ffi_c/libffi/.travis/install.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+if [[ $TRAVIS_OS_NAME != 'linux' ]]; then
+  brew update
+  # fix an issue with libtool on travis by reinstalling it
+  brew uninstall libtool;
+  brew install libtool dejagnu;
+else
+  sudo apt-get update
+  sudo apt-get install dejagnu texinfo
+  if [ "$HOST" = i386-pc-linux-gnu ] ; then
+      sudo apt-get install gcc-multilib g++-multilib;
+  fi
+fi

data/ext/ffi_c/libffi/.travis.yml

@@ -0,0 +1,30 @@
+---
+sudo: required
+
+language: cpp
+
+os:
+  - linux
+compiler:
+  - gcc
+  - clang
+env:
+  - CONFIGURE_OPTIONS=--disable-shared
+  - CONFIGURE_OPTIONS=
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+      env: HOST=i386-pc-linux-gnu
+
+install:
+  - ./.travis/install.sh
+
+script:
+  - ./autogen.sh
+  - if test x"$HOST" = x"i386-pc-linux-gnu"; then CC="$CC -m32"; CXX="$CXX -m32"; fi
+  - ./configure ${HOST+--host=$HOST} ${CONFIGURE_OPTIONS}
+  - make
+  - make dist
+  - make check
+  - cat */testsuite/libffi.log

data/ext/ffi_c/libffi/ChangeLog.libffi

@@ -574,8 +574,8 @@
 	* Makefile.am, include/Makefile.am: Move headers to
 	libffi_la_SOURCES for new automake.
 	* Makefile.in, include/Makefile.in: Rebuilt.
-	
-	* testsuite/lib/wrapper.exp: Copied from gcc tree to allow for 
+
+	* testsuite/lib/wrapper.exp: Copied from gcc tree to allow for
 	execution outside of gcc tree.
 	* testsuite/lib/target-libpath.exp: Ditto.