rbdc 1.0.0 → 1.1.0

data/dyncall/dyncall/dyncall_callvm_x64.c

@@ -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
@@ -167,7 +167,7 @@ DCCallVM_vt gVT_x64 =
 , &dc_callvm_mode_x64
 , &dc_callvm_argBool_x64
 , &dc_callvm_argChar_x64
-, &dc_callvm_argShort_x64 
+, &dc_callvm_argShort_x64
 , &dc_callvm_argInt_x64
 , &dc_callvm_argLong_x64
 , &dc_callvm_argLongLong_x64
@@ -188,7 +188,54 @@ DCCallVM_vt gVT_x64 =
 , NULL /* callStruct */
 };
 
-/* mode: only a single mode available currently. */
+
+/* --- syscall ------------------------------------------------------------- */
+
+#include <assert.h>
+void dc_callvm_call_x64_syscall_sysv(DCCallVM* in_self, DCpointer target)
+{
+  DCCallVM_x64* self;
+
+  /* syscalls can have up to 6 args, required to be "Only values of class INTEGER or class MEMORY" (from */
+  /* SysV manual), so we can use self->mRegData.i directly; verify this has space for at least 6 values, though. */
+  assert(numIntRegs >= 6);
+
+  self = (DCCallVM_x64*)in_self;
+  dcCall_x64_syscall_sysv(self->mRegData.i, target);
+}
+
+DCCallVM_vt gVT_x64_syscall_sysv =
+{
+  &dc_callvm_free_x64
+, &dc_callvm_reset_x64
+, &dc_callvm_mode_x64
+, &dc_callvm_argBool_x64
+, &dc_callvm_argChar_x64
+, &dc_callvm_argShort_x64
+, &dc_callvm_argInt_x64
+, &dc_callvm_argLong_x64
+, &dc_callvm_argLongLong_x64
+, &dc_callvm_argFloat_x64
+, &dc_callvm_argDouble_x64
+, &dc_callvm_argPointer_x64
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &dc_callvm_call_x64_syscall_sysv
+, (DCboolvmfunc*)       &dc_callvm_call_x64_syscall_sysv
+, (DCcharvmfunc*)       &dc_callvm_call_x64_syscall_sysv
+, (DCshortvmfunc*)      &dc_callvm_call_x64_syscall_sysv
+, (DCintvmfunc*)        &dc_callvm_call_x64_syscall_sysv
+, (DClongvmfunc*)       &dc_callvm_call_x64_syscall_sysv
+, (DClonglongvmfunc*)   &dc_callvm_call_x64_syscall_sysv
+, (DCfloatvmfunc*)      &dc_callvm_call_x64_syscall_sysv
+, (DCdoublevmfunc*)     &dc_callvm_call_x64_syscall_sysv
+, (DCpointervmfunc*)    &dc_callvm_call_x64_syscall_sysv
+, NULL /* callStruct */
+};
+
+
+
+/* mode */
+
 static void dc_callvm_mode_x64(DCCallVM* in_self, DCint mode)
 {
   DCCallVM_x64* self = (DCCallVM_x64*)in_self;
@@ -205,6 +252,13 @@ static void dc_callvm_mode_x64(DCCallVM* in_self, DCint mode)
     case DC_CALL_C_ELLIPSIS_VARARGS:
       vt = &gVT_x64;
       break;
+    case DC_CALL_SYS_DEFAULT:
+# if defined DC_UNIX
+    case DC_CALL_SYS_X64_SYSCALL_SYSV:
+      vt = &gVT_x64_syscall_sysv; break;
+# else
+      self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; return;
+# endif
     default:
       self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; 
       return;

data/dyncall/dyncall/dyncall_callvm_x86.c

@@ -6,7 +6,7 @@
  Description: Call VM for x86 architecture implementation
  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
@@ -499,19 +499,19 @@ DCCallVM_vt gVT_x86_win32_this_ms =
 
 /* call syscall */
 
-void dc_callvm_call_x86_sys_int80h_linux(DCCallVM* in_self, DCpointer target)
+void dc_callvm_call_x86_syscall_int80h_linux(DCCallVM* in_self, DCpointer target)
 {
   DCCallVM_x86* self = (DCCallVM_x86*) in_self;
-  dcCall_x86_sys_int80h_linux( target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead) );
+  dcCall_x86_syscall_int80h_linux( target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead) );
 }
 
