ffi 0.2.0 → 0.3.0

data/ext/{AutoPointer.c → ffi_c/AutoPointer.c}

@@ -19,17 +19,25 @@ static void autoptr_mark(AutoPointer* ptr);
 static void autoptr_free(AutoPointer* ptr);
 
 static VALUE
-autoptr_new(VALUE klass, VALUE other)
+autoptr_allocate(VALUE klass)
 {
     AutoPointer* p;
-    AbstractMemory* ptr;
-    VALUE retval;
+    VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, autoptr_free, p);
+    p->parent = Qnil;
+    return obj;
+}
+
+static VALUE
+autoptr_set_parent(VALUE self, VALUE parent)
+{
+    AutoPointer* p;
+    AbstractMemory* ptr = rb_FFI_AbstractMemory_cast(parent, rb_FFI_Pointer_class);
 
-    retval = Data_Make_Struct(klass, AutoPointer, autoptr_mark, autoptr_free, p);
-    ptr = (AbstractMemory *) DATA_PTR(other);
+    Data_Get_Struct(self, AutoPointer, p);
     p->memory = *ptr;
-    p->parent = other;
-    return retval;
+    p->parent = parent;
+
+    return self;
 }
 
 static void
@@ -50,5 +58,6 @@ rb_FFI_AutoPointer_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
     rb_FFI_AutoPointer_class = classAutoPointer = rb_define_class_under(moduleFFI, "AutoPointer", rb_FFI_Pointer_class);
-    rb_define_singleton_method(classAutoPointer, "__alloc", autoptr_new, 1);
+    rb_define_alloc_func(classAutoPointer, autoptr_allocate);
+    rb_define_protected_method(classAutoPointer, "parent=", autoptr_set_parent, 1);
 }

data/ext/ffi_c/Buffer.c

@@ -0,0 +1,136 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+
+typedef struct Buffer {
+    AbstractMemory memory;
+    char* storage; /* start of malloc area */
+    int type_size;
+    VALUE parent;
+} Buffer;
+
+static VALUE buffer_allocate(VALUE klass);
+static VALUE buffer_initialize(int argc, VALUE* argv, VALUE self);
+static void buffer_release(Buffer* ptr);
+static void buffer_mark(Buffer* ptr);
+static VALUE buffer_free(VALUE self);
+
+static VALUE classBuffer = Qnil;
+#define BUFFER(obj)  ((Buffer *) rb_FFI_AbstractMemory_cast((obj), classBuffer))
+
+static VALUE
+buffer_allocate(VALUE klass)
+{
+    Buffer* buffer;
+    return Data_Make_Struct(klass, Buffer, buffer_mark, buffer_release, buffer);
+}
+
+static VALUE
+buffer_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE size = Qnil, count = Qnil, clear = Qnil;
+    Buffer* p;
+    unsigned long msize;
+    void* memory;
+    int nargs;
+
+    nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
+    msize = rb_FFI_type_size(size) * (nargs > 1 ? NUM2LONG(count) : 1);
+    memory = malloc(msize + 7);
+    if (memory == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", msize);
+    }
+    Data_Get_Struct(self, Buffer, p);
+    p->storage = memory;
+    p->memory.size = msize;
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (void *) (((uintptr_t) memory + 0x7) & (uintptr_t) ~0x7UL);
+    p->parent = Qnil;
+    if (nargs > 2 && RTEST(clear) && p->memory.size > 0) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+    if (rb_block_given_p()) {
+        return rb_rescue(rb_yield, self, buffer_free, self);
+    }
+    return self;
+}
+
+static VALUE
+buffer_alloc_inout(int argc, VALUE* argv, VALUE klass)
+{
+    return buffer_initialize(argc, argv, buffer_allocate(klass));
+}
+
+static VALUE
+buffer_plus(VALUE self, VALUE offset)
+{
+    Buffer* ptr = BUFFER(self);
+    Buffer* p;
+    VALUE retval;
+    long off = NUM2LONG(offset);
+
+    checkBounds(&ptr->memory, off, 1);
+    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
+    p->memory.address = ptr->memory.address + off;;
+    p->memory.size = ptr->memory.size - off;
+    p->parent = self;
+    return retval;
+}
+
+static VALUE
+buffer_inspect(VALUE self)
+{
+    char tmp[100];
+    snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", BUFFER(self)->memory.size);
+    return rb_str_new2(tmp);
+}
+
+/* Only used to free the buffer if the yield in the initializer throws an exception */
+static VALUE
+buffer_free(VALUE self)
+{
+    Buffer* ptr = BUFFER(self);
+    if (ptr->parent == Qnil && ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    return self;
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->parent == Qnil && ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    xfree(ptr);
+}
+
+static void
+buffer_mark(Buffer* ptr)
+{
+    if (ptr->parent != Qnil) {
+        rb_gc_mark(ptr->parent);
+    }
+}
+
+void
+rb_FFI_Buffer_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
+    rb_define_alloc_func(classBuffer, buffer_allocate);
+
+    rb_define_singleton_method(classBuffer, "alloc_inout", buffer_alloc_inout, -1);
+    rb_define_singleton_method(classBuffer, "alloc_out", buffer_alloc_inout, -1);
+    rb_define_singleton_method(classBuffer, "alloc_in", buffer_alloc_inout, -1);
+    
+    rb_define_method(classBuffer, "initialize", buffer_initialize, -1);
+    rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
+    rb_define_method(classBuffer, "+", buffer_plus, 1);
+}
+

data/ext/{Callback.c → ffi_c/Callback.c}

@@ -1,6 +1,8 @@
 #include <sys/param.h>
 #include <sys/types.h>
