ffi 1.11.2 → 1.13.0

data/ext/ffi_c/Buffer.c

@@ -114,7 +114,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
         }
 
         /* ensure the memory is aligned on at least a 8 byte boundary */
-        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     
         if (p->memory.size > 0 && (nargs < 3 || RTEST(rbClear))) {
             memset(p->memory.address, 0, p->memory.size);
@@ -154,7 +154,7 @@ buffer_initialize_copy(VALUE self, VALUE other)
         return Qnil;
     }
     
-    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     

data/ext/ffi_c/Call.c

@@ -298,10 +298,6 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                     param->ptr = NULL;
 
                 } else {
-                    if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
-                        rb_raise(rb_eSecurityError, "Unsafe string parameter");
-                    }
-
                     param->ptr = StringValueCStr(argv[argidx]);
                 }
 
@@ -343,13 +339,7 @@ static void *
 call_blocking_function(void* data)
 {
     rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
-#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
-    b->frame->has_gvl = false;
-#endif
     ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
-#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
-    b->frame->has_gvl = true;
-#endif
 
     return NULL;
 }
@@ -357,7 +347,7 @@ call_blocking_function(void* data)
 VALUE
 rbffi_do_blocking_call(VALUE data)
 {
-    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (void *) -1, NULL);
+    rb_thread_call_without_gvl(call_blocking_function, (void*)data, (rb_unblock_function_t *) -1, NULL);
 
     return Qnil;
 }

data/ext/ffi_c/ClosurePool.c

