rbdc 0.9.0 → 1.0.0

data/dyncall/dyncall/dyncall_call_sparc64.h

@@ -6,7 +6,7 @@
  Description: 
  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,8 +24,8 @@
 
 
 
-#ifndef DYNCALL_CALL_SPARC64_H
-#define DYNCALL_CALL_SPARC64_H
+#ifndef DYNCALL_CALL_SPARC_V9_H
+#define DYNCALL_CALL_SPARC_V9_H
 
 #include "dyncall_types.h"
 
@@ -33,11 +33,11 @@
 extern "C" {
 #endif
 
-void dcCall_sparc64 (DCpointer target, DCsize size, DCpointer data);
+void dcCall_v9 (DCCallVM* vm, DCpointer target);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* DYNCALL_CALL_SPARC64_H */
+#endif /* DYNCALL_CALL_SPARC_v9_H */
 

data/dyncall/dyncall/dyncall_call_sparc64.s

@@ -0,0 +1,177 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_sparc64.S
+ Description: Call kernel for sparc64 (v9) ABI.
+ License:
+
+   Copyright (c) 2011-2015 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
+   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.
+
+*/
+
+
+/* NOTE: %sp/%fp for v9 are offset, using them needs a "BIAS" of 2047 */
+BIAS = 2047
+
+.text
+.global dcCall_v9
+	/* dcCall_sparc64( DCCallVM* , void * target ) */ 
+        /*                 o0          o1              */
+dcCall_v9:
+	or      %o0, %g0, %o3  /* o3: callvm   */
+	or      %o1, %g0, %o0  /* o0: target   */
+	ldx     [%o3+24], %o1  /* o1: mVecSize */
+	add     %o3, 32,  %o2  /* o2: stack    */
+	/* Compute a matching stack size (approximate): o3 = align(o1+136,16) */
+
+	add     %o1, (16+1+6)*8+15, %o3
+	and     %o3, -16, %o3
+	neg     %o3            /* o3: -stacksize */
+	save    %sp, %o3, %sp
+
+	ldd     [%i2+8*0 ], %f0  /* Load double-precision float registers. */
+	ldd     [%i2+8*1 ], %f2
+	ldd     [%i2+8*2 ], %f4
+	ldd     [%i2+8*3 ], %f6
+	ldd     [%i2+8*4 ], %f8
+	ldd     [%i2+8*5 ], %f10
+	ldd     [%i2+8*6 ], %f12
+	ldd     [%i2+8*7 ], %f14
+	ldd     [%i2+8*8 ], %f16
+	ldd     [%i2+8*9 ], %f18
+	ldd     [%i2+8*10], %f20
+	ldd     [%i2+8*11], %f22
+	ldd     [%i2+8*12], %f24
+	ldd     [%i2+8*13], %f26
+	ldd     [%i2+8*14], %f28
+	ldd     [%i2+8*15], %f30
+	ldx     [%i2+8*0 ], %o0  /* Load output registers. */
+	ldx     [%i2+8*1 ], %o1
+	ldx     [%i2+8*2 ], %o2
+	ldx     [%i2+8*3 ], %o3
+	ldx     [%i2+8*4 ], %o4
+	ldx     [%i2+8*5 ], %o5
+	sub     %i1, 48, %i1
+	cmp     %i1, 0
+	ble     .do_call
+	nop
+	/* Copy loop: */
+	add     %i2, 48, %i2   /* skip homing area */
+	or      %g0, %g0, %l0  /* l0 = offset initialized to 0. */
+	add     %sp, BIAS+((16+6)*8), %l2  /* l2 = argument area on stack space (7th word). (64+4+6*4 = byte offset 92). */
+.next:
+	ldx     [%i2+%l0],%l1   /* Read from arg buffer(%i2) to %l1. */
+	stx     %l1, [%l2+%l0]  /* Write %l1 to stack space(%l2). */
+	add     %l0, 8, %l0     /* Increment offset. */
+	sub     %i1, 8, %i1     /* Decrement copy size. */
+	cmp     %i1, 0
+	bgt     .next
+	nop
+.do_call:
+	call    %i0  /* Call target. */
+	nop
+	or      %o0, %g0, %i0   /* pass out retval (mov o0 -> i0) */
+	jmpl    %i7 + 8, %g0    /* optimized restore;retl;nop */
+	restore
+
+/* 
+@@@ complete manual with this, and remove from here once done
+
+Changes from v8:
+- fundamental data types
+	- (un)signed int: 8,16,32,64
+	- float: 32,64,128
+- float: IEEE 754 compilant
+	32 32-bit  float registers f0,f1,..,f31
+	32 64-bit  float registers f0,f2,..,f62
+	16 128-bit float registers f0,f4,..,f60
+
+Description:
+We need to raise up a dynamic stack frame.
+Therefore we need to compute the stack size. We do this first, 
+in the context of the caller as a leaf function (using o3 as scratch for addition).
+Then we raise the frame, ending up in o0-o3 is then i0-i3.
+
+
+Stack Layout:
+   BIAS = 2047
+
+   BIAS+XX: should be 16 byte aligned.
+                 ...
+       136: argument overflow area
+       128:  1 extended word  for struct/union poiner return value
+   BIAS+ 0: 16 extended words for registers (in/local) save area [register window]
+
+
+Function Argument Passing:
+- integer %o0..%o5 (caller view).
+- floating-point %f0 .. %f31
+- continuous memory starting at %sp+BIAS+136 (caller view).
+
+Register Usage:
+%fp0..%fp31  : floating-point arguments.
+%sp  or  %o6 : stack pointer, always 8 (or 16?)-byte aligned.
+%fp  or  %i6 : frame pointer.
+%i0  and %o0 : integer and pointer return values.
+%i7  and %o7 : return address. (caller puts return address to %o7, callee uses %i7)
+%fp0 and %fp1: return value (float).
+%i0..%i5     : input argument registers 
+%o0..%o5     : output argument registers
+%g0          : always zero, writes to it have no effect.
+
+Register Mappings:
+r0-7    -> globals
+r8-15   -> outs
+r16-r23 -> locals
+r24-r31 -> ins
+
+Integer Register Overview Table:
+ID   Class   Name   Description
+------------------------------------------------------------------------------
+0   globals   g0    always zero, writes to it have no effect
+1             g1
+2             g2
+3             g3
+4             g4
+5             g5
+6             g6
+7             g7
+8   out       o0    [int/ptr] arg 0 and return
+9             o1              arg 1
+10            o2              arg 2
+11            o3              arg 3
+12            o4              arg 4
+13            o5              arg 5
+14            o6    stack pointer
+15            o7
+16  local     l0    scratch
+17            l1
+18            l2
+19            l3
+20            l4
+21            l5
+22            l6
+23            l7
+24  in        i0    [int/pt] arg 0 and return
+25            i1
+26            i2
+27            i3
+28            i4
+29            i5
+30            i6    frame pointer
+31            i7
+*/
+

data/dyncall/dyncall/dyncall_call_x64.S

@@ -6,7 +6,7 @@
  Description: All x64 abi call kernel implementation
  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
@@ -30,72 +30,68 @@
 BEGIN_ASM
 
 /*---------------------------------------------------------------------------
-  
+
   Call Kernel for x64 System V
-  
-  Input:
-    RDI : size of arguments to be passed via stack 
-    RSI : pointer to arguments to be passed via the stack 
-    RDX : pointer to arguments of integral/pointer type to be passed via registers 
-    RCX : pointer to arguments of floating point type to be passed via registers 
-    R8  : target function pointer 
 
+  Input:
+    RDI : size of arguments to be passed via stack
+    RSI : pointer to arguments to be passed via the stack
+    RDX : pointer to arguments of integral/pointer type to be passed via registers
+    RCX : pointer to arguments of floating point type to be passed via registers
+    R8  : target function pointer
+  Notes:
+    RSP+8: is always 16-byte aligned (32-byte align if __m256 is used)
 */
 
 GLOBAL(dcCall_x64_sysv)
 BEGIN_PROC(dcCall_x64_sysv)
-
-	push	RBP			/* Pseudo-prolog - preserve RBP. */
-	push	RBX			/* Preserve RBX and store pointer to function in it. */
-
-	mov	RBP, RSP		/* Store stack pointer in RBP.   */
-
-	mov	RBX, R8
-
-	movsd	XMM0, qword ptr[RCX   ]	/* Copy first 8 floats to XMM0-XMM7 (this makes RCX free to use). */
-	movsd	XMM1, qword ptr[RCX+ 8]
-	movsd	XMM2, qword ptr[RCX+16]
-	movsd	XMM3, qword ptr[RCX+24]
-	movsd	XMM4, qword ptr[RCX+32]
-	movsd	XMM5, qword ptr[RCX+40]
-	movsd	XMM6, qword ptr[RCX+48]
-	movsd	XMM7, qword ptr[RCX+56]
-
-	sub	RSP, RDI		/* Setup stack frame by subtracting the size of the arguments. */
-
-	and     RSP, -32		/* Align stack to 32-byte border. */
-
-	mov	RCX, RDI		/* Store number of bytes to copy to stack in RCX (for rep movsb). */
-	mov	RDI, RSP		/* Store pointer to beginning of stack arguments in RDI (for rep movsb). */
-
-	rep movsb			/* @@@ should be optimized (e.g. movq) */
-
-	mov	RDI, qword ptr[RDX   ]	/* Copy first six int/pointer arguments to RDI, RSI, RDX, RCX, R8, R9. */
-	mov	RSI, qword ptr[RDX+ 8]
-	mov	RCX, qword ptr[RDX+24]
-	mov	R8,  qword ptr[RDX+32]
-	mov	R9,  qword ptr[RDX+40]
-	mov	RDX, qword ptr[RDX+16]	/* Set RDX last to not overwrite it to soon. */
-
-	mov	AL, 8						/* Put upper bound of number of used xmm registers in AL. */
-	call	RBX						/* Invoke function. */
-
-	mov	RSP, RBP					/* Restore stack pointer (such that we can pop the preserved vALues). */
-
-	pop	RBX						/* Restore RBX. */
-	pop	RBP						/* Pseudo-epilog. */
-
-	ret
+	PUSH(RBP)			/* Pseudo-prolog - preserve RBP. */
+	PUSH(RBX)			/* Preserve RBX and store pointer to function in it. */
+	MOV(RSP,RBP)			/* Store stack pointer in RBP. */
+	MOV(R8 ,RBX)
+	MOVSD(QWORD(RCX,0) ,XMM0)	/* Copy first 8 floats to XMM0-XMM7. */
+	MOVSD(QWORD(RCX,8) ,XMM1)
+	MOVSD(QWORD(RCX,16),XMM2)
+	MOVSD(QWORD(RCX,24),XMM3)
+	MOVSD(QWORD(RCX,32),XMM4)
+	MOVSD(QWORD(RCX,40),XMM5)
+	MOVSD(QWORD(RCX,48),XMM6)
+	MOVSD(QWORD(RCX,56),XMM7)
+
+	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. */
+	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). */
+	MOV(RSP,RDI)			/* Store pointer to beginning of stack arguments in RDI (for rep movsb). */
+
+	REP(MOVSB)			/* copy bytes (@@@ should be optimized, movq?). */
+
+	MOV(QWORD(RDX,0),RDI)		/* copy first six int/pointer arguments to RDI, RSI, RDX, RCX, R8, R9. */
+	MOV(QWORD(RDX,8),RSI)
+	MOV(QWORD(RDX,24),RCX)
+	MOV(QWORD(RDX,32),R8)
+	MOV(QWORD(RDX,40),R9)
+	MOV(QWORD(RDX,16),RDX)		/* Set RDX last to not overwrite it to soon. */
+
+	MOVB(LIT(8),AL)			/* Put upper bound of number of used xmm registers in AL. */
+	CALL_REG(RBX)			/* Call function. */
+
+	MOV(RBP,RSP)			/* Restore stack pointer. */
+	POP(RBX)			/* Restore RBX. */
+	POP(RBP)			/* Pseudo-epilog. */
+	RET()
 END_PROC(dcCall_x64_sysv)
 
 /*---------------------------------------------------------------------------
 
   Call Kernel for x64 Win64
-	
+
   Input:
-    RCX : size of arguments to be passed via stack 
-    RDX : pointer to arguments to be passed via the stack 
-    R8  : pointer to arguments of integral/pointer type to be passed via registers 
+    RCX : size of arguments to be passed via stack
+    RDX : pointer to arguments to be passed via the stack
+    R8  : pointer to arguments of integral/pointer type to be passed via registers
     R9  : target function pointer
 
 */
