ffi 1.0.0 → 1.17.1

data/ext/ffi_c/MemoryPointer.c

@@ -1,22 +1,31 @@
 /*
  * Copyright (c) 2008, 2009, Wayne Meissner
- * Copyright (c) 2008, Luc Heinrich <luc@honk-honk.com>
+ * Copyright (C) 2009 Luc Heinrich <luc@honk-honk.com>
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <stdbool.h>
@@ -28,21 +37,16 @@
 #include "Pointer.h"
 #include "MemoryPointer.h"
 
-typedef struct MemoryPointer {
-    AbstractMemory memory;
-    char* storage; /* start of malloc area */
-    bool autorelease;
-    bool allocated;
-} MemoryPointer;
 
 static VALUE memptr_allocate(VALUE klass);
-static void memptr_release(MemoryPointer* ptr);
+static void memptr_release(void *data);
+static size_t memptr_memsize(const void *data);
 static VALUE memptr_malloc(VALUE self, long size, long count, bool clear);
 static VALUE memptr_free(VALUE self);
 
 VALUE rbffi_MemoryPointerClass;
 
-#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, rbffi_MemoryPointerClass))
+#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, &memory_pointer_data_type))
 
 VALUE
 rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
@@ -50,16 +54,38 @@ rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
     return memptr_malloc(memptr_allocate(rbffi_MemoryPointerClass), size, count, clear);
 }
 
