rbdc 0.9.0 → 1.0.0

data/dyncall/dyncallback/{dyncall_args_arm32_arm.h → dyncall_args_arm32.h}

@@ -2,11 +2,11 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_args_arm32_arm.h
- Description: Callback's Arguments VM - Header for ARM32 (ARM mode)
+ File: dyncallback/dyncall_args_arm32.h
+ Description: Callback's Arguments VM - Header for ARM32 (ARM and THUMB mode)
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   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
@@ -24,8 +24,8 @@
 */
 
 
-#ifndef DYNCALLBACK_ARGS_ARM32_ARM_H
-#define DYNCALLBACK_ARGS_ARM32_ARM_H
+#ifndef DYNCALLBACK_ARGS_ARM32_H
+#define DYNCALLBACK_ARGS_ARM32_H
 
 #include "dyncall_args.h"
 
@@ -42,5 +42,5 @@ struct DCArgs
 #endif
 };
 
-#endif /* DYNCALLBACK_ARGS_ARM32_ARM_H */
+#endif /* DYNCALLBACK_ARGS_ARM32_H */
 

data/dyncall/dyncallback/dyncall_args_arm64.c

@@ -6,8 +6,8 @@
  Description: Callback's Arguments VM - Implementation for ARM64 / ARMv8 / AAPCS64
  License:
 
-   Copyright (c) 2015 Daniel Adler <dadler@uni-goettingen.de>,
-                      Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2015-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

data/dyncall/dyncallback/dyncall_args_arm64_apple.c

@@ -6,8 +6,8 @@
  Description: Callback's Arguments VM - Implementation for Apple's ARM64 / ARMv8 / AAPCS64
  License:
 
-   Copyright (c) 2015 Daniel Adler <dadler@uni-goettingen.de>,
-                      Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2015-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

data/dyncall/dyncallback/dyncall_args_mips.c

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncallback
  File: dyncallback/dyncall_args_mips.c
- Description: Callback's Arguments VM - Implementation for MIPS
+ Description: Callback's Arguments VM - Implementation for non-o32 MIPS
  License:
 
-   Copyright (c) 2013-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   Copyright (c) 2013-2018 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -26,25 +26,31 @@
 
 #include "dyncall_args_mips.h"
 
-DCint dcbArgInt(DCArgs* p) 
+DCint dcbArgInt(DCArgs* p)
 {
   DCint value;
-  if(p->ireg_count < 8)
-    value = p->ireg_data[p->ireg_count++];
+  if(p->reg_count.i < DCARGS_MIPS_NUM_IREGS)
+    value = p->ireg_data[p->reg_count.i++];
   else {
-    value = *((int*)p->stackptr);
-    p->stackptr += sizeof(int);
+    value = *((DCint*)p->stackptr);
+    p->stackptr += sizeof(DCint);
   }
   return value;
 }
 DCuint dcbArgUInt(DCArgs* p) { return (DCuint)dcbArgInt(p); }
 
-DCulonglong dcbArgULongLong(DCArgs* p) 
+DCulonglong dcbArgULongLong(DCArgs* p)
 {
   DCulonglong value;
-  p->ireg_count += (p->ireg_count & 1); // Skip one reg if not aligned.
+  p->reg_count.i += (p->reg_count.i & 1);         /* Skip one reg if not aligned. */
+  p->stackptr += ((DCulong)p->stackptr & 4) & -4; /* 64bit values are also always aligned on stack */
+#if defined(DC__Endian_LITTLE)
+  value  = dcbArgUInt(p);
+  value |= ((DCulonglong)dcbArgUInt(p)) << 32;
+#else
   value  = ((DCulonglong)dcbArgUInt(p)) << 32;
   value |= dcbArgUInt(p);
+#endif
   return value;
 }
 DClonglong dcbArgLongLong(DCArgs* p) { return (DClonglong)dcbArgULongLong(p); }