@@ -103,46 +99,47 @@ END_PROC(dcCall_x64_sysv)
 GLOBAL(dcCall_x64_win64)
 BEGIN_PROC(dcCall_x64_win64)
 
-	push	RBP			/* Pseudo-prolog - preserve RBP. */
-	push	RSI			/* Preserve RSI and RDI. */
-	push	RDI
-	
-	/* and  RSP, -16		/* Align frame to 16 bytes.    */
-	mov	RBP, RSP		/* Store stack pointer in RBP. */
+	PUSH(RBP)			/* Pseudo-prolog - preserve RBP. */
+	PUSH(RSI)			/* Preserve RSI and RDI. */
+	PUSH(RDI)
+
+	MOV(RSP,RBP)			/* Store stack pointer in RBP. */
+
+	ADD(LIT(15),RCX)		/* Align stack size to 16 bytes. */
+	AND(LIT(-16),RCX)
+	SUB(RCX,RSP)			/* Setup stack frame by subtracting the size of the arguments. */
+
 
-	add	RCX, 15			/* Align stack size to 16 bytes. */
-	and	RCX, -16
-	sub	RSP, RCX		/* Setup stack frame by subtracting the size of the arguments. */
+	MOV(RDX, RSI)			/* Let RSI point to the arguments. */
+	MOV(RSP, RDI)			/* Store pointer to beginning of stack arguments in RDI (for rep movsb). */
+	MOV(R9,  RAX)			/* Put function address in RAX. */
 
