ffi 1.11.2

data/ext/ffi_c/Call.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
+ * Copyright (c) 2009, Aman Gupta.
+ *
+ * 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 RBFFI_CALL_H
+#define	RBFFI_CALL_H
+
+#include "Thread.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#if defined(__i386__) && \
+  (defined(HAVE_RAW_API) || defined(USE_INTERNAL_LIBFFI)) && \
+  !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_RAW
+#endif
+
+#if (defined(__i386__) || defined(__x86_64__)) && !(defined(_WIN32) || defined(__WIN32__))
+#  define BYPASS_FFI 1
+#endif
+
+typedef union {
+#ifdef USE_RAW
+    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;
+    signed long sl;
+    unsigned long ul;
+    void* ptr;
+    float f32;
+    double f64;
+    long double ld;
+} FFIStorage;
+
+extern void rbffi_Call_Init(VALUE moduleFFI);
+
+extern void rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
+        FFIStorage* paramStorage, void** ffiValues,
+        VALUE* callbackParameters, int callbackCount, VALUE enums);
+
+struct FunctionType_;
+extern VALUE rbffi_CallFunction(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
+
+typedef VALUE (*Invoker)(int argc, VALUE* argv, void* function, struct FunctionType_* fnInfo);
+
+Invoker rbffi_GetInvoker(struct FunctionType_* fnInfo);
+
+extern VALUE rbffi_GetEnumValue(VALUE enums, VALUE value);
+extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums);
+
+typedef struct rbffi_blocking_call {
+    rbffi_frame_t* frame;
+    void* function;
+    ffi_cif cif;
+    void **ffiValues;
+    void* retval;
+    void* params;
+} rbffi_blocking_call_t;
+
+VALUE rbffi_do_blocking_call(VALUE data);
+VALUE rbffi_save_frame_exception(VALUE data, VALUE exc);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_CALL_H */
+

data/ext/ffi_c/ClosurePool.c

