koffi 1.2.0-alpha.3 → 1.2.0-alpha.4

package/src/abi_arm64.cc

@@ -209,7 +209,7 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 
 bool CallData::Prepare(const Napi::CallbackInfo &info)
 {
-    uint8_t *args_ptr = nullptr;
+    uint64_t *args_ptr = nullptr;
     uint64_t *gpr_ptr = nullptr;
     uint64_t *vec_ptr = nullptr;
 
@@ -244,16 +244,16 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
                 bool b = value.As<Napi::Boolean>();
 
+#ifdef __APPLE__
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)b;
                 } else {
-                    *args_ptr = (uint8_t)b;
-#ifdef __APPLE__
-                    args_ptr++;
+                    *(uint8_t *)args_ptr = b;
+                    args_ptr = (uint64_t *)((uint8_t *)args_ptr + 1);
+                }
 #else
-                    args_ptr += 8;
+                *((param.gpr_count ? gpr_ptr : args_ptr)++) = (uint64_t)b;
 #endif
-                }
             } break;
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
@@ -269,17 +269,17 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
                 int64_t v = CopyNumber<int64_t>(value);
 
+#ifdef __APPLE__
                 if (RG_LIKELY(param.gpr_count)) {
                     *(int64_t *)(gpr_ptr++) = v;
                 } else {
                     args_ptr = AlignUp(args_ptr, param.type->align);
                     *(int64_t *)args_ptr = v;
-#ifdef __APPLE__
-                    args_ptr += param.type->size;
+                    args_ptr = (uint64_t *)((uint8_t *)args_ptr + param.type->size);
+                }
 #else
-                    args_ptr += 8;
+                *(int64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++) = v;
 #endif
-                }
             } break;
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -289,13 +289,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
                 uint64_t v = CopyNumber<uint64_t>(value);
 
-                if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = v;
-                } else {
-                    args_ptr = AlignUp(args_ptr, param.type->align);
-                    *(uint64_t *)args_ptr = v;
-                    args_ptr += 8;
-                }
+#ifdef __APPLE__
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *((param.gpr_count ? gpr_ptr : args_ptr)++) = v;
             } break;
             case PrimitiveKind::String: {
                 const char *str;
@@ -310,13 +307,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = (uint64_t)str;
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    *(uint64_t *)args_ptr = (uint64_t)str;
-                    args_ptr += 8;
-                }
+#ifdef __APPLE__
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
@@ -331,13 +325,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = (uint64_t)str16;
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    *(uint64_t *)args_ptr = (uint64_t)str16;
-                    args_ptr += 8;
-                }
+#ifdef __APPLE__
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
             case PrimitiveKind::Pointer: {
                 uint8_t *ptr;
@@ -370,13 +361,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = (uint64_t)ptr;
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    *(uint64_t *)args_ptr = (uint64_t)ptr;
-                    args_ptr += 8;
-                }
+#ifdef __APPLE__
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
@@ -398,10 +386,12 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                             return false;
                         gpr_ptr += param.gpr_count;
                     } else if (param.type->size) {
+#ifdef __APPLE__
                         args_ptr = AlignUp(args_ptr, 8);
-                        if (!PushObject(obj, param.type, args_ptr))
+#endif
+                        if (!PushObject(obj, param.type, (uint8_t *)args_ptr))
                             return false;
-                        args_ptr += AlignLen(param.type->size, 8);
+                        args_ptr += (param.type->size + 7) / 8;
                     }
                 } else {
                     uint8_t *ptr;
@@ -412,11 +402,12 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         RG_ASSERT(param.gpr_count == 1);
                         RG_ASSERT(param.vec_count == 0);
 
-                        *(gpr_ptr++) = (uint64_t)ptr;
+                        *(uint8_t **)(gpr_ptr++) = ptr;
                     } else {
+#ifdef __APPLE__
                         args_ptr = AlignUp(args_ptr, 8);
-                        *(uint8_t **)args_ptr = ptr;
-                        args_ptr += 8;
+#endif
+                        *(uint8_t **)(args_ptr++) = ptr;
                     }
 
                     if (!PushObject(obj, param.type, ptr))
