rbdc 1.0.0 → 1.1.0

data/dyncall/dyncall/dyncall_call_x64.h

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2020 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -54,6 +54,7 @@ extern "C" {
 
 void dcCall_x64_sysv(DCsize stacksize, DCpointer stackdata, DCpointer regdata_i, DCpointer regdata_f, DCpointer target);
 void dcCall_x64_win64(DCsize stacksize, DCpointer stackdata, DCpointer regdata, DCpointer target);
+void dcCall_x64_syscall_sysv(DCpointer argdata, DCpointer target);
 
 #ifdef __cplusplus
 }

data/dyncall/dyncall/dyncall_call_x64_generic_masm.asm

@@ -1,6 +1,5 @@
 ; auto-generated by gen-masm.sh
 .CODE
-
 dcCall_x64_sysv PROC
 OPTION PROLOGUE:NONE, EPILOGUE:NONE
  push RBP
@@ -34,7 +33,7 @@ OPTION PROLOGUE:NONE, EPILOGUE:NONE
  pop RBX
  pop RBP
  ret
-dcCALl_x64_sysv ENDP
+dcCall_x64_sysv ENDP
 dcCall_x64_win64 PROC
 OPTION PROLOGUE:NONE, EPILOGUE:NONE
  push RBP
@@ -67,4 +66,16 @@ OPTION PROLOGUE:NONE, EPILOGUE:NONE
  pop RBP
  ret
 dcCall_x64_win64 ENDP
+dcCall_x64_syscall_sysv PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ mov RAX,RSI
+ mov R9,qword ptr [RDI+40]
+ mov R8,qword ptr [RDI+32]
+ mov R10,qword ptr [RDI+24]
+ mov RDX,qword ptr [RDI+16]
+ mov RSI,qword ptr [RDI+8]
+ mov RDI,qword ptr [RDI+0]
+ SYSCALL
+ ret
+dcCall_x64_syscall_sysv ENDP
 END

data/dyncall/dyncall/dyncall_call_x86.S

@@ -182,8 +182,8 @@ END_PROC(dcCall_x86_win32_fast)
 
 */
 
-GLOBAL(dcCall_x86_sys_int80h_linux)
-BEGIN_PROC(dcCall_x86_sys_int80h_linux)
+GLOBAL(dcCall_x86_syscall_int80h_linux)
+BEGIN_PROC(dcCall_x86_syscall_int80h_linux)
 	PUSH(EBP)        		/* prolog. */
 	MOVL(ESP,EBP)
 	PUSH(EBX)			/* save preserved. */
@@ -203,7 +203,7 @@ BEGIN_PROC(dcCall_x86_sys_int80h_linux)
 	MOVL(EBP,ESP)			/* epilog. */
 	POP(EBP)
 	RET()
-END_PROC(dcCall_x86_sys_int80h_linux)
+END_PROC(dcCall_x86_syscall_int80h_linux)
 
 /*--- syscall int80 bsd -----------------------------------------------------
 
@@ -212,8 +212,8 @@ END_PROC(dcCall_x86_sys_int80h_linux)
 
 */
 	
-GLOBAL(dcCall_x86_sys_int80h_bsd)
-BEGIN_PROC(dcCall_x86_sys_int80h_bsd)
+GLOBAL(dcCall_x86_syscall_int80h_bsd)
+BEGIN_PROC(dcCall_x86_syscall_int80h_bsd)
 	PUSH(EBP)			/* prolog. */
 	MOVL(ESP,EBP)
 	PUSH(ESI)			/* save preserved. */
@@ -233,7 +233,7 @@ BEGIN_PROC(dcCall_x86_sys_int80h_bsd)
 _do_int:
 	INT(LIT(HEX(80)))
 	RET()
-END_PROC(dcCall_x86_sys_int80h_bsd)
+END_PROC(dcCall_x86_syscall_int80h_bsd)
 
 END_ASM
 

data/dyncall/dyncall/dyncall_call_x86.h

