rbdc 0.9.0 → 1.0.0

data/dyncall/dyncallback/dyncall_callback_sparc64.c

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncallback
  File: dyncallback/dyncall_callback_sparc64.c
- Description: Callback - Implementation for sparc64 (TODO: not implemented yet)
+ Description: Callback - Implementation for sparc64
  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
@@ -25,25 +25,42 @@
 
 
 #include "dyncall_callback.h"
-#include "dyncall_callback_sparc32.h"
-
 #include "dyncall_alloc_wx.h"
+#include "dyncall_thunk.h"
+
+/* Callback symbol. */
+extern void dcCallbackThunkEntry();
+
+struct DCCallback
+{
+  DCThunk            thunk;         /* offset  0, size 56 */
+  DCCallbackHandler* handler;       /* offset 56, size  8 */
+  void*              userdata;      /* offset 64, size  8 */
+};
+
 
 void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
 {
+  pcb->handler  = handler;
+  pcb->userdata = userdata;
 }
 
-extern void dcCallbackThunkEntry();
-
 DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, void* userdata)
 {
   DCCallback* pcb;
   int err = dcAllocWX(sizeof(DCCallback), (void**) &pcb);
-  if (err != 0) return 0;
+  if(err)
+    return NULL;
 
   dcbInitThunk(&pcb->thunk, dcCallbackThunkEntry);
   dcbInitCallback(pcb, signature, handler, userdata);
 
+  err = dcInitExecWX(pcb, sizeof(DCCallback));
+  if(err) {
+    dcFreeWX(pcb, sizeof(DCCallback));
+    return NULL;
+  }
+
   return pcb;
 }
 
@@ -56,3 +73,4 @@ void* dcbGetUserData(DCCallback* pcb)
 {
   return pcb->userdata;
 }
+

data/dyncall/dyncallback/dyncall_callback_sparc64.s

@@ -3,11 +3,10 @@
  Package: dyncall
  Library: dyncallback
  File: dyncallback/dyncall_callback_sparc64.s
- Description: Callback Thunk - Implementation for Sparc 64-bit
+ Description: Callback - Implementation for Sparc 64-bit
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>,
-                           Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2017 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
@@ -23,8 +22,93 @@
 
 */
 
+/* input:
+	$i0    -> thunk
+	$i0+56 -> cb handler
+	$i0+64 -> userdata
+*/
+
+/* NOTE: %sp/%fp for v9 are offset, using them needs a "BIAS" of 2047 */
+BIAS = 2047
+
+.text
 .globl dcCallbackThunkEntry
+
+/* Called by thunk - thunk stores pointer to DCCallback */
+/* in %g1, and pointer to called function in %g2        */
 dcCallbackThunkEntry:
