rbdc 1.0.0 → 1.1.0

data/dyncall/dyncall/dyncall_call_mips_n64.S

@@ -0,0 +1,197 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_mips_n64.S
+ Description: mips "n64" abi call kernel implementation in GNU Assembler
+ License:
+
+   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
+   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 */
+	move    $13, $5
+	
+	/* load parameter registers (only ints on hardfloat) */
+
+	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)
+
+#if defined(DC__ABI_HARDFLOAT)
+
+	/* $14 = useDouble flags */
+	ld      $14, 128($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)
+
+#endif /* DC__ABI_HARDFLOAT) */
+
+.fregend:
+
+	/* jump-and-link to register $25 */
+
+	jal     $31, $25
+	nop /* branch-delay slot - no nop according to gcc assembly */
+	    /* output, but let's play safe */
+
+	/* 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_n64.h

@@ -53,8 +53,10 @@ extern "C" {
 struct DCRegData_mips_n64
 {
   DClonglong                       mIntData[8];
+#if defined(DC__ABI_HARDFLOAT)
   union { DCfloat f; DCdouble d; } mFloatData[8];
   DClonglong                       mUseDouble; /* bitmask: lower 8 bits specify to use float or double from union array. */
+#endif /* DC__ABI_HARDFLOAT */
 };
 
 void dcCall_mips_n64(DCpointer target, struct DCRegData_mips_n64* regdata, DCsize stksize, DCpointer stkdata);

data/dyncall/dyncall/{dyncall_call_mips_o32_gas.s → dyncall_call_mips_o32.S}

@@ -2,11 +2,11 @@
 
  Package: dyncall
  Library: dyncall
- File: dyncall/dyncall_call_mips_o32_gas.s
+ File: dyncall/dyncall_call_mips_o32.S
  Description: mips "o32" abi call kernel implementation in GNU Assembler
  License:
 
-   Copyright (c) 2007-2011 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
@@ -23,8 +23,8 @@
 
 */
 	/* $4   target function */
- 	/* $5   register data */
-	/* $6   stack size (min 16-byte aligned to 8-bytes already) */
+	/* $5   register data */
+	/* $6   stack size (guaranteed to be >= 16b and multiple of 8b) */
 	/* $7   stack data */
 
 
@@ -33,22 +33,22 @@
 	.previous
 	.abicalls
 	.text
-	.align	2
-	.globl	dcCall_mips_o32
-	.ent	dcCall_mips_o32
-	.type	dcCall_mips_o32, @function
+	.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
+	.frame  $fp,40,$31      /* vars=8, regs=2/0, args=16, gp=8 */
+	.mask   0xc0000000,-4
+	.fmask  0x00000000,0
+	.set    noreorder
 	
-	addiu	$sp,$sp,-8
-	sw	$31,4($sp)	/* save link register */
-	sw	$fp,0($sp)	/* save frame pointer */
+	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 */
+	move    $fp, $sp        /* frame pointer = sp */
+	sub     $sp, $sp, $6    /* increment stack */
 
 	/* copy stack data */
 
@@ -56,52 +56,54 @@ dcCall_mips_o32:
 	/* $14  destination (stack pointer) */
 	/* $6   byte count */
 
-	move	$12, $7
-	move	$14, $sp
+	move    $12,  $7
+	move    $14,  $sp
 
 .next:
-	beq	$6, $0, .skip
+	beq     $6,  $0, .skip
 	nop
-	lw	$2, 0($12)
+	lw      $2,  0($12)
 	nop
-	sw	$2, 0($14)
-	addiu	$12,$12, 4
-	addiu	$14,$14, 4
-	addiu	$6, $6, -4
-	j	.next
+	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) */
+#if defined(DC__ABI_HARDFLOAT)
+	/* load two double-precision floating-point argument registers ($f12, $f14) - not for softfloat */
 
 	l.d     $f12, 0($5)
 	l.d     $f14, 8($5)
+#endif
 
 	/* prepare call */
 
-	move	$12, $7		/* $12  stack data */
-	move	$25, $4		/* $25  target function */
+	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)
+	lw      $4,  0($12)
+	lw      $5,  4($12)
+	lw      $6,  8($12)
+	lw      $7, 12($12)
 
 	/* call target function */
 
-	jalr	$25
+	jalr    $25
 	nop
-	move	$sp,$fp 	/* restore stack pointer */
+	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 */
+	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	reorder
-	.end	dcCall_mips_o32 
-	.ident 	"handwritten"
+	.set    reorder
+	.end    dcCall_mips_o32 
+	.ident  "handwritten"
 

data/dyncall/dyncall/dyncall_call_mips_o32.h