@@ -433,14 +424,16 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 float f = CopyNumber<float>(value);
 
                 if (RG_LIKELY(param.vec_count)) {
+                    memset((uint8_t *)vec_ptr + 4, 0, 4);
                     *(float *)(vec_ptr++) = f;
                 } else {
+#ifdef __APPLE__
                     args_ptr = AlignUp(args_ptr, 4);
                     *(float *)args_ptr = f;
-#ifdef __APPLE__
-                    args_ptr += 4;
+                    args_ptr = (uint64_t *)((uint8_t *)args_ptr + 4);
 #else
-                    args_ptr += 8;
+                    memset((uint8_t *)args_ptr + 4, 0, 4);
+                    *(float *)(args_ptr++) = f;
 #endif
                 }
             } break;
@@ -455,9 +448,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.vec_count)) {
                     *(double *)(vec_ptr++) = d;
                 } else {
+#ifdef __APPLE__
                     args_ptr = AlignUp(args_ptr, 8);
-                    *(double *)args_ptr = d;
-                    args_ptr += 8;
+#endif
+                    *(double *)(args_ptr++) = d;
                 }
             } break;
             case PrimitiveKind::Callback: {
@@ -480,13 +474,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     return false;
                 }
 
-                if (RG_LIKELY(param.gpr_count)) {
-                    *(gpr_ptr++) = (uint64_t)ptr;
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    *(uint64_t *)args_ptr = (uint64_t)ptr;
-                    args_ptr += 8;
-                }
+#ifdef __APPLE__
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
         }
     }
@@ -977,6 +968,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             }
 
             float f = CopyNumber<float>(value);
+
+            memset((uint8_t *)&out_reg->d0 + 4, 0, 4);
             memcpy(&out_reg->d0, &f, 4);
         } break;
         case PrimitiveKind::Float64: {

package/src/abi_arm64_fwd.S

@@ -287,8 +287,8 @@ SYMBOL(TrampolineX15):
     trampoline_vec 15
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-# The propblem is that we're still running on the separate Koffi stack, and V8 will
-# preobably misdetect this as a "stack overflow". We have to restore the old
+# The problem is that we're still running on the separate Koffi stack, and V8 will
+# probably misdetect this as a "stack overflow". We have to restore the old
 # stack pointer, call Node.js/V8 and go back to ours.
 # The first three parameters (x0, x1, x2) are passed through untouched.
 SYMBOL(CallSwitchStack):

package/src/abi_arm64_fwd.asm

@@ -302,8 +302,8 @@ TrampolineX15 PROC
     ENDP
 
 ; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-; The propblem is that we're still running on the separate Koffi stack, and V8 will
-; preobably misdetect this as a "stack overflow". We have to restore the old
+; The problem is that we're still running on the separate Koffi stack, and V8 will
+; probably misdetect this as a "stack overflow". We have to restore the old
 ; stack pointer, call Node.js/V8 and go back to ours.
 ; The first three parameters (x0, x1, x2) are passed through untouched.
 CallSwitchStack PROC

package/src/abi_riscv64_fwd.S

@@ -300,8 +300,8 @@ TrampolineX15:
     trampoline_vec 15
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-# The propblem is that we're still running on the separate Koffi stack, and V8 will
-# preobably misdetect this as a "stack overflow". We have to restore the old
+# The problem is that we're still running on the separate Koffi stack, and V8 will
+# probably misdetect this as a "stack overflow". We have to restore the old
 # stack pointer, call Node.js/V8 and go back to ours.
 # The first three parameters (a0, a1, a2) are passed through untouched.
 CallSwitchStack:

package/src/abi_x64_sysv.cc

@@ -417,7 +417,10 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 }
 
                 float f = CopyNumber<float>(value);
-                *(float *)((param.xmm_count ? xmm_ptr : args_ptr)++) = f;
+                uint64_t *ptr = (param.xmm_count ? xmm_ptr : args_ptr)++;
+
+                memset((uint8_t *)ptr + 4, 0, 4);
+                *(float *)ptr = f;
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -838,6 +841,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             }
 
             float f = CopyNumber<float>(value);
