rbdc 0.8.0

data/dyncall/dyncallback/dyncall_callback_x86.S

@@ -0,0 +1,115 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_x86.S
+ Description: Callback Thunk entry for x86
+ 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.
+
+*/
+
+#include "../portasm/portasm-x86.S"
+BEGIN_ASM
+DCThunk_size		= 16
+DCArgs_size		= 20
+DCValue_size		=  8
+
+CTX_thunk		=  0
+CTX_phandler		= 16
+CTX_pargsvt		= 20
+CTX_stack_cleanup	= 24
+CTX_userdata		= 28
+
+frame_arg0         	=  8
+frame_ret          	=  4
+frame_parent       	=  0
+frame_CTX         	= -4
+frame_DCArgs       	= -24
+frame_DCValue      	= -32
+
+#define ASCII_L	76
+#define ASCII_l	108
+#define ASCII_d	100
+#define ASCII_f	102
+#define ASCII_i	105
+#define ASCII_v	118
+
+GLOBAL(dcCallbackThunkEntry)
+BEGIN_PROC(dcCallbackThunkEntry)
+	PUSH(EBP)
+	MOVL(ESP,EBP)
+	/* local variable frame_CTX) */
+	PUSH(EAX)				/* EAX = CTX* */
+	/* initialize DCArgs */
+	PUSH(LIT(0))				/* fast_count */
+	PUSH(EDX)				/* fast_data[1] */
+	PUSH(ECX)				/* fast_data[0] */
+	LEA(DWORD(EBP,frame_arg0),ECX)		/* compute arg stack address */
+	PUSH(ECX)				/* stack-ptr */
+	PUSH(DWORD(EAX,CTX_pargsvt))		/* vtbl-ptr */
+	MOVL(ESP,ECX)				/* ECX = DCArgs* */
+	/* initialize DCvalue */
+	PUSH(LIT(0))
+	PUSH(LIT(0))
+	
+	MOVL(ESP,EDX)				/* EDX = DCValue* */
+	ANDL(LIT(-16),ESP)			/* align stack to 16 bytes. */
+	/* call handler(context) */
+	PUSH(DWORD(EAX,CTX_userdata))		/* userdata */
+	PUSH(EDX)				/* DCValue* */
+	PUSH(ECX)				/* DCargs* */
+	PUSH(EAX)				/* DCCallback* */
+	CALL_DWORD(EAX,CTX_phandler)
+	/* cleanup stack */
+	MOVL(EBP,ESP)				/* reset esp to frame */
+	POP(ECX)				/* skip parent frame */	
+	POP(ECX)				/* pop return address */
+	MOVL(DWORD(EBP,frame_CTX),EDX)	
+	ADD(DWORD(EDX,CTX_stack_cleanup),ESP)	/* cleanup stack */
+	PUSH(ECX)				/* push back return address */
+	LEA(DWORD(EBP,frame_DCValue), EDX)
+	MOVL(DWORD(EBP,0), EBP)			/* EBP = parent frame */
+	/* handle return value */
+	CMP(LIT(ASCII_v),AL)
+	JE(LOCAL(return_void))
+	CMP(LIT(ASCII_d),AL)
+	JE(LOCAL(return_f64))
+	CMP(LIT(ASCII_f),AL)
+	JE(LOCAL(return_f32))
+	CMP(LIT(ASCII_l),AL)
+	JE(LOCAL(return_i64))
+	CMP(LIT(ASCII_L),AL)
+	JE(LOCAL(return_i64))
+	
+	/* All int cases <= 32 bits (+ pointer & string cases) fall in the 32 bits int case*/
+LOCAL(return_i32):
+	MOVL(DWORD(EDX,0),EAX)
+	RET()
+LOCAL(return_i64):
+	MOVL(DWORD(EDX,0),EAX)
+	MOVL(DWORD(EDX,4),EDX)
+	RET()
+LOCAL(return_f32):
+	FLDS(DWORD(EDX,0))
+	RET()
+LOCAL(return_f64):
+	FLDL(QWORD(EDX,0))
+LOCAL(return_void):
+	RET()
+END_PROC(dcCallbackThunkEntry)
+END_ASM
+

data/dyncall/dyncallback/dyncall_callback_x86.c