@@ -70,9 +70,6 @@
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
-#ifdef _WIN32
-  typedef char* caddr_t;
-#endif
 
 typedef struct Memory {
     void* code;
@@ -96,7 +93,7 @@ static bool freePage(void *);
 static bool protectPage(void *);
 
 ClosurePool*
-rbffi_ClosurePool_New(int closureSize, 
+rbffi_ClosurePool_New(int closureSize,
         bool (*prep)(void* ctx, void *code, Closure* closure, char* errbuf, size_t errbufsize),
         void* ctx)
 {
@@ -107,7 +104,7 @@ rbffi_ClosurePool_New(int closureSize,
     pool->ctx = ctx;
     pool->prep = prep;
     pool->refcnt = 1;
-    
+
     return pool;
 }
 
@@ -115,7 +112,7 @@ void
 cleanup_closure_pool(ClosurePool* pool)
 {
     Memory* memory;
-    
+
     for (memory = pool->blocks; memory != NULL; ) {
         Memory* next = memory->next;
         freePage(memory->code);
@@ -142,7 +139,7 @@ rbffi_Closure_Alloc(ClosurePool* pool)
 {
     Closure *list = NULL;
     Memory* block = NULL;
-    caddr_t code = NULL;
+    void *code = NULL;
     char errmsg[256];
     int nclosures;
     long trampolineSize;
@@ -152,7 +149,7 @@ rbffi_Closure_Alloc(ClosurePool* pool)
         Closure* closure = pool->list;
         pool->list = pool->list->next;
         pool->refcnt++;
-    
+
         return closure;
     }
 
@@ -161,17 +158,17 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     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));
+        closure->code = ((char *)code + (i * trampolineSize));
 
         if (!(*pool->prep)(pool->ctx, closure->code, closure, errmsg, sizeof(errmsg))) {
             goto error;
@@ -202,7 +199,7 @@ error:
     if (code != NULL) {
         freePage(code);
     }
-    
+
 
     rb_raise(rb_eRuntimeError, "%s", errmsg);
     return NULL;
@@ -249,8 +246,8 @@ 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;
+    void *page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    return (page != (void *) -1) ? page : NULL;
 #endif
 }
 

data/ext/ffi_c/DynamicLibrary.c

@@ -164,7 +164,7 @@ library_dlerror(VALUE self)
 {
     char errmsg[1024];
     dl_error(errmsg, sizeof(errmsg));
-    return rb_tainted_str_new2(errmsg);
+    return rb_str_new2(errmsg);
 }
 
 static void

data/ext/ffi_c/Function.c

@@ -99,26 +99,8 @@ static VALUE async_cb_event(void *);
 static VALUE async_cb_call(void *);
 #endif
 
-#ifdef HAVE_RUBY_THREAD_HAS_GVL_P
 extern int ruby_thread_has_gvl_p(void);
-#define rbffi_thread_has_gvl_p(frame) ruby_thread_has_gvl_p()
-#else
-static int rbffi_thread_has_gvl_p(rbffi_frame_t *frame)
-{
-    return frame != NULL && frame->has_gvl;
-}
-#endif
-
-#ifdef HAVE_RUBY_NATIVE_THREAD_P
 extern int ruby_native_thread_p(void);
-#define rbffi_native_thread_p(frame) ruby_native_thread_p()
-#else
-static int rbffi_native_thread_p(rbffi_frame_t *frame)
-{
-    return frame != NULL;
-}
-#endif
-
 
 VALUE rbffi_FunctionClass = Qnil;
 
@@ -476,8 +458,8 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 
     if (cb.frame != NULL) cb.frame->exc = Qnil;
 
-    if (rbffi_native_thread_p(cb.frame)) {
-      if(rbffi_thread_has_gvl_p(cb.frame)) {
+    if (ruby_native_thread_p()) {
+      if(ruby_thread_has_gvl_p()) {
         callback_with_gvl(&cb);
       } else {
         rb_thread_call_with_gvl(callback_with_gvl, &cb);
@@ -721,10 +703,10 @@ invoke_callback(VALUE data)
                 param = rb_float_new(*(double *) parameters[i]);
                 break;
             case NATIVE_LONGDOUBLE:
-	      param = rbffi_longdouble_new(*(long double *) parameters[i]);
+                param = rbffi_longdouble_new(*(long double *) parameters[i]);
                 break;
             case NATIVE_STRING:
-                param = (*(void **) parameters[i] != NULL) ? rb_tainted_str_new2(*(char **) parameters[i]) : Qnil;
+                param = (*(void **) parameters[i] != NULL) ? rb_str_new2(*(char **) parameters[i]) : Qnil;
                 break;
             case NATIVE_POINTER:
                 param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
@@ -793,6 +775,9 @@ invoke_callback(VALUE data)
         case NATIVE_FLOAT64:
             *((double *) retval) = NUM2DBL(rbReturnValue);
             break;
+        case NATIVE_LONGDOUBLE:
+            *((long double *) retval) = rbffi_num2longdouble(rbReturnValue);
+            break;
         case NATIVE_POINTER:
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
@@ -864,9 +849,9 @@ callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errm
     FunctionType* fnInfo = (FunctionType *) ctx;
     ffi_status ffiStatus;
 
-    ffiStatus = ffi_prep_closure(code, &fnInfo->ffi_cif, callback_invoke, closure);
+    ffiStatus = ffi_prep_closure_loc(code, &fnInfo->ffi_cif, callback_invoke, closure, code);
     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;
     }
 

data/ext/ffi_c/FunctionInfo.c

@@ -172,7 +172,7 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
     }
-    
+
     if (rb_obj_is_kind_of(fnInfo->rbReturnType, rbffi_StructByValueClass)) {
         fnInfo->hasStruct = true;
     }
@@ -180,7 +180,6 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
     Data_Get_Struct(fnInfo->rbReturnType, Type, fnInfo->returnType);
     fnInfo->ffiReturnType = fnInfo->returnType->ffiType;
 
-
 #if defined(X86_WIN32)
     rbConventionStr = (rbConvention != Qnil) ? rb_funcall2(rbConvention, rb_intern("to_s"), 0, NULL) : Qnil;
     fnInfo->abi = (rbConventionStr != Qnil && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)

data/ext/ffi_c/LongDouble.c

@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include <float.h>
 
-#if defined (__CYGWIN__) || defined(__INTERIX)
+#if defined (__CYGWIN__) || defined(__INTERIX) || defined(_MSC_VER)
 # define strtold(str, endptr)    ((long double) strtod((str), (endptr)))
 #endif /* defined (__CYGWIN__) */
 
@@ -21,7 +21,7 @@ rbffi_longdouble_new(long double ld)
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject) {
         char buf[128];
-        return rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
+        return rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
     }
 
     /* Fall through to handling as a float */
@@ -41,7 +41,9 @@ rbffi_num2longdouble(VALUE value)
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
         VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
-        return strtold(RSTRING_PTR(s), NULL);
+        long double ret = strtold(RSTRING_PTR(s), NULL);
+        RB_GC_GUARD(s);
+        return ret;
     }
 
     /* Fall through to handling as a float */

data/ext/ffi_c/LongDouble.h

@@ -36,10 +36,6 @@
 extern "C" {
 #endif
 
-#ifdef _MSC_VER
-#define strtold strtod
-#endif
-
 extern VALUE rbffi_longdouble_new(long double ld);
 extern long double rbffi_num2longdouble(VALUE value);
 

data/ext/ffi_c/MemoryPointer.c

@@ -112,7 +112,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     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) {

data/ext/ffi_c/MethodHandle.c

@@ -68,9 +68,6 @@
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
-#ifdef _WIN32
-  typedef char* caddr_t;
-#endif
 
 #ifdef USE_RAW
 #  define METHOD_CLOSURE ffi_raw_closure
@@ -123,20 +120,15 @@ rbffi_MethodHandle_Free(MethodHandle* 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;
 
@@ -148,10 +140,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(code, &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;
     }
 
@@ -237,7 +229,7 @@ custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 
 #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)
 
@@ -269,7 +261,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);
@@ -286,10 +278,10 @@ static long trampoline_ctx_offset, trampoline_func_offset;
 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;
         }
     }
 
@@ -315,12 +307,10 @@ trampoline_offsets(long* ctxOffset, long* 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());
+    memcpy(code, (void*) &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;
+    *(intptr_t *)((char*)code + trampoline_ctx_offset) = (intptr_t) closure;
+    *(intptr_t *)((char*)code + trampoline_func_offset) = (intptr_t) custom_trampoline;
 
     return true;
 }
@@ -328,7 +318,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 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 */
@@ -348,6 +338,10 @@ rbffi_MethodHandle_Init(VALUE module)
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
+    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) {

data/ext/ffi_c/MethodHandle.h

@@ -37,14 +37,15 @@ 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

data/ext/ffi_c/Platform.c

@@ -64,6 +64,7 @@ export_primitive_types(VALUE module)
     S(LONG, long);
     S(FLOAT, float);
     S(DOUBLE, double);
+    S(LONG_DOUBLE, long double);
     S(ADDRESS, void*);
 #undef S
 }

data/ext/ffi_c/Pointer.c

@@ -183,7 +183,7 @@ ptr_initialize_copy(VALUE self, VALUE other)
     
     dst->allocated = true;
     dst->autorelease = true;
-    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     

data/ext/ffi_c/Struct.c

@@ -90,7 +90,7 @@ struct_allocate(VALUE klass)
 {
     Struct* s;
     VALUE obj = Data_Make_Struct(klass, Struct, struct_mark, struct_free, s);
-    
+
     s->rbPointer = Qnil;
     s->rbLayout = Qnil;
 
@@ -112,7 +112,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     int nargs;
 
     Data_Get_Struct(self, Struct, s);
-    
+
     nargs = rb_scan_args(argc, argv, "01*", &rbPointer, &rest);
 
     /* Call up into ruby code to adjust the layout */
@@ -127,7 +127,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     }
 
     Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
-    
+
     if (rbPointer != Qnil) {
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
@@ -148,16 +148,16 @@ struct_initialize_copy(VALUE self, VALUE other)
 {
     Struct* src;
     Struct* dst;
-    
+
     Data_Get_Struct(self, Struct, dst);
     Data_Get_Struct(other, Struct, src);
     if (dst == src) {
         return self;
     }
-    
+
     dst->rbLayout = src->rbLayout;
     dst->layout = src->layout;
-    
+
     /*
      * A new MemoryPointer instance is allocated here instead of just calling
      * #dup on rbPointer, since the Pointer may not know its length, or may
@@ -176,7 +176,7 @@ struct_initialize_copy(VALUE self, VALUE other)
         dst->rbReferences = ALLOC_N(VALUE, dst->layout->referenceFieldCount);
         memcpy(dst->rbReferences, src->rbReferences, dst->layout->referenceFieldCount * sizeof(VALUE));
     }
-        
+
     return self;
 }
 
@@ -279,24 +279,25 @@ store_reference_value(StructField* f, Struct* s, VALUE value)
 }
 
 
-static VALUE
+static StructField *
 struct_field(Struct* s, VALUE fieldName)
 {
     StructLayout* layout = s->layout;
-    VALUE rbField;
-
-    if (likely(SYMBOL_P(fieldName) && st_lookup(layout->fieldSymbolTable, fieldName, (st_data_t *) &rbField))) {
-        return rbField;
-    }
-
-    // TODO does this ever return anything?
-    rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
-    if (rbField == Qnil) {
-        VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
-        rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+    struct field_cache_entry *p_ce = FIELD_CACHE_LOOKUP(layout, fieldName);
+
+    /* Do a hash lookup only if cache entry is empty or fieldName is unexpected? */
+    if (unlikely(!SYMBOL_P(fieldName) || !p_ce->fieldName || p_ce->fieldName != fieldName)) {
+        VALUE rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
+        if (unlikely(NIL_P(rbField))) {
+            VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
+            rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+        }
+        /* Write the retrieved coder to the cache */
+        p_ce->fieldName = fieldName;
+        p_ce->field = (StructField *) DATA_PTR(rbField);
     }
 
-    return rbField;
+    return p_ce->field;
 }
 
 /*
@@ -308,22 +309,19 @@ static VALUE
 struct_aref(VALUE self, VALUE fieldName)
 {
     Struct* s;
-    VALUE rbField;
     StructField* f;
 
     s = struct_validate(self);
 
-    rbField = struct_field(s, fieldName);
-    f = (StructField *) DATA_PTR(rbField);
-
+    f = struct_field(s, fieldName);
     if (f->get != NULL) {
         return (*f->get)(f, s);
-    
+
     } else if (f->memoryOp != NULL) {
         return (*f->memoryOp->get)(s->pointer, f->offset);
 
     } else {
-    
+        VALUE rbField = rb_hash_aref(s->layout->rbFieldMap, fieldName);
         /* call up to the ruby code to fetch the value */
         return rb_funcall2(rbField, id_get, 1, &s->rbPointer);
     }
@@ -340,22 +338,20 @@ static VALUE
 struct_aset(VALUE self, VALUE fieldName, VALUE value)
 {
     Struct* s;
-    VALUE rbField;
     StructField* f;
 
-
     s = struct_validate(self);
 
-    rbField = struct_field(s, fieldName);
-    f = (StructField *) DATA_PTR(rbField);
+    f = struct_field(s, fieldName);
     if (f->put != NULL) {
         (*f->put)(f, s, value);
 
     } else if (f->memoryOp != NULL) {
 
         (*f->memoryOp->put)(s->pointer, f->offset, value);
-    
+
     } else {
+        VALUE rbField = rb_hash_aref(s->layout->rbFieldMap, fieldName);
         /* call up to the ruby code to set the value */
         VALUE argv[2];
         argv[0] = s->rbPointer;
@@ -366,7 +362,7 @@ struct_aset(VALUE self, VALUE fieldName, VALUE value)
     if (f->referenceRequired) {
         store_reference_value(f, s, value);
     }
-    
+
     return value;
 }
 
@@ -389,7 +385,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
         return Qnil;
     }
 
-    
+
     Data_Get_Struct(self, Struct, s);
     Data_Get_Struct(pointer, AbstractMemory, memory);
     layout = struct_layout(self);
@@ -398,7 +394,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
         rb_raise(rb_eArgError, "memory of %ld bytes too small for struct %s (expected at least %ld)",
                 memory->size, rb_obj_classname(self), (long) layout->base.ffiType->size);
     }
