rbdc 0.8.0

data/dyncall/dyncall/dyncall_callvm_sparc_v9.c

@@ -0,0 +1,182 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_v9.c
+ Description: Call VM for sparc-v9 ABI.
+ License:
+
+   Copyright (c) 2011 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
+   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_callvm_sparc_v9.h"
+#include "dyncall_call_sparc_v9.h"
+#include "dyncall_utils.h"
+#include "dyncall_alloc.h"
+
+/* Reset argument buffer. */
+static void dc_callvm_reset_v9(DCCallVM* in_self)
+{
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecResize(&self->mVecHead,0);
+}
+
+/* Construtor. */
+static DCCallVM* dc_callvm_new_v9(DCCallVM_vt* vt, DCsize size)
+{
+  DCCallVM_v9* self = (DCCallVM_v9*) dcAllocMem(sizeof(DCCallVM_v9)+size);
+  dc_callvm_base_init(&self->mInterface, vt);
+  dcVecInit(&self->mVecHead,size);
+  dc_callvm_reset_v9(&self->mInterface);
+  return (DCCallVM*)self;
+}
+
+/* Destructor. */
+static void dc_callvm_free_v9(DCCallVM* in_self)
+{
+  dcFreeMem(in_self);
+}
+
+static void dc_callvm_argLongLong_v9(DCCallVM* in_self, DClonglong x)
+{
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
+}
+
+/* all integers are promoted to 64-bit. */
+static void dc_callvm_argLong_v9   (DCCallVM* in_self, DClong    x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+static void dc_callvm_argInt_v9    (DCCallVM* in_self, DCint     x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+static void dc_callvm_argBool_v9   (DCCallVM* in_self, DCbool    x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+static void dc_callvm_argChar_v9   (DCCallVM* in_self, DCchar    x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+static void dc_callvm_argShort_v9  (DCCallVM* in_self, DCshort   x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+static void dc_callvm_argPointer_v9(DCCallVM* in_self, DCpointer x) { dc_callvm_argLongLong_v9(in_self, (DClonglong) x ); }
+
+static void dc_callvm_argDouble_v9(DCCallVM* in_self, DCdouble x)
+{
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
+}
+
+static void dc_callvm_argDouble_v9_ellipsis(DCCallVM* in_self, DCdouble x)
+{
+  union {
+    long long l;
+    double d;
+  } u;
+  u.d = x;
+  dc_callvm_argLongLong_v9(in_self, u.l);
+}
+
+static void dc_callvm_argFloat_v9_ellipsis(DCCallVM* in_self, DCfloat x)
+{
+  dc_callvm_argDouble_v9_ellipsis(in_self, (DCdouble) x);
+}
+
+static void dc_callvm_argFloat_v9(DCCallVM* in_self, DCfloat x)
+{
+  union {
+    double d;
+    float  f[2];
+  } u;
+  u.f[1] = x;
+  dc_callvm_argDouble_v9(in_self, u.d);
+}
+
+static void dc_callvm_mode_v9(DCCallVM* in_self, DCint mode);
+
+DCCallVM_vt gVT_v9_ellipsis = 
+{
+  &dc_callvm_free_v9, 
+  &dc_callvm_reset_v9, 
+  &dc_callvm_mode_v9, 
+  &dc_callvm_argBool_v9, 
+  &dc_callvm_argChar_v9, 
+  &dc_callvm_argShort_v9, 
+  &dc_callvm_argInt_v9, 
+  &dc_callvm_argLong_v9, 
+  &dc_callvm_argLongLong_v9, 
+  &dc_callvm_argFloat_v9_ellipsis, 
+  &dc_callvm_argDouble_v9_ellipsis, 
+  &dc_callvm_argPointer_v9, 
+  NULL /* argStruct */, 
+  (DCvoidvmfunc*)       &dcCall_v9, 
+  (DCboolvmfunc*)       &dcCall_v9, 
+  (DCcharvmfunc*)       &dcCall_v9, 
+  (DCshortvmfunc*)      &dcCall_v9, 
+  (DCintvmfunc*)        &dcCall_v9, 
+  (DClongvmfunc*)       &dcCall_v9, 
+  (DClonglongvmfunc*)   &dcCall_v9, 
+  (DCfloatvmfunc*)      &dcCall_v9, 
+  (DCdoublevmfunc*)     &dcCall_v9, 
+  (DCpointervmfunc*)    &dcCall_v9, 
+  NULL /* callStruct */
+};
+
+/* CallVM virtual table. */
+DCCallVM_vt gVT_v9 =
+{
+  &dc_callvm_free_v9, 
+  &dc_callvm_reset_v9, 
+  &dc_callvm_mode_v9, 
+  &dc_callvm_argBool_v9, 
+  &dc_callvm_argChar_v9, 
+  &dc_callvm_argShort_v9, 
+  &dc_callvm_argInt_v9, 
+  &dc_callvm_argLong_v9, 
+  &dc_callvm_argLongLong_v9, 
+  &dc_callvm_argFloat_v9, 
+  &dc_callvm_argDouble_v9, 
+  &dc_callvm_argPointer_v9, 
+  NULL /* argStruct */, 
+  (DCvoidvmfunc*)       &dcCall_v9, 
+  (DCboolvmfunc*)       &dcCall_v9, 
+  (DCcharvmfunc*)       &dcCall_v9, 
+  (DCshortvmfunc*)      &dcCall_v9, 
+  (DCintvmfunc*)        &dcCall_v9, 
+  (DClongvmfunc*)       &dcCall_v9, 
+  (DClonglongvmfunc*)   &dcCall_v9, 
+  (DCfloatvmfunc*)      &dcCall_v9, 
+  (DCdoublevmfunc*)     &dcCall_v9, 
+  (DCpointervmfunc*)    &dcCall_v9, 
+  NULL /* callStruct */
+};
+
+/* mode: only a single mode available currently. */
+static void dc_callvm_mode_v9(DCCallVM* in_self, DCint mode)
+{
+  switch(mode) {
+    case DC_CALL_C_DEFAULT:
+    case DC_CALL_C_ELLIPSIS:
+    case DC_CALL_C_SPARC64:
+      in_self->mVTpointer = &gVT_v9; 
+      break;
+    case DC_CALL_C_ELLIPSIS_VARARGS:
+      in_self->mVTpointer = &gVT_v9_ellipsis; 
+      break;
+    default:
+      in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
+      break; 
+  }
+}
+
+
+/* Public API. */
+DCCallVM* dcNewCallVM(DCsize size)
+{
+  return dc_callvm_new_v9(&gVT_v9,size);
+}
+

data/dyncall/dyncall/dyncall_callvm_sparc_v9.h

@@ -0,0 +1,45 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_sparc_v9.h
+ Description: Call VM for sparc-v9 ABI.
+ License:
+
+   Copyright (c) 2011 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
+   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_SPARC_V9_H
+#define DYNCALL_CALLVM_SPARC_V9_H
+
+#include "dyncall_callvm.h"
+#include "dyncall_vector.h"
+
+typedef struct 
+{
+  DCCallVM     mInterface;	/*   0: +12:8 = 16*/
+  DCVecHead    mVecHead;        /* 16   152: mTotalSize +8 */
+                                /* 24   160: mSize      +8 */
+                                /* 32  168: mData  */ 
+} DCCallVM_v9;
+
+DCCallVM* dcNewCallVM_v9(DCsize size);
+
+#endif /* DYNCALL_CALLVM_SPARC_V9_H */
+
+
+

data/dyncall/dyncall/dyncall_callvm_x64.c

@@ -0,0 +1,228 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_x64.c
+ Description: 
+ 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.
+
+*/
+
+
+
+/* MS Windows x64 calling convention, AMD64 SystemV ABI. */
+
+
+#include "dyncall_callvm_x64.h"
+#include "dyncall_alloc.h"
+#include "dyncall_struct.h"
+
+static DCCallVM* dc_callvm_new_x64(DCCallVM_vt* vt, DCsize size)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)dcAllocMem(sizeof(DCCallVM_x64)+size);
+  
+  dc_callvm_base_init(&self->mInterface, vt);
+
+  /* Since we store register parameters in DCCallVM_x64 directly, adjust the stack size. */
+  size -= sizeof(DCRegData_x64);
+  size = (((signed long)size) < 0) ? 0 : size;
+
+
+  self->mRegCount.i = self->mRegCount.f =  0;
+
+  dcVecInit(&self->mVecHead, size);
+  return (DCCallVM*)self;
+}
+
+
+static void dc_callvm_free_x64(DCCallVM* in_self)
+{
+  dcFreeMem(in_self);
+}
+
+
+static void dc_callvm_reset_x64(DCCallVM* in_self)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+  dcVecReset(&self->mVecHead);
+  self->mRegCount.i = self->mRegCount.f =  0;
+}
+
+
+static void dc_callvm_mode_x64(DCCallVM* self, DCint mode)
+{
+  switch(mode) {
+    case DC_CALL_C_DEFAULT:
+    case DC_CALL_C_ELLIPSIS:
+      break;
+    default:
+      self->mError = DC_ERROR_UNSUPPORTED_MODE;
+      break;
+  }
+}
+
+
+static void dc_callvm_argLongLong_x64(DCCallVM* in_self, DClonglong x)
+{
+  /* A long long always has 64 bits on the supported x64 platforms (lp64 on unix and llp64 on windows). */
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+  if(self->mRegCount.i < numIntRegs)
+    self->mRegData.i[self->mRegCount.i++] = x;
+  else
+    dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
+}
+
+
+static void dc_callvm_argBool_x64(DCCallVM* in_self, DCbool x)
+{
+  dc_callvm_argLongLong_x64(in_self, (DClonglong)x);
+}
+
+
+static void dc_callvm_argChar_x64(DCCallVM* in_self, DCchar x)
+{
+  dc_callvm_argLongLong_x64(in_self, x);
+}
+
+
+static void dc_callvm_argShort_x64(DCCallVM* in_self, DCshort x)
+{
+  dc_callvm_argLongLong_x64(in_self, x);
+}
+
+
+static void dc_callvm_argInt_x64(DCCallVM* in_self, DCint x)
+{
+  dc_callvm_argLongLong_x64(in_self, x);
+}
+
+
+static void dc_callvm_argLong_x64(DCCallVM* in_self, DClong x)
+{
+  dc_callvm_argLongLong_x64(in_self, x);
+}
+
+
+static void dc_callvm_argFloat_x64(DCCallVM* in_self, DCfloat x)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+
+  /* Although not promoted to doubles, floats are stored with 64bits in this API.*/
+  union {
+    DCdouble d;
+    DCfloat  f;
+  } f;
+  f.f = x;
+
+  if(self->mRegCount.f < numFloatRegs)
+    *(DCfloat*)&self->mRegData.f[self->mRegCount.f++] = x;
+  else
+    dcVecAppend(&self->mVecHead, &f.f, sizeof(DCdouble));
+}
+
+
+static void dc_callvm_argDouble_x64(DCCallVM* in_self, DCdouble x)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+  if(self->mRegCount.f < numFloatRegs)
+    self->mRegData.f[self->mRegCount.f++] = x;
+  else
+    dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
+}
+
+
+static void dc_callvm_argPointer_x64(DCCallVM* in_self, DCpointer x)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+  if(self->mRegCount.i < numIntRegs)
+    *(DCpointer*)&self->mRegData.i[self->mRegCount.i++] = x;
+  else
+    dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));
+}
+
+static void dc_callvm_argStruct_x64(DCCallVM* in_self, DCstruct* s, DCpointer x)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+  dcVecAppend(&self->mVecHead, x, s->size);
+  /*printf("dc_callvm_argStruct_x64 size = %d\n", (int)s->size);@@@*/
+  if (s->size <= 64)
+  	  dcArgStructUnroll(in_self, s, x);
+  /*else@@@*/
+  /*	  dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));@@@*/
+}
+
+
+/* Call. */
+void dc_callvm_call_x64(DCCallVM* in_self, DCpointer target)
+{
+  DCCallVM_x64* self = (DCCallVM_x64*)in_self;
+#if defined(DC_UNIX)
+  dcCall_x64_sysv(
+#else
+  dcCall_x64_win64(
+#endif
+    dcVecSize(&self->mVecHead),  /* Size of stack data.                           */
+    dcVecData(&self->mVecHead),  /* Pointer to stack arguments.                   */
+    self->mRegData.i,            /* Pointer to register arguments (ints on SysV). */
+#if defined(DC_UNIX)
+    self->mRegData.f,            /* Pointer to floating point register arguments. */
+#endif
+    target
+  );
+}
+
+
+DCCallVM_vt gVT_x64 =
+{
+  &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
+, &dc_callvm_argStruct_x64
+, (DCvoidvmfunc*)       &dc_callvm_call_x64
+, (DCboolvmfunc*)       &dc_callvm_call_x64
+, (DCcharvmfunc*)       &dc_callvm_call_x64
+, (DCshortvmfunc*)      &dc_callvm_call_x64
+, (DCintvmfunc*)        &dc_callvm_call_x64
+, (DClongvmfunc*)       &dc_callvm_call_x64
+, (DClonglongvmfunc*)   &dc_callvm_call_x64
+, (DCfloatvmfunc*)      &dc_callvm_call_x64
+, (DCdoublevmfunc*)     &dc_callvm_call_x64
+, (DCpointervmfunc*)    &dc_callvm_call_x64
+, NULL /* callStruct */
+};
+
+
+DCCallVM* dcNewCallVM_x64(DCsize size) 
+{
+  return dc_callvm_new_x64(&gVT_x64, size);
+}
+
+DCCallVM* dcNewCallVM(DCsize size)
+{
+  return dcNewCallVM_x64(size);
+}
+