rbdc 0.9.0 → 1.0.0

data/dyncall/dyncall/dyncall_callvm_ppc64.h

@@ -54,7 +54,5 @@ struct DCCallVM_ppc64_
   DCVecHead mVecHead;
 };
 
-DCCallVM* dcNewCallVM_ppc64(DCsize size);
-
 #endif /* DYNCALL_CALLVM_PPC64_H */
 

data/dyncall/dyncall/dyncall_callvm_sparc.c

@@ -6,7 +6,7 @@
  Description: Call VM for sparc processor architecture.
  License:
 
-   Copyright (c) 2011-2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2011-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
@@ -29,16 +29,6 @@
 #include "dyncall_utils.h"
 #include "dyncall_alloc.h"
 #define DEFAULT_STACK_ALIGN	16
-/* Construtor. */
-/* the six output registers %o0-%o5 are always loaded, thus we need to ensure the argument buffer has space for at least 24 bytes. */
-static DCCallVM* dc_callvm_new_sparc(DCCallVM_vt* vt, DCsize size)
-{
-  size=DC_MAX(size,sizeof(void*)*(6+1));
-  DCCallVM_sparc* self = (DCCallVM_sparc*) dcAllocMem(sizeof(DCCallVM_sparc)+size);
-  dc_callvm_base_init(&self->mInterface, vt);
-  dcVecInit(&self->mVecHead,size);
-  return (DCCallVM*)self;
-}
 
 /* Destructor. */
 static void dc_callvm_free_sparc(DCCallVM* in_self)
@@ -95,20 +85,6 @@ static void dc_callvm_argDouble_sparc(DCCallVM* in_self, DCdouble x)
   dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
 }
   
-/* mode: only a single mode available currently. */
-static void dc_callvm_mode_sparc(DCCallVM* in_self, DCint mode)
-{
-  switch(mode) {
-    case DC_CALL_C_DEFAULT:
-    case DC_CALL_C_ELLIPSIS:
-    case DC_CALL_C_SPARC32:
-      break;
-    default:
-      in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
-      break; 
-  }
-}
-
 /* we call directly with 'RTYPE dcCall(DCCallVM* in_self, DCpointer target)' */
 #if 0
 /* call: delegate to default call kernel */
@@ -119,6 +95,8 @@ static void dc_callvm_call_sparc(DCCallVM* in_self, DCpointer target)
 }
 #endif
 
+static void dc_callvm_mode_sparc(DCCallVM* in_self, DCint mode);
+
 /* CallVM virtual table. */
 DCCallVM_vt gVT_sparc =
 {
@@ -148,9 +126,39 @@ DCCallVM_vt gVT_sparc =
   NULL /* callStruct */
 };
 
+/* mode: only a single mode available currently. */
+static void dc_callvm_mode_sparc(DCCallVM* in_self, DCint mode)
+{
+  DCCallVM_sparc* self = (DCCallVM_sparc*)in_self;
+  DCCallVM_vt* vt;
+
+  switch(mode) {
+    case DC_CALL_C_DEFAULT:
+    case DC_CALL_C_SPARC32:
+    case DC_CALL_C_ELLIPSIS:
+    case DC_CALL_C_ELLIPSIS_VARARGS:
+      vt = &gVT_sparc;
+      break;
+    default:
+      self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; 
+      return;
+  }
+  dc_callvm_base_init(&self->mInterface, vt);
+}
+
 /* Public API. */
 DCCallVM* dcNewCallVM(DCsize size)
 {
-  return dc_callvm_new_sparc(&gVT_sparc,size);
+  DCCallVM_sparc* p;
+
+  /* the six output registers %o0-%o5 are always loaded, thus we need to ensure the argument buffer has space for at least 24 bytes. */
+  size = DC_MAX(size, sizeof(void*)*(6+1));
+  p = (DCCallVM_sparc*)dcAllocMem(sizeof(DCCallVM_sparc)+size);
+
+  dc_callvm_mode_sparc((DCCallVM*)p, DC_CALL_C_DEFAULT);
+
+  dcVecInit(&p->mVecHead, size);
+
+  return (DCCallVM*)p;
 }
 

data/dyncall/dyncall/dyncall_callvm_sparc.h

@@ -6,7 +6,7 @@
  Description: Call VM for sparc processor architecture.
  License:
 