@@ -0,0 +1,283 @@
+/*
+ * 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.
+ *
+ * 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>
+#if defined(__CYGWIN__) || !defined(_WIN32)
+#  include <sys/mman.h>
+#endif
+#include <stdio.h>
+#ifndef _MSC_VER
+# include <stdint.h>
+# include <stdbool.h>
+#else
+# include "win32/stdbool.h"
+# include "win32/stdint.h"
+#endif
+#if defined(__CYGWIN__) || !defined(_WIN32)
+#  include <unistd.h>
+#else
+#  include <winsock2.h>
+#  define _WINSOCKAPI_
+#  include <windows.h>
+#endif
+#include <errno.h>
+#include <ruby.h>
+
+#if defined(_MSC_VER) && !defined(INT8_MIN)
+#  include "win32/stdint.h"
+#endif
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "Function.h"
+#include "Types.h"
+#include "Type.h"
+#include "LastError.h"
+#include "Call.h"
+
+#include "ClosurePool.h"
+
+
+#ifndef roundup
+#  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
+#endif
+#ifdef _WIN32
+  typedef char* caddr_t;
+#endif
+
+typedef struct Memory {
+    void* code;
+    void* data;
+    struct Memory* next;
+} Memory;
+
+struct ClosurePool_ {
+    void* ctx;
+    int closureSize;
+    bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize);
+    struct Memory* blocks; /* Keeps track of all the allocated memory for this pool */
+    Closure* list;
+    long refcnt;
+};
+
+static long pageSize;
+
+static void* allocatePage(void);
+static bool freePage(void *);
+static bool protectPage(void *);
+
+ClosurePool*
+rbffi_ClosurePool_New(int closureSize, 
+        bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
+        void* ctx)
+{
+    ClosurePool* pool;
+
+    pool = xcalloc(1, sizeof(*pool));
+    pool->closureSize = closureSize;
+    pool->ctx = ctx;
+    pool->prep = prep;
+    pool->refcnt = 1;
+    
+    return pool;
+}
+
+void
+cleanup_closure_pool(ClosurePool* pool)
+{
+    Memory* memory;
+    
+    for (memory = pool->blocks; memory != NULL; ) {
+        Memory* next = memory->next;
+        freePage(memory->code);
+        free(memory->data);
+        free(memory);
+        memory = next;
+    }
+    xfree(pool);
+}
+
+void
+rbffi_ClosurePool_Free(ClosurePool* pool)
+{
+    if (pool != NULL) {
+        long refcnt = --(pool->refcnt);
+        if (refcnt == 0) {
+            cleanup_closure_pool(pool);
+        }
+    }
+}
+
+Closure*
+rbffi_Closure_Alloc(ClosurePool* pool)
+{
+    Closure *list = NULL;
+    Memory* block = NULL;
+    caddr_t code = NULL;
+    char errmsg[256];
+    int nclosures;
+    long trampolineSize;
+    int i;
+
+    if (pool->list != NULL) {
+        Closure* closure = pool->list;
+        pool->list = pool->list->next;
+        pool->refcnt++;
+    
+        return closure;
+    }
+
+    trampolineSize = roundup(pool->closureSize, 8);
+    nclosures = (int) (pageSize / trampolineSize);
+    block = calloc(1, sizeof(*block));
+    list = calloc(nclosures, sizeof(*list));
+    code = allocatePage();
+    
+    if (block == NULL || list == NULL || code == NULL) {
+        snprintf(errmsg, sizeof(errmsg), "failed to allocate a page. errno=%d (%s)", errno, strerror(errno));
+        goto error;
+    }
+    
+    for (i = 0; i < nclosures; ++i) {
+        Closure* closure = &list[i];
+        closure->next = &list[i + 1];
+        closure->pool = pool;
+        closure->code = (code + (i * trampolineSize));
+
+        if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
+            goto error;
+        }
+    }
+
+    if (!protectPage(code)) {
+        goto error;
+    }
+
+    /* Track the allocated page + Closure memory area */
+    block->data = list;
+    block->code = code;
+    block->next = pool->blocks;
+    pool->blocks = block;
+
+    /* Thread the new block onto the free list, apart from the first one. */
+    list[nclosures - 1].next = pool->list;
+    pool->list = list->next;
+    pool->refcnt++;
+
+    /* Use the first one as the new handle */
+    return list;
+
+error:
+    free(block);
+    free(list);
+    if (code != NULL) {
+        freePage(code);
+    }
+    
+
+    rb_raise(rb_eRuntimeError, "%s", errmsg);
+    return NULL;
+}
+
+void
+rbffi_Closure_Free(Closure* closure)
+{
+    if (closure != NULL) {
+        ClosurePool* pool = closure->pool;
+        long refcnt;
+        /* Just push it on the front of the free list */
+        closure->next = pool->list;
+        pool->list = closure;
+        refcnt = --(pool->refcnt);
+        if (refcnt == 0) {
+            cleanup_closure_pool(pool);
+        }
+    }
+}
+
+void*
+rbffi_Closure_CodeAddress(Closure* handle)
+{
+    return handle->code;
+}
+
+
+static long
+getPageSize()
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+#else
+    return sysconf(_SC_PAGESIZE);
+#endif
+}
+
+static void*
+allocatePage(void)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    return VirtualAlloc(NULL, pageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    caddr_t page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    return (page != (caddr_t) -1) ? page : NULL;
+#endif
+}
+
+static bool
+freePage(void *addr)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    return VirtualFree(addr, 0, MEM_RELEASE);
+#else
+    return munmap(addr, pageSize) == 0;
+#endif
+}
+
+static bool
+protectPage(void* page)
+{
+#if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__))
+    DWORD oldProtect;
+    return VirtualProtect(page, pageSize, PAGE_EXECUTE_READ, &oldProtect);
+#else
+    return mprotect(page, pageSize, PROT_READ | PROT_EXEC) == 0;
+#endif
+}
+
+void
+rbffi_ClosurePool_Init(VALUE module)
+{
+    pageSize = getPageSize();
+}
+

data/ext/ffi_c/ClosurePool.h

@@ -0,0 +1,57 @@
+/*
+ * 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.
+ *
+ * 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 RUBYFFI_CLOSUREPOOL_H
+#define RUBYFFI_CLOSUREPOOL_H
+
+typedef struct ClosurePool_ ClosurePool;
+typedef struct Closure_ Closure;
+
+struct Closure_ {
+    void* info;      /* opaque handle for storing closure-instance specific data */
+    void* function;  /* closure-instance specific function, called by custom trampoline */
+    void* code;      /* The native trampoline code location */
+    struct ClosurePool_* pool;
+    Closure* next;
+};
+
+void rbffi_ClosurePool_Init(VALUE module);
+
+ClosurePool* rbffi_ClosurePool_New(int closureSize, 
+        bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
+        void* ctx);
+
+void rbffi_ClosurePool_Free(ClosurePool *);
+
+Closure* rbffi_Closure_Alloc(ClosurePool *);
+void rbffi_Closure_Free(Closure *);
+
+void* rbffi_Closure_GetCodeAddress(Closure *);
+
+#endif /* RUBYFFI_CLOSUREPOOL_H */
+

data/ext/ffi_c/DynamicLibrary.c

