rbdc 0.8.7 → 0.9.0

data/dyncall/dyncall/dyncall_callvm_arm32_arm.c

@@ -6,7 +6,7 @@
  Description: ARM 32-bit "arm" ABI callvm implementation
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -24,6 +24,7 @@
 */
 
 
+
 /*
 
   dyncall callvm for 32bit ARM32 family of processors

data/dyncall/dyncall/dyncall_callvm_arm32_arm.h

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -24,6 +24,7 @@
 */
 
 
+
 /*
 
   dyncall callvm for 32bit ARM32 family of processors

data/dyncall/dyncall/dyncall_callvm_arm32_arm_armhf.c

@@ -2,11 +2,11 @@
 
  Package: dyncall
  Library: dyncall
- File: dyncall/arm_armhf.c
+ File: dyncall/dyncall_callvm_arm32_arm_armhf.c
  Description: ARM 'armhf' ABI implementation
  License:
 
-   Copyright (c) 2007-2012 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -23,13 +23,14 @@
 
 */
 
+
 #include "dyncall_callvm_arm32_arm_armhf.h"
 #include "dyncall_alloc.h"
 
 
 static DCCallVM* dc_callvm_new_arm32_armhf(DCCallVM_vt* vt, DCsize size)
 {
-  /* Store at least 16 bytes (4 words) for internal spill area. Assembly code depends on it. */
+  /* Store at least 16 bytes (4 words for first 4 int args) for internal spill area. Assembly code depends on it. */
   DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)dcAllocMem(sizeof(DCCallVM_arm32_armhf)+size+16);
   dc_callvm_base_init(&p->mInterface, vt);
   dcVecInit(&p->mVecHead, size);
@@ -71,6 +72,7 @@ static void a_bool    (DCCallVM* in_self, DCbool  x) { a_int(in_self, (DCint)x);
 static void a_char    (DCCallVM* in_self, DCchar  x) { a_int(in_self, x); }
 static void a_short   (DCCallVM* in_self, DCshort x) { a_int(in_self, x); }
 static void a_long    (DCCallVM* in_self, DClong  x) { a_int(in_self, x); }
+
 static void a_longlong(DCCallVM* in_self, DClonglong x)
 {
   DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_self;
@@ -85,6 +87,7 @@ static void a_longlong(DCCallVM* in_self, DClonglong x)
     dcVecAppend(&p->mVecHead, &x, sizeof(DClonglong));
   }
 }
+
 static void a_pointer(DCCallVM* in_p, DCpointer x) { a_int(in_p, (DCint) x ); }
 
 static void a_float(DCCallVM* in_p, DCfloat x)
@@ -99,44 +102,43 @@ static void a_float(DCCallVM* in_p, DCfloat x)
     }
   } else {
     dcVecAppend(&p->mVecHead, &x, sizeof(DCfloat));
-  } 
+  }
 }
 
 static void a_double(DCCallVM* in_p, DCdouble x)
 {
+  union {
+    DCdouble d;
+    DCchar   b[8];
+  } v;
+
   DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_p;
   if (p->d < 16) {
     * (double*) &p->S[p->d] = x;
     p->d += 2;
     if (!(p->s & 1)) {
-      /* if s is even it always equals d. 
-	 otherwise, s points to an odd float register. 
-       */
+      /* if s is even it always equals d. otherwise, s points to an odd float register. */
       p->s = p->d;
     }
   } else {
-    p->s = 16;
-    union {
-      DCdouble d;
-      DCchar   b[8];
-    } v; // ,w;
+    p->s = 16; /* fp registers all full - need to use stack now: stop filling gaps for single precision, also */
     v.d = x;
-#if 0
-    w.b[0] = v.b[7];
-    w.b[1] = v.b[6];
-    w.b[2] = v.b[5];
-    w.b[3] = v.b[4];
-    w.b[4] = v.b[3];
-    w.b[5] = v.b[2];
-    w.b[6] = v.b[1];
-    w.b[7] = v.b[0];
-#endif
     /* 64 bit values need to be aligned on 8 byte boundaries */
     dcVecSkip(&p->mVecHead, dcVecSize(&p->mVecHead) & 4);
     dcVecAppend(&p->mVecHead, &v.b[0], sizeof(DCdouble));
   }
 }
 
+static void a_float_ellipsis(DCCallVM* in_p, DCfloat x)
+{
+  a_int(in_p, *(DCint*)&x);
+}
+
+static void a_double_ellipsis(DCCallVM* in_p, DCdouble x)
+{
+  a_longlong(in_p, *(DClonglong*)&x);
+}
+
 void call(DCCallVM* in_p, DCpointer target)
 {
   DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_p;
@@ -150,7 +152,7 @@ DCCallVM_vt vt_armhf =
 , &mode
 , &a_bool
 , &a_char
-, &a_short 
+, &a_short
 , &a_int
 , &a_long
 , &a_longlong
@@ -171,7 +173,35 @@ DCCallVM_vt vt_armhf =
 , NULL /* callStruct */
 };
 