+
+            memset((uint8_t *)&out_reg->xmm0 + 4, 0, 4);
             memcpy(&out_reg->xmm0, &f, 4);
         } break;
         case PrimitiveKind::Float64: {

package/src/abi_x64_sysv_fwd.S

@@ -321,8 +321,8 @@ SYMBOL(TrampolineX15):
     trampoline_xmm 15
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-# The propblem is that we're still running on the separate Koffi stack, and V8 will
-# preobably misdetect this as a "stack overflow". We have to restore the old
+# The problem is that we're still running on the separate Koffi stack, and V8 will
+# probably misdetect this as a "stack overflow". We have to restore the old
 # stack pointer, call Node.js/V8 and go back to ours.
 # The first three parameters (rdi, rsi, rdx) are passed through untouched.
 SYMBOL(CallSwitchStack):

package/src/abi_x64_win.cc

@@ -244,6 +244,8 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 }
 
                 float f = CopyNumber<float>(value);
+
+                memset((uint8_t *)args_ptr + 4, 0, 4);
                 *(float *)(args_ptr++) = f;
             } break;
             case PrimitiveKind::Float64: {
@@ -622,6 +624,8 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             }
 
             float f = CopyNumber<float>(value);
+
+            memset((uint8_t *)&out_reg->xmm0 + 4, 0, 4);
             memcpy(&out_reg->xmm0, &f, 4);
         } break;
         case PrimitiveKind::Float64: {

package/src/abi_x64_win_fwd.asm

@@ -164,7 +164,7 @@ trampoline macro ID
     lea r8, qword ptr [rsp+128]
     lea r9, qword ptr [rsp+96]
     call RelayCallBack
-    mov qword ptr [rsp+96], rax
+    mov rax, qword ptr [rsp+96]
     add rsp, 120
     ret
 endm
@@ -188,8 +188,8 @@ trampoline_xmm macro ID
     lea r8, qword ptr [rsp+128]
     lea r9, qword ptr [rsp+96]
     call RelayCallBack
-    mov qword ptr [rsp+96], rax
-    movsd qword ptr [rsp+104], xmm0
+    mov rax, qword ptr [rsp+96]
+    movsd xmm0, qword ptr [rsp+104]
     add rsp, 120
     ret
 endm
@@ -293,8 +293,8 @@ TrampolineX15 proc frame
 TrampolineX15 endp
 
 ; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-; The propblem is that we're still running on the separate Koffi stack, and V8 will
-; preobably misdetect this as a "stack overflow". We have to restore the old
+; The problem is that we're still running on the separate Koffi stack, and V8 will
+; probably misdetect this as a "stack overflow". We have to restore the old
 ; stack pointer, call Node.js/V8 and go back to ours.
 ; The first three parameters (rcx, rdx, r8) are passed through untouched.
 CallSwitchStack proc frame

package/src/abi_x86.cc

@@ -442,7 +442,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     used_trampolines &= ~(1u << idx);
 
     uint32_t *args_ptr = (uint32_t *)caller_sp;
+
     uint8_t *return_ptr = !proto->ret.trivial ? (uint8_t *)args_ptr[0] : nullptr;
+    args_ptr += !proto->ret.trivial;
 
     LocalArray<napi_value, MaxParameters> arguments;
 

package/src/abi_x86_fwd.S

@@ -162,8 +162,8 @@ ForwardCallRD:
     call GetEIP
     addl $_GLOBAL_OFFSET_TABLE_, %ecx
     call *RelayCallBack@GOT(%ecx)
-    cmpb $1, 36(%esp)
-    je 2f
+    cmpb $0, 36(%esp)
+    jne 2f
 1:
     flds 32(%esp)
     jmp 3f
@@ -249,8 +249,8 @@ TrampolineX15:
     trampoline_x87 15
 
 # When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-# The propblem is that we're still running on the separate Koffi stack, and V8 will
-# preobably misdetect this as a "stack overflow". We have to restore the old
+# The problem is that we're still running on the separate Koffi stack, and V8 will
+# probably misdetect this as a "stack overflow". We have to restore the old
 # stack pointer, call Node.js/V8 and go back to ours.
 CallSwitchStack:
     .cfi_startproc

package/src/abi_x86_fwd.asm

@@ -158,8 +158,8 @@ trampoline_x87 macro ID
     lea eax, dword ptr [esp+16]
     mov dword ptr [esp+12], eax
     call RelayCallBack
-    cmp byte ptr[esp+36], 1
-    je l2
+    cmp byte ptr[esp+36], 0
+    jne l2
 l1:
     fld dword ptr [esp+32]
     jmp l3
@@ -271,8 +271,8 @@ TrampolineX15 proc
 TrampolineX15 endp
 
 ; When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
-; The propblem is that we're still running on the separate Koffi stack, and V8 will
-; preobably misdetect this as a "stack overflow". We have to restore the old
+; The problem is that we're still running on the separate Koffi stack, and V8 will
+; probably misdetect this as a "stack overflow". We have to restore the old
 ; stack pointer, call Node.js/V8 and go back to ours.
 CallSwitchStack proc
     endbr32

package/src/call.cc

@@ -116,11 +116,13 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     return buf.ptr;
 }
 
-bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
+bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
+    Size offset = 0;
+
     for (const RecordMember &member: type->members) {
         Napi::Value value = obj.Get(member.name);
 
@@ -130,7 +132,9 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
         }
 
         int16_t align = std::max(member.align, realign);
-        dest = AlignUp(dest, align);
+        offset = AlignLen(offset, align);
+
+        uint8_t *dest = origin + offset;
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -313,18 +317,19 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
             } break;
         }
 
-        dest += member.type->size;
+        offset += member.type->size;
     }
 
     return true;
 }
 
-bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
+bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(obj.IsArray() || obj.IsTypedArray() || obj.IsString());
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
+    Size offset = 0;
 
     if (obj.IsArray()) {
         Napi::Array array = obj.As<Napi::Array>();
@@ -340,7 +345,9 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                     Napi::Value value = array[i]; \
                      \
                     int16_t align = std::max(type->ref->align, realign); \
-                    dest = AlignUp(dest, align); \
+                     \
+                    offset = AlignLen(offset, align); \
+                    uint8_t *dest = origin + offset; \
                      \
                     if (RG_UNLIKELY(!(Check))) { \
                         ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
@@ -349,7 +356,7 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                      \
                     GetCode \
                      \
-                    dest += type->ref->size; \
+                    offset += type->ref->size; \
                 } \
             } while (false)
 
@@ -467,7 +474,9 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
                     Napi::Value value = array[i];
 
                     int16_t align = std::max(type->ref->align, realign);
-                    dest = AlignUp(dest, align);
+                    offset = AlignLen(offset, align);
+
+                    uint8_t *dest = origin + offset;
 
                     void *ptr;
 
@@ -491,7 +500,7 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
 
                     *(void **)dest = ptr;
 
-                    dest += type->ref->size;
+                    offset += type->ref->size;
                 }
             } break;
         }
@@ -526,20 +535,22 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
 
         for (uint32_t i = 0; i < len; i++) {
             int16_t align = std::max(type->ref->align, realign);
-            dest = AlignUp(dest, align);
+            offset = AlignLen(offset, align);
+
+            uint8_t *dest = origin + offset;
 
             memcpy(dest, buf + i * type->ref->size, type->ref->size);
 
-            dest += type->ref->size;
+            offset += type->ref->size;
         }
     } else if (obj.IsString()) {
         size_t encoded = 0;
 
         if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
-            napi_status status = napi_get_value_string_utf8(env, obj, (char *)dest, type->size, &encoded);
+            napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
             RG_ASSERT(status == napi_ok);
         } else if (type->ref->primitive == PrimitiveKind::Int16 || type->ref->primitive == PrimitiveKind::UInt16) {
-            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)dest, type->size / 2, &encoded);
+            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)origin, type->size / 2, &encoded);
             RG_ASSERT(status == napi_ok);
 
             encoded *= 2;
@@ -548,7 +559,7 @@ bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *
             return false;
         }
 
-        memset_safe(dest + encoded, 0, type->size - encoded);
+        memset_safe(origin + encoded, 0, type->size - encoded);
     } else {
         RG_UNREACHABLE();
     }
@@ -574,16 +585,20 @@ Size CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
     return idx;
 }
 