@@ -53,14 +53,14 @@ extern "C" {
 */
 
 #if defined(DC__OS_Plan9) /* No support for other cconvs on Plan9 and vice-versa. */
-void dcCall_x86_plan9        (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_plan9               (DCpointer target, DCpointer stackdata, DCsize size);
 #else
-void dcCall_x86_cdecl        (DCpointer target, DCpointer stackdata, DCsize size);
-void dcCall_x86_win32_std    (DCpointer target, DCpointer stackdata, DCsize size);
-void dcCall_x86_win32_fast   (DCpointer target, DCpointer stackdata, DCsize size);
-void dcCall_x86_win32_msthis (DCpointer target, DCpointer stackdata, DCsize size);
-void dcCall_x86_sys_int80h_linux (DCpointer target, DCpointer stackdata, DCsize size);
-void dcCall_x86_sys_int80h_bsd   (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_cdecl               (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_std           (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_fast          (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_msthis        (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_syscall_int80h_linux(DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_syscall_int80h_bsd  (DCpointer target, DCpointer stackdata, DCsize size);
 #endif
 
 #ifdef __cplusplus

data/dyncall/dyncall/dyncall_call_x86_generic_masm.asm

@@ -2,7 +2,6 @@
 .386
 .MODEL FLAT
 .CODE
-
 _dcCall_x86_cdecl PROC
 OPTION PROLOGUE:NONE, EPILOGUE:NONE
  push EBP
@@ -89,10 +88,10 @@ OPTION PROLOGUE:NONE, EPILOGUE:NONE
  pop EBP
  ret
 _dcCall_x86_win32_fast ENDP
-_dcCall_x86_sys_int80h_linux PROC
+_dcCall_x86_syscall_int80h_linux PROC
 OPTION PROLOGUE:NONE, EPILOGUE:NONE
  push EBP
-  mov EBP,ESP
+ mov EBP,ESP
  push EBX
  push ESI
  push EDI
@@ -110,11 +109,11 @@ OPTION PROLOGUE:NONE, EPILOGUE:NONE
  mov ESP,EBP
  pop EBP
  ret
-_dcCall_x86_sys_int80h_linux ENDP
-_dcCall_x86_sys_int80h_bsd PROC
+_dcCall_x86_syscall_int80h_linux ENDP
+_dcCall_x86_syscall_int80h_bsd PROC
 OPTION PROLOGUE:NONE, EPILOGUE:NONE
  push EBP
-  mov EBP,ESP
+ mov EBP,ESP
  push ESI
  push EDI
  mov ESI,dword ptr [EBP+12]
@@ -132,5 +131,5 @@ OPTION PROLOGUE:NONE, EPILOGUE:NONE
 _do_int:
  int 80h
  ret
-_dcCall_x86_sys_int80h_bsd ENDP
+_dcCall_x86_syscall_int80h_bsd ENDP
 END

data/dyncall/dyncall/dyncall_callvm_mips_n64.c

@@ -58,7 +58,9 @@ static void dc_callvm_reset_mips_n64(DCCallVM* in_self)
   DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
   dcVecReset(&self->mVecHead);
   self->mRegCount = 0;
+#if defined(DC__ABI_HARDFLOAT)
   self->mRegData.mUseDouble = 0LL;
+#endif /* DC__ABI_HARDFLOAT */
 }
 
 
@@ -75,24 +77,24 @@ static void dc_callvm_free_mips_n64(DCCallVM* in_self)
 
 /* arg int -- fillup 64-bit integer register file OR push on stack */
 
-static void dc_callvm_argLongLong_mips_n64(DCCallVM* in_self, DClonglong Lv)
+static void dc_callvm_argLongLong_mips_n64(DCCallVM* in_self, DClonglong x)
 {
   DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
   /* fillup integer register file */
   if (self->mRegCount < 8)
-    self->mRegData.mIntData[self->mRegCount++] = Lv;
+    self->mRegData.mIntData[self->mRegCount++] = x;
   else
-    dcVecAppend(&self->mVecHead, &Lv, sizeof(DClonglong));
+    dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
 }
 
-static void dc_callvm_argInt_mips_n64(DCCallVM* in_self, DCint i)
+static void dc_callvm_argInt_mips_n64(DCCallVM* in_self, DCint x)
 {
-  dc_callvm_argLongLong_mips_n64(in_self, (DClonglong) i );
+  dc_callvm_argLongLong_mips_n64(in_self, (DClonglong)x);
 }
 
 static void dc_callvm_argPointer_mips_n64(DCCallVM* in_self, DCpointer x)
 {
-  dc_callvm_argLongLong_mips_n64(in_self, * (DClonglong*) &x );
+  dc_callvm_argLongLong_mips_n64(in_self, *(DClonglong*)&x);
 }
 
 static void dc_callvm_argBool_mips_n64(DCCallVM* in_self, DCbool x)
@@ -117,25 +119,41 @@ static void dc_callvm_argLong_mips_n64(DCCallVM* in_self, DClong x)
 
 static void dc_callvm_argDouble_mips_n64(DCCallVM* in_self, DCdouble x)
 {
+#if defined(DC__ABI_HARDFLOAT)
   DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
   if (self->mRegCount < 8) {
     self->mRegData.mUseDouble |= 1<<( self->mRegCount );
     self->mRegData.mFloatData[self->mRegCount++].d = x;
   } else {
-    dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble) );
+    dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
   }
+#else
+  dc_callvm_argLongLong_mips_n64(in_self, *(DClonglong*)&x);
+#endif /* DC__ABI_HARDFLOAT */
 }
 
 static void dc_callvm_argFloat_mips_n64(DCCallVM* in_self, DCfloat x)
 {
+#if defined(DC__ABI_HARDFLOAT)
   DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
   if (self->mRegCount < 8) {
     /*self->mRegData.mFloatData[self->mRegCount++].d = (DCdouble) x;*/
     self->mRegData.mFloatData[self->mRegCount++].f = x;
   } else {
-    dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
-    dcVecSkip(&self->mVecHead, sizeof(DCfloat) );
+    dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat));
+    dcVecSkip(&self->mVecHead, sizeof(DCfloat));
+  }
+#else
+  DCfloat f[] = {x,0.f};
+# if defined(DC__Endian_BIG)
+  // floats in regs always right justified
+  if (((DCCallVM_mips_n64*)in_self)->mRegCount < 8) {
+    f[1] = f[0];
+    f[0] = 0.f;
   }
+# endif /* DC__Endian_BIG */
+  dc_callvm_argLongLong_mips_n64(in_self, *(DClonglong*)&f);
+#endif /* DC__ABI_HARDFLOAT */
 }
 
 

data/dyncall/dyncall/dyncall_callvm_mips_o32.c

@@ -77,7 +77,7 @@ static void dc_callvm_argInt_mips_o32(DCCallVM* in_self, DCint i)
 
 static void dc_callvm_argPointer_mips_o32(DCCallVM* in_self, DCpointer x)
 {
-  dc_callvm_argInt_mips_o32(in_self, * (DCint*) &x );
+  dc_callvm_argInt_mips_o32(in_self, *(DCint*)&x);
 }
 
 static void dc_callvm_argBool_mips_o32(DCCallVM* in_self, DCbool x)
@@ -100,51 +100,56 @@ static void dc_callvm_argLong_mips_o32(DCCallVM* in_self, DClong x)
   dc_callvm_argInt_mips_o32(in_self, (DCint)x);
 }
 
-static void dc_callvm_argLongLong_mips_o32(DCCallVM* in_self, DClonglong Lv)
+static void dc_callvm_argLongLong_mips_o32(DCCallVM* in_self, DClonglong x)
 {
   DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
-    
+
   /* 64-bit values need to be aligned on 8 byte boundaries */
   dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
-  dcVecAppend(&self->mVecHead, &Lv, sizeof(DClonglong));
-  self->mArgCount += 1;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
+  self->mArgCount++;
 }
 
 static void dc_callvm_argFloat_mips_o32(DCCallVM* in_self, DCfloat x)
 {
   DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
 
-  dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat));
+
+#if defined(DC__ABI_HARDFLOAT)
   if (self->mArgCount < 2) {
-#if defined(DC__Endian_LITTLE)
+    /* @@@ unsure if we should zero init, here; seems to work as-is */
+# if defined(DC__Endian_LITTLE)
     self->mRegData.u[self->mArgCount].f[0] = x;
-#else
-    self->mRegData.u[self->mArgCount].f[1] = x;
-#endif
-#if 0
+# else
+    self->mRegData.u[self->mArgCount].f[1] = x; // floats in regs always right justified
+# endif
+# if 0
     self->mRegData.u[self->mArgCount].f[1] = x;
    call kernel
         
-        mips:
-        lwc1	$f12, 4($5)       <--- byte offset 4
-	lwc1	$f13, 0($5)
-	lwc1	$f14, 12($5)      <--- byte offset 12 
-	lwc1	$f15, 8($5)
-        mipsel:
-        lwc1	$f12, 0($5)       <--- byte offset 4
-	lwc1	$f13, 4($5)
-	lwc1	$f14, 8($5)      <--- byte offset 12 
-	lwc1	$f15, 12($5)
-
-#if defined(DC__Endian_LITTLE)
+	mips:
+	lwc1  $f12,  4($5)    <--- byte offset 4
+	lwc1  $f13,  0($5)
+	lwc1  $f14, 12($5)    <--- byte offset 12 
+	lwc1  $f15,  8($5)
+	mipsel:
+	lwc1  $f12,  0($5)    <--- byte offset 4
+	lwc1  $f13,  4($5)
+	lwc1  $f14,  8($5)    <--- byte offset 12 
+	lwc1  $f15, 12($5)
+
+#  if defined(DC__Endian_LITTLE)
     /* index 0 and 2 */
     self->mRegData.floats[self->mArgCount*2] = x;
-#else
+#  else
     /* index 1 and 3 */
     self->mRegData.floats[self->mArgCount*2+1] = x;
-#endif
-#endif
+#  endif
+# endif
   }
+#endif /* DC__ABI_HARDFLOAT */
+
   self->mArgCount++;
 }
 
