rbdc 0.9.0 → 1.0.0

data/dyncall/dyncallback/dyncall_callback_ppc32.c

@@ -6,7 +6,7 @@
  Description: Callback - Implementation Header for ppc32
  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,7 +25,20 @@
 
 
 #include "dyncall_callback.h"
-#include "dyncall_callback_ppc32.h"
+#include "dyncall_alloc_wx.h"
+#include "dyncall_thunk.h"
+
+/* Callback symbol. */
+extern void dcCallbackThunkEntry();
+
+struct DCCallback
+{
+  DCThunk            thunk;         /* offset  0 size 24 */
+  DCCallbackHandler* handler;       /* offset 24 size  4 */
+  size_t             stack_cleanup; /* offset 28 size  4 */
+  void*              userdata;      /* offset 32 size  4 */
+};                                  /*     total size 36 */                                  
+
 
 void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
 {
@@ -36,17 +49,22 @@ void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler*
   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;
 }
 

data/dyncall/dyncallback/dyncall_callback_ppc32_apple.s

@@ -23,99 +23,90 @@
 
 */
 
-	.machine ppc
-	.text
-	.align 2
+.machine ppc
+.text
+.align 2
 
 /* Callback Thunk Entry code for PowerPC 32-bit Darwin/Apple Mac OS X. */
 
 
 /* Stack Frame Layout: 
-	
-       204 DCValue ( )
-	56 DCArgs (32+104+4+8 = 148)
-	24 Parameter area ( 4*8 = 32 )
-	0  Linkage area   ( 24 )
 
+	204 DCValue ()
+	 56 DCArgs (32+104+4+8 = 148)
+	 24 Parameter area (4*8 = 32)
+	  0 Linkage area   (24)
 
 */
 
 /* Constants. */
-INT_REGS	= 8
-FLOAT_REGS	= 13
-SIZEOF_INT      = 4
-SIZEOF_DOUBLE	= 8
+INT_REGS      = 8
+FLOAT_REGS    = 13
+SIZEOF_INT    = 4
+SIZEOF_DOUBLE = 8
+
 
-	
 /* Linkage area. */
-LINK_SP 	= 0
-LINK_CR    	= 4
-LINK_LR    	= 8
-LINK_OFFSET	= 0
-LINK_SIZE	= 24
+LINK_SP     = 0
+LINK_CR     = 4
+LINK_LR     = 8
+LINK_OFFSET = 0
+LINK_SIZE   = 24
 /* Parameter area. */
-PAR_OFFSET	= LINK_SIZE
-PAR_SIZE	= 32
+PAR_OFFSET = LINK_SIZE
+PAR_SIZE   = 32
 /* local struct DCArgs */
-ARGS_OFFSET	= (PAR_OFFSET+PAR_SIZE)
-ARGS_SIZE 	= (SIZEOF_INT*INT_REGS)+(SIZEOF_DOUBLE*FLOAT_REGS) /* = 136 */
+ARGS_OFFSET = (PAR_OFFSET+PAR_SIZE)
+ARGS_SIZE   = (SIZEOF_INT*INT_REGS)+(SIZEOF_DOUBLE*FLOAT_REGS) /* = 136 */
 /* local struct DCValue */
-RESULT_OFFSET	= (ARGS_OFFSET+ARGS_SIZE)
-RESULT_SIZE	= 16
+RESULT_OFFSET = (ARGS_OFFSET+ARGS_SIZE)
+RESULT_SIZE   = 16
 /* additional locals (reg 30/31) */
-LOCALS_OFFSET   = (RESULT_OFFSET+RESULT_SIZE)
-LOCALS_SIZE     = 2*SIZEOF_INT
+LOCALS_OFFSET = (RESULT_OFFSET+RESULT_SIZE)
+LOCALS_SIZE   = 2*SIZEOF_INT
 /* total */
-FRAME_SIZE	= ( (LOCALS_OFFSET+LOCALS_SIZE)+15 & (-16) )
+FRAME_SIZE = ((LOCALS_OFFSET+LOCALS_SIZE)+15 & (-16))
 
 /* struct DCCallback */
-DCB_THUNK 	= 0
-DCB_HANDLER	= 24
-DCB_STACKCLEAN	= 28
-DCB_USERDATA	= 32
+DCB_THUNK      = 0
+DCB_HANDLER    = 24
+DCB_STACKCLEAN = 28
+DCB_USERDATA   = 32
 
 /* struct DCArgs */
