ffi 0.5.0-x86-mingw32

data/ext/ffi_c/LastError.h

@@ -0,0 +1,18 @@
+#ifndef RBFFI_LASTERROR_H
+#define	RBFFI_LASTERROR_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+void rbffi_LastError_Init(VALUE moduleFFI);
+
+void rbffi_save_errno(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_LASTERROR_H */
+

data/ext/ffi_c/MemoryPointer.c

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2008, Luc Heinrich <luc@honk-honk.com>
+ *
+ * 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.
+ * * 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.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#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 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))
+
+VALUE
+rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
+{
+    return memptr_malloc(memptr_allocate(rbffi_MemoryPointerClass), size, count, clear);
+}
+
+static VALUE
+memptr_allocate(VALUE klass)
+{
+    MemoryPointer* p;
+    VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->memory.access = MEM_RD | MEM_WR;
+
+    return obj;
+}
+
+static VALUE
+memptr_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE size = Qnil, count = Qnil, clear = Qnil;
+    int nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
+
+    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);
+    }
+
+    return self;
+}
+
+static VALUE
+memptr_malloc(VALUE self, long size, long count, bool clear)
+{
+    MemoryPointer* p;
+    unsigned long msize;
+
+    Data_Get_Struct(self, MemoryPointer, p);
+
+    msize = size * count;
+
+    p->storage = xmalloc(msize + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", msize);
+    }
+    p->autorelease = true;
+    p->memory.typeSize = 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->allocated = true;
+
+    if (clear && p->memory.size > 0) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+
+    return self;
+}
+
+static VALUE
+memptr_inspect(VALUE self)
+{
+    MemoryPointer* ptr;
+    char tmp[100];
+
+    Data_Get_Struct(self, MemoryPointer, ptr);
+
+    snprintf(tmp, sizeof(tmp), "#<FFI::MemoryPointer address=%p size=%lu>", ptr->memory.address, ptr->memory.size);
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+memptr_free(VALUE self)
+{
+    MemoryPointer* ptr;
+
+    Data_Get_Struct(self, MemoryPointer, ptr);
+
+    if (ptr->allocated) {
+        if (ptr->storage != NULL) {
+            free(ptr->storage);
+            ptr->storage = NULL;
+        }
+        ptr->allocated = false;
+    }
+
+    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)
+{
+    if (ptr->autorelease && ptr->allocated && ptr->storage != NULL) {
+        xfree(ptr->storage);
+        ptr->storage = NULL;
+    }
+    xfree(ptr);
+}
+
+void
+rbffi_MemoryPointer_Init(VALUE moduleFFI)
+{
+    rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", rbffi_PointerClass);
+    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, "inspect", memptr_inspect, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "autorelease=", memptr_autorelease, 1);
+    rb_define_method(rbffi_MemoryPointerClass, "free", memptr_free, 0);
+}

data/ext/ffi_c/MemoryPointer.h

@@ -0,0 +1,20 @@
+
+#ifndef _MEMORYPOINTER_H
+#define	_MEMORYPOINTER_H
+
+#include <stdbool.h>
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    extern void rbffi_MemoryPointer_Init(VALUE moduleFFI);
+    extern VALUE rbffi_MemoryPointerClass;
+    extern VALUE rbffi_MemoryPointer_NewInstance(long size, long count, bool clear);
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _MEMORYPOINTER_H */
+

data/ext/ffi_c/MethodHandle.c

@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * 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.
+ * * 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.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#ifndef _WIN32
+#  include <sys/mman.h>
+#endif
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#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"
+
+#include "Function.h"
+#include "Types.h"
+#include "Type.h"
+#include "LastError.h"
+#include "Call.h"
+#include "ClosurePool.h"
+#include "MethodHandle.h"
+
+
+#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
+#  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 int trampoline_size(void);
+
+#if defined(__x86_64__) && defined(__GNUC__)
+# define CUSTOM_TRAMPOLINE 1
+#endif
+
+
+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,
+    &ffi_type_ulong,
+};
+
+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 int
+trampoline_size(void)
+{
+    return sizeof(METHOD_CLOSURE);
+}
+
+/*
+ * attached_method_vinvoke 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 = *(ffi_sarg *) 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;
+    return (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+}
+
+#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 speedup 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,
+ * 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)
+{
+    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(int *, int *);
+
+static int trampoline_ctx_offset, trampoline_func_offset;
+
+static int
+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;
+        }
+    }
+
+    return -1;
+}
+
+static int
+trampoline_offsets(int* ctxOffset, int* fnOffset)
+{
+    *ctxOffset = trampoline_offset(0, TRAMPOLINE_CTX_MAGIC);
+    if (*ctxOffset == -1) {
+        return -1;
+    }
+
+    *fnOffset = trampoline_offset(0, TRAMPOLINE_FUN_MAGIC);
+    if (*fnOffset == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+
+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;
+
+    return true;
+}
+
+static int
+trampoline_size(void)
+{
+    return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
+}
+
+#endif /* CUSTOM_TRAMPOLINE */
+
+
+void
+rbffi_MethodHandle_Init(VALUE module)
+{
+    defaultClosurePool = rbffi_ClosurePool_New(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);
+    if (ffiStatus != FFI_OK) {
+        rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);
+    }
+
+#endif
+}
+