rbdc 0.8.0

data/dyncall/dyncall/dyncall_call_mips_n64.h

@@ -0,0 +1,67 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_mips_n64.h
+ Description: mips "n64" ABI call-kernel C interface.
+ 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.
+
+*/
+
+
+#ifndef DYNCALL_CALL_MIPS_N64_H
+#define DYNCALL_CALL_MIPS_N64_H
+
+#include "dyncall_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+  two register-files for integer (promoted to 64-bit) and float (not promoted!)
+  are used.
+
+  arguments are transfered in a free slot on the corresponding register file.
+  the other register-file will be skipped by one.
+
+  float arguments are either loaded from single or double -
+  a auto-conversion into double and then loaded as double precision
+  turned out to fail for several tests.
+
+  therefore a union for storage of float or double is used instead.
+  a bitmask (mUseDouble) records which type is used and will be
+  interpreted in the call-kernel.
+*/
+
+struct DCRegData_mips_n64
+{
+  DClonglong   mIntData[8];
+  union { DCfloat f; DCdouble d; } mFloatData[8];
+  DClonglong   mUseDouble; /* bitmask: lower 8 bits specifies to use float or double from union array. */
+};
+
+void dcCall_mips_n64(DCpointer target, struct DCRegData_mips_n64* regdata, DCsize stksize, DCpointer stkdata);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DYNCALL_CALL_MIPS_N64_H */
+

data/dyncall/dyncall/dyncall_call_mips_n64_gas.s

@@ -0,0 +1,192 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_mips_n64_gas.s
+ Description: mips "n64" abi call kernel implementation in GNU Assembler
+ 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.
+
+*/
+
+	.section .mdebug.abi64
+	.previous
+	.abicalls
+	.text
+	.align	2
+	.globl	dcCall_mips_n64
+	.ent	dcCall_mips_n64
+dcCall_mips_n64:
+
+	/* Stack-frame prolog */
+
+	# .frame	$fp,64,$31		/* vars=16, regs=3/0, args=0, extra=16 */
+	# .mask	0xd0000000,-8
+	# .fmask	0x00000000,0
+	dsubu	$sp,$sp,64
+	sd	$31,48($sp)	/* save return address register (ra) */
+	sd	$30,40($sp)	/* save frame pointer register (fp) */
+	sd	$28,32($sp)	/* save global pointer register (gp) */
+	move	$fp,$sp
+
+
+	/* arguments: */
+		
+	/* $4 target function */
+ 	/* $5 register data */
+	/* $6 stack size */
+	/* $7 stack data */
+	
+
+	/* allocate argument stack space */
+
+	dsubu	$sp, $sp, $6
+	
+	/* copy stack data */
+
+	/* n64 abi call assumptions:
+           - stack data is 16-byte aligned.
+           - no extra-storage for arguments passed via registers.
+        */
+
+	/* $12  source pointer (parameter stack data) */
+	/* $14  destination (stack pointer) */
+	/* $6   byte count */
+
+	move	$12, $7
+	move	$14, $sp
+
+.next:
+	beq	$6, $0, .skip
+	# nop
+	daddiu	$6, $6, -8
+	ld	$2, 0($12)
+	sd	$2, 0($14)
+	daddiu	$12,$12, 8
+	daddiu	$14,$14, 8
+	b	.next
+.skip:
+	move	$25, $4
+
+	/* load registers */
+
+	/* locals: */
+	/* $13 = register data */
+	/* $14 = useDouble flags */
+	move	$13, $5
+	ld	$14, 128($13)
+	
+	/* load integer parameter registers */
+
+	ld	$4 , 0($13)
+	ld	$5 , 8($13)
+	ld	$6 ,16($13)
+	ld	$7 ,24($13)
+	ld	$8 ,32($13)
+	ld	$9 ,40($13)
+	ld	$10,48($13)
+	ld	$11,56($13)
+
+	/* load float-or-double floating pointer parameter registers 
+           a 64-bit bitmask given at byte offset 128 of regdata indicates
+           if loading a float (bit cleared) or double (bit set), starting
+           at bit position 0 in bitmask.
+        */
+.t0:
+	and     $15, $14, 1
+	bgtz	$15, .d0
+.f0:
+	l.s	$f12, 64($13)
+	j	.t1
+.d0:
+	l.d	$f12, 64($13)
+
+.t1:
+	and	$15, $14, 2
+	bgtz	$15, .d1
+.f1:
+	l.s	$f13, 72($13)
+	j	.t2
+.d1:
+	l.d	$f13, 72($13)
+.t2:	
+	and	$15, $14, 4
+	bgtz	$15, .d2
+.f2:
+	l.s	$f14, 80($13)
+	j	.t3
+.d2:	
+	l.d	$f14, 80($13)
+.t3:
+	and	$15, $14, 8
+	bgtz	$15, .d3
+.f3:
+	l.s	$f15, 88($13)
+	j	.t4
+.d3:
+	l.d	$f15, 88($13)
+.t4:
+	and	$15, $14, 16
+	bgtz	$15, .d4
+.f4:
+	l.s	$f16, 96($13)
+	j	.t5
+.d4:
+	l.d	$f16, 96($13)
+.t5:
+	and	$15, $14, 32
+	bgtz	$15, .d5
+.f5:
+	l.s	$f17,104($13)
+	j	.t6
+.d5:
+	l.d	$f17,104($13)
+.t6:
+	and	$15, $14, 64
+	bgtz	$15, .d6
+.f6:
+	l.s	$f18,112($13)
+	j	.t7
+.d6:
+	l.d	$f18,112($13)
+.t7:
+	and	$15, $14, 128
+	bgtz	$15, .d7
+.f7:
+	l.s	$f19,120($13)
+	j	.fregend
+.d7:
+	l.d	$f19,120($13)
+
+.fregend:
+
+	/* jump-and-link to register $25 */
+
+	jal	$31, $25
+
+	/* no nop according to gcc assembly output */	
+
+	/* Stack-frame epilog */	
+	move	$sp,$fp 
+	ld	$ra,48($sp)	/* restore ra register */
+	ld	$fp,40($sp)	/* restore fp register */
+	ld	$gp,32($sp)	/* restore gp register */
+	daddu	$sp,$sp,64
+	j	$ra
+	.end	dcCall_mips_n64
+	.size	dcCall_mips_n64, .-dcCall_mips_n64
+