-void dc_callvm_call_x86_sys_int80h_bsd(DCCallVM* in_self, DCpointer target)
+void dc_callvm_call_x86_syscall_int80h_bsd(DCCallVM* in_self, DCpointer target)
 {
   DCCallVM_x86* self = (DCCallVM_x86*) in_self;
-  dcCall_x86_sys_int80h_bsd( target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead) );
+  dcCall_x86_syscall_int80h_bsd( target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead) );
 }
 
-DCCallVM_vt gVT_x86_sys_int80h_linux =
+DCCallVM_vt gVT_x86_syscall_int80h_linux =
 {
   &dc_callvm_free_x86
 , &dc_callvm_reset_x86
@@ -526,20 +526,20 @@ DCCallVM_vt gVT_x86_sys_int80h_linux =
 , &dc_callvm_argDouble_x86
 , &dc_callvm_argPointer_x86
 , NULL /* argStruct */
-, (DCvoidvmfunc*)       &dc_callvm_call_x86_sys_int80h_linux
-, (DCboolvmfunc*)       &dc_callvm_call_x86_sys_int80h_linux
-, (DCcharvmfunc*)       &dc_callvm_call_x86_sys_int80h_linux
-, (DCshortvmfunc*)      &dc_callvm_call_x86_sys_int80h_linux
-, (DCintvmfunc*)        &dc_callvm_call_x86_sys_int80h_linux
-, (DClongvmfunc*)       &dc_callvm_call_x86_sys_int80h_linux
-, (DClonglongvmfunc*)   &dc_callvm_call_x86_sys_int80h_linux
-, (DCfloatvmfunc*)      &dc_callvm_call_x86_sys_int80h_linux
-, (DCdoublevmfunc*)     &dc_callvm_call_x86_sys_int80h_linux
-, (DCpointervmfunc*)    &dc_callvm_call_x86_sys_int80h_linux
+, (DCvoidvmfunc*)       &dc_callvm_call_x86_syscall_int80h_linux
+, (DCboolvmfunc*)       &dc_callvm_call_x86_syscall_int80h_linux
+, (DCcharvmfunc*)       &dc_callvm_call_x86_syscall_int80h_linux
+, (DCshortvmfunc*)      &dc_callvm_call_x86_syscall_int80h_linux
+, (DCintvmfunc*)        &dc_callvm_call_x86_syscall_int80h_linux
+, (DClongvmfunc*)       &dc_callvm_call_x86_syscall_int80h_linux
+, (DClonglongvmfunc*)   &dc_callvm_call_x86_syscall_int80h_linux
+, (DCfloatvmfunc*)      &dc_callvm_call_x86_syscall_int80h_linux
+, (DCdoublevmfunc*)     &dc_callvm_call_x86_syscall_int80h_linux
+, (DCpointervmfunc*)    &dc_callvm_call_x86_syscall_int80h_linux
 , NULL /* callStruct */
 };
 
-DCCallVM_vt gVT_x86_sys_int80h_bsd =
+DCCallVM_vt gVT_x86_syscall_int80h_bsd =
 {
   &dc_callvm_free_x86
 , &dc_callvm_reset_x86
@@ -554,16 +554,16 @@ DCCallVM_vt gVT_x86_sys_int80h_bsd =
 , &dc_callvm_argDouble_x86
 , &dc_callvm_argPointer_x86
 , NULL /* argStruct */
-, (DCvoidvmfunc*)       &dc_callvm_call_x86_sys_int80h_bsd
-, (DCboolvmfunc*)       &dc_callvm_call_x86_sys_int80h_bsd
-, (DCcharvmfunc*)       &dc_callvm_call_x86_sys_int80h_bsd
-, (DCshortvmfunc*)      &dc_callvm_call_x86_sys_int80h_bsd
-, (DCintvmfunc*)        &dc_callvm_call_x86_sys_int80h_bsd
-, (DClongvmfunc*)       &dc_callvm_call_x86_sys_int80h_bsd
-, (DClonglongvmfunc*)   &dc_callvm_call_x86_sys_int80h_bsd
-, (DCfloatvmfunc*)      &dc_callvm_call_x86_sys_int80h_bsd
-, (DCdoublevmfunc*)     &dc_callvm_call_x86_sys_int80h_bsd
-, (DCpointervmfunc*)    &dc_callvm_call_x86_sys_int80h_bsd
+, (DCvoidvmfunc*)       &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCboolvmfunc*)       &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCcharvmfunc*)       &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCshortvmfunc*)      &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCintvmfunc*)        &dc_callvm_call_x86_syscall_int80h_bsd
+, (DClongvmfunc*)       &dc_callvm_call_x86_syscall_int80h_bsd
+, (DClonglongvmfunc*)   &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCfloatvmfunc*)      &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCdoublevmfunc*)     &dc_callvm_call_x86_syscall_int80h_bsd
+, (DCpointervmfunc*)    &dc_callvm_call_x86_syscall_int80h_bsd
 , NULL /* callStruct */
 };
 
