rbdc 0.8.0

data/dyncall/dyncall/dyncall_call_sparc64.h

@@ -0,0 +1,42 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_sparc64.h
+ Description: 
+ License:
+
+   Copyright (c) 2011 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.
+
+*/
+
+
+#ifndef DYNCALL_CALL_SPARC64_H
+#define DYNCALL_CALL_SPARC64_H
+
+#include "dyncall_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void dcCall_sparc64 (DCpointer target, DCsize size, DCpointer data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DYNCALL_CALL_SPARC64_H */
+

data/dyncall/dyncall/dyncall_call_sparc_v9.S

@@ -0,0 +1,220 @@
+#define BIAS 2047
+.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
+	jmpl	%i7 + 8, %g0
+    	restore
+
+/* 
+    or     %o0, %g0, %i0
+    or     %o1, %g0, %i1
+    or     %o2, %g0, %i2
+    or     %o3, %g0, %i3
+	return  %i7 + 8
+    nop
+
+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 .. %f15
+- 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
+*/
+
+/* --------------------------------------------------------------------------- 
+
+call kernel for sparc64 v9 abi
+tested on sparc64/linux/debian [gcc54.fsffrance.org - thanx to the farm!] 
+
+new C Interface:
+  void dcCall_sparc (DCCallVM* callvm, DCpointer target);
+                     %i0               %1 
+
+see dyncall_call_sparc.S for details.
+
+old C Interface:
+  void dcCall_sparc (DCpointer target, DCsize size, DCpointer data);
+		     %i0             , %i1        , %i2
+Input:
+  i0   target
+  i1   size
+  i2   data
+
+*/
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_sparc64.S
+ Description: Call kernel for sparc64 v9 ABI.
+ License:
+
+   Copyright (c) 2011-2013 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.
+
+*/
+
+#if 0
+
+
+#define REGSIZE 8
+
+
+
+#define SHEAD ((16+6)*8)
+#define ALIGN 16 
+#define IREGS 6
+#define FREGS 16
+#define SREGS 16
+#define IBASE  0
+#define FBASE  (IREGS*8)
+
+// #define DHEAD  ((IREGS+FREGS)*8)+SREGS*4
+
+CALLVM_regdata = 72
+CALLVM_size    = 208
+CALLVM_buffer  = 216
+
+#endif

data/dyncall/dyncall/dyncall_call_sparc_v9.h

@@ -0,0 +1,42 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_sparc_v9.h
+ Description: 
+ License:
+
+   Copyright (c) 2011-2013 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.
+
+*/
+
+
+#ifndef DYNCALL_CALL_SPARC_V9_H
+#define DYNCALL_CALL_SPARC_V9_H
+
+#include "dyncall_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void dcCall_v9 (DCCallVM* vm, DCpointer target);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DYNCALL_CALL_SPARC_v9_H */
+

data/dyncall/dyncall/dyncall_call_x64-att.S

@@ -0,0 +1,146 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x64-att.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-att.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 
+  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(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). */
+
+	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 
+    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)
+	
+	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. */
+
+
+	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. */
+
+	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)
+
+	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)
+
+	CALL_REG(RAX)			/* Invoke function. */
+
+	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. */
+
+	RET()
+
+END_PROC(dcCall_x64_win64)
+
+END_ASM
+