-    
+
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
     rb_ivar_set(self, id_pointer_ivar, pointer);
@@ -491,7 +487,7 @@ struct_order(int argc, VALUE* argv, VALUE self)
         VALUE retval = rb_obj_dup(self);
         VALUE rbPointer = rb_funcall2(s->rbPointer, rb_intern("order"), argc, argv);
         struct_set_pointer(retval, rbPointer);
-        
+
         return retval;
     }
 }
@@ -527,7 +523,7 @@ static VALUE
 inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
 {
     InlineArray* array;
-    
+
     Data_Get_Struct(self, InlineArray, array);
     array->rbMemory = rbMemory;
     array->rbField = rbField;
@@ -536,12 +532,12 @@ inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
     Data_Get_Struct(rbField, StructField, array->field);
     Data_Get_Struct(array->field->rbType, ArrayType, array->arrayType);
     Data_Get_Struct(array->arrayType->rbComponentType, Type, array->componentType);
-    
+
     array->op = get_memory_op(array->componentType);
     if (array->op == NULL && array->componentType->nativeType == NATIVE_MAPPED) {
         array->op = get_memory_op(((MappedType *) array->componentType)->type);
     }
-    
+
     array->length = array->arrayType->length;
 
     return self;
@@ -585,15 +581,15 @@ inline_array_aref(VALUE self, VALUE rbIndex)
     Data_Get_Struct(self, InlineArray, array);
 
     if (array->op != NULL) {
-        VALUE rbNativeValue = array->op->get(array->memory, 
+        VALUE rbNativeValue = array->op->get(array->memory,
                 inline_array_offset(array, NUM2INT(rbIndex)));
         if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
-            return rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+            return rb_funcall(((MappedType *) array->componentType)->rbConverter,
                     rb_intern("from_native"), 2, rbNativeValue, Qnil);
         } else {
-            return rbNativeValue; 
+            return rbNativeValue;
         }
-        
+
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         VALUE rbOffset = INT2NUM(inline_array_offset(array, NUM2INT(rbIndex)));
         VALUE rbLength = INT2NUM(array->componentType->ffiType->size);
@@ -622,12 +618,12 @@ inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
 
     if (array->op != NULL) {
         if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
-            rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+            rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter,
                     rb_intern("to_native"), 2, rbValue, Qnil);
         }
         array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
             rbValue);
