rbdc 0.8.0

data/dyncall/dyncall/dyncall_call_x64.S

@@ -0,0 +1,149 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x64.S
+ Description: All x64 abi call kernel implementation
+ 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-x64.S"
+
+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 
+
+*/
+
+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
+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 
+    R9  : target function pointer
+
+*/
+
+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. */
+
+	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	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) */
+
+	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
+
+	push	R9			/* Push first four arguments onto the stack preserve area. */
+	push	R8
+	push	RDX
+	push	RCX
+
+	call	RAX			/* Invoke function. */
+
+	mov	RSP, RBP		/* Restore stack pointer (such that we can pop the preserved vALues). */
+
+	pop	RDI			/* Restore RSI and RDI. */
+	pop	RSI
+	pop	RBP			/* Pseudo-epilog. */
+
+	ret
+
+END_PROC(dcCall_x64_win64)
+
+END_ASM
+

data/dyncall/dyncall/dyncall_call_x64.h

@@ -0,0 +1,63 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x64.h
+ Description: 
+ 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.
+
+*/
+
+
+/*
+
+  dyncall x64
+
+  REVISION
+  2007/12/11 initial
+
+*/
+
+
+#ifndef DYNCALL_CALL_X64_H
+#define DYNCALL_CALL_X64_H
+
+
+#include "dyncall.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 
+** x64 SystemV calling convention 
+**
+** - hybrid return-type call (bool ... pointer)
+**
+*/
+
+void dcCall_x64_sysv(DCsize stacksize, DCpointer stackdata, DCpointer regdata_i, DCpointer regdata_f, DCpointer target);
+void dcCall_x64_win64(DCsize stacksize, DCpointer stackdata, DCpointer regdata, DCpointer target);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DYNCALL_CALL_X64_H */
+

data/dyncall/dyncall/dyncall_call_x64_generic_masm.asm

@@ -0,0 +1,70 @@
+; auto-generated by gen-masm.sh
+.CODE
+
+dcCall_x64_sysv PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push RBP
+ push RBX
+ mov RBP,RSP
+ mov RBX,R8
+ movsd XMM0,qword ptr [RCX+0]
+ 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]
+ add RDI,31
+ and RDI,-32
+ add RDI,8
+ sub RSP,RDI
+ mov RCX,RDI
+ mov RDI,RSP
+ rep movsb
+ mov RDI,qword ptr [RDX+0]
+ 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]
+ mov AL,8
+ call RBX
+ mov RSP,RBP
+ pop RBX
+ pop RBP
+ ret
+dcCALl_x64_sysv ENDP
+dcCall_x64_win64 PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push RBP
+ push RSI
+ push RDI
+ mov RBP,RSP
+ add RCX,15
+ and RCX,-16
+ sub RSP,RCX
+ mov RSI,RDX
+ mov RDI,RSP
+ mov RAX,R9
+ rep movsb
+ mov RCX,qword ptr [R8+0]
+ mov RDX,qword ptr [R8+8]
+ mov R9,qword ptr [R8+24]
+ mov R8,qword ptr [R8+16]
+ movd XMM0,RCX
+ movd XMM1,RDX
+ movd XMM2,R8
+ movd XMM3,R9
+ push R9
+ push R8
+ push RDX
+ push RCX
+ call RAX
+ mov RSP,RBP
+ pop RDI
+ pop RSI
+ pop RBP
+ ret
+dcCall_x64_win64 ENDP
+END

data/dyncall/dyncall/dyncall_call_x86.S