+static const rb_data_type_t memory_pointer_data_type = {
+    .wrap_struct_name = "FFI::MemoryPointer",
+    .function = {
+        .dmark = NULL,
+        .dfree = memptr_release,
+        .dsize = memptr_memsize,
+    },
+    .parent = &rbffi_pointer_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
 static VALUE
 memptr_allocate(VALUE klass)
 {
-    MemoryPointer* p;
-    VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    Pointer* p;
+    VALUE obj = TypedData_Make_Struct(klass, Pointer, &memory_pointer_data_type, p);
+    RB_OBJ_WRITE(obj, &p->rbParent, Qnil);
     p->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
 
+/*
+ * call-seq: initialize(size, count=1, clear=true)
+ * @param [Integer, Symbol, FFI::Type] size size of a memory cell (in bytes, or type whom size will be used)
+ * @param [Integer] count number of cells in memory
+ * @param [Boolean] clear set memory to all-zero if +true+
+ * @return [self]
+ * A new instance of FFI::MemoryPointer.
+ */
 static VALUE
 memptr_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -68,7 +94,7 @@ memptr_initialize(int argc, VALUE* argv, VALUE self)
 
     memptr_malloc(self, rbffi_type_size(size), nargs > 1 ? NUM2LONG(count) : 1,
         RTEST(clear) || clear == Qnil);
-    
+
     if (rb_block_given_p()) {
         return rb_ensure(rb_yield, self, memptr_free, self);
     }
@@ -79,10 +105,10 @@ memptr_initialize(int argc, VALUE* argv, VALUE self)
 static VALUE
 memptr_malloc(VALUE self, long size, long count, bool clear)
 {
-    MemoryPointer* p;
+    Pointer* p;
     unsigned long msize;
 
-    Data_Get_Struct(self, MemoryPointer, p);
+    TypedData_Get_Struct(self, Pointer, &memory_pointer_data_type, p);
 
     msize = size * count;
 
@@ -92,12 +118,12 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
         return Qnil;
     }
     p->autorelease = true;
-    p->memory.typeSize = size;
+    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) {
         memset(p->memory.address, 0, p->memory.size);
     }
@@ -108,9 +134,10 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
 static VALUE
 memptr_free(VALUE self)
 {
-    MemoryPointer* ptr;
+    Pointer* ptr;
 
-    Data_Get_Struct(self, MemoryPointer, ptr);
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pointer, &memory_pointer_data_type, ptr);
 
     if (ptr->allocated) {
         if (ptr->storage != NULL) {
@@ -123,20 +150,10 @@ memptr_free(VALUE self)
     return self;
 }
 
-static VALUE
-memptr_autorelease(VALUE self, VALUE autorelease)
-{
-    MemoryPointer* ptr;
-
-    Data_Get_Struct(self, MemoryPointer, ptr);
-    ptr->autorelease = autorelease == Qtrue;
-
-    return autorelease;
-}
-
 static void
-memptr_release(MemoryPointer* ptr)
+memptr_release(void *data)
 {
+    Pointer *ptr = (Pointer *)data;
     if (ptr->autorelease && ptr->allocated && ptr->storage != NULL) {
         xfree(ptr->storage);
         ptr->storage = NULL;
@@ -144,14 +161,59 @@ memptr_release(MemoryPointer* ptr)
     xfree(ptr);
 }
 
+static size_t
+memptr_memsize(const void *data)
+{
+    const Pointer *ptr = (const Pointer *)data;
+    size_t memsize = sizeof(Pointer);
+    if (ptr->allocated) {
+        memsize += ptr->memory.size;
+    }
+    return memsize;
+}
+
+/*
+ * call-seq: from_string(s)
+ * @param [String] s string
+ * @return [MemoryPointer]
+ * Create a {MemoryPointer} with +s+ inside.
+ */
+static VALUE
+memptr_s_from_string(VALUE klass, VALUE to_str)
+{
+    VALUE s = StringValue(to_str);
+    VALUE args[] = { INT2FIX(1), LONG2NUM(RSTRING_LEN(s) + 1), Qfalse };
+    VALUE obj = rb_class_new_instance(3, args, klass);
+    rb_funcall(obj, rb_intern("put_string"), 2, INT2FIX(0), s);
+
+    return obj;
+}
+
 void
 rbffi_MemoryPointer_Init(VALUE moduleFFI)
 {
-    rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", rbffi_PointerClass);
+    VALUE ffi_Pointer;
+
+    ffi_Pointer = rbffi_PointerClass;
+
+    /*
+     * Document-class: FFI::MemoryPointer < FFI::Pointer
+     * A MemoryPointer is a specific {Pointer}. It points to a memory composed of cells. All cells have the
+     * same size.
+     *
+     * @example Create a new MemoryPointer
+     *  mp = FFI::MemoryPointer.new(:long, 16)   # Create a pointer on a memory of 16 long ints.
+     * @example Create a new MemoryPointer from a String
+     *  mp1 = FFI::MemoryPointer.from_string("this is a string")
+     *  # same as:
+     *  mp2 = FFI::MemoryPointer.new(:char,16)
+     *  mp2.put_string("this is a string")
+     */
+    rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", ffi_Pointer);
     rb_global_variable(&rbffi_MemoryPointerClass);
 
     rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
     rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
-    rb_define_method(rbffi_MemoryPointerClass, "autorelease=", memptr_autorelease, 1);
-    rb_define_method(rbffi_MemoryPointerClass, "free", memptr_free, 0);
+    rb_define_singleton_method(rbffi_MemoryPointerClass, "from_string", memptr_s_from_string, 1);
 }
+

data/ext/ffi_c/MemoryPointer.h

@@ -1,8 +1,37 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2008, Luc Heinrich <luc@honk-honk.com>
+ *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
-#ifndef _MEMORYPOINTER_H
-#define	_MEMORYPOINTER_H
+#ifndef RBFFI_MEMORYPOINTER_H
+#define	RBFFI_MEMORYPOINTER_H
 
-#include <stdbool.h>
+# include <stdbool.h>
 #include <ruby.h>
 
 #ifdef	__cplusplus
@@ -16,5 +45,5 @@ extern "C" {
 }
 #endif
 
-#endif	/* _MEMORYPOINTER_H */
+#endif	/* RBFFI_MEMORYPOINTER_H */
 

data/ext/ffi_c/MethodHandle.c

@@ -1,40 +1,43 @@
 /*
- * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, 2010 Wayne Meissner
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * * Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright notice
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * * The name of the author or authors may not be used to endorse or promote
- *   products derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * 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>
+# include <sys/mman.h>
 #endif
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
 #ifndef _WIN32
-#  include <unistd.h>
+# include <unistd.h>
 #endif
 #include <errno.h>
 #include <ruby.h>
@@ -57,16 +60,9 @@
 
 #define MAX_METHOD_FIXED_ARITY (6)
 
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-#  define USE_PTHREAD_LOCAL
-#endif
-
 #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
@@ -79,9 +75,11 @@
 
 
 static bool prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
-static int trampoline_size(void);
+static long trampoline_size(void);
 
-#if defined(__x86_64__) && defined(__GNUC__)
+#if defined(__x86_64__) && \
+    (defined(__linux__) || defined(__APPLE__)) && \
+    !USE_FFI_ALLOC
 # define CUSTOM_TRAMPOLINE 1
 #endif
 
@@ -116,23 +114,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;
 
@@ -144,10 +138,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;
     }
 
@@ -155,14 +149,14 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 }
 
 
-static int
+static long
 trampoline_size(void)
 {
     return sizeof(METHOD_CLOSURE);
 }
 
 /*
- * attached_method_vinvoke is used functions with more than 6 parameters, or
+ * attached_method_invoke is used functions with more than 6 parameters, or
  * with struct param or return values
  */
 static void
@@ -204,7 +198,7 @@ static VALUE custom_trampoline(int argc, VALUE* argv, VALUE self, Closure*);
  *
  * This results in approx a 30% speedup for x86_64 FFI dispatch
  */
-asm(
+__asm__(
     ".text\n\t"
     ".globl ffi_trampoline\n\t"
     ".globl _ffi_trampoline\n\t"
@@ -223,23 +217,28 @@ static VALUE
 custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
-    return (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+    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*);
+static VALUE custom_trampoline(void *args, Closure*);
 #define TRAMPOLINE_CTX_MAGIC (0xfee1dead)
 #define TRAMPOLINE_FUN_MAGIC (0xbeefcafe)
 
 /*
- * This is a hand-coded trampoline to speedup entry from ruby to the FFI translation
+ * 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 discernable difference vs a raw closure, so for now,
+ * This does not make a discernible difference vs a raw closure, so for now,
  * it is not enabled.
  */
-asm(
+__asm__(
     ".text\n\t"
     ".globl ffi_trampoline\n\t"
     ".globl _ffi_trampoline\n\t"
@@ -260,7 +259,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);
@@ -270,17 +269,17 @@ custom_trampoline(caddr_t args, Closure* handle)
 
 extern void ffi_trampoline(int argc, VALUE* argv, VALUE self);
 extern void ffi_trampoline_end(void);
-static int trampoline_offsets(int *, int *);
+static int trampoline_offsets(long *, long *);
 
-static int trampoline_ctx_offset, trampoline_func_offset;
+static long trampoline_ctx_offset, trampoline_func_offset;
 
-static int
+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;
         }
     }
 
@@ -288,7 +287,7 @@ trampoline_offset(int off, const long value)
 }
 
 static int
-trampoline_offsets(int* ctxOffset, int* fnOffset)
+trampoline_offsets(long* ctxOffset, long* fnOffset)
 {
     *ctxOffset = trampoline_offset(0, TRAMPOLINE_CTX_MAGIC);
     if (*ctxOffset == -1) {
@@ -306,20 +305,18 @@ trampoline_offsets(int* ctxOffset, int* 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());
-    // 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;
+    memcpy(code, (void*) &ffi_trampoline, trampoline_size());
+    /* Patch the context and function addresses into the stub code */
+    *(intptr_t *)((char*)code + trampoline_ctx_offset) = (intptr_t) closure;
+    *(intptr_t *)((char*)code + trampoline_func_offset) = (intptr_t) custom_trampoline;
 
     return true;
 }
 
-static int
+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 */
@@ -328,14 +325,22 @@ trampoline_size(void)
 void
 rbffi_MethodHandle_Init(VALUE module)
 {
-    defaultClosurePool = rbffi_ClosurePool_New(trampoline_size(), prep_trampoline, NULL);
+#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
-    ffi_status ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
+    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) {
         rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);
@@ -343,4 +348,3 @@ rbffi_MethodHandle_Init(VALUE module)
 
 #endif
 }
-

data/ext/ffi_c/MethodHandle.h

@@ -1,32 +1,34 @@
 /*
  * Copyright (c) 2009, Wayne Meissner
+ *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * * Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright notice
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * * The name of the author or authors may not be used to endorse or promote
- *   products derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _METHODHANDLE_H
-#define	_METHODHANDLE_H
+#ifndef RBFFI_METHODHANDLE_H
+#define	RBFFI_METHODHANDLE_H
 
 #ifdef	__cplusplus
 extern "C" {
@@ -35,19 +37,20 @@ 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
 }
 #endif
 
-#endif	/* _METHODHANDLE_H */
+#endif	/* RBFFI_METHODHANDLE_H */