-DCA_IARRAY 	= 0
-DCA_FARRAY	= SIZEOF_INT*INT_REGS
-DCA_SP          = DCA_FARRAY + SIZEOF_DOUBLE*FLOAT_REGS
-DCA_ICOUNT	= DCA_SP + 4
-DCA_FCOUNT	= DCA_ICOUNT + 4
-
-/* struct DCValue */
-DCV_INT		= 0
-DCV_FLOAT	= 0 
-DCV_DOUBLE	= 0
-DCV_LONG_HI32	= 0
-DCV_LONG_LO32	= 4
-DCV_SIZE	= 8
-
-iregfile	= ARGS_OFFSET+DCA_IARRAY
-fregfile	= ARGS_OFFSET+DCA_FARRAY
-save_sp		= ARGS_OFFSET+DCA_SP
-icount		= ARGS_OFFSET+DCA_ICOUNT
-fcount		= ARGS_OFFSET+DCA_FCOUNT
-	.globl _dcCallbackThunkEntry
-
-	/* 
-	  Thunk entry:
-	  R2 = DCCallback*
-	*/
+DCA_IARRAY = 0
+DCA_FARRAY = SIZEOF_INT*INT_REGS
+DCA_SP     = DCA_FARRAY + SIZEOF_DOUBLE*FLOAT_REGS
+DCA_ICOUNT = DCA_SP + 4
+DCA_FCOUNT = DCA_ICOUNT + 4
+
+iregfile = ARGS_OFFSET+DCA_IARRAY
+fregfile = ARGS_OFFSET+DCA_FARRAY
+save_sp  = ARGS_OFFSET+DCA_SP
+icount   = ARGS_OFFSET+DCA_ICOUNT
+fcount   = ARGS_OFFSET+DCA_FCOUNT
+
+.globl _dcCallbackThunkEntry
+
+/* 
+  Thunk entry:
+  r2 = DCCallback*
+*/
 _dcCallbackThunkEntry:
 
-	mflr	r0			
-	stw	r0,  8(r1)		/* store return address */
-	/* stmw  r30, -8(r1) */	/* store preserved registers (r30/r31) */
-	addi	r12, r1, PAR_OFFSET	/* temporary r12 = parameter area on callers stack frame */
-	stwu	r1, -FRAME_SIZE(r1)	/* save callers stack pointer and make new stack frame. */
-	stw	r3, iregfile+0*4(r1)	/* spill 8 integer parameter registers */
-	stw	r4, iregfile+1*4(r1)
-	stw	r5, iregfile+2*4(r1)
-	stw     r6, iregfile+3*4(r1)
-	stw     r7, iregfile+4*4(r1)
-	stw     r8, iregfile+5*4(r1)
-	stw     r9, iregfile+6*4(r1)
-	stw     r10,iregfile+7*4(r1)
-	stfd    f1, fregfile+ 0*8(r1)	/* spill 13 float parameter registers */
+	mflr    r0
+	stw     r0, 8(r1)             /* store return address */
+	addi    r12,r1, PAR_OFFSET    /* temporary r12 = parameter area on callers stack frame */
+	stwu    r1, -FRAME_SIZE(r1)   /* save callers stack pointer and make new stack frame. */
+	stw     r3, iregfile+ 0*4(r1) /* spill 8 integer parameter registers */
+	stw     r4, iregfile+ 1*4(r1)
+	stw     r5, iregfile+ 2*4(r1)
+	stw     r6, iregfile+ 3*4(r1)
+	stw     r7, iregfile+ 4*4(r1)
+	stw     r8, iregfile+ 5*4(r1)
+	stw     r9, iregfile+ 6*4(r1)
+	stw     r10,iregfile+ 7*4(r1)
+	stfd    f1, fregfile+ 0*8(r1) /* spill 13 float parameter registers */
 	stfd    f2, fregfile+ 1*8(r1)
 	stfd    f3, fregfile+ 2*8(r1)
 	stfd    f4, fregfile+ 3*8(r1)
@@ -128,54 +119,38 @@ _dcCallbackThunkEntry:
 	stfd    f11,fregfile+10*8(r1)
 	stfd    f12,fregfile+11*8(r1)
 	stfd    f13,fregfile+12*8(r1)