@@ -153,9 +158,13 @@ static void dc_callvm_argDouble_mips_o32(DCCallVM* in_self, DCdouble x)
   DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
   /* 64-bit values need to be aligned on 8 byte boundaries */
   dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
-  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble) );
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
+
+#if defined(DC__ABI_HARDFLOAT)
   if (self->mArgCount < 2)
     self->mRegData.u[self->mArgCount].d = x;
+#endif /* DC__ABI_HARDFLOAT */
+
   self->mArgCount++;
 }
 
@@ -163,11 +172,9 @@ static void dc_callvm_argDouble_mips_o32(DCCallVM* in_self, DCdouble x)
 void dc_callvm_call_mips_o32(DCCallVM* in_self, DCpointer target)
 {
   DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
-  /* at minimum provide 16-bytes
-     which hold the first four integer register as spill area 
-     and are automatically loaded to $4-$7
-   */
 
+  /* provide multiple of 8 (reflecting stack area alignment requirement), and
+     minimum of 16-bytes (to hold first 4 int regis as spill area ($4-$7)) */
   size_t size = DC_MAX(16, ( ( (unsigned) dcVecSize(&self->mVecHead) ) +7UL ) & (-8UL) );
 
   dcCall_mips_o32(target, &self->mRegData, size, dcVecData(&self->mVecHead));

data/dyncall/dyncall/dyncall_callvm_mips_o32.c.orig

@@ -0,0 +1,247 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_mips_o32.c
+ Description: mips "o32" ABI callvm implementation
+ License:
+
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+
+/*
+
+  dyncall callvm for mips o32 abi
+
+  REVISION
+  2010/06/03 initial
+
+  NOTES:
+  we need an argument counter for supporting floating point arguments
+  correctly.
+
+  first two (if any) double/float arguments are mapped via a common structure --
+  code must take care to write the right float argument indices which
+  differs on C and Assembly-side depending on endianness. (therefore
+  both sources have two variants 'mipseb' and 'mipsel'.)
+  (only for the first two float/double arguments) see float/double handling
+
+  although, the abi does not expect usage of floats if first argument is
+  not floating point, the call kernel can be used universal for all cases.
+
+*/
+
+
+#include "dyncall_callvm_mips_o32.h"
+#include "dyncall_alloc.h"
+#include "dyncall_utils.h"
+
+
+static void dc_callvm_reset_mips_o32(DCCallVM* in_self)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+  dcVecReset(&self->mVecHead);
+  self->mArgCount = 0;
+}
+
+
+static void dc_callvm_free_mips_o32(DCCallVM* in_self)
+{
+  dcFreeMem(in_self);
+}
+
+/* arg int -- fillup integer register file OR push on stack */
+
+static void dc_callvm_argInt_mips_o32(DCCallVM* in_self, DCint i)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+  dcVecAppend(&self->mVecHead, &i, sizeof(DCint));
+  self->mArgCount++;
+}
+
+static void dc_callvm_argPointer_mips_o32(DCCallVM* in_self, DCpointer x)
+{
+  dc_callvm_argInt_mips_o32(in_self, *(DCint*)&x);
+}
+
+static void dc_callvm_argBool_mips_o32(DCCallVM* in_self, DCbool x)
+{
+  dc_callvm_argInt_mips_o32(in_self, (DCint)x);
+}
+
+static void dc_callvm_argChar_mips_o32(DCCallVM* in_self, DCchar x)
+{
+  dc_callvm_argInt_mips_o32(in_self, (DCint)x);
+}
+
+static void dc_callvm_argShort_mips_o32(DCCallVM* in_self, DCshort x)
+{
+  dc_callvm_argInt_mips_o32(in_self, (DCint)x);
+}
+
+static void dc_callvm_argLong_mips_o32(DCCallVM* in_self, DClong x)
+{
+  dc_callvm_argInt_mips_o32(in_self, (DCint)x);
+}
+
+static void dc_callvm_argLongLong_mips_o32(DCCallVM* in_self, DClonglong x)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+
+  /* 64-bit values need to be aligned on 8 byte boundaries */
+  dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
+  dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
+  self->mArgCount++;
+}
+
+static void dc_callvm_argFloat_mips_o32(DCCallVM* in_self, DCfloat x)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat));
+
+#if defined(DC__ABI_HARDFLOAT)
+  if (self->mArgCount < 2) {
+    /* @@@ unsure if we should zero init, here; seems to work as-is */
+# if defined(DC__Endian_LITTLE)
+    self->mRegData.u[self->mArgCount].f[0] = x;
+# else
+    self->mRegData.u[self->mArgCount].f[1] = x; // floats in regs always right justified
+# endif
+# if 0
+    self->mRegData.u[self->mArgCount].f[1] = x;
+   call kernel
+        
+	mips:
+	lwc1  $f12,  4($5)    <--- byte offset 4
+	lwc1  $f13,  0($5)
+	lwc1  $f14, 12($5)    <--- byte offset 12 
+	lwc1  $f15,  8($5)
+	mipsel:
+	lwc1  $f12,  0($5)    <--- byte offset 4
+	lwc1  $f13,  4($5)
+	lwc1  $f14,  8($5)    <--- byte offset 12 
+	lwc1  $f15, 12($5)
+
+#  if defined(DC__Endian_LITTLE)
+    /* index 0 and 2 */
+    self->mRegData.floats[self->mArgCount*2] = x;
+#  else
+    /* index 1 and 3 */
+    self->mRegData.floats[self->mArgCount*2+1] = x;
+#  endif
+# endif
+  }
+#endif /* DC__ABI_HARDFLOAT */
+
+  self->mArgCount++;
+}
+
+static void dc_callvm_argDouble_mips_o32(DCCallVM* in_self, DCdouble x)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+  /* 64-bit values need to be aligned on 8 byte boundaries */
+  dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
+
+#if defined(DC__ABI_HARDFLOAT)
+  if (self->mArgCount < 2)
+    self->mRegData.u[self->mArgCount].d = x;
+#endif /* DC__ABI_HARDFLOAT */
+
+  self->mArgCount++;
+}
+
+/* Call. */
+void dc_callvm_call_mips_o32(DCCallVM* in_self, DCpointer target)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+  /* at minimum provide 16-bytes
+     which hold the first four integer register as spill area 
+     and are automatically loaded to $4-$7
+   */
+
+  size_t size = DC_MAX(16, ( ( (unsigned) dcVecSize(&self->mVecHead) ) +7UL ) & (-8UL) );
+
+  dcCall_mips_o32(target, &self->mRegData, size, dcVecData(&self->mVecHead));
+}
+
+static void dc_callvm_mode_mips_o32(DCCallVM* in_self, DCint mode);
+
+DCCallVM_vt gVT_mips_o32 =
+{
+  &dc_callvm_free_mips_o32
+, &dc_callvm_reset_mips_o32
+, &dc_callvm_mode_mips_o32
+, &dc_callvm_argBool_mips_o32
+, &dc_callvm_argChar_mips_o32
+, &dc_callvm_argShort_mips_o32 
+, &dc_callvm_argInt_mips_o32
+, &dc_callvm_argLong_mips_o32
+, &dc_callvm_argLongLong_mips_o32
+, &dc_callvm_argFloat_mips_o32
+, &dc_callvm_argDouble_mips_o32
+, &dc_callvm_argPointer_mips_o32
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &dc_callvm_call_mips_o32
+, (DCboolvmfunc*)       &dc_callvm_call_mips_o32
+, (DCcharvmfunc*)       &dc_callvm_call_mips_o32
+, (DCshortvmfunc*)      &dc_callvm_call_mips_o32
+, (DCintvmfunc*)        &dc_callvm_call_mips_o32
+, (DClongvmfunc*)       &dc_callvm_call_mips_o32
+, (DClonglongvmfunc*)   &dc_callvm_call_mips_o32
+, (DCfloatvmfunc*)      &dc_callvm_call_mips_o32
+, (DCdoublevmfunc*)     &dc_callvm_call_mips_o32
+, (DCpointervmfunc*)    &dc_callvm_call_mips_o32
+, NULL /* callStruct */
+};
+
+/* mode: only a single mode available currently. */
+static void dc_callvm_mode_mips_o32(DCCallVM* in_self, DCint mode)
+{
+  DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
+  DCCallVM_vt* vt;
+
+  switch(mode) {
+    case DC_CALL_C_DEFAULT:
+    case DC_CALL_C_MIPS32_O32:
+    case DC_CALL_C_ELLIPSIS:
+    case DC_CALL_C_ELLIPSIS_VARARGS:
+      vt = &gVT_mips_o32;
+      break;
+    default:
+      self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; 
+      return;
+  }
+  dc_callvm_base_init(&self->mInterface, vt);
+}
+
+/* Public API. */
+DCCallVM* dcNewCallVM(DCsize size)
+{
+  DCCallVM_mips_o32* p = (DCCallVM_mips_o32*)dcAllocMem(sizeof(DCCallVM_mips_o32)+size);
+
+  dc_callvm_mode_mips_o32((DCCallVM*)p, DC_CALL_C_DEFAULT);
+
+  dcVecInit(&p->mVecHead, size);
+  dc_callvm_reset_mips_o32((DCCallVM*)p);
+
+  return (DCCallVM*)p;
+}
+