-DCCallVM* dcNewCallVM(DCsize size) 
+DCCallVM_vt vt_armhf_ellipsis =
+{
+  &deinit
+, &reset
+, &mode
+, &a_bool
+, &a_char
+, &a_short
+, &a_int
+, &a_long
+, &a_longlong
+, &a_float_ellipsis
+, &a_double_ellipsis
+, &a_pointer
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &call
+, (DCboolvmfunc*)       &call
+, (DCcharvmfunc*)       &call
+, (DCshortvmfunc*)      &call
+, (DCintvmfunc*)        &call
+, (DClongvmfunc*)       &call
+, (DClonglongvmfunc*)   &call
+, (DCfloatvmfunc*)      &call
+, (DCdoublevmfunc*)     &call
+, (DCpointervmfunc*)    &call
+, NULL /* callStruct */
+};
+
+DCCallVM* dcNewCallVM(DCsize size)
 {
 #if defined(DC__ABI_ARM_EABI)
   return dc_callvm_new_arm32_arm(&eabi, size);
@@ -187,18 +217,18 @@ DCCallVM* dcNewCallVM(DCsize size)
 static void mode(DCCallVM* in_self,DCint mode)
 {
   DCCallVM_arm32_armhf* self = (DCCallVM_arm32_armhf*) in_self;
-  DCCallVM_vt*  vt;
   switch(mode) {
-    case DC_CALL_C_DEFAULT:        
+    case DC_CALL_C_DEFAULT:
+    case DC_CALL_C_ARM_ARMHF:
+      self->mInterface.mVTpointer = &vt_armhf;
+      break;
     case DC_CALL_C_ELLIPSIS:
     case DC_CALL_C_ELLIPSIS_VARARGS:
-    case DC_CALL_C_ARM_ARMHF:        
-      vt = &vt_armhf;
+      self->mInterface.mVTpointer = &vt_armhf_ellipsis;
       break;
-    default: 
+    default:
       in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
       return;
   }
-  self->mInterface.mVTpointer = vt;
 }
 

data/dyncall/dyncall/dyncall_callvm_arm32_arm_armhf.h

@@ -2,11 +2,11 @@
 
  Package: dyncall
  Library: dyncall
- File: dyncall/dyncall_callvm_arm32_armhf.h
+ File: dyncall/dyncall_callvm_arm32_arm_armhf.h
  Description: 
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -24,6 +24,7 @@
 */
 
 
+
 /*
 
   dyncall callvm for 32bit ARM32 family of processors

data/dyncall/dyncall/dyncall_callvm_arm32_thumb.c

@@ -6,7 +6,7 @@
  Description: ARM 32-bit "thumb" ABI callvm implementation
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -24,6 +24,7 @@
 */
 
 
+
 /*
 
   dyncall callvm for 32bit ARM32 family of processors
@@ -143,11 +144,6 @@ static void dc_callvm_argPointer_arm32_thumb(DCCallVM* in_self, DCpointer x)
   dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));
 }
 
-typedef void       (*call_void)  (DCpointer target, DCpointer data, DCsize size);
-typedef DClong     (*call_word)  (DCpointer target, DCpointer data, DCsize size);
-typedef DClonglong (*call_dword) (DCpointer target, DCpointer data, DCsize size);
-
-
 
 /* Call. */
 void dc_callvm_call_arm32_thumb(DCCallVM* in_self, DCpointer target)
@@ -157,24 +153,6 @@ void dc_callvm_call_arm32_thumb(DCCallVM* in_self, DCpointer target)
 }
 
 