@@ -0,0 +1,281 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_x86.c
+ Description: Callback - Implementation for x86
+ 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 "dyncall_callback_x86.h"
+#include "dyncall_args_x86.h"
+
+#include "dyncall_alloc_wx.h"
+#include "dyncall_signature.h"
+
+/*
+ * assembly thunk entry for callbacks
+ */
+
+extern void dcCallbackThunkEntry();
+
+/* compute stacksize for callee cleanup calling conventions:
+ *
+ * stdcall,fastcall_ms,fastcall_gnu
+ */
+
+static int dcbCleanupSize_x86_cdecl(const char* signature)
+{
+  return 0;
+}
+
+static int dcbCleanupSize_x86_std(const char* signature)
+{
+  const char* ptr = signature;
+  int size = 0;
+  char ch;
+  while( (ch = *ptr++) != DC_SIGCHAR_ENDARG ) {
+    switch(ch) {
+      case DC_SIGCHAR_BOOL:
+      case DC_SIGCHAR_CHAR:
+      case DC_SIGCHAR_SHORT:
+      case DC_SIGCHAR_INT:
+      case DC_SIGCHAR_LONG:
+      case DC_SIGCHAR_POINTER:
+      case DC_SIGCHAR_UCHAR:
+      case DC_SIGCHAR_USHORT:
+      case DC_SIGCHAR_UINT:
+      case DC_SIGCHAR_ULONG:
+      case DC_SIGCHAR_STRING:
+      case DC_SIGCHAR_FLOAT:
+        size += 4;
+        break;
+      case DC_SIGCHAR_DOUBLE:
+      case DC_SIGCHAR_LONGLONG:
+      case DC_SIGCHAR_ULONGLONG:
+        size += 8;
+        break;
+    }
+  }
+  return size;
+}
+
+static int dcbCleanupSize_x86_this_ms(const char* signature)
+{
+  const char* ptr = signature;
+  int size = 0;
+  char ch;
+  while( (ch = *ptr++) != DC_SIGCHAR_ENDARG )
+  {
+    switch(ch)
+    {
+    case DC_SIGCHAR_BOOL:
+    case DC_SIGCHAR_CHAR:
+    case DC_SIGCHAR_SHORT:
+    case DC_SIGCHAR_INT:
+    case DC_SIGCHAR_LONG:
+    case DC_SIGCHAR_POINTER:
+    case DC_SIGCHAR_UCHAR:
+    case DC_SIGCHAR_USHORT:
+    case DC_SIGCHAR_UINT:
+    case DC_SIGCHAR_ULONG:
+    case DC_SIGCHAR_STRING:
+    case DC_SIGCHAR_FLOAT:
+      size += 4;
+      break;
+    case DC_SIGCHAR_DOUBLE:
+    case DC_SIGCHAR_LONGLONG:
+    case DC_SIGCHAR_ULONGLONG:
+      size += 8;
+      break;
+    }
+  }
+  return size;
+}
+
+static int dcbCleanupSize_x86_fast_ms(const char* signature)
+{
+  const char* ptr = signature;
+  int size = 0;
+  int regs = 0;
+  char ch;
+  while( (ch = *ptr++) != DC_SIGCHAR_ENDARG )
+  {
+    switch(ch)
+    {
+    case DC_SIGCHAR_BOOL:
+    case DC_SIGCHAR_CHAR:
+    case DC_SIGCHAR_SHORT:
+    case DC_SIGCHAR_INT:
+    case DC_SIGCHAR_LONG:
+    case DC_SIGCHAR_POINTER:
+    case DC_SIGCHAR_UCHAR:
+    case DC_SIGCHAR_USHORT:
+    case DC_SIGCHAR_UINT:
+    case DC_SIGCHAR_ULONG:
+    case DC_SIGCHAR_STRING:
+      if (regs < 2) regs++;
+      else size += 4;
+      break;
+    case DC_SIGCHAR_FLOAT:
+      size += 4;
+      break;
+    case DC_SIGCHAR_DOUBLE:
+      size += 8;
+      break;
+    case DC_SIGCHAR_LONGLONG:
+    case DC_SIGCHAR_ULONGLONG:
+      size += 8;
+      break;
+    }
+  }
+  return size;
+}
+
+static int dcbCleanupSize_x86_fast_gnu(const char* signature)
+{
+  const char* ptr = signature;
+  char ch;
+  int size = 0;
+  int regs = 0;
+  while( (ch = *ptr++) != DC_SIGCHAR_ENDARG ) {
+    switch(ch) {
+      case DC_SIGCHAR_FLOAT:
+        size += 4;
+        break;
+      case DC_SIGCHAR_DOUBLE:
+        size += 8;
+        break;
+      case DC_SIGCHAR_LONGLONG:
+      case DC_SIGCHAR_ULONGLONG:
+        regs  = 2;
+        size += 8;
+        break;
+      default:
+        if (regs < 2) regs++;
+        else size += 4;
+        break;
+    }
+  }
+  return size;
+}
+
+void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
+{
+  const char* ptr;
+  char  ch;
+  int mode;
+  pcb->handler = handler;
+  pcb->userdata = userdata;
+
+  ptr = signature;
+  ch = *ptr;
+
+  /* x86 hints: */
+
+  mode = DC_CALL_C_X86_CDECL;
+
+  if(ch == DC_SIGCHAR_CC_PREFIX)
+  {
+    ptr++;
+    ch = *ptr++;
+    switch(ch) {
+      case DC_SIGCHAR_CC_STDCALL:      mode = DC_CALL_C_X86_WIN32_STD;      break;
+      case DC_SIGCHAR_CC_THISCALL_MS:  mode = DC_CALL_C_X86_WIN32_THIS_MS;  break;
+      case DC_SIGCHAR_CC_FASTCALL_GNU: mode = DC_CALL_C_X86_WIN32_FAST_GNU; break;
+      case DC_SIGCHAR_CC_FASTCALL_MS:  mode = DC_CALL_C_X86_WIN32_FAST_MS;  break;
+    }
+  }
+
+  /* x86 configuration: */
+
+  switch(mode) {
+    case DC_CALL_C_X86_CDECL:
+      pcb->args_vt = &dcArgsVT_default;
+      pcb->stack_cleanup = dcbCleanupSize_x86_cdecl(ptr);
+      break;
+    case DC_CALL_C_X86_WIN32_STD:
+      pcb->args_vt = &dcArgsVT_default;
+      pcb->stack_cleanup = dcbCleanupSize_x86_std(ptr);
+      break;
+    case DC_CALL_C_X86_WIN32_THIS_MS:
+      pcb->args_vt = &dcArgsVT_this_ms;
+      pcb->stack_cleanup = dcbCleanupSize_x86_this_ms(ptr);
+      break;
+    case DC_CALL_C_X86_WIN32_FAST_MS:
+      pcb->args_vt = &dcArgsVT_fast_ms;
+      pcb->stack_cleanup = dcbCleanupSize_x86_fast_ms(ptr);
+      break;
+    case DC_CALL_C_X86_WIN32_FAST_GNU:
+      pcb->args_vt = &dcArgsVT_fast_gnu;
+      pcb->stack_cleanup = dcbCleanupSize_x86_fast_gnu(ptr);
+      break;
+  }
+
+#if defined(DC_PLAN9)
+  /* HACK for Plan9 - 'reuse' pcb->stack_cleanup as a flag
+     to indicate if return value is 64bit. The field is not
+     used anyways as the caller is responsible to clean up
+     the stack in Plan9. If set to '1' the callback kernel
+     takes into account an extra stack-parameter (pointer
+     to 64bit return value).
+     I thought of introducing a new field, but for one single
+     x86 calling convention out of many, it seemed overkill
+     to change the struct for everybody else. Maybe renaming
+     would be a good idea, though. ~ Tassilo
+  */
+  while(*ptr) {
+    if(*ptr++ == DC_SIGCHAR_ENDARG) {
+      pcb->stack_cleanup = (*ptr == DC_SIGCHAR_LONGLONG) || (*ptr == DC_SIGCHAR_ULONGLONG);
+      break;
+    }
+  }
+#endif
+}
+
+/*
+ * callback constructor
+ */
+
+DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, void* userdata)
+{
+  int err;
+  DCCallback* pcb;
+  err = dcAllocWX(sizeof(DCCallback), (void**) &pcb);
+  if (err != 0) return 0;
+
+  dcbInitThunk(&pcb->thunk, dcCallbackThunkEntry);
+  dcbInitCallback(pcb, signature, handler, userdata);
+  return pcb;
+}
+
+/*
+ * free
+ */
+
+void dcbFreeCallback(DCCallback* pcb)
+{
+  dcFreeWX(pcb, sizeof(DCCallback));
+}
+
+void* dcbGetUserData(DCCallback* pcb)
+{
+  return pcb->userdata;
+}