@@ -37,10 +37,13 @@ extern "C" {
 /* 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.
+  The call-kernel on hardfloat platforms implements loads two doubles, which
+  involves four 32-bit floating pointer registers. It's unused for softfloat
+  platforms.
+
   Float arguments map as following:
   
     float argument 0 is at u[0][0] for little, u[0][1] for big endian and
@@ -49,12 +52,14 @@ extern "C" {
 
 */
 
-typedef struct DCRegData_mips_o32_
+typedef struct
 {
+#if defined(DC__ABI_HARDFLOAT)
   union {
     double d;
     float  f[2];
   } u[2];
+#endif /* DC__ABI_HARDFLOAT */
 } DCRegData_mips_o32;
 
 

data/dyncall/dyncall/dyncall_call_ppc32.S

@@ -268,6 +268,7 @@ ENTRY_C(dcCall_ppc32_sysv)
 
 	.align 2
 
+/* @@@ Bus Error on Darwin */
 GLOBAL_C(dcCall_ppc32_syscall)
 ENTRY_C(dcCall_ppc32_syscall)
 	mflr r0			/* r0 = return address */
@@ -282,10 +283,11 @@ ENTRY_C(dcCall_ppc32_syscall)
 	lwz  r5 , 8(r11)
 	lwz  r6 ,12(r11)
 	lwz  r7 ,16(r11)
+	/* @@@ missing r8,r9,10 on some platforms? */
 	sc
 
 	lwz  r1, 0(r1)		/* restore stack */
 	lwz  r0, 4(r1)		/* r0 = return address */
 	mtlr r0			/* setup link register */
 	blr
-	
+

data/dyncall/dyncall/dyncall_call_ppc32.h

@@ -47,13 +47,14 @@ struct DCRegData_ppc32_
 */
 
 /* Darwin ABI */
-
 void     dcCall_ppc32_darwin (DCpointer target, struct DCRegData_ppc32_* ppc32data, DCsize stksize, DCpointer stkdata);
 
-/* System V (Linux) ABI */
-
+/* System V ABI */
 void     dcCall_ppc32_sysv (DCpointer target, struct DCRegData_ppc32_* ppc32data, DCsize stksize, DCpointer stkdata);
 
+/* syscall @@@ Bus Error on Darwin */
+void     dcCall_ppc32_syscall (DCpointer target, struct DCRegData_ppc32_* ppc32data, DCsize stksize, DCpointer stkdata);
+
 #ifdef __cplusplus
 }
 #endif

data/dyncall/dyncall/dyncall_call_ppc64.S

@@ -197,7 +197,7 @@ ENTRY_C(dcCall_ppc64_syscall)
 	ld  r5 ,16(r11)
 	ld  r6 ,24(r11)
 	ld  r7 ,32(r11)
-	
+	/* @@@ missing r8,r9,10 on some platforms? */
 	sc                    /* system call */
 
 	/* epilog */

data/dyncall/dyncall/dyncall_call_ppc64.h

@@ -47,6 +47,9 @@ struct DCRegData_ppc64_
 
 void     dcCall_ppc64(DCpointer target, struct DCRegData_ppc64_* ppc64data, DCsize stksize, DCpointer stkdata);
 
+/* syscall */
+void     dcCall_ppc64_syscall(DCpointer target, struct DCRegData_ppc64_* ppc64data, DCsize stksize, DCpointer stkdata);
+
 #ifdef __cplusplus
 }
 #endif

data/dyncall/dyncall/dyncall_call_x64.S

@@ -6,7 +6,7 @@
  Description: All x64 abi call kernel implementation
  License:
 
-   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>,
+   Copyright (c) 2007-2020 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -60,7 +60,7 @@ BEGIN_PROC(dcCall_x64_sysv)
 
 	ADD(LIT(31),RDI)		/* Align stack to 32-byte. */
 	AND(LIT(-32),RDI)
-	ADD(LIT(8),RDI)		/* Adjust by 8-byte for the return-address. */
+	ADD(LIT(8),RDI)			/* Adjust by 8-byte for the return-address. */
 	SUB(RDI,RSP)			/* Setup stack frame by subtracting the size of arguments. */
 
 	MOV(RDI,RCX)			/* Store number of bytes to copy to stack in RCX (for rep movsb). */
@@ -143,5 +143,30 @@ BEGIN_PROC(dcCall_x64_win64)
 
 END_PROC(dcCall_x64_win64)
 
+/*---------------------------------------------------------------------------
+
+  Call Kernel for x64 System V syscalls
+
+  Input:
+    RDI : pointer to arguments
+    RSI : syscall id
+
+*/
+	
+GLOBAL(dcCall_x64_syscall_sysv)
+BEGIN_PROC(dcCall_x64_syscall_sysv)
+
+	MOV(RSI,RAX)			/* load system call id. */
+	MOV(QWORD(RDI,40),R9)		/* copy first six int/pointer arguments to RDI, RSI, RDX, R10, R8, R9. */
+	MOV(QWORD(RDI,32),R8)
+	MOV(QWORD(RDI,24),R10)
+	MOV(QWORD(RDI,16),RDX)
+	MOV(QWORD(RDI,8),RSI)
+	MOV(QWORD(RDI,0),RDI)		/* Set RDI last to not overwrite it to soon. */
+	SYSCALL
+	RET()
+
+END_PROC(dcCall_x64_syscall_sysv)
+
 END_ASM