rbdc 0.8.0

data/dyncall/dyncall/dyncall_callf.c

@@ -0,0 +1,112 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callf.c
+ Description: formatted call C interface (extension module)
+ License:
+
+   Copyright (c) 2007-2011 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_callf.h"
+
+void dcVCallF(DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, va_list args)
+{
+  const DCsigchar* ptr = signature;
+  DCsigchar ch;
+  dcReset(vm);
+  while ( (ch=*ptr++) != '\0' && ch != DC_SIGCHAR_ENDARG) {
+
+    switch(ch) {
+      case DC_SIGCHAR_BOOL: 
+        dcArgBool      (vm, (DCbool)       va_arg( args, DCint  ) ); 
+        break;
+      case DC_SIGCHAR_CHAR:
+        dcArgChar      (vm, (DCchar)       va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_UCHAR:
+        dcArgChar      (vm, (DCchar) (DCuchar)      va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_SHORT:
+        dcArgShort     (vm, (DCshort)      va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_USHORT:
+        dcArgShort     (vm, (DCshort) (DCushort)     va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_INT:
+        dcArgInt       (vm, (DCint)        va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_UINT:
+        dcArgInt       (vm, (DCint) (DCuint)       va_arg( args, DCint  ) );
+        break;
+      case DC_SIGCHAR_LONG:
+        dcArgLong      (vm, (DClong)       va_arg( args, DClong ) );
+        break;
+      case DC_SIGCHAR_ULONG:
+        dcArgLong      (vm, (DCulong)      va_arg( args, DClong ) );
+        break;
+      case DC_SIGCHAR_LONGLONG:
+        dcArgLongLong  (vm, (DClonglong)   va_arg( args, DClonglong ) );
+        break;
+      case DC_SIGCHAR_ULONGLONG:
+        dcArgLongLong  (vm, (DCulonglong)  va_arg( args, DClonglong ) );
+        break;
+      case DC_SIGCHAR_FLOAT:
+        dcArgFloat     (vm, (DCfloat)      va_arg( args, DCdouble ) );
+        break;
+      case DC_SIGCHAR_DOUBLE:
+        dcArgDouble    (vm, (DCdouble)     va_arg( args, DCdouble ) );
+        break;
+      case DC_SIGCHAR_POINTER:
+        dcArgPointer   (vm, (DCpointer)    va_arg( args, DCpointer ) );
+        break;
+      case DC_SIGCHAR_STRING:
+        dcArgPointer   (vm, (DCpointer)    va_arg( args, DCpointer ) );
+        break;
+    }
+  }
+
+  switch(*ptr) {
+    case DC_SIGCHAR_VOID:                   dcCallVoid      (vm,funcptr); break;
+    case DC_SIGCHAR_BOOL:       result->B = dcCallBool      (vm,funcptr); break;
+    case DC_SIGCHAR_CHAR:       result->c = dcCallChar      (vm,funcptr); break;
+    case DC_SIGCHAR_UCHAR:      result->C = (DCuchar) dcCallChar      (vm,funcptr); break;
+    case DC_SIGCHAR_SHORT:      result->s = dcCallShort     (vm,funcptr); break;
+    case DC_SIGCHAR_USHORT:     result->S = dcCallShort     (vm,funcptr); break;
+    case DC_SIGCHAR_INT:        result->i = dcCallInt       (vm,funcptr); break;
+    case DC_SIGCHAR_UINT:       result->I = dcCallInt       (vm,funcptr); break;
+    case DC_SIGCHAR_LONG:       result->j = dcCallLong      (vm,funcptr); break;
+    case DC_SIGCHAR_ULONG:      result->J = dcCallLong      (vm,funcptr); break;
+    case DC_SIGCHAR_LONGLONG:   result->l = dcCallLongLong  (vm,funcptr); break;
+    case DC_SIGCHAR_ULONGLONG:  result->L = dcCallLongLong  (vm,funcptr); break;
+    case DC_SIGCHAR_FLOAT:      result->f = dcCallFloat     (vm,funcptr); break;
+    case DC_SIGCHAR_DOUBLE:     result->d = dcCallDouble    (vm,funcptr); break;
+    case DC_SIGCHAR_POINTER:    result->p = dcCallPointer   (vm,funcptr); break;
+    case DC_SIGCHAR_STRING:     result->Z = dcCallPointer   (vm,funcptr); break;
+  }
+}
+
+void dcCallF(DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, ...)
+{
+  va_list va;
+  va_start(va, signature);
+  dcVCallF(vm,result,funcptr,signature,va);
+  va_end(va);
+}
+

data/dyncall/dyncall/dyncall_callf.h

@@ -0,0 +1,52 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callf.h
+ Description: formatted call interface to dyncall
+ License:
+
+   Copyright (c) 2007-2011 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 formatted calls C API
+
+  REVISION
+  2007/12/11 initial
+  
+*/
+
+
+#ifndef DYNCALL_CALLF_H
+#define DYNCALL_CALLF_H
+
+/* dyncall formatted calls */
+
+#include "dyncall.h"
+#include "dyncall_signature.h"
+#include "dyncall_value.h"
+
+#include <stdarg.h>
+
+void dcCallF (DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, ...);
+void dcVCallF(DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, va_list args);
+
+#endif /* DYNCALL_CALLF_H */
+

data/dyncall/dyncall/dyncall_callvm.c

@@ -0,0 +1,68 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm.c
+ Description: auto-select default callvm (includes other C sources).
+ License:
+
+   Copyright (c) 2007-2011 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_macros.h"
+
+#if defined(DC__Arch_Intel_x86)
+#  include "dyncall_callvm_x86.c"
+#elif defined(DC__Arch_AMD64)
+#  include "dyncall_callvm_x64.c"
+#elif defined(DC__Arch_PowerPC)
+#  include "dyncall_callvm_ppc32.c"
+#elif defined(DC__Arch_PPC64)
+#  include "dyncall_callvm_ppc64.c"
+#elif defined(DC__Arch_MIPS) || defined(DC__Arch_MIPS64)
+#  if defined(DC__ABI_MIPS_EABI)
+#    include "dyncall_callvm_mips_eabi.c"
+#  elif defined(DC__ABI_MIPS_O32)
+#    include "dyncall_callvm_mips_o32.c"
+#  elif defined(DC__ABI_MIPS_N64)
+#    include "dyncall_callvm_mips_n64.c"
+#  elif defined(DC__ABI_MIPS_N32)
+#    include "dyncall_callvm_mips_n32.c"
+#  else
+#    error Unknown MIPS ABI.
+#  endif /* DC__Arch_MIPS || DC__Arch_MIPS64 */
+#elif defined(DC__Arch_ARM_ARM)
+#  if defined(DC__ABI_ARM_HF)
+#    include "dyncall_callvm_arm32_arm_armhf.c"
+#  else
+#    include "dyncall_callvm_arm32_arm.c"
+#  endif
+#elif defined(DC__Arch_ARM_THUMB)
+#  if defined(DC__ABI_ARM_HF)
+#    include "dyncall_callvm_arm32_arm_armhf.c"
+#  else
+#    include "dyncall_callvm_arm32_thumb.c"
+#  endif
+#elif defined(DC__Arch_Sparc)
+#  include "dyncall_callvm_sparc.c"
+#elif defined(DC__Arch_Sparcv9)
+#  include "dyncall_callvm_sparc_v9.c"
+#else
+#  error unsupported platform
+#endif
+

data/dyncall/dyncall/dyncall_callvm.h

@@ -0,0 +1,88 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm.h
+ Description: Common call vm binary interface.
+ License:
+
+   Copyright (c) 2007-2011 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.
+
+*/
+
+
+#ifndef DYNCALL_CALLVM_H
+#define DYNCALL_CALLVM_H
+
+#include "dyncall.h"
+
+/* --- callvm virtual function table --------------------------------------- */
+
+/* NOTE: if something changes in DCCallVM_, update offset marks in dyncall_call_sparc.S */
+
+typedef struct DCCallVM_vt_ DCCallVM_vt;
+
+struct DCCallVM_
+{
+  DCCallVM_vt* mVTpointer;
+  DCint        mError;
+};
+
+struct DCCallVM_vt_
+{
+  void         (*free)           (DCCallVM* vm);
+  void         (*reset)          (DCCallVM* vm);
+  void         (*mode)           (DCCallVM* vm,DCint        mode);
+  void         (*argBool)        (DCCallVM* vm,DCbool          B);
+  void         (*argChar)        (DCCallVM* vm,DCchar          c);
+  void         (*argShort)       (DCCallVM* vm,DCshort         s);
+  void         (*argInt)         (DCCallVM* vm,DCint           i);
+  void         (*argLong)        (DCCallVM* vm,DClong          l);
+  void         (*argLongLong)    (DCCallVM* vm,DClonglong      L);
+  void         (*argFloat)       (DCCallVM* vm,DCfloat         f);
+  void         (*argDouble)      (DCCallVM* vm,DCdouble        d);
+  void         (*argPointer)     (DCCallVM* vm,DCpointer       p);
+  void         (*argStruct)      (DCCallVM* vm,DCstruct* s, DCpointer p);
+  void         (*callVoid)       (DCCallVM* vm,DCpointer funcptr);
+  DCbool       (*callBool)       (DCCallVM* vm,DCpointer funcptr);
+  DCchar       (*callChar)       (DCCallVM* vm,DCpointer funcptr);
+  DCshort      (*callShort)      (DCCallVM* vm,DCpointer funcptr);
+  DCint        (*callInt)        (DCCallVM* vm,DCpointer funcptr);
+  DClong       (*callLong)       (DCCallVM* vm,DCpointer funcptr);
+  DClonglong   (*callLongLong)   (DCCallVM* vm,DCpointer funcptr);
+  DCfloat      (*callFloat)      (DCCallVM* vm,DCpointer funcptr);
+  DCdouble     (*callDouble)     (DCCallVM* vm,DCpointer funcptr);
+  DCpointer    (*callPointer)    (DCCallVM* vm,DCpointer funcptr);
+  void         (*callStruct)     (DCCallVM* vm,DCpointer funcptr,DCstruct* s, DCpointer returnValue);
+};
+
+typedef DCvoid       (DCvoidvmfunc)      (DCCallVM* vm,DCpointer funcptr); 
+typedef DCbool       (DCboolvmfunc)      (DCCallVM* vn,DCpointer funcptr);
+typedef DCchar       (DCcharvmfunc)      (DCCallVM* vm,DCpointer funcptr);
+typedef DCshort      (DCshortvmfunc)     (DCCallVM* vm,DCpointer funcptr);
+typedef DCint        (DCintvmfunc)       (DCCallVM* vm,DCpointer funcptr);
+typedef DClong       (DClongvmfunc)      (DCCallVM* vm,DCpointer funcptr);
+typedef DClonglong   (DClonglongvmfunc)  (DCCallVM* vm,DCpointer funcptr);
+typedef DCfloat      (DCfloatvmfunc)     (DCCallVM* vm,DCpointer funcptr);
+typedef DCdouble     (DCdoublevmfunc)    (DCCallVM* vm,DCpointer funcptr);
+typedef DCpointer    (DCpointervmfunc)   (DCCallVM* vm,DCpointer funcptr);
+
+/* Common base functions for CallVM implementations. */
+
+void dc_callvm_base_init(DCCallVM *pInstance, DCCallVM_vt* pVTable);
+
+#endif /* DYNCALL_CALLVM_H */
+

data/dyncall/dyncall/dyncall_callvm_arm32_arm.c

@@ -0,0 +1,250 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_arm32_arm.c
+ Description: ARM 32-bit "arm" ABI callvm implementation
+ License:
+
+   Copyright (c) 2007-2011 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 32bit ARM32 family of processors
+
+  SUPPORTED CALLING CONVENTIONS
+  armcall
+
+  REVISION
+  2007/12/11 initial
+
+*/
+
+
+#include "dyncall_callvm_arm32_arm.h"
+#include "dyncall_alloc.h"
+
+static void dc_callvm_mode_arm32_arm(DCCallVM* in_self,DCint mode);
+
+static DCCallVM* dc_callvm_new_arm32_arm(DCCallVM_vt* vt, DCsize size)
+{
+  /* Store at least 16 bytes (4 words) for internal spill area. Assembly code depends on it. */
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)dcAllocMem(sizeof(DCCallVM_arm32_arm)+size+16);
+  dc_callvm_base_init(&self->mInterface, vt);
+  dcVecInit(&self->mVecHead, size);
+  return (DCCallVM*)self;
+}
+
+
+static void dc_callvm_free_arm32_arm(DCCallVM* in_self)
+{
+  dcFreeMem(in_self);
+}
+
+
+static void dc_callvm_reset_arm32_arm(DCCallVM* in_self)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecReset(&self->mVecHead);
+}
+
+
+static void dc_callvm_argInt_arm32_arm(DCCallVM* in_self, DCint x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCint));
+}
+
+
+static void dc_callvm_argBool_arm32_arm(DCCallVM* in_self, DCbool x)
+{
+  dc_callvm_argInt_arm32_arm(in_self, (DCint)x);
+}
+
+
+static void dc_callvm_argChar_arm32_arm(DCCallVM* in_self, DCchar x)
+{
+  dc_callvm_argInt_arm32_arm(in_self, x);
+}
+
+
+static void dc_callvm_argShort_arm32_arm(DCCallVM* in_self, DCshort x)
+{
+  dc_callvm_argInt_arm32_arm(in_self, x);
+}
+
+
+static void dc_callvm_argLong_arm32_arm(DCCallVM* in_self, DClong x)
+{
+  dc_callvm_argInt_arm32_arm(in_self, x);
+}
+
+
+static void dc_callvm_argLongLong_arm32_arm(DCCallVM* in_self, DClonglong x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
+}
+
+
+static void dc_callvm_argLongLong_arm32_arm_eabi(DCCallVM* in_self, DClonglong x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)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));
+}
+
+
+static void dc_callvm_argFloat_arm32_arm(DCCallVM* in_self, DCfloat x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat));
+}
+
+
+static void dc_callvm_argDouble_arm32_arm(DCCallVM* in_self, DCdouble x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
+}
+
+
+static void dc_callvm_argDouble_arm32_arm_eabi(DCCallVM* in_self, DCdouble x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)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));
+}
+
+
+static void dc_callvm_argPointer_arm32_arm(DCCallVM* in_self, DCpointer x)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));
+}
+
+
+/* Call. */
+void dc_callvm_call_arm32_arm(DCCallVM* in_self, DCpointer target)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*)in_self;
+  dcCall_arm32_arm(target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead));
+}
+
+
+DCCallVM_vt gVT_arm32_arm =
+{
+  &dc_callvm_free_arm32_arm
+, &dc_callvm_reset_arm32_arm
+, &dc_callvm_mode_arm32_arm
+, &dc_callvm_argBool_arm32_arm
+, &dc_callvm_argChar_arm32_arm
+, &dc_callvm_argShort_arm32_arm 
+, &dc_callvm_argInt_arm32_arm
+, &dc_callvm_argLong_arm32_arm
+, &dc_callvm_argLongLong_arm32_arm
+, &dc_callvm_argFloat_arm32_arm
+, &dc_callvm_argDouble_arm32_arm
+, &dc_callvm_argPointer_arm32_arm
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCboolvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCcharvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCshortvmfunc*)      &dc_callvm_call_arm32_arm
+, (DCintvmfunc*)        &dc_callvm_call_arm32_arm
+, (DClongvmfunc*)       &dc_callvm_call_arm32_arm
+, (DClonglongvmfunc*)   &dc_callvm_call_arm32_arm
+, (DCfloatvmfunc*)      &dc_callvm_call_arm32_arm
+, (DCdoublevmfunc*)     &dc_callvm_call_arm32_arm
+, (DCpointervmfunc*)    &dc_callvm_call_arm32_arm
+, NULL /* callStruct */
+};
+
+
+DCCallVM_vt gVT_arm32_arm_eabi =
+{
+  &dc_callvm_free_arm32_arm
+, &dc_callvm_reset_arm32_arm
+, &dc_callvm_mode_arm32_arm
+, &dc_callvm_argBool_arm32_arm
+, &dc_callvm_argChar_arm32_arm
+, &dc_callvm_argShort_arm32_arm 
+, &dc_callvm_argInt_arm32_arm
+, &dc_callvm_argLong_arm32_arm
+, &dc_callvm_argLongLong_arm32_arm_eabi
+, &dc_callvm_argFloat_arm32_arm
+, &dc_callvm_argDouble_arm32_arm_eabi
+, &dc_callvm_argPointer_arm32_arm
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCboolvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCcharvmfunc*)       &dc_callvm_call_arm32_arm
+, (DCshortvmfunc*)      &dc_callvm_call_arm32_arm
+, (DCintvmfunc*)        &dc_callvm_call_arm32_arm
+, (DClongvmfunc*)       &dc_callvm_call_arm32_arm
+, (DClonglongvmfunc*)   &dc_callvm_call_arm32_arm
+, (DCfloatvmfunc*)      &dc_callvm_call_arm32_arm
+, (DCdoublevmfunc*)     &dc_callvm_call_arm32_arm
+, (DCpointervmfunc*)    &dc_callvm_call_arm32_arm
+, NULL /* callStruct */
+};
+
+
+DCCallVM* dcNewCallVM_arm32_arm(DCsize size) 
+{
+/* Check OS if we need EABI as default. */
+#if defined(DC__ABI_ARM_EABI)
+  return dc_callvm_new_arm32_arm(&gVT_arm32_arm_eabi, size);
+#else
+  return dc_callvm_new_arm32_arm(&gVT_arm32_arm, size);
+#endif
+}
+
+
+DCCallVM* dcNewCallVM(DCsize size)
+{
+  return dcNewCallVM_arm32_arm(size);
+}
+
+static void dc_callvm_mode_arm32_arm(DCCallVM* in_self,DCint mode)
+{
+  DCCallVM_arm32_arm* self = (DCCallVM_arm32_arm*) in_self;
+  DCCallVM_vt*  vt;
+  switch(mode) {
+/* Check OS if we need EABI as default. */
+    case DC_CALL_C_ELLIPSIS:
+    case DC_CALL_C_ELLIPSIS_VARARGS:
+#if defined(DC__ABI_ARM_EABI)
+    case DC_CALL_C_DEFAULT:          vt = &gVT_arm32_arm_eabi; break;
+#else
+    case DC_CALL_C_DEFAULT:          vt = &gVT_arm32_arm;      break;
+#endif
+    case DC_CALL_C_ARM_ARM:          vt = &gVT_arm32_arm;      break;
+    case DC_CALL_C_ARM_ARM_EABI:     vt = &gVT_arm32_arm_eabi; break;
+    default: 
+      in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
+      return;
+  }
+  self->mInterface.mVTpointer = vt;
+}
+