-        
+
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         int offset = inline_array_offset(array, NUM2INT(rbIndex));
         Struct* s;
@@ -665,11 +661,11 @@ static VALUE
 inline_array_each(VALUE self)
 {
     InlineArray* array;
-    
+
     int i;
 
     Data_Get_Struct(self, InlineArray, array);
-    
+
     for (i = 0; i < array->length; ++i) {
         rb_yield(inline_array_aref(self, INT2FIX(i)));
     }
@@ -692,7 +688,7 @@ inline_array_to_a(VALUE self)
     Data_Get_Struct(self, InlineArray, array);
     obj = rb_ary_new2(array->length);
 
-    
+
     for (i = 0; i < array->length; ++i) {
         rb_ary_push(obj, inline_array_aref(self, INT2FIX(i)));
     }
@@ -713,7 +709,7 @@ inline_array_to_s(VALUE self)
     VALUE argv[2];
 
     Data_Get_Struct(self, InlineArray, array);
- 
+
     if (array->componentType->nativeType != NATIVE_INT8 && array->componentType->nativeType != NATIVE_UINT8) {
         VALUE dummy = Qnil;
         return rb_call_super(0, &dummy);
@@ -734,7 +730,7 @@ static VALUE
 inline_array_to_ptr(VALUE self)
 {
     InlineArray* array;
-    
+
     Data_Get_Struct(self, InlineArray, array);
 
     return rb_funcall(array->rbMemory, rb_intern("slice"), 2,
@@ -778,7 +774,7 @@ rbffi_Struct_Init(VALUE moduleFFI)
     /*
      * Document-class: FFI::StructLayout::CharArray < FFI::Struct::InlineArray
      */
-    rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass, "CharArray", 
+    rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass, "CharArray",
                                                              rbffi_StructInlineArrayClass);
     rb_global_variable(&rbffi_StructLayoutCharArrayClass);
 
@@ -787,7 +783,7 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rb_define_method(StructClass, "initialize", struct_initialize, -1);
     rb_define_method(StructClass, "initialize_copy", struct_initialize_copy, 1);
     rb_define_method(StructClass, "order", struct_order, -1);
-    
+
     rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new");
     rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new");
     rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new");