-        jmpl %i7 + 8, %g0			/* Return from proc. */
-	 nop
+
+	/* Prolog. */
+	/* Frame size of 336b comes from needing storage space for the following: */
+	/*   req_reg_save_area:128 + spill:48 + dcargs:144 + retval:8 + pad:8 */
+	/* Spill area could theoretically be only 32b, b/c cbHandler function has */
+ 	/* 4 arguments, but let's be conservative. */
+	save %sp, -336, %sp
+
+	/* Spill register args as dcargs is based on that (in prev frame, after */
+	/* req_reg_save_area). */
+	add  %fp, BIAS + 128, %l0
+	stx  %i0,  [ %l0 +  0 ]          /* reg arg 0 */
+	stx  %i1,  [ %l0 +  8 ]          /* reg arg 1 */
+	stx  %i2,  [ %l0 + 16 ]          /* reg arg 2 */
+	stx  %i3,  [ %l0 + 24 ]          /* reg arg 3 */
+	stx  %i4,  [ %l0 + 32 ]          /* reg arg 4 */
+	stx  %i5,  [ %l0 + 40 ]          /* reg arg 5 */
+	stx  %l0,  [ %sp + BIAS + 176 ]  /* set DCArg's arg_ptr */
+	st   %f0,  [ %sp + BIAS + 184 ]  /* store fp args in DCArgs's dreg_data */
+	st   %f1,  [ %sp + BIAS + 188 ]  /* @@@ I think stx should work to store */
+	st   %f2,  [ %sp + BIAS + 192 ]  /*     all 64bits, but I get "Illegal   */
+	st   %f3,  [ %sp + BIAS + 196 ]  /*     Operands", so using single prec. */
+	st   %f4,  [ %sp + BIAS + 200 ]  /*     store (st) */
+	st   %f5,  [ %sp + BIAS + 204 ]
+	st   %f6,  [ %sp + BIAS + 208 ]
+	st   %f7,  [ %sp + BIAS + 212 ]
+	st   %f8,  [ %sp + BIAS + 216 ]
+	st   %f9,  [ %sp + BIAS + 220 ]
+	st   %f10, [ %sp + BIAS + 224 ]
+	st   %f11, [ %sp + BIAS + 228 ]
+	st   %f12, [ %sp + BIAS + 232 ]
+	st   %f13, [ %sp + BIAS + 236 ]
+	st   %f14, [ %sp + BIAS + 240 ]
+	st   %f15, [ %sp + BIAS + 244 ]
+	st   %f16, [ %sp + BIAS + 248 ]
+	st   %f17, [ %sp + BIAS + 252 ]
+	st   %f18, [ %sp + BIAS + 256 ]
+	st   %f19, [ %sp + BIAS + 260 ]
+	st   %f20, [ %sp + BIAS + 264 ]
+	st   %f21, [ %sp + BIAS + 268 ]
+	st   %f22, [ %sp + BIAS + 272 ]
+	st   %f23, [ %sp + BIAS + 276 ]
+	st   %f24, [ %sp + BIAS + 280 ]
+	st   %f25, [ %sp + BIAS + 284 ]
+	st   %f26, [ %sp + BIAS + 288 ]
+	st   %f27, [ %sp + BIAS + 292 ]
+	st   %f28, [ %sp + BIAS + 296 ]
+	st   %f29, [ %sp + BIAS + 300 ]
+	st   %f30, [ %sp + BIAS + 304 ]
+	st   %f31, [ %sp + BIAS + 308 ]
+	stx  %g0,  [ %sp + BIAS + 312 ] /* init DCArg's i */
+
+	/* Zero retval store. */
+	stx  %g0, [ %sp + BIAS + 320 ]
+
+	/* Prepare callback handler call. */
+	mov  %g1, %o0                   /* Param 0 = DCCallback*, %g1 holds ptr to thunk */
+	add  %sp, BIAS + 176, %o1       /* Param 1 = DCArgs* (ptr to struct with args ptr) */
+	add  %sp, BIAS + 320, %o2       /* Param 2 = results ptr to 8b of local stack data */
+	ldx  [ %g1 + 64 ], %o3          /* Param 3 = userdata ptr */
+
+	/* Fetch callback handler address (after thunk blob) and call. */
+	ldx  [ %g1 + 56 ], %l0
+	call %l0
+	nop
+
+	/* Put retval in %i0 (to be in caller's %o0), and %f0. */
+	ldx  [ %sp + BIAS + 320 ], %i0
+	ldd  [ %sp + BIAS + 320 ], %f0
+
+	/* Epilog. */
+	restore                 /* unshift reg window */
+	retl                    /* Return from proc. -- jmpl %i7 + 8, %g0 */
+	nop
 

data/dyncall/dyncallback/dyncall_callback_x64.S

@@ -6,7 +6,7 @@
  Description: Callback Thunk entry for x64 (portasm version)
  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,7 +24,7 @@
 
 
 
-#include "../portasm/portasm-x64-att.S"
+#include "../portasm/portasm-x64.S"
 
 /* structure sizes */
 
@@ -58,7 +58,7 @@ SET(DCCallback_size,40)
 
 GLOBAL(dcCallback_x64_sysv)
 BEGIN_PROC(dcCallback_x64_sysv)
-	
+
 	PUSH(RBP)
 	MOV(RSP,RBP)
 
@@ -66,7 +66,7 @@ BEGIN_PROC(dcCallback_x64_sysv)
 
 	/* float parameters (8 registers spill to DCArgs) */
 