@@ -592,18 +592,18 @@ void dc_callvm_mode_x86(DCCallVM* in_self, DCint mode)
     case DC_CALL_C_X86_WIN32_THIS_MS:  vt = &gVT_x86_win32_this_ms;  break;
     case DC_CALL_C_X86_WIN32_FAST_GNU: vt = &gVT_x86_win32_fast_gnu; break;
     case DC_CALL_C_X86_WIN32_THIS_GNU: vt = &gVT_x86_cdecl;          break;
-    case DC_CALL_SYS_DEFAULT:         
+    case DC_CALL_SYS_DEFAULT:
 # if defined DC_UNIX
 #   if defined DC__OS_Linux
-      vt = &gVT_x86_sys_int80h_linux; break;
+      vt = &gVT_x86_syscall_int80h_linux; break;
 #   else
-      vt = &gVT_x86_sys_int80h_bsd;   break;
+      vt = &gVT_x86_syscall_int80h_bsd;   break;
 #   endif
 # else
       self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; return;
 # endif
-    case DC_CALL_SYS_X86_INT80H_LINUX: vt = &gVT_x86_sys_int80h_linux; break;
-    case DC_CALL_SYS_X86_INT80H_BSD:   vt = &gVT_x86_sys_int80h_bsd;   break;
+    case DC_CALL_SYS_X86_INT80H_LINUX: vt = &gVT_x86_syscall_int80h_linux; break;
+    case DC_CALL_SYS_X86_INT80H_BSD:   vt = &gVT_x86_syscall_int80h_bsd;   break;
 #endif
     default: 
       self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;

data/dyncall/dyncall/dyncall_macros.h

@@ -189,7 +189,7 @@
 # define DC__Arch_MIPS
 #elif defined(__arm__)
 # define DC__Arch_ARM
-#elif defined(__aarch64__)
+#elif defined(__aarch64__) || defined(__arm64) || defined(__arm64__)
 # define DC__Arch_ARM64
 #elif defined(__sh__)
 # define DC__Arch_SuperH
@@ -238,16 +238,21 @@
 #endif /* ARM */
 
 #if defined(DC__Arch_MIPS) || defined(DC__Arch_MIPS64)
-# if defined(_ABIO32) || defined(_MIPS_ARCH_MIPS1) || defined(_MIPS_ARCH_MIPS2)
+# if defined(_ABIO32) || defined(__mips_o32) || defined(_MIPS_ARCH_MIPS1) || defined(_MIPS_ARCH_MIPS2)
 #  define DC__ABI_MIPS_O32
-# elif defined(_ABI64) || defined(_mips_n64)
+# elif defined(_ABI64) || defined(__mips_n64)
 #  define DC__ABI_MIPS_N64
 # elif defined(_ABIN32)
 #  define DC__ABI_MIPS_N32
 # else
 #  define DC__ABI_MIPS_EABI
 # endif
-/*@@@implement/support: __mips_hard_float*/
+/* Set extra flag to know if FP hardware ABI, default to yes, if unsure */
+# if (defined(__mips_hard_float) && (__mips_hard_float == 1)) || !defined(__mips_soft_float) || (__mips_soft_float != 1)
+#  define DC__ABI_HARDFLOAT /* @@@ make this general for all archs? */
+# else
+#  define DC__ABI_SOFTFLOAT
+# endif
 #endif /* MIPS */
 
 #if defined(DC__Arch_PPC64)
@@ -266,16 +271,14 @@
 # define DC__Endian_BIG
 #else                                                      /* all others are bi-endian */
 /* @@@check flags used on following bi-endianness archs:
-DC__Arch_ARM
-DC__Arch_ARM64
 DC__Arch_Itanium
 DC__Arch_PPC32
 DC__Arch_PPC64
 DC__Arch_SuperH
 */
-# if (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 1)) || defined(_BIG_ENDIAN) || defined(MIPSEB) || defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
+# if (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 1)) || defined(_BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(MIPSEB) || defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || defined(__ARMEB__) || defined(__AARCH64EB__)
 #  define DC__Endian_BIG