data/dyncall/dyncall/dyncall_call_mips_o32.h

@@ -0,0 +1,70 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_mips_o32.h
+ Description: mips "o32" abi call kernel C interface.
+ 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.
+
+*/
+
+
+#ifndef DYNCALL_CALL_MIPS_O32_H
+#define DYNCALL_CALL_MIPS_O32_H
+
+#include "dyncall_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Call-kernel register data:
+
+  Details:
+  The structure holds the argument data for transfering float/double arguments
+  via registers as well.
+  The call-kernel implements loads two doubles, which involves four
+  32-bit floating pointer registers.
+  Float arguments map as following:
+  
+    float argument 0 is at floats[1] and
+    float argument 1 is at floats[3] of DCRegData_mips_o32 union.
+
+*/
+
+typedef struct DCRegData_mips_o32_
+{
+  union {
+    double d;
+    float  f[2];
+  } u[2];
+} DCRegData_mips_o32;
+
+
+/* Call kernel. */
+
+void dcCall_mips_o32(DCpointer target, DCRegData_mips_o32* regdata, DCsize stksize, DCpointer stkdata);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DYNCALL_CALL_MIPS_O32_H */
+

data/dyncall/dyncall/dyncall_call_mips_o32_gas.s

@@ -0,0 +1,109 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_mips_o32_gas.s
+ Description: mips "o32" abi call kernel implementation in GNU Assembler
+ 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.
+
+*/
+	/* $4   target function */
+ 	/* $5   register data */
+	/* $6   stack size (min 16-byte aligned to 8-bytes already) */
+	/* $7   stack data */
+
+
+
+	.section .mdebug.abi32
+	.previous
+	.abicalls
+	.text
+	.align	2
+	.globl	dcCall_mips_o32
+	.ent	dcCall_mips_o32
+	.type	dcCall_mips_o32, @function
+dcCall_mips_o32:
+	.frame	$fp,40,$31		/* vars=8, regs=2/0, args=16, gp=8 */
+	.mask	0xc0000000,-4
+	.fmask	0x00000000,0
+	.set	noreorder
+	.set	nomacro
+	
+	addiu	$sp,$sp,-8
+	sw	$31,4($sp)	/* save link register */
+	sw	$fp,0($sp)	/* save frame pointer */
+	nop
+	move	$fp,$sp		/* frame pointer = sp */
+	sub	$sp, $sp, $6	/* increment stack */
+
+	/* copy stack data */
+
+	/* $12  source pointer (parameter stack data) */
+	/* $14  destination (stack pointer) */
+	/* $6   byte count */
+
+	move	$12, $7
+	move	$14, $sp
+
+.next:
+	beq	$6, $0, .skip
+	nop
+	lw	$2, 0($12)
+	nop
+	sw	$2, 0($14)
+	addiu	$12,$12, 4
+	addiu	$14,$14, 4
+	addiu	$6, $6, -4
+	j	.next
+	nop
+.skip:
+
+	/* load two double-precision floating-point argument registers ($f12, $f14) */
+
+	l.d     $f12, 0($5)
+	l.d     $f14, 8($5)
+	/* prepare call */
+
+
+	move	$12, $7		/* $12  stack data */
+	move	$25, $4		/* $25  target function */
+
+	/* load first four integer arguments ($4-$7) */
+
+	lw	$4, 0($12)
+	lw	$5, 4($12)
+	lw	$6, 8($12)
+	lw	$7,12($12)
+
+	/* call target function */
+
+	jalr	$25
+	nop
+	move	$sp,$fp 	/* restore stack pointer */
+	nop
+	lw	$31,4($sp)	/* restore return address */
+	lw	$fp,0($sp)	/* restore frame pointer */
+	addiu	$sp,$sp,8	/* end stack frame */
+	j	$31		/* return */
+	nop
+
+	.set	macro
+	.set	reorder
+	.end	dcCall_mips_o32 
+	.ident 	"handwritten"
+