-	SUB(LIT(8*8),RSP)	
+	SUB(LIT(8*8),RSP)
 
 	MOVSD(XMM7, QWORD(RSP,8*7))		/* struct offset 120: float parameter 7 */
 	MOVSD(XMM6, QWORD(RSP,8*6))		/* struct offset 112: float parameter 6 */
@@ -95,7 +95,7 @@ BEGIN_PROC(dcCallback_x64_sysv)
 	PUSH(RDX)
 
 	MOV(RSP,RSI)				/* arg 1 RSI : DCArgs* */
-	
+
 	/* initialize DCValue */
 
 	PUSH(LIT(0))				/* struct offset 0: return value (max long long) */
@@ -121,7 +121,7 @@ END_PROC(dcCallback_x64_sysv)
 
 GLOBAL(dcCallback_x64_win64)
 BEGIN_PROC(dcCallback_x64_win64)
-	
+
 	PUSH(RBP)
 	MOV(RSP,RBP)
 
@@ -129,7 +129,7 @@ BEGIN_PROC(dcCallback_x64_win64)
 
 	/* float parameters (4 registers spill to DCArgs) */
 
-	SUB(LIT(4*8),RSP)	
+	SUB(LIT(4*8),RSP)
 
 	MOVSD(XMM3, QWORD(RSP,8*3))		/* struct offset  72: float parameter 3 */
 	MOVSD(XMM2, QWORD(RSP,8*2))		/* struct offset  64: float parameter 2 */
@@ -174,7 +174,7 @@ BEGIN_PROC(dcCallback_x64_win64)
 	POP(RBP)
 	RET()
 
-END_PROC(dcCallback_x64_win64)	
+END_PROC(dcCallback_x64_win64)
 
 END_ASM
 

data/dyncall/dyncallback/dyncall_callback_x64.c

@@ -6,7 +6,7 @@
  Description: Callback - Implementation for x64
  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,16 +24,21 @@
 */
 
 
-
-#include "dyncall_callback_x64.h"
-#include "dyncall_args_x64.h"
+#include "dyncall_callback.h"
 #include "dyncall_alloc_wx.h"
-
+#include "dyncall_thunk.h"
 
 /* Callback symbol. */
 extern void dcCallback_x64_sysv();
 extern void dcCallback_x64_win64();
 
+struct DCCallback
+{
+  DCThunk  	         thunk;    // offset 0,  size 24
+  DCCallbackHandler* handler;  // offset 24
+  void*              userdata; // offset 32
+};
+
 
 void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
 {
@@ -47,7 +52,8 @@ DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, vo
   int err;
   DCCallback* pcb;
   err = dcAllocWX(sizeof(DCCallback), (void**) &pcb);
-  if (err != 0) return 0;
+  if(err)
+    return NULL;
 
 #if defined (DC__OS_Win64)
   dcbInitThunk(&pcb->thunk, dcCallback_x64_win64); 
@@ -55,6 +61,13 @@ DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, vo
   dcbInitThunk(&pcb->thunk, dcCallback_x64_sysv); 
 #endif
   dcbInitCallback(pcb, signature, handler, userdata);
+
+  err = dcInitExecWX(pcb, sizeof(DCCallback));
+  if(err) {
+    dcFreeWX(pcb, sizeof(DCCallback));
+    return NULL;
+  }
+
   return pcb;
 }
 

data/dyncall/dyncallback/dyncall_callback_x86.S

@@ -6,7 +6,7 @@
  Description: Callback Thunk entry for x86
  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,30 +24,32 @@
 
 
 #include "../portasm/portasm-x86.S"
+#include "../dyncall/dyncall_macros.h"
+
 BEGIN_ASM
-DCThunk_size		= 16
-DCArgs_size		= 20
-DCValue_size		=  8
+DCThunk_size = 16
+DCArgs_size  = 20
+DCValue_size =  8
 
-CTX_thunk		=  0
-CTX_phandler		= 16
-CTX_pargsvt		= 20
-CTX_stack_cleanup	= 24
-CTX_userdata		= 28
+CTX_thunk         =  0
+CTX_phandler      = 16
+CTX_pargsvt       = 20
+CTX_stack_cleanup = 24
+CTX_userdata      = 28
 