@@ -59,24 +65,23 @@ DCbool      dcbArgBool   (DCArgs* p) { return (DCbool)   dcbArgUInt(p); }
 DCpointer   dcbArgPointer(DCArgs* p) { return (DCpointer)dcbArgUInt(p); }
 
 DCfloat dcbArgFloat(DCArgs* p)
-{ 
+{
   DCfloat result;
-  if(p->freg_count < 8)
-    result = (DCfloat)p->freg_data[p->freg_count++];
+  if(p->reg_count.f < DCARGS_MIPS_NUM_FREGS)
+    result = p->freg_data[p->reg_count.f++];
   else {
-    result = *((float*)p->stackptr);
-    p->stackptr += sizeof(float);
+    result = *((DCfloat*)p->stackptr);
+    p->stackptr += sizeof(DCfloat);
   }
-  return result; 
+  return result;
 }
-DCdouble dcbArgDouble(DCArgs* p) 
-{ 
+DCdouble dcbArgDouble(DCArgs* p)
+{
   union {
     DCdouble result;
-    DCfloat f[2];
+    DCulonglong i;
   } d;
-  p->freg_count += (p->freg_count & 1); // Skip one reg if not aligned.
-  d.f[0] = dcbArgFloat(p);
-  d.f[1] = dcbArgFloat(p);
+  d.i = dcbArgULongLong(p); /* those are passed via int regs */
   return d.result;
 }
+

data/dyncall/dyncallback/dyncall_args_mips.h

@@ -6,7 +6,7 @@
  Description: Callback's Arguments VM - Header for MIPS
  License:
 
-   Copyright (c) 2013-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   Copyright (c) 2013-2018 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -31,11 +31,23 @@
 
 struct DCArgs
 {
-  int            ireg_data[8];
-  float          freg_data[8];
-  int            ireg_count;
-  int            freg_count;
-  unsigned char* stackptr;
+	/* 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;
+#else
+#  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;
+#  endif
+#endif
+	DCuchar* stackptr;
 };
 
 #endif /* DYNCALLBACK_ARGS_MIPS_H */

data/dyncall/dyncallback/dyncall_args_mips64.c

@@ -0,0 +1,81 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_args_mips64.c
+ Description: Callback's Arguments VM - Implementation for MIPS64 n32&n64
+ License:
+
+   Copyright (c) 2016-2018 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_args_mips.h"
+
+/* @@@ test and add n32 code here, also, if needed */
+
+DClonglong dcbArgLongLong(DCArgs* p)
+{
+  DClonglong value;
+  if(p->reg_count < DCARGS_MIPS_NUM_IREGS)
+    value = p->ireg_data[p->reg_count++];
+  else {
+    value = *((DClonglong*)p->stackptr);
+    p->stackptr += sizeof(DClonglong);
+  }
+  return value;
+}
+DCulonglong dcbArgULongLong(DCArgs* p) { return (DCulonglong)dcbArgLongLong(p); }
+
+DCint       dcbArgInt    (DCArgs* p) { return (DCint)    dcbArgLongLong(p); }
+DCuint      dcbArgUInt   (DCArgs* p) { return (DCuint)   dcbArgLongLong(p); }
+DClong      dcbArgLong   (DCArgs* p) { return (DClong)   dcbArgLongLong(p); }
+DCulong     dcbArgULong  (DCArgs* p) { return (DCulong)  dcbArgLongLong(p); }
+DCchar      dcbArgChar   (DCArgs* p) { return (DCchar)   dcbArgLongLong(p); }
+DCuchar     dcbArgUChar  (DCArgs* p) { return (DCuchar)  dcbArgLongLong(p); }
+DCshort     dcbArgShort  (DCArgs* p) { return (DCshort)  dcbArgLongLong(p); }
+DCushort    dcbArgUShort (DCArgs* p) { return (DCushort) dcbArgLongLong(p); }
+DCbool      dcbArgBool   (DCArgs* p) { return (DCbool)   dcbArgLongLong(p); }
+DCpointer   dcbArgPointer(DCArgs* p) { return (DCpointer)dcbArgLongLong(p); }
+
+DCdouble dcbArgDouble(DCArgs* p)
+{
+  DCdouble result;
+  if(p->reg_count < DCARGS_MIPS_NUM_FREGS)
+    result = p->freg_data[p->reg_count++];
+  else {
+    result = *((DCdouble*)p->stackptr);
+    p->stackptr += sizeof(DCdouble);
+  }
+  return result;
+}
+DCfloat dcbArgFloat(DCArgs* p)
+{
+  DCfloat result;
+  if(p->reg_count < DCARGS_MIPS_NUM_FREGS) {
+    result = ((DCfloat*)&p->freg_data[p->reg_count++])
+#if defined(DC__Endian_LITTLE)
+      [0];
+#else
+      [1]; /* single precision floats are right-justified in big-endian registers */
+#endif
+  } else {
+    result = *((DCfloat*)p->stackptr); /* single precision floats are left-justified on stack in 64bit slots */
+    p->stackptr += sizeof(DCdouble);
+  }
+  return result;
+}
+

data/dyncall/dyncallback/dyncall_args_mips_o32.c

@@ -0,0 +1,104 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_args_mips_o32.c
+ Description: Callback's Arguments VM - Implementation for MIPS o32
+ License:
+
+   Copyright (c) 2013-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_args_mips.h"
+
+DCint dcbArgInt(DCArgs* p)
+{
+  DCint value;
+  p->freg_count = 2; /* first int will disable float reg use. */
+  value = *((int*)p->stackptr);
+  p->stackptr += sizeof(int);
+  return value;
+}
+DCuint dcbArgUInt(DCArgs* p) { return (DCuint)dcbArgInt(p); }
+
+DCulonglong dcbArgULongLong(DCArgs* p)
+{
+  DCulonglong value;
+  p->stackptr += ((int)p->stackptr & 4); /* Skip one slot if not aligned. */
+#if defined(DC__Endian_LITTLE)
+  value  = dcbArgUInt(p);
+  value |= ((DCulonglong)dcbArgUInt(p)) << 32;
+#else
+  value  = ((DCulonglong)dcbArgUInt(p)) << 32;
+  value |= dcbArgUInt(p);
+#endif
+  return value;
+}
+DClonglong dcbArgLongLong(DCArgs* p) { return (DClonglong)dcbArgULongLong(p); }
+
+DClong      dcbArgLong   (DCArgs* p) { return (DClong)   dcbArgUInt(p); }
+DCulong     dcbArgULong  (DCArgs* p) { return (DCulong)  dcbArgUInt(p); }
+DCchar      dcbArgChar   (DCArgs* p) { return (DCchar)   dcbArgUInt(p); }
+DCuchar     dcbArgUChar  (DCArgs* p) { return (DCuchar)  dcbArgUInt(p); }
+DCshort     dcbArgShort  (DCArgs* p) { return (DCshort)  dcbArgUInt(p); }
+DCushort    dcbArgUShort (DCArgs* p) { return (DCushort) dcbArgUInt(p); }
+DCbool      dcbArgBool   (DCArgs* p) { return (DCbool)   dcbArgUInt(p); }
+DCpointer   dcbArgPointer(DCArgs* p) { return (DCpointer)dcbArgUInt(p); }
+
+DCfloat dcbArgFloat(DCArgs* p)
+{
+  DCfloat result;
+  if(p->freg_count < 2) {
+	/* Stored float regs (max 2) are always 8b aligned. The way we look them up, */
+	/* relative to a diverging p->stackptr, we need consider this. Only works    */
+	/* with up to two float args, which is all we need. Hacky, but saves us      */
+	/* from one more variable and more bookkeeping in DCArgs.                    */
+    result = ((DCfloat*)(p->stackptr + ((int)p->stackptr & 4)) - 4) /* '-4' b/c those regs are stored right before the args */
+#if defined(DC__Endian_LITTLE)
+      [0];
+#else
+      [1];
+#endif
+	++p->freg_count;
+  } else {
+    result = *((DCfloat*)p->stackptr);
+  }
+  p->stackptr += sizeof(DCfloat);
+  return result;
+}
+DCdouble dcbArgDouble(DCArgs* p)
+{
+  union {
+    DCdouble result;
+    DCfloat f[2];
+  } d;
+  p->stackptr += ((int)p->stackptr & 4); /* Skip one slot if not aligned. */
+  if(p->freg_count < 2) {
+    /*result = *((DCdouble*)p->stackptr-2); this changes the value, slightly*/
+    d.f[0] = ((DCfloat*)p->stackptr-4)[0]; /* '-4' b/c those regs are stored right before the args */
+    d.f[1] = ((DCfloat*)p->stackptr-4)[1];
+    ++p->freg_count;
+  } else {
+    /*result = *((DCdouble*)p->stackptr); this changes the value, slightly*/
+    d.f[0] = ((DCfloat*)p->stackptr)[0];
+    d.f[1] = ((DCfloat*)p->stackptr)[1];
+  }
+  p->stackptr += sizeof(DCdouble);
+  return d.result;
+}
+

data/dyncall/dyncallback/dyncall_args_ppc32.c

@@ -6,7 +6,7 @@
  Description: Callback's Arguments VM - Implementation for ppc32
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   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
@@ -41,7 +41,7 @@ DCuint      dcbArgUInt     (DCArgs* p) { return (DCuint)  dcbArgInt(p);  }
 DCulonglong  dcbArgULongLong (DCArgs* p) 
 {
   DCulonglong value;
-  value  = ( (DCulonglong) dcbArgUInt(p) ) << 16UL;
+  value  = ( (DCulonglong) dcbArgUInt(p) ) << 32UL;
   value |= dcbArgUInt(p);
   return value;
 }

data/dyncall/dyncallback/dyncall_args_ppc32.h

@@ -6,7 +6,7 @@
  Description: Callback's Arguments VM - Header for ppc32
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   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

data/dyncall/dyncallback/dyncall_args_ppc32_sysv.c

@@ -6,7 +6,7 @@
  Description: Callback's Args Implementation for PowerPC 32-bit System V ABI
  License:
 
-   Copyright (c) 2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2015-2018 Daniel Adler <dadler@uni-goettingen.de>
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above

data/dyncall/dyncallback/dyncall_args_ppc64.c

@@ -50,8 +50,8 @@ DCbool      dcbArgBool     (DCArgs* p) { return (DCbool)  dcbArgLongLong(p); }
 
 DCpointer   dcbArgPointer  (DCArgs* p) { return (DCpointer)dcbArgLongLong(p); }
 
-DCdouble    dcbArgDouble   (DCArgs* p) 
-{ 
+DCdouble    dcbArgDouble   (DCArgs* p)
+{
   DCdouble result;
 
   if (p->freg_count < 13) {
@@ -67,5 +67,26 @@ DCdouble    dcbArgDouble   (DCArgs* p)
   return result;
 }
 
-DCfloat     dcbArgFloat    (DCArgs* p) { return (DCfloat)dcbArgDouble(p); }
+DCfloat    dcbArgFloat   (DCArgs* p)
+{
+  DCfloat result;
+
+#if defined(DC__Endian_BIG)
+  struct sf { DCfloat f_pad; DCfloat f; } sf;
+#else /* Endian_LITTLE */
+  struct sf { DCfloat f; DCfloat f_pad; } sf;
+#endif
 
+  if (p->freg_count < 13) {
+    result = (float)p->freg_data[p->freg_count++];
+    if (p->ireg_count < 8) {
+      p->ireg_count++;
+    }
+  } else {
+    sf = * ( (struct sf*) p->stackptr );
+    result = sf.f;
+  }
+
+  p->stackptr += sizeof(double);
+  return result;
+}

data/dyncall/dyncallback/dyncall_args_sparc32.c

@@ -6,7 +6,7 @@
  Description: Callback's Arguments VM - Implementation for sparc32 - not yet
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   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
@@ -26,17 +26,43 @@
 
 #include "dyncall_args_sparc32.h"
 
-DCint       dcbArgInt      (DCArgs* p) { return 0; }
-DCuint      dcbArgUInt     (DCArgs* p) { return 0; }
-DCulonglong dcbArgULongLong (DCArgs* p) {  return 0; }
-DClonglong  dcbArgLongLong(DCArgs* p) { return (DClonglong)dcbArgULongLong(p); }
-DClong      dcbArgLong     (DCArgs* p) { return (DClong)  dcbArgUInt(p); }
-DCulong     dcbArgULong    (DCArgs* p) { return (DCulong) dcbArgUInt(p); }
-DCchar      dcbArgChar     (DCArgs* p) { return (DCchar)  dcbArgUInt(p); }
-DCuchar     dcbArgUChar    (DCArgs* p) { return (DCuchar) dcbArgUInt(p); }
-DCshort     dcbArgShort    (DCArgs* p) { return (DCshort) dcbArgUInt(p); }
-DCushort    dcbArgUShort   (DCArgs* p) { return (DCushort)dcbArgUInt(p); }
-DCbool      dcbArgBool     (DCArgs* p) { return (DCbool)  dcbArgUInt(p); }
-DCpointer   dcbArgPointer  (DCArgs* p) { return (DCpointer)dcbArgUInt(p); }
-DCdouble    dcbArgDouble   (DCArgs* p) { return 0.0; }
-DCfloat     dcbArgFloat    (DCArgs* p) { return 0.0f; }
+/* Compiler aligns this to 8-byte boundaries, b/c of dword members, a fact needed below */
+typedef union {
+  DCdouble    d;
+  DCulonglong L;
+  DCulong     l[2];
+} DCAligned64BitVal_t;
+
+static void* sparc_word(DCArgs* args)
+{
+  return args->arg_ptr++;
+}
+
+static void* sparc_dword(DCArgs* args)
+{
+  void *p = args->arg_ptr;
+  args->arg_ptr += 2;
+  return p;
+}
+
+/* copy words so that dwords are 8-byte aligned, for 64bit value indirection; unaligned
+   access results in SIGBUS; not quite sure why compiler doesn't abstract this (maybe b/c
+   of not having any idea about our assembler code?) */
+DCulonglong dcbArgULongLong(DCArgs* p) { DCAligned64BitVal_t v; DCulong *l = (DCulong*)sparc_dword(p); v.l[0]=l[0]; v.l[1]=l[1]; return v.L; }
+DCdouble    dcbArgDouble   (DCArgs* p) { DCAligned64BitVal_t v; DCulong *l = (DCulong*)sparc_dword(p); v.l[0]=l[0]; v.l[1]=l[1]; return v.d; }
+
+/* rest of getters based on above functions */
+DCuint      dcbArgUInt     (DCArgs* p) { return *(DCuint*)sparc_word(p); }
+DClonglong  dcbArgLongLong (DCArgs* p) { return (DClonglong)dcbArgULongLong(p); }
+DCint       dcbArgInt      (DCArgs* p) { return (DCint)     dcbArgUInt(p); }
+DClong      dcbArgLong     (DCArgs* p) { return (DClong)    dcbArgUInt(p); }
+DCulong     dcbArgULong    (DCArgs* p) { return (DCulong)   dcbArgUInt(p); }
+DCchar      dcbArgChar     (DCArgs* p) { return (DCchar)    dcbArgUInt(p); }
+DCuchar     dcbArgUChar    (DCArgs* p) { return (DCuchar)   dcbArgUInt(p); }
+DCshort     dcbArgShort    (DCArgs* p) { return (DCshort)   dcbArgUInt(p); }
+DCushort    dcbArgUShort   (DCArgs* p) { return (DCushort)  dcbArgUInt(p); }
+DCbool      dcbArgBool     (DCArgs* p) { return (DCbool)    dcbArgUInt(p); }
+DCpointer   dcbArgPointer  (DCArgs* p) { return (DCpointer) dcbArgUInt(p); }
+
+DCfloat     dcbArgFloat    (DCArgs* p) { return *(DCfloat*) sparc_word(p); }
+