-# elif (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 2)) || defined(_LITTLE_ENDIAN) || defined(MIPSEL) || defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__)
+# elif (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 2)) || defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || defined(MIPSEL) || defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || defined(__ARMEL__) || defined(__AARCH64EL__)
 #  define DC__Endian_LITTLE
 # elif defined(DC__Arch_Sparc64) && !defined(__BYTE_ORDER__) /* Sparc64 default is big-endian, except if explicitly defined */
 #    define DC__Endian_BIG

data/dyncall/dyncall/dyncall_struct.c

@@ -54,7 +54,7 @@ void dcStructField(DCstruct* s, DCint type, DCint alignment, DCsize arrayLength)
 		return;
 	}
 	assert(s && s->pCurrentStruct);
-	assert(s->pCurrentStruct->nextField <= (DCint)s->pCurrentStruct->fieldCount - 1);
+	assert(s->pCurrentStruct->nextField < (DCint)s->pCurrentStruct->fieldCount);
 	f = s->pCurrentStruct->pFields + (s->pCurrentStruct->nextField++);
 	f->type = type;
 	f->alignment = alignment;
@@ -107,6 +107,8 @@ static void dcComputeStructSize(DCstruct* s)
 {
 	DCsize i;
 	assert(s);
+
+	/* compute field sizes and alignments, recurse if needed */
 	for (i = 0; i < s->fieldCount; i++) {
 		DCfield *f = s->pFields + i;
 		DCsize fieldAlignment;
@@ -114,19 +116,23 @@ static void dcComputeStructSize(DCstruct* s)
 			dcComputeStructSize(f->pSubStruct);
 			f->size = f->pSubStruct->size;
 			fieldAlignment = f->pSubStruct->alignment;
-		} else {
+		} else
 			fieldAlignment = f->size;
-		}
+
 		if (!f->alignment)
 			f->alignment = fieldAlignment;
-		
+
+		/* if field alignment > struct alignment, choose former */
 		if (f->alignment > s->alignment)
 			s->alignment = f->alignment;
-		
+
+		/* if array, it's x times the size */
 		f->size *= f->arrayLength;
-		
+
 		/*printf("FIELD %d, size = %d, alignment = %d\n", (int)i, (int)f->size, (int)f->alignment);@@@*/
 	}