-   Copyright (c) 2011-2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2011-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
@@ -39,7 +39,5 @@ struct DCCallVM_sparc_
   DCVecHead mVecHead;	/* 8 bytes (max,size)       */
 };
 
-DCCallVM* dcNewCallVM_sparc(DCsize size);
-
 #endif /* DYNCALL_CALLVM_SPARC_H */
 

data/dyncall/dyncall/dyncall_callvm_sparc64.c

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncall
  File: dyncall/dyncall_callvm_sparc64.c
- Description: Call VM for sparc64 64-bit processor architecture.
+ Description: Call VM for sparc64 (v9) ABI.
  License:
 
-   Copyright (c) 2011-2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2011-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
@@ -28,212 +28,156 @@
 #include "dyncall_call_sparc64.h"
 #include "dyncall_alloc.h"
 
-#define IREGS 6
-#define FREGS 16
-#define SREGS 16
-#define DHEAD (IREGS+FREGS)*8+SREGS*4
-
 /* Reset argument buffer. */
-static void dc_callvm_reset_sparc64(DCCallVM* in_self)
+static void dc_callvm_reset_v9(DCCallVM* in_self)
 {
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
-  dcVecResize(&self->mVecHead,DHEAD);
-  self->mIntRegs        = 0;
-  self->mFloatRegs      = 0;
-  self->mUseSingleFlags = 0;
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecResize(&self->mVecHead, 0);
 }
 
-/* Construtor. */
-/* the six output registers %o0-%o5 are always loaded, thus we need to ensure the argument buffer has space for at least 24 bytes. */
-static DCCallVM* dc_callvm_new_sparc64(DCCallVM_vt* vt, DCsize size)
-{
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*) dcAllocMem(sizeof(DCCallVM_sparc64)+DHEAD+size);
-  dc_callvm_base_init(&self->mInterface, vt);
-  dcVecInit(&self->mVecHead,DHEAD+size);
-  dc_callvm_reset_sparc64(&self->mInterface);
-  return (DCCallVM*)self;
-}
 
 /* Destructor. */
-static void dc_callvm_free_sparc64(DCCallVM* in_self)
+static void dc_callvm_free_v9(DCCallVM* in_self)
 {
   dcFreeMem(in_self);
 }
 
-/* all integers are promoted to 64-bit. */
-
-static void dc_callvm_argLongLong_sparc64(DCCallVM* in_self, DClonglong x)
+static void dc_callvm_argLongLong_v9(DCCallVM* in_self, DClonglong x)
 {
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
-  if (self->mIntRegs < IREGS) {
-    * ( (DClonglong*) ( dcVecAt(&self->mVecHead, (self->mIntRegs++)*8) ) ) = x;
-  } else {
-    dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
-  }
-  if (self->mFloatRegs < FREGS) self->mFloatRegs++;
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
 }
 