-frame_arg0         	=  8
-frame_ret          	=  4
-frame_parent       	=  0
-frame_CTX         	= -4
-frame_DCArgs       	= -24
-frame_DCValue      	= -32
+frame_arg0    =  8
+frame_ret     =  4
+frame_parent  =  0
+frame_CTX     = -4
+frame_DCArgs  = -24
+frame_DCValue = -32
 
-#define ASCII_L	76
-#define ASCII_l	108
-#define ASCII_d	100
-#define ASCII_f	102
-#define ASCII_i	105
-#define ASCII_v	118
+#define ASCII_L 76
+#define ASCII_l 108
+#define ASCII_d 100
+#define ASCII_f 102
+#define ASCII_i 105
+#define ASCII_v 118
 
 GLOBAL(dcCallbackThunkEntry)
 BEGIN_PROC(dcCallbackThunkEntry)
@@ -77,7 +79,7 @@ BEGIN_PROC(dcCallbackThunkEntry)
 	CALL_DWORD(EAX,CTX_phandler)
 	/* cleanup stack */
 	MOVL(EBP,ESP)				/* reset esp to frame */
-	POP(ECX)				/* skip parent frame */	
+	POP(ECX)				/* skip parent frame */
 	POP(ECX)				/* pop return address */
 	MOVL(DWORD(EBP,frame_CTX),EDX)	
 	ADD(DWORD(EDX,CTX_stack_cleanup),ESP)	/* cleanup stack */
@@ -85,13 +87,15 @@ BEGIN_PROC(dcCallbackThunkEntry)
 	LEA(DWORD(EBP,frame_DCValue), EDX)
 	MOVL(DWORD(EBP,0), EBP)			/* EBP = parent frame */
 	/* handle return value */
-	
+
+#if !defined(DC__OS_Minix)
 	CMP(LIT(ASCII_f),AL)
 	JE(LOCAL(return_f32))
 	CMP(LIT(ASCII_d),AL)
 	JE(LOCAL(return_f64))
-	
-	/* All int cases <= 32 bits (+ pointer & string cases) fall in the 32 bits int case*/
+#endif
+
+	/* All int cases (+ pointer & string cases) fall in the return_i64 case, here */
 LOCAL(return_i64):
 	MOVL(DWORD(EDX,0),EAX)
 	MOVL(DWORD(EDX,4),EDX)

data/dyncall/dyncallback/dyncall_callback_x86.c

@@ -6,7 +6,7 @@
  Description: Callback - Implementation for x86
  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,22 +24,27 @@
 */
 
 
-
-#include "dyncall_callback_x86.h"
+#include "dyncall_callback.h"
+#include "dyncall_alloc_wx.h"
+#include "dyncall_thunk.h"
 #include "dyncall_args_x86.h"
 
-#include "dyncall_alloc_wx.h"
-#include "dyncall_signature.h"
+/* Callback symbol. */
+extern void dcCallbackThunkEntry();
 
-/*
- * assembly thunk entry for callbacks
- */
+struct DCCallback
+{
+  DCThunk            thunk;         /* offset 0,  size 16 */
+  DCCallbackHandler* handler;       /* offset 16 */
+  DCArgsVT*          args_vt;       /* offset 20 */
+  size_t             stack_cleanup; /* offset 24 */
+  void*              userdata;      /* offset 28 */
+};
 
-extern void dcCallbackThunkEntry();
 
 /* compute stacksize for callee cleanup calling conventions:
  *
- * stdcall,fastcall_ms,fastcall_gnu
+ * cdecl,stdcall,thiscall_ms,fastcall_ms,fastcall_gnu
  */
 
 static int dcbCleanupSize_x86_cdecl(const char* signature)
@@ -260,10 +265,18 @@ DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, vo
   int err;
   DCCallback* pcb;
   err = dcAllocWX(sizeof(DCCallback), (void**) &pcb);
-  if (err != 0) return 0;
+  if(err)
+    return NULL;
 
   dcbInitThunk(&pcb->thunk, dcCallbackThunkEntry);
   dcbInitCallback(pcb, signature, handler, userdata);
+
+  err = dcInitExecWX(pcb, sizeof(DCCallback));
+  if(err) {
+    dcFreeWX(pcb, sizeof(DCCallback));
+    return NULL;
+  }
+
   return pcb;
 }