+
+	/* compute overall struct size */
 	for (i = 0; i < s->fieldCount; i++) {
 		DCfield *f = s->pFields + i;
 		dcAlign(&s->size, f->alignment);

data/dyncall/dyncall/dyncall_struct.h

@@ -53,7 +53,7 @@ struct DCstruct_ {
 	DCsize size, alignment, fieldCount;
 	
 	/* struct building uses a state machine. */
-	DCint nextField;       /* == -1 if struct is closed */
+	DCint nextField;                        /* == -1 if struct is closed */
 	DCstruct *pCurrentStruct, *pLastStruct; /* == this, unless we're in a sub struct */
 };
 

data/dyncall/dyncall/dyncall_vector.c

@@ -34,18 +34,19 @@ void dcVecAppend(DCVecHead* pHead, const void* pData, size_t size)
   size_t newSize = pHead->mSize + size;
   if(newSize <= pHead->mTotal) 
   {
-  	void* dst = (DCchar*)dcVecData(pHead) + pHead->mSize;
-  	switch (size) {
-  	  case 1: *(DCchar    *)dst = *(const DCchar    *)pData; break;
-  	  case 2: *(DCshort   *)dst = *(const DCshort   *)pData; break;
-  	  case 4: *(DCint     *)dst = *(const DCint     *)pData; break;
-  	  case 8: *(DCint     *)( ( (char*)dst )+4) = *(const DCint     *)( ( (char*)pData )+4); 
-  	          *(DCint     *)dst = *(const DCint     *)pData; break;
- 	  /* On sparc 32-bit, this one crashes if ptrs are not aligned.
-          case 8: *(DClonglong*)dst = *(const DClonglong*)pData; break;
-  	  */
-          default: memcpy(dst, pData, size); /* for all the rest. */
-  	}
+    void* dst = (DCchar*)dcVecData(pHead) + pHead->mSize;
+    switch (size) {
+      case 1: *(DCchar    *)dst = *(const DCchar    *)pData; break;
+      case 2: *(DCshort   *)dst = *(const DCshort   *)pData; break;
+      case 4: *(DCint     *)dst = *(const DCint     *)pData; break;
+      case 8: *(DCint     *)( ( (char*)dst )+4) = *(const DCint     *)( ( (char*)pData )+4); 
+              *(DCint     *)dst = *(const DCint     *)pData; break;
+      /* On sparc 32-bit, this one crashes if ptrs are not aligned, so use above.
+      case 8: *(DClonglong*)dst = *(const DClonglong*)pData; break;
+      */
+
+      default: memcpy(dst, pData, size); /* for all the rest. */
+    }
     pHead->mSize = newSize;
   }
   /*else @@@ warning? error?*/

data/dyncall/dyncall/dyncall_vector.c.orig

@@ -0,0 +1,53 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_vector.c
+ Description: Simple dynamic vector container type 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.
+
+*/
+
+
+
+#include "dyncall_vector.h"
+#include <string.h>
+
+
+void dcVecAppend(DCVecHead* pHead, const void* pData, size_t size)
+{
+  size_t newSize = pHead->mSize + size;
+  if(newSize <= pHead->mTotal) 
+  {
+  	void* dst = (DCchar*)dcVecData(pHead) + pHead->mSize;
+  	switch (size) {
+  	  case 1: *(DCchar    *)dst = *(const DCchar    *)pData; break;
+  	  case 2: *(DCshort   *)dst = *(const DCshort   *)pData; break;
+  	  case 4: *(DCint     *)dst = *(const DCint     *)pData; break;
+  	  case 8: *(DCint     *)( ( (char*)dst )+4) = *(const DCint     *)( ( (char*)pData )+4); 
+  	          *(DCint     *)dst = *(const DCint     *)pData; break;
+ 	  /* On sparc 32-bit, this one crashes if ptrs are not aligned.
+          case 8: *(DClonglong*)dst = *(const DClonglong*)pData; break;
+  	  */
+          default: memcpy(dst, pData, size); /* for all the rest. */
+  	}
+    pHead->mSize = newSize;
+  }
+  /*else @@@ warning? error?*/
+}
+

data/dyncall/dyncall/gen-masm.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
+cd `dirname $0`
+
+../portasm/gen-masm.sh dyncall_call_x86 _generic_masm
+../portasm/gen-masm.sh dyncall_call_x64 _generic_masm
 
-# Uses portasm to generates MASM sources for intel platforms.
-printf "; auto-generated by `basename $0`\r\n" > dyncall_call_x86_generic_masm.asm
-printf "; auto-generated by `basename $0`\r\n" > dyncall_call_x64_generic_masm.asm
-gcc -E -P -DGEN_MASM dyncall_call_x86.S | awk '{printf "%s\r\n", $0}' >> dyncall_call_x86_generic_masm.asm
-gcc -E -P -DGEN_MASM dyncall_call_x64.S | awk '{printf "%s\r\n", $0}' >> dyncall_call_x64_generic_masm.asm

data/dyncall/dyncallback/dyncall_args_mips.h

@@ -33,19 +33,37 @@ struct DCArgs
 {
 	/* Don't change order or types, laid out for asm code to fill in! */
 #if defined(DC__Arch_MIPS) && defined(DC__ABI_MIPS_O32)
-	DCint freg_count;
+
+	DCint freg_count; /* unused on soft-float targets, but keep as 4b-padding */
+
 #else
+
+# if defined(DC__Arch_MIPS)
+
 #  define DCARGS_MIPS_NUM_IREGS 8
 #  define DCARGS_MIPS_NUM_FREGS 8
-#  if defined(DC__Arch_MIPS)
 	DCint   ireg_data[DCARGS_MIPS_NUM_IREGS];
 	DCfloat freg_data[DCARGS_MIPS_NUM_FREGS];
 	struct { DCshort i; DCshort f; } reg_count;
-#  elif defined(DC__Arch_MIPS64)
-	DClonglong ireg_data[DCARGS_MIPS_NUM_IREGS];
-	DCdouble   freg_data[DCARGS_MIPS_NUM_FREGS];
-	DClonglong reg_count;
+
+# elif defined(DC__Arch_MIPS64)
+
+   /* single counter for both, int & float: mips64 uses 8 max, total, either */
+   /* skipping over other/type's reg, or only using int regs on soft-float   */
+#  define DCARGS_MIPS_NUM_REGS 8
+#  if defined(DC__ABI_SOFTFLOAT)
+	union
+#  else
+	struct
 #  endif
+	{
+		DClonglong ireg_data[DCARGS_MIPS_NUM_REGS];
+		DCdouble   freg_data[DCARGS_MIPS_NUM_REGS];
+	};
+	DClonglong reg_count;
+
+# endif
+
 #endif
 	DCuchar* stackptr;
 };