-static void dc_callvm_argLong_sparc64   (DCCallVM* in_self, DClong    x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-static void dc_callvm_argInt_sparc64    (DCCallVM* in_self, DCint     x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-static void dc_callvm_argBool_sparc64   (DCCallVM* in_self, DCbool    x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-static void dc_callvm_argChar_sparc64   (DCCallVM* in_self, DCchar    x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-static void dc_callvm_argShort_sparc64  (DCCallVM* in_self, DCshort   x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-static void dc_callvm_argPointer_sparc64(DCCallVM* in_self, DCpointer x) { dc_callvm_argLongLong_sparc64(in_self, (DClonglong) x ); }
-
-static void dc_callvm_argDouble_sparc64(DCCallVM* in_self, DCdouble x)
+/* 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_sparc64* self = (DCCallVM_sparc64*)in_self;
-  if (self->mFloatRegs < FREGS) {
-    * ((double*)dcVecAt(&self->mVecHead,(IREGS+(self->mFloatRegs++))*8)) = x;
-  }
-  if (self->mIntRegs < IREGS) {
-    self->mIntRegs++;
-  } else {
-    dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
-  }
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
 }
 
-static void dc_callvm_argDouble_sparc64_ellipsis(DCCallVM* in_self, DCdouble x)
+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_sparc64(in_self, u.l);
+  dc_callvm_argLongLong_v9(in_self, u.l);
 }
 
-static void dc_callvm_argFloat_sparc64_ellipsis(DCCallVM* in_self, DCfloat x)
+static void dc_callvm_argFloat_v9_ellipsis(DCCallVM* in_self, DCfloat x)
 {
-  dc_callvm_argDouble_sparc64_ellipsis(in_self, (DCdouble) x);
+  dc_callvm_argDouble_v9_ellipsis(in_self, (DCdouble) x);
 }
 
-static void dc_callvm_argFloat_sparc64(DCCallVM* in_self, DCfloat x)
+static void dc_callvm_argFloat_v9(DCCallVM* in_self, DCfloat x)
 {
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
-  if (self->mFloatRegs < FREGS) {
-    self->mUseSingleFlags |= 1<<self->mFloatRegs;
-    * ((float*)dcVecAt(&self->mVecHead,(IREGS+FREGS)*8 + (self->mFloatRegs++)*4)) = x;
-  } 
-  
-  if (self->mIntRegs < IREGS) {
-    self->mIntRegs++;
-  } else {
-    union {
-      DCdouble d;
-      DClonglong l;
-      DCfloat f[2];
-    } u;
-    u.f[1] = x;
-    dcVecAppend(&self->mVecHead, &u.l, sizeof(DClonglong));
-  }
-}
-
-#if 0
-/* call: delegate to default call kernel */
-static void dc_callvm_call_sparc64(DCCallVM* in_self, DCpointer target)
-{
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
-  dcCall_sparc64(target, dcVecSize(&self->mVecHead), dcVecData(&self->mVecHead));
+  union {
+    double d;
+    float  f[2];
+  } u;
+  u.f[1] = x;
+  dc_callvm_argDouble_v9(in_self, u.d);
 }
-#endif
 
-static void dc_callvm_mode_sparc64(DCCallVM* in_self, DCint mode);
+static void dc_callvm_mode_v9(DCCallVM* in_self, DCint mode);
 
-DCCallVM_vt gVT_sparc64_ellipsis = 
+DCCallVM_vt gVT_v9_ellipsis = 
 {
-  &dc_callvm_free_sparc64, 
-  &dc_callvm_reset_sparc64, 
-  &dc_callvm_mode_sparc64, 
-  &dc_callvm_argBool_sparc64, 
-  &dc_callvm_argChar_sparc64, 
-  &dc_callvm_argShort_sparc64, 
-  &dc_callvm_argInt_sparc64, 
-  &dc_callvm_argLong_sparc64, 
-  &dc_callvm_argLongLong_sparc64, 
-  &dc_callvm_argFloat_sparc64_ellipsis, 
-  &dc_callvm_argDouble_sparc64_ellipsis, 
-  &dc_callvm_argPointer_sparc64, 
+  &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_sparc64, 
-  (DCboolvmfunc*)       &dcCall_sparc64, 
-  (DCcharvmfunc*)       &dcCall_sparc64, 
-  (DCshortvmfunc*)      &dcCall_sparc64, 
-  (DCintvmfunc*)        &dcCall_sparc64, 
-  (DClongvmfunc*)       &dcCall_sparc64, 
-  (DClonglongvmfunc*)   &dcCall_sparc64, 
-  (DCfloatvmfunc*)      &dcCall_sparc64, 
-  (DCdoublevmfunc*)     &dcCall_sparc64, 
-  (DCpointervmfunc*)    &dcCall_sparc64, 
+  (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_sparc64 =
+DCCallVM_vt gVT_v9 =
 {
-  &dc_callvm_free_sparc64, 
-  &dc_callvm_reset_sparc64, 
-  &dc_callvm_mode_sparc64, 
-  &dc_callvm_argBool_sparc64, 
-  &dc_callvm_argChar_sparc64, 
-  &dc_callvm_argShort_sparc64, 
-  &dc_callvm_argInt_sparc64, 
-  &dc_callvm_argLong_sparc64, 
-  &dc_callvm_argLongLong_sparc64, 
-  &dc_callvm_argFloat_sparc64, 
-  &dc_callvm_argDouble_sparc64, 
-  &dc_callvm_argPointer_sparc64, 
+  &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_sparc64, 
-  (DCboolvmfunc*)       &dcCall_sparc64, 
-  (DCcharvmfunc*)       &dcCall_sparc64, 
-  (DCshortvmfunc*)      &dcCall_sparc64, 
-  (DCintvmfunc*)        &dcCall_sparc64, 
-  (DClongvmfunc*)       &dcCall_sparc64, 
-  (DClonglongvmfunc*)   &dcCall_sparc64, 
-  (DCfloatvmfunc*)      &dcCall_sparc64, 
-  (DCdoublevmfunc*)     &dcCall_sparc64, 
-  (DCpointervmfunc*)    &dcCall_sparc64, 
+  (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_sparc64(DCCallVM* in_self, DCint mode)
+static void dc_callvm_mode_v9(DCCallVM* in_self, DCint mode)
 {
+  DCCallVM_v9* self = (DCCallVM_v9*)in_self;
+  DCCallVM_vt* vt;
+
   switch(mode) {
     case DC_CALL_C_DEFAULT:
-    case DC_CALL_C_ELLIPSIS:
     case DC_CALL_C_SPARC64:
-      in_self->mVTpointer = &gVT_sparc64; 
+    case DC_CALL_C_ELLIPSIS:
+      vt = &gVT_v9;
       break;
     case DC_CALL_C_ELLIPSIS_VARARGS:
-      in_self->mVTpointer = &gVT_sparc64_ellipsis; 
+      vt = &gVT_v9_ellipsis;
       break;
     default:
-      in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
-      break; 
+      self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; 
+      return; 
   }
+  dc_callvm_base_init(&self->mInterface, vt);
 }
 
-
 /* Public API. */
 DCCallVM* dcNewCallVM(DCsize size)
 {
-  return dc_callvm_new_sparc64(&gVT_sparc64,size);
-}
+  DCCallVM_v9* p = (DCCallVM_v9*)dcAllocMem(sizeof(DCCallVM_v9)+size);
 
-#if 0
-/* Load integer 32-bit. */
-static void dc_callvm_argInt_sparc64(DCCallVM* in_self, DCint x)
-{
-  DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
-  dcVecAppend(&self->mVecHead, &x, sizeof(DCint));
-}
+  dc_callvm_mode_v9((DCCallVM*)p, DC_CALL_C_DEFAULT);
 
-/* we propagate Bool,Char,Short,Int to LongLong. */
+  dcVecInit(&p->mVecHead,size);
+  dc_callvm_reset_v9(&p->mInterface);
 
-static void dc_callvm_argBool_sparc64(DCCallVM* in_self, DCbool x)   { dc_callvm_argInt_sparc64(in_self, (DCint)x); }
-static void dc_callvm_argChar_sparc64(DCCallVM* in_self, DCchar x)   { dc_callvm_argInt_sparc64(in_self, (DCint)x); }
-static void dc_callvm_argShort_sparc64(DCCallVM* in_self, DCshort x) { dc_callvm_argInt_sparc64(in_self, (DCint)x); }
-#endif
+  return (DCCallVM*)p;
+}
 

data/dyncall/dyncall/dyncall_callvm_sparc64.h

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncall
  File: dyncall/dyncall_callvm_sparc64.h
- Description: Call VM for sparc64 processor architecture.
+ Description: Call VM for sparc64 (v9) ABI.
  License:
 
-   Copyright (c) 2011-2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2011-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
@@ -24,25 +24,19 @@
 
 
 
-#ifndef DYNCALL_CALLVM_SPARC_H
-#define DYNCALL_CALLVM_SPARC_H
+#ifndef DYNCALL_CALLVM_SPARC_V9_H
+#define DYNCALL_CALLVM_SPARC_V9_H
 
 #include "dyncall_callvm.h"
 #include "dyncall_vector.h"
 
-typedef struct DCCallVM_sparc64_ DCCallVM_sparc64;
-struct DCCallVM_sparc64_
+typedef struct 
 {
-  DCCallVM     mInterface;	/* 12:8 -> 16 */
-  int          mIntRegs;	/* 16 */
-  int          mFloatRegs;      /* 20 */
-  unsigned int mUseSingleFlags; /* 24 */
-  DCVecHead    mVecHead;        /* 36:16, 28 => 40 */
-};
-
-DCCallVM* dcNewCallVM_sparc64(DCsize size);
-
-#endif /* DYNCALL_CALLVM_SPARC64_H */
-
+  DCCallVM     mInterface;      /*   0: +12:8 = 16*/
+  DCVecHead    mVecHead;        /* 16   152: mTotalSize +8 */
+                                /* 24   160: mSize      +8 */
+                                /* 32  168: mData  */ 
+} DCCallVM_v9;
 
+#endif /* DYNCALL_CALLVM_SPARC_V9_H */