-#include <sys/mman.h>
+#ifndef _WIN32
+# include <sys/mman.h>
+#endif
 #include <ruby.h>
 #include <ffi.h>
 #include "AbstractMemory.h"
@@ -26,7 +28,7 @@ ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
 
 static VALUE classCallbackInfo = Qnil;
 static VALUE classNativeCallback = Qnil;
-static ID callID = Qnil;
+static ID callID = Qnil, cbTableID = Qnil;
 
 VALUE rb_FFI_CallbackInfo_class = Qnil;
 
@@ -55,7 +57,7 @@ CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
     if (cbInfo->ffiReturnType == NULL) {
         rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType);
     }
-#ifdef _WIN32
+#if defined(_WIN32) && defined(notyet)
     cbInfo->abi = (flags & STDCALL) ? FFI_STDCALL : FFI_DEFAULT_ABI;
 #else
     cbInfo->abi = FFI_DEFAULT_ABI;
@@ -126,41 +128,41 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     for (i = 0; i < cbInfo->parameterCount; ++i) {
         VALUE param;
         switch (cbInfo->parameterTypes[i]) {
-            case INT8:
+            case NATIVE_INT8:
                 param = INT2NUM(*(int8_t *) parameters[i]);
                 break;
-            case UINT8:
-                param = UINT2NUM(*(u_int8_t *) parameters[i]);
+            case NATIVE_UINT8:
+                param = UINT2NUM(*(uint8_t *) parameters[i]);
                 break;
-            case INT16:
+            case NATIVE_INT16:
                 param = INT2NUM(*(int16_t *) parameters[i]);
                 break;
-            case UINT16:
-                param = UINT2NUM(*(u_int16_t *) parameters[i]);
+            case NATIVE_UINT16:
+                param = UINT2NUM(*(uint16_t *) parameters[i]);
                 break;
-            case INT32:
+            case NATIVE_INT32:
                 param = INT2NUM(*(int32_t *) parameters[i]);
                 break;
-            case UINT32:
-                param = UINT2NUM(*(u_int32_t *) parameters[i]);
+            case NATIVE_UINT32:
+                param = UINT2NUM(*(uint32_t *) parameters[i]);
                 break;
-            case INT64:
+            case NATIVE_INT64:
                 param = LL2NUM(*(int64_t *) parameters[i]);
                 break;
-            case UINT64:
-                param = ULL2NUM(*(u_int64_t *) parameters[i]);
+            case NATIVE_UINT64:
+                param = ULL2NUM(*(uint64_t *) parameters[i]);
                 break;
-            case FLOAT32:
+            case NATIVE_FLOAT32:
                 param = rb_float_new(*(float *) parameters[i]);
                 break;
-            case FLOAT64:
+            case NATIVE_FLOAT64:
                 param = rb_float_new(*(double *) parameters[i]);
                 break;
-            case STRING:
+            case NATIVE_STRING:
                 param = rb_tainted_str_new2(*(char **) parameters[i]);
                 break;
-            case POINTER:
-                param = rb_FFI_Pointer_new(*(caddr_t *) parameters[i]);
+            case NATIVE_POINTER:
+                param = rb_FFI_Pointer_new(*(void **) parameters[i]);
                 break;
             default:
                 param = Qnil;
@@ -172,30 +174,35 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     if (rbReturnValue == Qnil || TYPE(rbReturnValue) == T_NIL) {
         memset(retval, 0, cbInfo->ffiReturnType->size);
     } else switch (cbInfo->returnType) {
-        case INT8:
-        case INT16:
-        case INT32:
-            *((long *) retval) = NUM2INT(rbReturnValue);
+        case NATIVE_INT8:
+        case NATIVE_INT16:
+        case NATIVE_INT32:
+            *((ffi_sarg *) retval) = NUM2INT(rbReturnValue);
             break;
-        case UINT8:
-        case UINT16:
-        case UINT32:
-            *((unsigned long *) retval) = NUM2UINT(rbReturnValue);
+        case NATIVE_UINT8:
+        case NATIVE_UINT16:
+        case NATIVE_UINT32:
+            *((ffi_arg *) retval) = NUM2UINT(rbReturnValue);
             break;
-        case INT64:
+        case NATIVE_INT64:
             *((int64_t *) retval) = NUM2LL(rbReturnValue);
             break;
-        case UINT64:
-            *((u_int64_t *) retval) = NUM2ULL(rbReturnValue);
+        case NATIVE_UINT64:
+            *((uint64_t *) retval) = NUM2ULL(rbReturnValue);
             break;
-        case FLOAT32:
+        case NATIVE_FLOAT32:
             *((float *) retval) = (float) NUM2DBL(rbReturnValue);
             break;
-        case FLOAT64:
+        case NATIVE_FLOAT64:
             *((double *) retval) = NUM2DBL(rbReturnValue);
             break;
-        case POINTER:
-            *((caddr_t *) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
+        case NATIVE_POINTER:
+            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rb_FFI_Pointer_class)) {
+                *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
+            } else {
+                // Default to returning NULL if not a value pointer object.  handles nil case as well
+                *((void **) retval) = NULL;
+            }
             break;
         default:
             break;
@@ -228,6 +235,23 @@ rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
     return Data_Wrap_Struct(classNativeCallback, native_callback_mark, native_callback_free, closure);
 }
 
+VALUE
+rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo)
+{
+    VALUE callback;
+    VALUE cbTable = RTEST(rb_ivar_defined(proc, cbTableID)) ? rb_ivar_get(proc, cbTableID) : Qnil;
+    if (cbTable == Qnil) {
+        cbTable = rb_hash_new();
+        rb_ivar_set(proc, cbTableID, cbTable);
+    }
+    callback = rb_hash_aref(cbTable, cbInfo);
+    if (callback != Qnil) {
+        return callback;
+    }
+    callback = rb_FFI_NativeCallback_new(cbInfo, proc);
+    rb_hash_aset(cbTable, cbInfo, callback);
+    return callback;
+}
 #if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
 /*
  * versions of ffi_closure_alloc, ffi_closure_free and ffi_prep_closure_loc for older
@@ -275,4 +299,5 @@ rb_FFI_Callback_Init()
     rb_define_singleton_method(classCallbackInfo, "new", CallbackInfo_new, 2);
     classNativeCallback = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
     callID = rb_intern("call");
+    cbTableID = rb_intern("@__ffi_callback_table__");
 }

data/ext/{Callback.h → ffi_c/Callback.h}

@@ -1,10 +1,3 @@
-/* 
- * File:   Callback.h
- * Author: wayne
- *
- * Created on September 11, 2008, 10:01 AM
- */
-
 #ifndef _CALLBACK_H
 #define	_CALLBACK_H
 