-					/* initialize struct DCCallback */
-	stw	r12,save_sp(r1)		/* init stack pointer */
-	xor	r0, r0, r0		/* init register counters */
-	stw	r0, icount(r1)
-	stw	r0, fcount(r1)
-					/* invoke callback handler */
-	mr	r3, r2			/* arg 1: DCCallback* pcb 	*/
-	addi	r4, r1, ARGS_OFFSET	/* arg 2: DCArgs* args 		*/
-	addi	r5, r1, RESULT_OFFSET	/* arg 3: DCValue* result	*/
-	lwz	r6, DCB_USERDATA(r2)    /* arg 4: void* userdata 	*/
-
-					/* branch-and-link to DCCallback.handler */
-	lwz	r12,  DCB_HANDLER(r2)
-	mtctr	r12
+	/* initialize struct DCCallback */
+	stw     r12,save_sp(r1) /* init stack pointer */
+	xor     r0, r0, r0      /* init register counters */
+	stw     r0, icount(r1)
+	stw     r0, fcount(r1)
+	/* invoke callback handler */
+	mr      r3, r2                  /* arg 1: DCCallback* pcb */
+	addi    r4, r1, ARGS_OFFSET     /* arg 2: DCArgs* args    */
+	addi    r5, r1, RESULT_OFFSET   /* arg 3: DCValue* result */
+	lwz     r6, DCB_USERDATA(r2)    /* arg 4: void* userdata  */
+
+	/* branch-and-link to DCCallback.handler */
+	lwz     r12,DCB_HANDLER(r2)
+	mtctr   r12
 	bctrl
-	addi	r0, r1, RESULT_OFFSET	/* r0 = DCValue* */
-					/* switch on base result type */	
-	cmpi	cr0, r3, 'B
-	beq	.i32
-	cmpi	cr0, r3, 'i
-	beq	.i32 
-	cmpi	cr0, r3, 'l
-	beq	.i64
-	cmpi	cr0, r3, 'f
-	beq	.f32
-	cmpi	cr0, r3, 'd
-	beq	.f64
-	cmpi	cr0, r3, 'p
-	beq	.i32
-.void:				/* ignore result (void call) */
-	b	.end
-.i32:				/* result is integer <= 32-bit result */
-	lwz	r3, RESULT_OFFSET + DCV_INT(r1)	
-	b	.end
-.f32:				/* result is C float result */
-	lfs	f1, RESULT_OFFSET + DCV_FLOAT(r1)
-	b	.end
+	/* switch on base result type */
+	cmpi    cr0, r3, 0x66 /* 'f */
+	beq .f32
+	cmpi    cr0, r3, 0x64 /* 'd */
+	beq .f64
+.i64:
+	lwz     r3, RESULT_OFFSET     (r1)
+	lwz     r4, RESULT_OFFSET + 4 (r1)
+.end:
+	lwz     r1,  0(r1) /* restore stack pointer */
+	lwz     r0,  8(r1) /* load link register with return address */
+	mtlr    r0
+	blr                /* branch back to link register */
+.f32:
+	lfs     f1, RESULT_OFFSET(r1)
+	b .end
 .f64:
-	lfd	f1, RESULT_OFFSET + DCV_FLOAT(r1)
-	b	.end
-.i64:				/* result is C double result */
-	lwz    r3, RESULT_OFFSET + DCV_LONG_HI32(r1)
-	lwz    r4, RESULT_OFFSET + DCV_LONG_LO32(r1)
+	lfd     f1, RESULT_OFFSET(r1)
 	b .end
-.end:
-	lwz    r1,  0(r1)	/* restore stack pointer */
-	/* lmw   r30, -8(r1)	*/  /* restore preserved registers */
-	lwz    r0,  8(r1)	/* load link register with return address */
-	mtlr   r0
-	blr			/* branch back to link register */
 

data/dyncall/dyncallback/dyncall_callback_ppc64.S

@@ -147,9 +147,9 @@ Input:
 	bctrl
 
 	/* check result type */
-	cmpi    cr0, r3, 'f
+	cmpi    cr0, r3, 0x66 /* 'f */
 	beq     .f32
-	cmpi    cr0, r3, 'd
+	cmpi    cr0, r3, 0x64 /* 'd */
 	beq     .f64
 .i64:
 	ld      r3, SP_RESULT(r1)

data/dyncall/dyncallback/dyncall_callback_ppc64.c

@@ -6,7 +6,7 @@
  Description: Callback - Implementation Header for ppc64
  License:
 