-void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign)
+void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign)
 {
     Napi::Env env = obj.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
+    Size offset = 0;
+
     for (const RecordMember &member: type->members) {
         int16_t align = std::max(realign, member.align);
-        src = AlignUp(src, align);
+        offset = AlignLen(offset, align);
+
+        const uint8_t *src = origin + offset;
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -663,18 +678,18 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *t
             } break;
         }
 
-        src += member.type->size;
+        offset += member.type->size;
     }
 }
 
-Napi::Object CallData::PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign)
+Napi::Object CallData::PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign)
 {
     Napi::Object obj = Napi::Object::New(env);
-    PopObject(obj, src, type, realign);
+    PopObject(obj, origin, type, realign);
     return obj;
 }
 
-Size WideStringLength(const char16_t *str16, Size max)
+static Size WideStringLength(const char16_t *str16, Size max)
 {
     Size len = 0;
 
@@ -685,13 +700,14 @@ Size WideStringLength(const char16_t *str16, Size max)
     return len;
 }
 
-Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign)
+Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
+    Size offset = 0;
 
 #define POP_ARRAY(SetCode) \
         do { \
@@ -699,11 +715,13 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
              \
             for (uint32_t i = 0; i < len; i++) { \
                 int16_t align = std::max(realign, type->ref->align); \
-                src = AlignUp(src, align); \
+                offset = AlignLen(offset, align); \
+                 \
+                const uint8_t *src = origin + offset; \
                  \
                 SetCode \
                  \
-                src += type->ref->size; \
+                offset += type->ref->size; \
             } \
              \
             return array; \
@@ -720,12 +738,14 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
                  \
                 for (uint32_t i = 0; i < len; i++) { \
                     int16_t align = std::max(realign, type->ref->align); \
-                    src = AlignUp(src, align); \
+                    offset = AlignLen(offset, align); \
+                     \
+                    const uint8_t *src = origin + offset; \
                      \
                     CType f = *(CType *)src; \
                     array[i] = f; \
                      \
-                    src += type->ref->size; \
+                    offset += type->ref->size; \
                 } \
                  \
                 return array; \
@@ -745,7 +765,7 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
             if (type->hint == TypeInfo::ArrayHint::String) {
                 RG_ASSERT(!realign);
 
-                const char *ptr = (const char *)src;
+                const char *ptr = (const char *)origin;
                 size_t count = strnlen(ptr, (size_t)len);
 
                 Napi::String str = Napi::String::New(env, ptr, count);
@@ -758,7 +778,7 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
             if (type->hint == TypeInfo::ArrayHint::String) {
                 RG_ASSERT(!realign);
 
-                const char *ptr = (const char *)src;
+                const char *ptr = (const char *)origin;
                 size_t count = strnlen(ptr, (size_t)len);
 
                 Napi::String str = Napi::String::New(env, ptr, count);
@@ -771,7 +791,7 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
             if (type->hint == TypeInfo::ArrayHint::String) {
                 RG_ASSERT(!realign);
 
-                const char16_t *ptr = (const char16_t *)src;
+                const char16_t *ptr = (const char16_t *)origin;
                 Size count = WideStringLength(ptr, len);
 
                 Napi::String str = Napi::String::New(env, ptr, count);
@@ -784,7 +804,7 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
             if (type->hint == TypeInfo::ArrayHint::String) {
                 RG_ASSERT(!realign);
 
-                const char16_t *ptr = (const char16_t *)src;
+                const char16_t *ptr = (const char16_t *)origin;
                 Size count = WideStringLength(ptr, len);
 
                 Napi::String str = Napi::String::New(env, ptr, count);
@@ -856,24 +876,7 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
     RG_UNREACHABLE();
 }
 
-static void DumpMemory(const char *type, Span<const uint8_t> bytes)
-{
-    if (bytes.len) {
-        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
-
-        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
-            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
-                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
-                                              FmtArg(ptr - bytes.begin()).Pad(-4));
-            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
-                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
-            }
-            PrintLn(stderr);
-        }
-    }
-}
-
-void CallData::DumpDebug() const
+void CallData::DumpForward() const
 {
     PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);