@@ -38,6 +31,7 @@ typedef struct {
 
 extern VALUE rb_FFI_CallbackInfo_class;
 extern VALUE rb_FFI_NativeCallback_new(VALUE, VALUE);
+extern VALUE rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo);
 
 #ifdef	__cplusplus
 }

data/ext/{Invoker.c → ffi_c/Invoker.c}

@@ -1,12 +1,17 @@
+#include <sys/param.h>
 #include <sys/types.h>
+#ifndef _WIN32
+#  include <sys/mman.h>
+#endif
 #include <stdio.h>
 #include <stdint.h>
-#include <dlfcn.h>
+#include <stdbool.h>
+#include <unistd.h>
 #include <errno.h>
 #include <ruby.h>
 
 #include <ffi.h>
-#ifdef HAVE_NATIVETHREAD
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
 # include <pthread.h>
 #endif
 #include "rbffi.h"
@@ -14,11 +19,23 @@
 
 #include "AbstractMemory.h"
 #include "Pointer.h"
+#include "Struct.h"
 #include "Platform.h"
 #include "Callback.h"
 #include "Types.h"
 
-typedef struct Invoker {
+#if defined(__i386__) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_RAW
+#endif
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_PTHREAD_LOCAL
+#endif
+#define MAX_FIXED_ARITY (3)
+
+typedef struct MethodHandle MethodHandle;
+typedef struct Invoker Invoker;
+
+struct Invoker {
     VALUE library;
     void* function;
     ffi_cif cif;
@@ -30,11 +47,36 @@ typedef struct Invoker {
     int callbackCount;
     VALUE* callbackParameters;
     ffi_abi abi;
-} Invoker;
+    MethodHandle* methodHandle;
+};
+#ifdef USE_RAW
+#  define METHOD_CLOSURE ffi_raw_closure
+#else
+#  define METHOD_CLOSURE ffi_closure
+#endif
+typedef struct MethodHandlePool MethodHandlePool;
+struct MethodHandle {
+    Invoker* invoker;
+    int arity;
+    METHOD_CLOSURE* closure;
+    void* code;
+    ffi_cif cif;
+    struct MethodHandlePool* pool;
+    MethodHandle* next;
+};
+#if !defined(_WIN32) && !defined(__WIN32__)
+struct MethodHandlePool {
+#ifdef HAVE_NATIVETHREAD
+    pthread_mutex_t mutex;
+#endif
+    MethodHandle* list;
+};
+#endif /* _WIN32 */
 typedef struct ThreadData {
     int td_errno;
 } ThreadData;
-static VALUE invoker_new(VALUE self, VALUE library, VALUE function, VALUE parameterTypes,
+static VALUE invoker_allocate(VALUE klass);
+static VALUE invoker_initialize(VALUE self, VALUE library, VALUE function, VALUE parameterTypes,
         VALUE returnType, VALUE convention);
 static void invoker_mark(Invoker *);
 static void invoker_free(Invoker *);
@@ -42,20 +84,32 @@ static VALUE invoker_call(int argc, VALUE* argv, VALUE self);
 static VALUE invoker_call0(VALUE self);
 static VALUE invoker_arity(VALUE self);
 static void* callback_param(VALUE proc, VALUE cbinfo);
+#ifdef USE_RAW
+static void attached_method_invoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+static void attached_method_vinvoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+#else
+#ifndef _WIN32
+static void attached_method_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif /* _WIN32 */
+static void attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif
+static MethodHandle* method_handle_alloc(int arity);
+static void method_handle_free(MethodHandle *);
+
 static inline ThreadData* thread_data_get(void);
+
+#ifndef _WIN32
+static int PageSize;
+#endif
 static VALUE classInvoker = Qnil, classVariadicInvoker = Qnil;
-static ID cbTableID, to_ptr;
+static ID to_ptr;
 
-#ifdef HAVE_NATIVETHREAD
+#if defined(USE_PTHREAD_LOCAL)
 static pthread_key_t threadDataKey;
 #endif
 
 #define threadData (thread_data_get())
 
-#if defined(__i386__)
-#  define USE_RAW
-#endif
-
 #ifdef USE_RAW
 #  ifndef __i386__
 #    error "RAW argument packing only supported on i386"
@@ -79,21 +133,26 @@ static pthread_key_t threadDataKey;
 #endif /* USE_RAW */
 
 #ifdef USE_RAW
-#  define ADJ(p, a) ((p) = (FFIStorage*) (((caddr_t) p) + a##_ADJ))
+#  define ADJ(p, a) ((p) = (FFIStorage*) (((char *) p) + a##_ADJ))
 #else
 #  define ADJ(p, a) (++(p))
 #endif
 
+static VALUE
+invoker_allocate(VALUE klass)
+{
+    Invoker *invoker;
+    return Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
+}
 
 static VALUE
-invoker_new(VALUE klass, VALUE library, VALUE function, VALUE parameterTypes,
+invoker_initialize(VALUE self, VALUE library, VALUE function, VALUE parameterTypes,
         VALUE returnType, VALUE convention)
 {
     Invoker* invoker = NULL;
     ffi_type* ffiReturnType;
     ffi_abi abi;
     ffi_status ffiStatus;
-    VALUE retval = Qnil;
     int i;
 
     Check_Type(parameterTypes, T_ARRAY);
@@ -101,10 +160,10 @@ invoker_new(VALUE klass, VALUE library, VALUE function, VALUE parameterTypes,
     Check_Type(convention, T_STRING);
     Check_Type(library, T_DATA);
     Check_Type(function, T_DATA);
-    
-    retval = Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
+
+    Data_Get_Struct(self, Invoker, invoker);
     invoker->library = library;
-    invoker->function = ((AbstractMemory *) DATA_PTR(function))->address;
+    invoker->function = rb_FFI_AbstractMemory_cast(function, rb_FFI_Pointer_class)->address;
     invoker->paramCount = RARRAY_LEN(parameterTypes);
     invoker->paramTypes = ALLOC_N(NativeType, invoker->paramCount);
     invoker->ffiParamTypes = ALLOC_N(ffi_type *, invoker->paramCount);
@@ -115,7 +174,7 @@ invoker_new(VALUE klass, VALUE library, VALUE function, VALUE parameterTypes,
             invoker->callbackParameters = REALLOC_N(invoker->callbackParameters, VALUE,
                     invoker->callbackCount + 1);
             invoker->callbackParameters[invoker->callbackCount++] = entry;
-            invoker->paramTypes[i] = CALLBACK;
+            invoker->paramTypes[i] = NATIVE_CALLBACK;
             invoker->ffiParamTypes[i] = &ffi_type_pointer;
         } else {
             int paramType = FIX2INT(entry);
@@ -131,8 +190,8 @@ invoker_new(VALUE klass, VALUE library, VALUE function, VALUE parameterTypes,
     if (ffiReturnType == NULL) {
         rb_raise(rb_eArgError, "Invalid return type");
     }
-#ifdef _WIN32
-    abi = strcmp(StringValueCPtr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
+#if defined(_WIN32) || defined(__WIN32__)
+    abi = strcmp(StringValueCStr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
 #else
     abi = FFI_DEFAULT_ABI;
 #endif
@@ -148,8 +207,9 @@ invoker_new(VALUE klass, VALUE library, VALUE function, VALUE parameterTypes,
         default:
             rb_raise(rb_eArgError, "Unknown FFI error");
     }
-    
-    return retval;
+    invoker->methodHandle = method_handle_alloc(invoker->callbackCount < 1 ? invoker->paramCount : -1);
+    invoker->methodHandle->invoker = invoker;
+    return self;
 }
 
 static VALUE
@@ -165,9 +225,9 @@ variadic_invoker_new(VALUE klass, VALUE library, VALUE function, VALUE returnTyp
 
     retval = Data_Make_Struct(klass, Invoker, invoker_mark, invoker_free, invoker);
     invoker->library = library;
-    invoker->function = ((AbstractMemory *) DATA_PTR(function))->address;
-#ifdef _WIN32
-    invoker->abi = strcmp(StringValueCPtr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
+    invoker->function = rb_FFI_AbstractMemory_cast(function, rb_FFI_Pointer_class)->address;
+#if defined(_WIN32) || defined(__WIN32__)
+    invoker->abi = strcmp(StringValueCStr(convention), "stdcall") == 0 ? FFI_STDCALL : FFI_DEFAULT_ABI;
 #else
     invoker->abi = FFI_DEFAULT_ABI;
 #endif
@@ -176,9 +236,201 @@ variadic_invoker_new(VALUE klass, VALUE library, VALUE function, VALUE returnTyp
     return retval;
 }
 
+static ffi_type* methodHandleParamTypes[MAX_FIXED_ARITY + 2];
+static ffi_type* methodHandleVarargParamTypes[]= {
+    &ffi_type_sint,
+    &ffi_type_pointer,
+    NULL,
+};
+
+#if defined(_WIN32) || defined(__WIN32__)
+static MethodHandle*
+method_handle_alloc(int arity)
+{
+    char errmsg[1024];
+    ffi_type* ffiReturnType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    int ffiParamCount, ffiStatus;
+    MethodHandle* method = NULL;
+    ffi_type** ffiParamTypes;
+    void (*fn)(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+
+    ffiParamCount = 3;
+    ffiParamTypes = methodHandleVarargParamTypes;
+    fn = attached_method_vinvoke;
+    method = ALLOC_N(MethodHandle, 1);
+    memset(method, 0, sizeof(*method));
+    method->arity = -1;
+    ffiStatus = ffi_prep_cif(&method->cif, FFI_DEFAULT_ABI, ffiParamCount,
+            ffiReturnType, ffiParamTypes);
+    if (ffiStatus != FFI_OK) {
+        snprintf(errmsg, sizeof (errmsg), "ffi_prep_cif failed.  status=%#x", ffiStatus);
+        goto error;
+    }
+    method->closure = ffi_closure_alloc(sizeof(*method->closure), &method->code);
+    if (method->closure == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "ffi_closure_alloc failed");
+        goto error;
+    }
+    ffiStatus = ffi_prep_closure_loc(method->closure, &method->cif, fn, method, method->code);
+    if (ffiStatus != FFI_OK) {
+        snprintf(errmsg, sizeof (errmsg), "ffi_prep_closure failed.  status=%#x", ffiStatus);
+        goto error;
+    }
+    return method;
+error:
+    if (method != NULL) {
+        if (method->closure != NULL) {
+            ffi_closure_free(method->closure);
+        }
+        xfree(method);
+    }
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+}
+static void
+method_handle_free(MethodHandle* method)
+{
+    if (method->closure != NULL) {
+        ffi_closure_free(method->closure);
+    }
+    xfree(method);
+}
+#else
+static MethodHandlePool methodHandlePool[MAX_FIXED_ARITY + 1], defaultMethodHandlePool;
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
+#  define pool_lock(p) pthread_mutex_lock(&(p)->mutex)
+#  define pool_unlock(p)  pthread_mutex_unlock(&(p)->mutex)
+#else
+#  define pool_lock(p)
+#  define pool_unlock(p)
+#endif
+static MethodHandle*
+method_handle_alloc(int arity)
+{
+    MethodHandle* method, *list = NULL;
+    MethodHandlePool* pool;
+    ffi_type** ffiParamTypes;
+    ffi_type* ffiReturnType;
+    caddr_t page;
+    int ffiParamCount, ffiStatus;
+    int nclosures, closureSize, methodArity;
+    int i;
+#ifdef USE_RAW
+    void (*fn)(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data);
+#else
+    void (*fn)(ffi_cif* cif, void* retval, void** parameters, void* user_data);
+#endif
+    
+    
+    pool = (arity >= 0 && arity <= MAX_FIXED_ARITY) ? &methodHandlePool[arity] : &defaultMethodHandlePool;
+    pool_lock(pool);
+    if (pool->list != NULL) {
+        method = pool->list;
+        pool->list = pool->list->next;
+        pool_unlock(pool);
+        return method;
+    }
+    ffiReturnType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    closureSize = roundup(sizeof(METHOD_CLOSURE), 8);
+    nclosures = PageSize / closureSize;
+    page = mmap(NULL, PageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (page == (caddr_t) -1) {
+        pool_unlock(pool);
+        rb_raise(rb_eRuntimeError, "mmap failed. errno=%d (%s)", errno, strerror(errno));
+    }
+
+    /* figure out whichh function to bounce the execution through */
+    if (arity >= 0 && arity <= MAX_FIXED_ARITY) {
+        ffiParamCount = arity + 1;
+        ffiParamTypes = methodHandleParamTypes;
+        fn = attached_method_invoke;
+        methodArity = arity;
+    } else {
+        ffiParamCount = 3;
+        ffiParamTypes = methodHandleVarargParamTypes;
+        fn = attached_method_vinvoke;
+        methodArity = -1;
+    }
+
+    for (i = 0; i < nclosures; ++i) {
+        char errmsg[256];
+        method = calloc(1, sizeof(MethodHandle));
+        if (method == NULL) {
+            snprintf(errmsg, sizeof(errmsg), "malloc failed: %s", strerror(errno));
+            goto error;
+        }
+        method->next = list;
+        list = method;
+        method->pool = pool;
+        method->code = method->closure = (METHOD_CLOSURE *) (page + (i * closureSize));
+
+        ffiStatus = ffi_prep_cif(&method->cif, FFI_DEFAULT_ABI, ffiParamCount,
+                    ffiReturnType, ffiParamTypes);
+        if (ffiStatus != FFI_OK) {
+            snprintf(errmsg, sizeof(errmsg), "ffi_prep_cif failed.  status=%#x", ffiStatus);
+            goto error;
+        }
+
+#ifdef USE_RAW
+        ffiStatus = ffi_prep_raw_closure(method->closure, &method->cif, fn, method);
+#else
+        ffiStatus = ffi_prep_closure(method->closure, &method->cif, fn, method);
+#endif
+        if (ffiStatus != FFI_OK) {
+            snprintf(errmsg, sizeof(errmsg), "ffi_prep_closure failed.  status=%#x", ffiStatus);
+            goto error;
+        }
+        method->arity = methodArity;
+        continue;
+error:
+        while (list != NULL) {
+            method = list;
+            list = list->next;
+            free(method);
+        }
+        munmap(page, PageSize);
+        pool_unlock(pool);
+        rb_raise(rb_eRuntimeError, "%s", errmsg);
+    }
+    mprotect(page, PageSize, PROT_READ | PROT_EXEC);
+
+    /* take the first member of the list for this handle */
+    method = list;
+    list = list->next;
+
+    /* now add the new block of MethodHandles to the pool */
+    if (list != NULL) {
+        list->next = pool->list;
+        pool->list = list;
+    }
+    pool_unlock(pool);
+    return method;
+}
+static void
+method_handle_free(MethodHandle* method)
+{
+    MethodHandlePool* pool = method->pool;
+    pool_lock(pool);
+    method->next = pool->list;
+    pool->list = method;
+    pool_unlock(pool);
+}
+#endif /* _WIN32 */
+
 typedef union {
-    signed long i;
-    unsigned long u;
+#if BYTE_ORDER == LITTLE_ENDIAN
+    signed int s8, s16, s32;
+    unsigned int u8, u16, u32;
+#else
+    signed char s8;
+    unsigned char u8;
+    signed short s16;
+    unsigned short u16;
+    signed int s32;
+    unsigned int u32;
+#endif
     signed long long i64;
     unsigned long long u64;
     void* ptr;
@@ -250,32 +502,32 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
         ffiValues[i] = param;
         
         switch (paramTypes[i]) {
-            case INT8:
-                param->i = getSignedInt(argv[argidx++], type, -128, 127, "char");
+            case NATIVE_INT8:
+                param->s8 = getSignedInt(argv[argidx++], type, -128, 127, "char");
                 ADJ(param, INT8);
                 break;
-            case INT16:
-                param->i = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short");
+            case NATIVE_INT16:
+                param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short");
                 ADJ(param, INT16);
                 break;
-            case INT32:
-                param->i = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int");
+            case NATIVE_INT32:
+                param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int");
                 ADJ(param, INT32);
                 break;
-            case UINT8:
-                param->u = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char");
+            case NATIVE_UINT8:
+                param->u8 = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char");
                 ADJ(param, INT8);
                 break;
-            case UINT16:
-                param->u = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short");
+            case NATIVE_UINT16:
+                param->u16 = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short");
                 ADJ(param, INT16);
                 break;
-            case UINT32:
+            case NATIVE_UINT32:
                 /* Special handling/checking for unsigned 32 bit integers */
-                param->u = getUnsignedInt32(argv[argidx++], type);
+                param->u32 = getUnsignedInt32(argv[argidx++], type);
                 ADJ(param, INT32);
                 break;
-            case INT64:
+            case NATIVE_INT64:
                 if (type != T_FIXNUM && type != T_BIGNUM) {
                     rb_raise(rb_eTypeError, "Expected an Integer parameter");
                 }
@@ -283,15 +535,15 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                 ADJ(param, INT64);
                 ++argidx;
                 break;
-            case UINT64:
+            case NATIVE_UINT64:
                 if (type != T_FIXNUM && type != T_BIGNUM) {
                     rb_raise(rb_eTypeError, "Expected an Integer parameter");
                 }
-                param->i64 = NUM2ULL(argv[argidx]);
+                param->u64 = NUM2ULL(argv[argidx]);
                 ADJ(param, INT64);
                 ++argidx;
                 break;
-            case FLOAT32:
+            case NATIVE_FLOAT32:
                 if (type != T_FLOAT && type != T_FIXNUM) {
                     rb_raise(rb_eTypeError, "Expected a Float parameter");
                 }
@@ -299,7 +551,7 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                 ADJ(param, FLOAT32);
                 ++argidx;
                 break;
-            case FLOAT64:
+            case NATIVE_FLOAT64:
                 if (type != T_FLOAT && type != T_FIXNUM) {
                     rb_raise(rb_eTypeError, "Expected a Float parameter");
                 }
@@ -307,12 +559,12 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                 ADJ(param, FLOAT64);
                 ++argidx;
                 break;
-            case STRING:
+            case NATIVE_STRING:
                 if (type == T_STRING) {
                     if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
                         rb_raise(rb_eSecurityError, "Unsafe string parameter");
                     }
-                    param->ptr = StringValuePtr(argv[argidx]);
+                    param->ptr = StringValueCStr(argv[argidx]);
                 } else if (type == T_NIL) {
                     param->ptr = NULL;
                 } else {
@@ -321,12 +573,15 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                 ADJ(param, ADDRESS);
                 ++argidx;
                 break;
-            case POINTER:
-            case BUFFER_IN:
-            case BUFFER_OUT:
-            case BUFFER_INOUT:
-                if (rb_obj_is_kind_of(argv[argidx], rb_FFI_AbstractMemory_class) && type == T_DATA) {
+            case NATIVE_POINTER:
+            case NATIVE_BUFFER_IN:
+            case NATIVE_BUFFER_OUT:
+            case NATIVE_BUFFER_INOUT:
+                if (type == T_DATA && rb_obj_is_kind_of(argv[argidx], rb_FFI_AbstractMemory_class)) {
                     param->ptr = ((AbstractMemory *) DATA_PTR(argv[argidx]))->address;
+                } else if (type == T_DATA && rb_obj_is_kind_of(argv[argidx], rb_FFI_Struct_class)) {
+                    AbstractMemory* memory = ((Struct *) DATA_PTR(argv[argidx]))->pointer;
+                    param->ptr = memory != NULL ? memory->address : NULL;
                 } else if (type == T_STRING) {
                     if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
                         rb_raise(rb_eSecurityError, "Unsafe string parameter");
@@ -336,7 +591,7 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                     param->ptr = NULL;
                 } else if (rb_respond_to(argv[argidx], to_ptr)) {
                     VALUE ptr = rb_funcall2(argv[argidx], to_ptr, 0, NULL);
-                    if (rb_obj_is_kind_of(ptr, rb_FFI_Pointer_class) && TYPE(ptr) == T_DATA) {
+                    if (rb_obj_is_kind_of(ptr, rb_FFI_AbstractMemory_class) && TYPE(ptr) == T_DATA) {
                         param->ptr = ((AbstractMemory *) DATA_PTR(ptr))->address;
                     } else {
                         rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
@@ -348,7 +603,7 @@ ffi_arg_setup(const Invoker* invoker, int argc, VALUE* argv, NativeType* paramTy
                 ADJ(param, ADDRESS);
                 ++argidx;
                 break;
-            case CALLBACK:
+            case NATIVE_CALLBACK:
                 if (callbackProc != Qnil) {
                     param->ptr = callback_param(callbackProc, invoker->callbackParameters[cbidx++]);
                 } else {
@@ -371,7 +626,11 @@ ffi_invoke(ffi_cif* cif, void* function, NativeType returnType, void** ffiValues
 #else
     ffi_call(cif, FFI_FN(function), &retval, ffiValues);
 #endif
+#if defined(_WIN32) || defined(__WIN32__)
+    threadData->td_errno = GetLastError();
+#else
     threadData->td_errno = errno;
+#endif
     return rb_FFI_NativeValueToRuby(returnType, &retval);
 }
 static VALUE
@@ -386,6 +645,18 @@ invoker_call(int argc, VALUE* argv, VALUE self)
     return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
 }
 
+static inline VALUE
+invoker_callN(VALUE self, int argc, VALUE* argv)
+{
+    Invoker* invoker;
+    FFIStorage params[3];
+    void* ffiValues[3];
+
+    Data_Get_Struct(self, Invoker, invoker);
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+}
+
 static VALUE
 invoker_call0(VALUE self)
 {
@@ -400,41 +671,102 @@ invoker_call0(VALUE self)
 static VALUE
 invoker_call1(VALUE self, VALUE arg1)
 {
-    Invoker* invoker;
-    void* ffiValues[1];
-    FFIStorage params[1];
-
-    Data_Get_Struct(self, Invoker, invoker);
-    ffi_arg_setup(invoker, 1, &arg1, invoker->paramTypes, params, ffiValues);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+    return invoker_callN(self, 1, &arg1);
 }
 
 static VALUE
 invoker_call2(VALUE self, VALUE arg1, VALUE arg2)
 {
-    Invoker* invoker;
-    void* ffiValues[2];
-    FFIStorage params[2];
     VALUE argv[] = { arg1, arg2 };
-
-    Data_Get_Struct(self, Invoker, invoker);
-    ffi_arg_setup(invoker, 2, argv, invoker->paramTypes, params, ffiValues);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+    return invoker_callN(self, 2, argv);
 }
 
 static VALUE
 invoker_call3(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3)
 {
-    Invoker* invoker;
-    void* ffiValues[3];
-    FFIStorage params[3];
     VALUE argv[] = { arg1, arg2, arg3 };
+    return invoker_callN(self, 3, argv);
+}
 
-    Data_Get_Struct(self, Invoker, invoker);
-    ffi_arg_setup(invoker, 3, argv, invoker->paramTypes, params, ffiValues);
-    return ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+#ifdef USE_RAW
+static void
+attached_method_invoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void* ffiValues[MAX_FIXED_ARITY];
+    FFIStorage params[MAX_FIXED_ARITY];
+
+    if (invoker->paramCount > 0) {
+        ffi_arg_setup(invoker, invoker->paramCount, (VALUE *)&parameters[1],
+                invoker->paramTypes, params, ffiValues);
+    }
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+}
+
+static void
+attached_method_vinvoke(ffi_cif* cif, void* retval, ffi_raw* parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void** ffiValues = ALLOCA_N(void *, invoker->paramCount);
+    FFIStorage* params = ALLOCA_N(FFIStorage, invoker->paramCount);
+    int argc = parameters[0].sint;
+    VALUE* argv = *(VALUE **) &parameters[1];
+
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+}
+
+#else
+#ifndef _WIN32
+static void
+attached_method_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void* ffiValues[MAX_FIXED_ARITY];
+    FFIStorage params[MAX_FIXED_ARITY];
+    VALUE argv[MAX_FIXED_ARITY];
+    int i;
+    //printf("Attached method invoke nargs=%d paramCount=%d\n", cif->nargs, invoker->paramCount); fflush(stdout);
+    for (i = 0; i < invoker->paramCount; ++i) {
+        memcpy(&argv[i], parameters[i + 1], sizeof(argv[i]));
+    }
+    if (invoker->paramCount > 0) {
+        ffi_arg_setup(invoker, invoker->paramCount, argv, invoker->paramTypes, params, ffiValues);
+    }
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
 }
+#endif /* _WIN32 */
+static void
+attached_method_vinvoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
+{
+    MethodHandle* handle =  (MethodHandle *) user_data;
+    Invoker* invoker = handle->invoker;
+    void** ffiValues = ALLOCA_N(void *, invoker->paramCount);
+    FFIStorage* params = ALLOCA_N(FFIStorage, invoker->paramCount);
+    int argc = *(int *) parameters[0];
+    VALUE* argv = *(VALUE **) parameters[1];
 
+    ffi_arg_setup(invoker, argc, argv, invoker->paramTypes, params, ffiValues);
+    *((VALUE *) retval) = ffi_invoke(&invoker->cif, invoker->function, invoker->returnType, ffiValues);
+}
+#endif
+static VALUE
+invoker_attach(VALUE self, VALUE module, VALUE name)
+{
+    Invoker* invoker;
+    MethodHandle* handle;
+    char var[1024];
+    Data_Get_Struct(self, Invoker, invoker);
+    handle = invoker->methodHandle;
+    rb_define_module_function(module, StringValuePtr(name), 
+            handle->code, handle->arity);
+    snprintf(var, sizeof(var), "@@%s", StringValueCStr(name));
+    rb_cv_set(module, var, self);
+    return self;
+}
 static VALUE
 invoker_arity(VALUE self)
 {
@@ -470,6 +802,9 @@ invoker_free(Invoker *invoker)
             xfree(invoker->callbackParameters);
             invoker->callbackParameters = NULL;
         }
+        if (invoker->methodHandle != NULL) {
+            method_handle_free(invoker->methodHandle);
+        }
         xfree(invoker);
     }
 }
@@ -503,18 +838,18 @@ variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
         VALUE entry = rb_ary_entry(parameterTypes, i);
         int paramType = FIX2INT(entry);
         switch (paramType) {
-            case INT8:
-            case INT16:
-            case INT32:
-                paramType = INT32;
+            case NATIVE_INT8:
+            case NATIVE_INT16:
+            case NATIVE_INT32:
+                paramType = NATIVE_INT32;
                 break;
-            case UINT8:
-            case UINT16:
-            case UINT32:
-                paramType = UINT32;
+            case NATIVE_UINT8:
+            case NATIVE_UINT16:
+            case NATIVE_UINT32:
+                paramType = NATIVE_UINT32;
                 break;
-            case FLOAT32:
-                paramType = FLOAT64;
+            case NATIVE_FLOAT32:
+                paramType = NATIVE_FLOAT64;
                 break;
         }
         paramTypes[i] = paramType;
@@ -547,21 +882,15 @@ variadic_invoker_call(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 static void* 
 callback_param(VALUE proc, VALUE cbInfo)
 {
-    VALUE callback;
-    VALUE cbTable = RTEST(rb_ivar_defined(proc, cbTableID)) ? rb_ivar_get(proc, cbTableID) : Qnil;
-    if (!cbTable || cbTable == Qnil) {
-        cbTable = rb_hash_new();
-        rb_ivar_set(proc, cbTableID, cbTable);
+    VALUE callback ;
+    if (proc == Qnil) {
+        return NULL ;
     }
-    callback = rb_hash_aref(cbTable, cbInfo);
-    if (callback != Qnil) {
-        return ((NativeCallback *) DATA_PTR(callback))->code;
-    }
-    callback = rb_FFI_NativeCallback_new(cbInfo, proc);
-    rb_hash_aset(cbTable, cbInfo, callback);
+    callback = rb_FFI_NativeCallback_for_proc(proc, cbInfo);
     return ((NativeCallback *) DATA_PTR(callback))->code;
 }
-#ifdef HAVE_NATIVETHREAD
+
+#if defined(USE_PTHREAD_LOCAL)
 static ThreadData*
 thread_data_init()
 {
@@ -570,6 +899,7 @@ thread_data_init()
     pthread_setspecific(threadDataKey, td);
     return td;
 }
+
 static inline ThreadData*
 thread_data_get()
 {
@@ -582,13 +912,31 @@ thread_data_free(void *ptr)
 {
     xfree(ptr);
 }
-#else /* !HAVE_NATIVETHREAD */
-static ThreadData td0;
+
+#else
+static ID thread_data_id;
+
+static ThreadData*
+thread_data_init()
+{
+    ThreadData* td;
+    VALUE obj;
+    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
+    rb_thread_local_aset(rb_thread_current(), thread_data_id, obj);
+    return td;
+}
+
 static inline ThreadData*
 thread_data_get()
 {
-    return &td0;
+    VALUE obj = rb_thread_local_aref(rb_thread_current(), thread_data_id);
+
+    if (obj != Qnil && TYPE(obj) == T_DATA) {
+        return (ThreadData *) DATA_PTR(obj);
+    }
+    return thread_data_init();
 }
+
 #endif
 static VALUE
 get_last_error(VALUE self)
@@ -604,25 +952,47 @@ set_last_error(VALUE self, VALUE error)
 void 
 rb_FFI_Invoker_Init()
 {
+    ffi_type* ffiValueType;
+    int i;
     VALUE moduleFFI = rb_define_module("FFI");
     VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
     classInvoker = rb_define_class_under(moduleFFI, "Invoker", rb_cObject);
-    rb_define_singleton_method(classInvoker, "new", invoker_new, 5);
+    rb_define_alloc_func(classInvoker, invoker_allocate);
+    rb_define_method(classInvoker, "initialize", invoker_initialize, 5);
     rb_define_method(classInvoker, "call", invoker_call, -1);
     rb_define_method(classInvoker, "call0", invoker_call0, 0);
     rb_define_method(classInvoker, "call1", invoker_call1, 1);
     rb_define_method(classInvoker, "call2", invoker_call2, 2);
     rb_define_method(classInvoker, "call3", invoker_call3, 3);
     rb_define_method(classInvoker, "arity", invoker_arity, 0);
+    rb_define_method(classInvoker, "attach", invoker_attach, 2);
     classVariadicInvoker = rb_define_class_under(moduleFFI, "VariadicInvoker", rb_cObject);
     rb_define_singleton_method(classVariadicInvoker, "__new", variadic_invoker_new, 4);
     rb_define_method(classVariadicInvoker, "invoke", variadic_invoker_call, 2);
-    cbTableID = rb_intern("__ffi_callback_table__");
     to_ptr = rb_intern("to_ptr");
     
     rb_define_module_function(moduleError, "error", get_last_error, 0);
     rb_define_module_function(moduleError, "error=", set_last_error, 1);
-#ifdef HAVE_NATIVETHREAD
+
+    ffiValueType = (sizeof (VALUE) == sizeof (long))
+            ? &ffi_type_ulong : &ffi_type_uint64;
+    for (i = 0; i <= MAX_FIXED_ARITY + 1; ++i) {
+        methodHandleParamTypes[i] = ffiValueType;
+    }
+    methodHandleVarargParamTypes[2] = ffiValueType;
+
+#ifndef _WIN32
+    PageSize = sysconf(_SC_PAGESIZE);
+#endif /* _WIN32 */
+
+#if defined(USE_PTHREAD_LOCAL)
     pthread_key_create(&threadDataKey, thread_data_free);
-#endif
+    for (i = 0; i < 4; ++i) {
+        pthread_mutex_init(&methodHandlePool[i].mutex, NULL);
+    }
+    pthread_mutex_init(&defaultMethodHandlePool.mutex, NULL);
+#else
+    thread_data_id = rb_intern("ffi_thread_local_data");
+#endif /* USE_PTHREAD_LOCAL */
+
 }