-   Copyright (c) 2014-2015 Masanori Mitsugi <mitsugi@linux.vnet.ibm.com>
+   Copyright (c) 2014-2016 Masanori Mitsugi <mitsugi@linux.vnet.ibm.com>
 
    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,20 @@
 
 
 #include "dyncall_callback.h"
-#include "dyncall_callback_ppc64.h"
+#include "dyncall_alloc_wx.h"
+#include "dyncall_thunk.h"
+
+/* Callback symbol. */
+extern void dcCallbackThunkEntry();
+
+struct DCCallback                   /*       ELF v1      |       ELF v2      */
+{                                   /* ------------------+------------------ */
+  DCThunk            thunk;         /* offset  0 size 64 | offset  0 size 48 */
+  DCCallbackHandler* handler;       /* offset 64 size  8 | offset 48 size  8 */
+  size_t             stack_cleanup; /* offset 72 size  8 | offset 56 size  8 */
+  void*              userdata;      /* offset 80 size  8 | offset 64 size  8 */
+};
+
 
 void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
 {
@@ -35,17 +48,22 @@ void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler*
   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;
 }
 

data/dyncall/dyncallback/dyncall_callback_sparc32.c

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncallback
  File: dyncallback/dyncall_callback_sparc32.c
- Description: Callback - Implementation for sparc32 (TODO: not implemented yet)
+ Description: Callback - Implementation for sparc32
  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 24 */
+  DCCallbackHandler* handler;       /* offset 24 size  4 */
+  void*              userdata;      /* offset 28 size  4 */
+};
+
 
 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_sparc32.s

@@ -3,10 +3,10 @@
  Package: dyncall
  Library: dyncallback
  File: dyncallback/dyncall_callback_sparc32.s
- Description: Callback Thunk - Implementation for Sparc 32-bit
+ Description: Callback - Implementation for Sparc 32-bit
  License:
 
-   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>,
+   Copyright (c) 2007-2017 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -23,8 +23,59 @@
 
 */
 
+/* input:
+	$i0    -> thunk
+	$i0+24 -> cb handler
+	$i0+28 -> userdata
+*/
+
+.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 104b comes from needing storage space for the following: */
+	/*   req_reg_save_area:64 + spill:24 + dcargs:4 + retval:8 + pad:4 */
+	/* Spill area could theoretically be only 16b, b/c cbHandler function has */
+ 	/* 4 arguments, but let's be conservative. */ /* cbHandler function might decide to spill (6x4b) @@@ testcode, or rely on 8byte return space in parent stack */
+	save %sp, -104, %sp 
+
+	/* Spill register args as dcargs is based on that (in prev frame, after */
+	/* req_reg_save_area and struct_ret_ptr). */
+	add  %fp, 68, %l0
+	st   %i0, [ %l0 +  0 ]  /* reg arg 0 */
+	st   %i1, [ %l0 +  4 ]  /* reg arg 1 */
+	st   %i2, [ %l0 +  8 ]  /* reg arg 2 */
+	st   %i3, [ %l0 + 12 ]  /* reg arg 3 */
+	st   %i4, [ %l0 + 16 ]  /* reg arg 4 */
+	st   %i5, [ %l0 + 20 ]  /* reg arg 5 */
+	st   %l0, [ %sp + 88 ]  /* init arg_ptr */
+
+	/* Zero retval store. */
+	st   %g0, [ %sp +  96 ]
+	st   %g0, [ %sp + 100 ]
+
+	/* Prepare callback handler call. */
+	mov  %g1, %o0           /* Param 0 = DCCallback*, %g1 holds ptr to thunk */
+	add  %sp, 88, %o1       /* Param 1 = DCArgs* (ptr to struct with args ptr) */
+	add  %sp, 96, %o2       /* Param 2 = results ptr to 8b of local stack data */
+	ld   [ %g1 + 28 ], %o3  /* Param 3 = userdata ptr */
+
+	ld   [ %g1 + 24 ], %l0
+	call %l0
+	nop
+
+	/* Put retval in %i0/%i1 (to be in caller's %o0/%o1), and %f0/%f1. */
+	ld   [ %sp +  96 ], %i0
+	ld   [ %sp + 100 ], %i1
+	ld   [ %sp +  96 ], %f0
+	ld   [ %sp + 100 ], %f1
+
+	/* Epilog. */
+	restore                 /* unshift reg window */
+	retl                    /* Return from proc. -- jmpl %i7 + 8, %g0 */
+	nop