-	mov	RSI, RDX		/* Let RSI point to the arguments. */
-	mov	RDI, RSP		/* Store pointer to beginning of stack arguments in RDI (for rep movsb). */
-	mov	RAX, R9			/* Put function address in RAX. */
+	REP(MOVSB) 			/* @@@ should be optimized (e.g. movq) */
 
-	rep movsb			/* @@@ should be optimized (e.g. movq) */
+	MOV(QWORD(R8,0),RCX)		/* Copy first four arguments to RCX, RDX, R9, R8 ( and XMM0-XMM3. ) */
+	MOV(QWORD(R8,8),RDX)
+	MOV(QWORD(R8,24),R9)
+	MOV(QWORD(R8,16),R8)
 
-	mov	RCX,  qword ptr[R8   ]	/* Copy first four arguments to RCX, RDX, R8, R9 and XMM0-XMM3. */
-	mov	RDX,  qword ptr[R8+ 8]
-	mov	R9,   qword ptr[R8+24]	/* Set R9 first to not overwrite R8 too soon. */
-	mov	R8,   qword ptr[R8+16]
-	movd	XMM0, RCX
-	movd	XMM1, RDX
-	movd	XMM2, R8
-	movd	XMM3, R9
+	MOVD(RCX, XMM0)
+	MOVD(RDX, XMM1)
+	MOVD(R8,  XMM2)
+	MOVD(R9,  XMM3)
 