data/dyncall/dyncall/dyncall_call_ppc32.S

@@ -0,0 +1,266 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_ppc32.S
+ Description: Call Kernel for PowerPC 32-bit Architecture
+ 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.
+
+*/
+
+
+#include "../portasm/portasm-ppc.S"
+
+/*
+  Call Kernel Implementations for PowerPC.
+  Supported Calling Conventions: sysv, darwin
+
+*/
+
+	.machine ppc
+	.text
+
+/* ============================================================================
+   DynCall Call Kernels for PPC32 Architecture
+   -------------------------------------------------------------------------
+   C Interface:
+     struct DCRegData { int i[8]; double d[13]; };
+     dcCall_ppc32_XXX(DCpointer target, struct DCRegData* pRegData, DCsize stacksize, DCptr stackdata);
+   
+   Where XXX is one of the following Calling Conventions:
+	darwin, sysv
+  
+  ChangeLog:
+  2011-04-03: Using portasm.
+  2009-01-09: Added Support for System V ABI.
+  2007-11-28: Initial Support for Darwin.
+
+*/
+
+/*---------------------------------------------------------------------------
+  
+  Call Kernel for ppc32 Darwin
+
+  Input:	
+    r3 : target address ptr 
+    r4 : register data ptr (8 x GPR 32 bytes, 13 x FPR 64 bytes)
+    r5 : stack data size  
+    r6 : stack data ptr
+
+  Details:
+  - Stack frames are always aligned on 16 byte
+  - The GPR3 .. GPR10 are loaded
+  - The FPR1 .. FPR13 are loaded
+  - No support for Vector Parameters so far. 
+  - Parameter Area (min. 32 Bytes)
+  - Linkage Area (24 Bytes)
+*/
+
+	.align 2
+GLOBAL_C(dcCall_ppc32_darwin)
+ENTRY_C(dcCall_ppc32_darwin)
+
+
+	mflr r0			/* r0 = return address */
+	stw  r0,8(r1)		/* store return address in caller link-area */
+
+	/* compute aligned stack-size */
+
+	/* add link area and align to 16 byte border */
+
+	addi r0,r5,24+15	/* r0 = stacksize + link area */
+                                
+	rlwinm r0,r0,0,0,27	/* r0 = r0 and -15 */
+				/* r0 = r0 and -15 */
+	neg r2,r0		/* r2 = -stacksize */
+
+	stwux r1,r1,r2		/* r1 = r1 - stacksize */
+
+	/* copy stack data */
+
+	subi r6,r6,4		/* r6 = 4 bytes before source stack ptr */
+	addi r7,r1,20		/* r7 = 4 bytes before target stack parameter-block */
+
+	srwi r5,r5,2		/* r5 = size in words */
+
+	cmpi cr0,r5,0		/* if stacksize != 0 .. */
+	beq  cr0,.osx_done
+
+	mtctr r5		/* copy loop */
+
+.osx_next:	
+	lwzu r0, 4(r6)		
+	stwu r0, 4(r7)
+	bdnz .osx_next
+
+.osx_done:
+
+	mr    r12, r3		/* r12 = target function */
+	mtctr r12		/* control register = target function */
+	mr     r2, r4		/* r2 = reg data */
+
+        /* load 8 integer registers */
+
+	lwz  r3 , 0(r2)
+	lwz  r4 , 4(r2)
+	lwz  r5 , 8(r2)
+	lwz  r6 ,12(r2)
+	lwz  r7 ,16(r2)
+	lwz  r8 ,20(r2)
+	lwz  r9 ,24(r2)
+	lwz  r10,28(r2)
+
+	/* load 13 float registers */
+
+	lfd  f1 ,32(r2)
+	lfd  f2 ,40(r2)
+	lfd  f3 ,48(r2)
+	lfd  f4 ,56(r2)
+	lfd  f5 ,64(r2)
+	lfd  f6 ,72(r2)
+	lfd  f7 ,80(r2)
+	lfd  f8 ,88(r2)
+	lfd  f9 ,96(r2)
+	lfd  f10,104(r2)
+	lfd  f11,112(r2)
+	lfd  f12,120(r2)
+	lfd  f13,128(r2)
+
+	/* branch */
+
+	bctrl
+
+	/* epilog */
+
+	lwz  r1, 0(r1)		/* restore stack */
+	lwz  r0, 8(r1)		/* r0 = return address */
+	mtlr r0			/* setup link register */
+	blr			/* return */
+
+/* ----------------------------------------------------------------------------
+
+  Call Kernel for ppc32 System 
+
+  Input:	
+    r3 : target address ptr 
+    r4 : register data ptr (8 x GPR 32 bytes, 8 x FPR 64 bytes)
+    r5 : stack data size  
+    r6 : stack data ptr
+
+  Details:
+   - Stack frames are always aligned on 16 byte
+   - Reserve GPR2 (System register)  
+   - The GPR3 .. GPR10 are loaded
+   - The FPR1 .. FPR8 are loaded
+   - No support for Vector Parameters so far. 
+
+   Frame structure:
+
+     on entry, parent frame layout:
+
+     offset
+     4:      LR save word (Callee stores LR in parent frame)
+     0:      parent stack frame (back-chain)
+
+     after frame initialization:
+
+    	stack size = ( (8+15) + stacksize ) & -(16)
+
+     ...     locals and register spills
+     8:      parameter list area
+     4:      LR save word (Callee stores LR in parent frame)
+     0:      parent stack frame (back-chain)
+*/
+
+	.align 2
+GLOBAL_C(dcCall_ppc32_sysv)
+ENTRY_C(dcCall_ppc32_sysv)
+	mflr r0			/* r0 = return address */
+	stw  r0,4(r1)		/* store r0 to link-area */
+
+	/* compute aligned stack-size */
+	
+	/* add link area (+8) and align to 16 byte (+15) */
+	
+	/* r0 = stacksize + frame parameter(back-chain link, this callee's call return address) */
+	addi r0,r5,8+15		/* r0 = r5 + 8 + 15 */
+	rlwinm r0,r0,0,0,27  	/* r0 = r0 and -15 */
+	neg r0,r0 		/* r0 = -r0 */
+	stwux r1,r1,r0 		/* store r1 and decrement */
+
+	/* copy stack data */
+
+	subi r6,r6,4		/* r6 = 4 bytes before source stack ptr */
+	                      
+			        /* 4 bytes before target stack parameter-block */
+	addi r7,r1,4		/* r7 = r1 + 8 offset - 4 displacement */
+
+	srwi r5,r5,2		/* r5 = size in words */
+
+	cmpi cr0,r5,0		/* if stacksize != 0 .. */
+	beq  cr0,.sysv_done
+
+	mtctr r5		/* copy loop */
+
+.sysv_next:	
+	lwzu r0, 4(r6)		
+	stwu r0, 4(r7)
+	bdnz .sysv_next
+
+.sysv_done:
+
+	/* this call support using ctr branch register */
+
+	mr    r12, r3		/* r12 = target function */
+	mtctr r12		/* control register = r12 */
+	mr    r11, r4		/* r11 = reg data */
+
+	/* load 8 integer registers */
+	
+	lwz  r3 , 0(r11)
+	lwz  r4 , 4(r11)
+	lwz  r5 , 8(r11)
+	lwz  r6 ,12(r11)
+	lwz  r7 ,16(r11)
+	lwz  r8 ,20(r11)
+	lwz  r9 ,24(r11)
+	lwz  r10,28(r11)
+
+	/* load 8 float registers */
+	
+	lfd  f1 ,32(r11)
+	lfd  f2 ,40(r11)
+	lfd  f3 ,48(r11)
+	lfd  f4 ,56(r11)
+	lfd  f5 ,64(r11)
+	lfd  f6 ,72(r11)
+	lfd  f7 ,80(r11)
+	lfd  f8 ,88(r11)
+	
+	creqv 6,6,6		/* used for ellipsis calls */
+	
+	bctrl 			/* branch with this call support */
+
+	/* epilog */
+
+	lwz  r1, 0(r1)		/* restore stack */
+	lwz  r0, 4(r1)		/* r0 = return address */
+	mtlr r0			/* setup link register */
+	blr			/* return */
+
+