@@ -0,0 +1,238 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x86.S
+ Description: All - except Plan9 - x86 abi call kernel implementation
+ 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-x86.S"
+BEGIN_ASM
+/* ============================================================================
+   DynCall Call Kernels for X86 Architecture
+   ----------------------------------------------------------------------------
+   C Interface:
+      dcCall_x86_XXX(void* target, void* args, size_t size);
+      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.
+
+   Parameter Stack layout:
+      size    :=  EBP + 16
+      args    :=  EBP + 12
+      target  :=  EBP +  8
+  
+   NOTES:
+    - epilog restore ESP serves callee cleanup 
+    - 16 byte alignment (to be compatible with darwin).
+*/
+
+
+/*--- default / cdecl --------------------------------------------------------
+
+  Details:
+  - caller clean-up
+
+*/
+
+GLOBAL(dcCall_x86_cdecl)
+BEGIN_PROC(dcCall_x86_cdecl)
+	PUSH(EBP)			/* prolog. */
+	MOVL(ESP,EBP)
+	PUSH(ESI)			/* save preserved registers. */
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),ESI)		/* ESI = arg buffer ptr */
+	MOVL(DWORD(EBP,16),ECX)		/* ECX = arg buffer size */
+	ADDL(LIT(15),ECX)		/* ECX = align(ECX,16) */
+	ANDL(LIT(-16),ECX)
+	MOVL(ECX,DWORD(EBP,16))		/* save ECX. */
+	SUBL(ECX,ESP)			/* allocate stack size */
+	MOVL(ESP,EDI)			/* EDI = stack ptr */			
+	
+	/* 
+		work around for rep movsd (not supported by SunPro) 
+	
+	SHRL(LIT(2),ECX)		
+	REP(MOVSD)
+	
+	*/
+
+	REP(MOVSB)
+	CALL_DWORD(EBP,8)
+	ADDL(DWORD(EBP,16),ESP)
+	POP(EDI)
+	POP(ESI)
+	MOVL(EBP,ESP)
+	POP(EBP)
+	RET()
+END_PROC(dcCall_x86_cdecl)
+/* ---- C++ this calls (microsoft) ------------------------------------------ 
+
+  Details:
+  - this pointer is in ECX
+
+*/
+
+GLOBAL(dcCall_x86_win32_msthis)
+BEGIN_PROC(dcCall_x86_win32_msthis)
+	PUSH(EBP)               	/* prolog. */
+	MOVL(ESP,EBP)
+	PUSH(ESI)               	/* save preserved. */
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),ESI)		/* ESI = pointer on args. */
+	MOVL(DWORD(EBP,16),ECX)		/* ECX = size. */
+	MOVL(DWORD(ESI,0),EAX) 		/* EAX = this pointer. */ 
+	ADDL(LIT(4),ESI)           		/* increment args pointer by thisptr. */
+	SUBL(LIT(4),ECX)        		/* decrement size by sizeof(thisptr). */
+	SUBL(ECX,ESP)         		/* allocate argument-block on stack. */
+	MOVL(ESP,EDI)       		/* EDI = stack args. */
+	REP(MOVSB)              	/* copy arguments. */
+	MOVL(EAX,ECX)        		/* ECX = this pointer. */
+	CALL_DWORD(EBP,8)		/* call function. */
+	POP(EDI)			/* restore preserved. */
+	POP(ESI)
+	MOVL(EBP,ESP)       		/* epilog. */
+	POP(EBP)
+	RET()
+END_PROC(dcCall_x86_win32_msthis)
+
+/*---- win32 stdcall ---------------------------------------------------------
+  
+  Details:
+  - callee cleans up stack
+
+*/
+
+GLOBAL(dcCall_x86_win32_std)
+BEGIN_PROC(dcCall_x86_win32_std)
+	PUSH(EBP)			/* prolog. */
+	MOVL(ESP,EBP)
+	PUSH(ESI)			/* save ESI, EDI. */
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),ESI)		/* ESI = args. */
+	MOVL(DWORD(EBP,16),ECX)		/* ECX = size. */
+	SUBL(ECX,ESP)			/* allocate size bytes on stack. */
+	MOVL(ESP,EDI)			/* EDI = copy destination stack. */
+	REP(MOVSB)			/* copy BYTEs. */
+	CALL_DWORD(EBP,8)		/* call target. */
+	POP(EDI)			/* restore EDI, ESI. */
+	POP(ESI)
+	MOVL(EBP,ESP)			/* epilog. */
+	POP(EBP)
+	RET()
+END_PROC(dcCall_x86_win32_std)
+
+/*---- win32 fastcall (GNU/Microsoft) ----------------------------------------
+
+  Details:
+  - callee cleans up stack
+  - first two integer (up to 32bits) are passed in ECX and EDX
+
+*/
+
+GLOBAL(dcCall_x86_win32_fast)
+BEGIN_PROC(dcCall_x86_win32_fast)
+	PUSH(EBP)			/* prolog. */
+	MOVL(ESP,EBP)
+	PUSH(ESI)			/* save preserved. */
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),ESI)		/* ESI = copy source args. */
+	MOVL(DWORD(EBP,16),ECX)		/* ECX = size. */
+	MOVL(DWORD(ESI,0),EAX)		/* EAX = first argument. */
+	MOVL(DWORD(ESI,4),EDX)		/* EDX = second argument. */
+	ADDL(LIT(8),ESI)		/* skip registers. */
+	SUBL(LIT(8),ECX)
+	MOVL(ECX,DWORD(EBP,16))		/* save stack alloc size. */
+	SUBL(ECX,ESP)  			/* allocate stack. */
+	MOVL(ESP,EDI)  			/* EDI = stack args. */ 
+	REP(MOVSB) 			/* copy BYTEs. */
+	MOVL(EAX,ECX)			/* ECX = first argument. */ 
+	CALL_DWORD(EBP,8)		/* call target. */
+	POP(EDI)			/* restore preserved. */
+	POP(ESI)
+	MOVL(EBP,ESP)			/* epilog. */
+	POP(EBP)
+	RET()
+END_PROC(dcCall_x86_win32_fast)
+
+/*--- syscall int80 linux ---------------------------------------------------
+  
+  Details:
+  - all arguments are passed via registers
+
+*/
+
+GLOBAL(dcCall_x86_sys_int80h_linux)
+BEGIN_PROC(dcCall_x86_sys_int80h_linux)
+	PUSH(EBP)        		/* prolog. */
+ 	MOVL(ESP,EBP)
+	PUSH(EBX)			/* save preserved. */
+	PUSH(ESI)               
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),EAX)		/* EAX = argument buffer. */
+	MOVL(DWORD(EAX,0),EBX)		/* move first five arguments. */
+	MOVL(DWORD(EAX,4),ECX)	
+	MOVL(DWORD(EAX,8),EDX)
+	MOVL(DWORD(EAX,12),ESI)
+	MOVL(DWORD(EAX,16),EDI)
+	MOVL(DWORD(EBP,8),EAX)		/* EAX = syscall id. */
+	INT(LIT(HEX(80)))
+	POP(EDI)			/* restore preserved. */
+	POP(ESI)
+	POP(EBX)
+	MOVL(EBP,ESP)			/* epilog. */
+	POP(EBP)
+	RET()
+END_PROC(dcCall_x86_sys_int80h_linux)
+
+/*--- syscall int80 bsd -----------------------------------------------------
+
+  Details:
+  - all arguments are passed via stack
+
+*/
+	
+GLOBAL(dcCall_x86_sys_int80h_bsd)
+BEGIN_PROC(dcCall_x86_sys_int80h_bsd)
+	PUSH(EBP)			/* prolog. */
+ 	MOVL(ESP,EBP)
+	PUSH(ESI)			/* save preserved. */
+	PUSH(EDI)
+	MOVL(DWORD(EBP,12),ESI)    	/* ESI = pointer on args. */
+	MOVL(DWORD(EBP,16),ECX)   	/* ECX = size. */
+	SUBL(ECX,ESP)       		/* allocate stack space. */
+	MOVL(ESP,EDI)           		/* EDI = stack args. */
+	REP(MOVSB)
+	MOVL(DWORD(EBP,8),EAX)		/* load system call id. */
+	CALL(_do_int)
+	POP(EDI)               		/* restore preserved. */
+	POP(ESI)
+	MOVL(EBP,ESP)          		/* epilog. */
+	POP(EBP)
+	RET()
+_do_int:
+	INT(LIT(HEX(80)))
+	RET()
+END_PROC(dcCall_x86_sys_int80h_bsd)
+
+END_ASM
+