-	push	R9			/* Push first four arguments onto the stack preserve area. */
-	push	R8
-	push	RDX
-	push	RCX
+	PUSH(R9)			/* Push first four arguments onto the stack preserve area. */
+	PUSH(R8)
+	PUSH(RDX)
+	PUSH(RCX)
 
-	call	RAX			/* Invoke function. */
+	CALL_REG(RAX)			/* Invoke function. */
 
-	mov	RSP, RBP		/* Restore stack pointer (such that we can pop the preserved vALues). */
+	MOV(RBP, RSP)			/* Restore stack pointer (such that we can pop the preserved vALues). */
 
-	pop	RDI			/* Restore RSI and RDI. */
-	pop	RSI
-	pop	RBP			/* Pseudo-epilog. */
+	POP(RDI)			/* Restore RSI and RDI. */
+	POP(RSI)
+	POP(RBP)			/* Pseudo-epilog. */
 
-	ret
+	RET()
 
 END_PROC(dcCall_x64_win64)
 

data/dyncall/dyncall/dyncall_call_x64.h

@@ -6,7 +6,7 @@
  Description: 
  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

data/dyncall/dyncall/dyncall_call_x86.S

@@ -6,7 +6,7 @@
  Description: All - except Plan9 - x86 abi call kernel implementation
  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
@@ -35,7 +35,7 @@ BEGIN_ASM
       ddCall_x86_sys_XXX(int_ptr target, void* args, size_t size);
  
    Where XXX is one of calling-conventions,
-	cdecl, win32_msthis, win32_std, win32_fastcall.
+      cdecl, win32_msthis, win32_std, win32_fastcall.
 
    Parameter Stack layout:
       size    :=  EBP + 16
@@ -67,14 +67,14 @@ BEGIN_PROC(dcCall_x86_cdecl)
 	ANDL(LIT(-16),ECX)
 	MOVL(ECX,DWORD(EBP,16))		/* save ECX. */
 	SUBL(ECX,ESP)			/* allocate stack size */
-	MOVL(ESP,EDI)			/* EDI = stack ptr */			
-	
+	MOVL(ESP,EDI)			/* EDI = stack ptr */
+
 	/* 
 		work around for rep movsd (not supported by SunPro) 
-	
-	SHRL(LIT(2),ECX)		
+
+	SHRL(LIT(2),ECX)
 	REP(MOVSD)
-	
+
 	*/
 
 	REP(MOVSB)
@@ -185,7 +185,7 @@ END_PROC(dcCall_x86_win32_fast)
 GLOBAL(dcCall_x86_sys_int80h_linux)
 BEGIN_PROC(dcCall_x86_sys_int80h_linux)
 	PUSH(EBP)        		/* prolog. */
- 	MOVL(ESP,EBP)
+	MOVL(ESP,EBP)
 	PUSH(EBX)			/* save preserved. */
 	PUSH(ESI)               
 	PUSH(EDI)
@@ -215,7 +215,7 @@ END_PROC(dcCall_x86_sys_int80h_linux)
 GLOBAL(dcCall_x86_sys_int80h_bsd)
 BEGIN_PROC(dcCall_x86_sys_int80h_bsd)
 	PUSH(EBP)			/* prolog. */
- 	MOVL(ESP,EBP)
+	MOVL(ESP,EBP)
 	PUSH(ESI)			/* save preserved. */
 	PUSH(EDI)
 	MOVL(DWORD(EBP,12),ESI)    	/* ESI = pointer on args. */