data/dyncall/dyncallback/dyncall_callback_x86.h

@@ -0,0 +1,49 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_x86.h
+ Description: Callback - Header for x86
+ 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_CALLBACK_X86_H_
+#define DYNCALL_CALLBACK_X86_H_
+
+#include "dyncall_callback.h"
+
+#include "dyncall_thunk.h"
+#include "dyncall_args_x86.h"
+
+struct DCCallback
+{
+  DCThunk            thunk;         /* offset 0,  size 16 */
+  DCCallbackHandler* handler;       /* offset 16 */
+  DCArgsVT*          args_vt;       /* offset 20 */
+  size_t             stack_cleanup; /* offset 24 */
+  void*              userdata;      /* offset 28 */
+};
+
+int dcCleanupSize_x86_cdecl   (const char* args_signature);
+int dcCleanupSize_x86_std     (const char* args_signature);
+int dcCleanupSize_x86_fast_ms (const char* args_signature);
+int dcCleanupSize_x86_fast_gnu(const char* args_signature);
+
+#endif /* DYNCALL_CALLBACK_X86_H_ */

data/dyncall/dyncallback/dyncall_callback_x86_8a.s

@@ -0,0 +1,100 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callback_x86_8a.s
+ Description: x86 abi callback kernel implementation for Plan9's 8a
+ License:
+
+   Copyright (c) 2013 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.
+
+*/
+
+
+TEXT dcCallbackThunkEntry(SB), $0
+
+	/* input:
+		AX    -> thunk
+		AX+16 -> cb handler
+		AX+20 -> dcargsvt
+		AX+24 -> stack cleanup <-- not used for stack cleaning as caller cleans up,
+		AX+28 -> userdata          however reused as flag to indicate 64bit return value)
+	*/
+
+	/* prolog */
+	MOVL SP, BP
+
+	/* copy of DCargs passed to cb handler */
+	PUSHL $0           /* fast_count (unused on plan9, but using shared x86 dcargs struct) */
+	SUBL  $8, SP       /* skip fast_data[] ( " ) */
+	LEAL  8(BP), CX    /* ptr to args on stack, depending if return val is 64bit ... */
+	CMPL  24(AX), $1
+	JEQ   is_ll_ret
+	LEAL  4(BP), CX    /* ... or not */
+is_ll_ret:
+	PUSHL CX
+	PUSHL 20(AX)       /* args vtable ptr */
+	MOVL  SP, CX       /* DCArgs-ptr (data pushed above) */
+
+	/* space for return value (long long) */
+	PUSHL $0
+	PUSHL $0
+	MOVL  SP, DX       /* retval ptr */
+
+	/* call the handler */
+	PUSHL 28(AX)       /* userdata for handler */
+	PUSHL DX           /* results */
+	PUSHL CX           /* args */
+	PUSHL AX           /* callback obj */
+	MOVL  16(AX), AX
+	CALL  AX
+
+	/* copy retval from ptr on stack to AX or stack space if 64bit */
+	MOVL 8(SP), BX     /* ptr to retval */
+	CMPL  AX, $0x6c    /* 'l' @@@ compares return from handler, might be different from sig - design currently in discussion */
+	JEQ   ll_ret;
+	CMPL  AX, $0x4c    /* 'L' @@@ compares return from handler, might be different from sig - design currently in discussion */
+	JEQ   ll_ret;
+	CMPL  AX, $0x66    /* 'f' @@@ compares return from handler, might be different from sig - design currently in discussion */
+	JEQ   f_ret;
+	CMPL  AX, $0x64    /* 'd' @@@ compares return from handler, might be different from sig - design currently in discussion */
+	JEQ   d_ret;
+	JMP   other_ret
+
+ll_ret:
+	MOVL  48(SP), DX    /* ptr to ret address space; 48 = stack size + caller's ret address */
+	MOVL  (BX), CX
+	MOVL  CX, (DX)
+	MOVL  4(BX), CX
+	MOVL  CX, 4(DX)
+	JMP   cont_ret
+
+f_ret:
+	FMOVF (BX), F0
+	JMP   cont_ret
+
+d_ret:
+	FMOVD (BX), F0
+	JMP   cont_ret
+
+other_ret:
+	MOVL (BX), AX      /* 32bit non-fp are returned in AX */
+
+	/* epilog */
+cont_ret:
+	ADDL $44, SP       /* Cleanup stack */
+	POPL CX            /* hack to emulate RET without getting overly strict */
+	JMP CX             /* 'unbalanced PUSH/POP' warning/error from 8l */
+