@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2008-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.
+ *
+ * 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 <sys/types.h>
+#include <stdio.h>
+#ifndef _MSC_VER
+#  include <stdint.h>
+#endif
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
+# include <winsock2.h>
+# define _WINSOCKAPI_
+# include <windows.h>
+# include <shlwapi.h>
+#else
+# include <dlfcn.h>
+#endif
+#include <ruby.h>
+#if defined(_MSC_VER) && !defined(INT8_MIN)
+#  include "win32/stdint.h"
+#endif
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "compat.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "DynamicLibrary.h"
+
+typedef struct LibrarySymbol_ {
+    Pointer base;
+    VALUE library;
+    VALUE name;
+} LibrarySymbol;
+
+static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
+static void library_free(Library* lib);
+
+
+static VALUE symbol_allocate(VALUE klass);
+static VALUE symbol_new(VALUE library, void* address, VALUE name);
+static void symbol_mark(LibrarySymbol* sym);
+
+static VALUE LibraryClass = Qnil, SymbolClass = Qnil;
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
+static void* dl_open(const char* name, int flags);
+static void dl_error(char* buf, int size);
+#define dl_sym(handle, name) GetProcAddress(handle, name)
+#define dl_close(handle) FreeLibrary(handle)
+#else
+# define dl_open(name, flags) dlopen(name, flags != 0 ? flags : RTLD_LAZY)
+# define dl_error(buf, size) do { snprintf(buf, size, "%s", dlerror()); } while(0)
+# define dl_sym(handle, name) dlsym(handle, name)
+# define dl_close(handle) dlclose(handle)
+#endif
+
+static VALUE
+library_allocate(VALUE klass)
+{
+    Library* library;
+    return Data_Make_Struct(klass, Library, NULL, library_free, library);
+}
+
+/*
+ * call-seq: DynamicLibrary.open(libname, libflags)
+ * @param libname (see #initialize)
+ * @param libflags (see #initialize)
+ * @return [FFI::DynamicLibrary]
+ * @raise {LoadError} if +libname+ cannot be opened
+ * Open a library.
+ */
+static VALUE
+library_open(VALUE klass, VALUE libname, VALUE libflags)
+{
+    return library_initialize(library_allocate(klass), libname, libflags);
+}
+
+/*
+ * call-seq: initialize(libname, libflags)
+ * @param [String] libname name of library to open
+ * @param [Fixnum] libflags flags for library to open
+ * @return [FFI::DynamicLibrary]
+ * @raise {LoadError} if +libname+ cannot be opened
+ * A new DynamicLibrary instance.
+ */
+static VALUE
+library_initialize(VALUE self, VALUE libname, VALUE libflags)
+{
+    Library* library;
+    int flags;
+
+    Check_Type(libflags, T_FIXNUM);
+
+    Data_Get_Struct(self, Library, library);
+    flags = libflags != Qnil ? NUM2UINT(libflags) : 0;
+    
+    library->handle = dl_open(libname != Qnil ? StringValueCStr(libname) : NULL, flags);
+    if (library->handle == NULL) {
+        char errmsg[1024];
+        dl_error(errmsg, sizeof(errmsg));
+        rb_raise(rb_eLoadError, "Could not open library '%s': %s",
+                libname != Qnil ? StringValueCStr(libname) : "[current process]",
+                errmsg);
+    }
+#ifdef __CYGWIN__
+    // On Cygwin 1.7.17 "dlsym(dlopen(0,0), 'getpid')" fails. (dlerror: "No such process")
+    // As a workaround we can use "dlsym(RTLD_DEFAULT, 'getpid')" instead.
+    // Since 0 == RTLD_DEFAULT we won't call dl_close later.
+    if (libname == Qnil) {
+        dl_close(library->handle);
+        library->handle = RTLD_DEFAULT;
+    }
+#endif
+    rb_iv_set(self, "@name", libname != Qnil ? libname : rb_str_new2("[current process]"));
+    return self;
+}
+
+static VALUE
+library_dlsym(VALUE self, VALUE name)
+{
+    Library* library;
+    void* address = NULL;
+    Check_Type(name, T_STRING);
+
+    Data_Get_Struct(self, Library, library);
+    address = dl_sym(library->handle, StringValueCStr(name));
+    
+    return address != NULL ? symbol_new(self, address, name) : Qnil;
+}
+
+/*
+ * call-seq: last_error
+ * @return [String] library's last error string
+ */
+static VALUE
+library_dlerror(VALUE self)
+{
+    char errmsg[1024];
+    dl_error(errmsg, sizeof(errmsg));
+    return rb_tainted_str_new2(errmsg);
+}
+
+static void
+library_free(Library* library)
+{
+    /* dlclose() on MacOS tends to segfault - avoid it */
+#ifndef __APPLE__
+    if (library->handle != NULL) {
+        dl_close(library->handle);
+    }
+#endif
+    xfree(library);
+}
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
+static void*
+dl_open(const char* name, int flags)
+{
+    if (name == NULL) {
+        return GetModuleHandle(NULL);
+    } else {
+        DWORD dwFlags = PathIsRelativeA(name) ? 0 : LOAD_WITH_ALTERED_SEARCH_PATH;
+        return LoadLibraryExA(name, NULL, dwFlags);
+    }
+}
+
+static void
+dl_error(char* buf, int size)
+{
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
+            0, buf, size, NULL);
+}
+#endif
+
+static VALUE
+symbol_allocate(VALUE klass)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(klass, LibrarySymbol, NULL, -1, sym);
+    sym->name = Qnil;
+    sym->library = Qnil;
+    sym->base.rbParent = Qnil;
+
+    return obj;
+}
+
+
+/*
+ * call-seq: initialize_copy(other)
+ * @param [Object] other
+ * @return [nil]
+ * DO NOT CALL THIS METHOD
+ */
+static VALUE
+symbol_initialize_copy(VALUE self, VALUE other)
+{
+    rb_raise(rb_eRuntimeError, "cannot duplicate symbol");
+    return Qnil;
+}
+
+static VALUE
+symbol_new(VALUE library, void* address, VALUE name)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(SymbolClass, LibrarySymbol, symbol_mark, -1, sym);
+
+    sym->base.memory.address = address;
+    sym->base.memory.size = LONG_MAX;
+    sym->base.memory.typeSize = 1;
+    sym->base.memory.flags = MEM_RD | MEM_WR;
+    sym->library = library;
+    sym->name = name;
+
+    return obj;
+}
+
+static void
+symbol_mark(LibrarySymbol* sym)
+{
+    rb_gc_mark(sym->library);
+    rb_gc_mark(sym->name);
+}
+
+/*
+ * call-seq: inspect
+ * @return [String]
+ * Inspect.
+ */
+static VALUE
+symbol_inspect(VALUE self)
+{
+    LibrarySymbol* sym;
+    char buf[256];
+
+    Data_Get_Struct(self, LibrarySymbol, sym);
+    snprintf(buf, sizeof(buf), "#<FFI::Library::Symbol name=%s address=%p>",
+             StringValueCStr(sym->name), sym->base.memory.address);
+    return rb_str_new2(buf);
+}
+
+void
+rbffi_DynamicLibrary_Init(VALUE moduleFFI)
+{
+    /*
+     * Document-class: FFI::DynamicLibrary
+     */
+    LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
+    rb_global_variable(&LibraryClass);
+    /*
+     * Document-class: FFI::DynamicLibrary::Symbol < FFI::Pointer
+     *
+     * An instance of this class represents a library symbol. It may be a {Pointer pointer} to
+     * a function or to a variable.
+     */
+    SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass);
+    rb_global_variable(&SymbolClass);
+
+    /*
+     * Document-const: FFI::NativeLibrary
+     * Backward compatibility for FFI::DynamicLibrary
+     */
+    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); /* backwards compat library */
+    rb_define_alloc_func(LibraryClass, library_allocate);
+    rb_define_singleton_method(LibraryClass, "open", library_open, 2);
+    rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_method(LibraryClass, "initialize", library_initialize, 2);
+    /*
+     * Document-method: find_symbol
+     * call-seq: find_symbol(name)
+     * @param [String] name library symbol's name
+     * @return [FFI::DynamicLibrary::Symbol] library symbol
+     */
+    rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1);
+    /*
+     * Document-method: find_function
+     * call-seq: find_function(name)
+     * @param [String] name library function's name
+     * @return [FFI::DynamicLibrary::Symbol] library function symbol
+     */
+    rb_define_method(LibraryClass, "find_function", library_dlsym, 1);
+    /*
+     * Document-method: find_variable
+     * call-seq: find_variable(name)
+     * @param [String] name library variable's name
+     * @return [FFI::DynamicLibrary::Symbol] library variable symbol
+     */
+    rb_define_method(LibraryClass, "find_variable", library_dlsym, 1);
+    rb_define_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_attr(LibraryClass, "name", 1, 0);
+
+    rb_define_alloc_func(SymbolClass, symbol_allocate);
+    rb_undef_method(SymbolClass, "new");
+    rb_define_method(SymbolClass, "inspect", symbol_inspect, 0);
+    rb_define_method(SymbolClass, "initialize_copy", symbol_initialize_copy, 1);
+
+#define DEF(x) rb_define_const(LibraryClass, "RTLD_" #x, UINT2NUM(RTLD_##x))
+    DEF(LAZY);
+    DEF(NOW);
+    DEF(GLOBAL);
+    DEF(LOCAL);
+    DEF(NOLOAD);
+    DEF(NODELETE);
+    DEF(FIRST);
+    DEF(DEEPBIND);
+    DEF(MEMBER);
+    DEF(BINDING_MASK);
+    DEF(LOCATION_MASK);
+    DEF(ALL_MASK);
+#undef DEF
+
+}
+