-#if 0
-DClong dc_callvm_call_arm32_thumb_word(DCCallVM* in_self, DCpointer target)
-{
-  DCCallVM_arm32_thumb* self = (DCCallVM_arm32_thumb*)in_self;
-  // return dcCall_arm32_thumb_word(target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead));
-  return ( (call_word) dcCall_arm32_thumb) (target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead));
-}
-
-
-DClonglong dc_callvm_call_arm32_thumb_dword(DCCallVM* in_self, DCpointer target)
-{
-  DCCallVM_arm32_thumb* self = (DCCallVM_arm32_thumb*)in_self;
-  // return dcCall_arm32_thumb_dword(target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead));
-  return ( (call_dword) dcCall_arm32_thumb ) (target, dcVecData(&self->mVecHead), dcVecSize(&self->mVecHead));
-}
-#endif
-
-
 DCCallVM_vt gVT_arm32_thumb =
 {
   &dc_callvm_free_arm32_thumb

data/dyncall/dyncall/dyncall_callvm_arm32_thumb.h

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -24,6 +24,7 @@
 */
 
 
+
 /*
 
   dyncall callvm for 32bit ARM32 family of processors

data/dyncall/dyncall/dyncall_callvm_arm64.c

@@ -0,0 +1,165 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_arm64.c
+ Description: ARM 64-bit ABI implementation
+ License:
+
+   Copyright (c) 2015 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_callvm_arm64.h"
+#include "dyncall_alloc.h"
+
+static DCCallVM* dc_callvm_new_arm64(DCCallVM_vt* vt, DCsize size)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*) dcAllocMem(size);
+
+  dc_callvm_base_init(&p->mInterface, vt);
+
+  dcVecInit(&p->mVecHead, size);
+
+  p->i = 0;
+  p->f = 0;
+
+  return (DCCallVM*)p;
+}
+
+static void reset(DCCallVM* in_p)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
+  p->i = 0;
+  p->f = 0;
+  dcVecReset(&p->mVecHead);
+}
+
+
+static void mode(DCCallVM* in_self,DCint mode);
+
+static void deinit(DCCallVM* in_self)
+{
+  dcFreeMem(in_self);
+}
+
+
+
+static void a_i64(DCCallVM* in_self, DClonglong x)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*)in_self;
+  if (p->i < 8) {
+    p->I[p->i] = x;
+    p->i++;
+  } else {
+    dcVecAppend(&p->mVecHead, &x, sizeof(DClonglong));
+  }
+}
+
+static void a_bool    (DCCallVM* self, DCbool  x)   { a_i64(self, (DClonglong)x); }
+static void a_char    (DCCallVM* self, DCchar  x)   { a_i64(self, x); }
+static void a_short   (DCCallVM* self, DCshort x)   { a_i64(self, x); }
+static void a_int     (DCCallVM* self, DCint x)     { a_i64(self, x); }
+static void a_long    (DCCallVM* self, DClong  x)   { a_i64(self, x); }
+static void a_pointer (DCCallVM* self, DCpointer x) { a_i64(self, (DClonglong) x ); }
+
+static void a_float(DCCallVM* in_p, DCfloat x)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
+
+  if (p->f < 8) {
+    p->u.S[ p->f << 1 ] = x;
+    p->f++;
+  } else {
+    dcVecAppend(&p->mVecHead, &x, sizeof(DCfloat));
+    dcVecSkip(&p->mVecHead, 4);	/* align to 8-bytes */
+  }
+}
+
+static void a_double(DCCallVM* in_p, DCdouble x)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
+  if (p->f < 8) {
+    p->u.D[ p->f ] = x;
+    p->f++; 
+  } else {
+    dcVecAppend(&p->mVecHead, &x, sizeof(DCdouble));
+  }
+}
+
+void call(DCCallVM* in_p, DCpointer target)
+{
+  DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
+  
+  /*
+  ** copy 'size' argument is given in number of 16-byte 'pair' blocks.
+  */
+  
+  dcCall_arm64(target, dcVecData(&p->mVecHead), ( dcVecSize(&p->mVecHead) + 15 ) & -16, &p->u.S[0]);
+}
+
+DCCallVM_vt vt_arm64 =
+{
+  &deinit
+, &reset
+, &mode
+, &a_bool
+, &a_char
+, &a_short 
+, &a_int
+, &a_long
+, &a_i64
+, &a_float
+, &a_double
+, &a_pointer
+, NULL /* argStruct */
+, (DCvoidvmfunc*)       &call
+, (DCboolvmfunc*)       &call
+, (DCcharvmfunc*)       &call
+, (DCshortvmfunc*)      &call
+, (DCintvmfunc*)        &call
+, (DClongvmfunc*)       &call
+, (DClonglongvmfunc*)   &call
+, (DCfloatvmfunc*)      &call
+, (DCdoublevmfunc*)     &call
+, (DCpointervmfunc*)    &call
+, NULL /* callStruct */
+};
+
+DCCallVM* dcNewCallVM(DCsize size) 
+{
+  return dc_callvm_new_arm64(&vt_arm64, size);
+}
+
+static void mode(DCCallVM* in_self,DCint mode)
+{
+  DCCallVM_arm64* self = (DCCallVM_arm64*) in_self;
+  DCCallVM_vt*  vt;
+  switch(mode) {
+    case DC_CALL_C_DEFAULT:        
+    case DC_CALL_C_ELLIPSIS:
+    case DC_CALL_C_ELLIPSIS_VARARGS:
+    case DC_CALL_C_ARM64:        
+      vt = &vt_arm64;
+      break;
+    default: 
+      in_self->mError = DC_ERROR_UNSUPPORTED_MODE;
+      return;
+  }
+  self->mInterface.mVTpointer = vt;
+}
+