rbdc 0.8.0

data/dyncall/dyncall/dyncall_call_x86.h

@@ -0,0 +1,70 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x86.h
+ Description: heap memory management interface (header only)
+ 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 32bit Intel x86 family interface
+
+  REVISION
+  2007/12/10 initial
+
+*/
+
+
+#ifndef DYNCALL_CALL_X86_H
+#define DYNCALL_CALL_X86_H
+
+
+#include "dyncall_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 
+** x86 calling convention calls 
+**
+** - hybrid return-type call (bool ... pointer)
+**
+*/
+
+#if defined(DC__OS_Plan9) /* No support for other cconvs on Plan9 and vice-versa. */
+void dcCall_x86_plan9        (DCpointer target, DCpointer stackdata, DCsize size);
+#else
+void dcCall_x86_cdecl        (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_std    (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_fast   (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_win32_msthis (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_sys_int80h_linux (DCpointer target, DCpointer stackdata, DCsize size);
+void dcCall_x86_sys_int80h_bsd   (DCpointer target, DCpointer stackdata, DCsize size);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DYNCALL_CALL_X86_H */

data/dyncall/dyncall/dyncall_call_x86_8a.s

@@ -0,0 +1,127 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_call_x86_8a.s
+ Description: All x86 abi call kernel implementations in Plan9's assembler
+ 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.
+
+*/
+
+
+
+/* 64 bit integer return value calls require caller to create space for return
+   value, and pass a pointer to it as 1st argument. This main function handles
+   all cases (32 and 64 bit integers, as well as floats and doubles), however,
+   it has to be called through the 2 corresponding functions at the end of
+   this file.
+   In order to keep things simple, we basically put the pointer to the
+   return value in EDX and call the other assembler code, above. If EDX
+   is not null, then the code below will push it to the stack as first
+   argument.
+*/
+
+call_main:
+
+    /* Since all registers except SP are scratch, and we have a variable
+       argument size depending on the function to call, we have to find
+       a way to store and restore SP.
+       The idea is to replace the return address with a custom one on the
+       stack, and to put some logic there, jumping back to the real
+       return address. This allows us, to put the SP somewhere next to
+       the fake return address on the stack, so that we can get it back
+       with a fixed offset (relative to the program counter, in our case).
+
+       The only real issue with this approach would be a non-executable
+       stack. However, Plan9 doesn't support w^x at the time of writing.
+    */
+
+    /* On the stack at this point:
+       RETADDR  0(SP)
+       FUNPTR   4(SP)
+       ARGS     8(SP)
+       SIZE    12(SP)
+    */
+
+    MOVL  SP, BP      /* base pointer for convenience */
+    PUSHL SP          /* save stack pointer */
+
+    MOVL   8(BP), SI  /* SI = pointer on args */
+    MOVL  12(BP), CX  /* CX = size of args */
+
+    SUBL  $16, SP     /* Make some room for our SP-refetch logic */
+    MOVL   SP, BX     /* Copy address to new, executable stack space to BX */
+
+/* This part fills our executable stack space with instructions. We
+       need to get the program counter, first, with a little hack. */
+    MOVL  $0x000003e8, 0(SP) /* Copy 'call (cur ip+8)' */
+    MOVL  $0x00000000, 4(SP) /* '00' for call address, rest is garbage */
+    MOVL  $0x5a909090, 8(SP) /* 'nop, nop, nop, pop edx' to get eip+5 in edx */
+    MOVL  $0xc30b628b,12(SP) /* Restore stack ptr and return: 'mov [edx+11] to esp, ret' */
+
+    SUBL  CX, SP      /* allocate 'size' bytes on stack for args */
+    MOVL  SP, DI      /* DI = stack args */
+
+    SHRL $2, SP       /* Align stack. */
+    SHLL $2, SP       /*   "     "    */
+
+    /* I didn't figure out how to use MOVSB with the 8a syntax. The following
+       can probably be written in a better way. */
+    JMP  copy_loop_cmp
+copy_loop:
+    MOVL 0(SI), AX     /* Copy args. */
+    MOVL AX, 0(DI)
+    SUBL $4, CX
+    ADDL $4, SI
+    ADDL $4, DI
+copy_loop_cmp:
+    CMPL CX, $0
+    JGT  copy_loop
+
+    /* Check if we need to push a pointer to long long that might be used as
+       container for 64-bit return values. */
+    CMPL DX, $0
+    JEQ  call_ffi
+    PUSHL DX
+
+    /* Now we try to fake a call, meaning setting up our fake return address,
+       and then jumping to the FFI call. This should call the function, but
+       the return will jump into our stack space we reserved above. */
+call_ffi:
+    PUSHL BX
+    MOVL  4(BP), BX
+    JMP   BX
+
+    /* Note that there is no return here, b/c the return is in the asm code
+       above, that has been generated on the fly. */
+
+
+/* Main call for 32 bit integer return values and floating point arguments.
+   See call_main for explanation. */
+TEXT dcCall_x86_plan9(SB), $0
+
+    MOVL $0, DX
+    JMP call_main
+
+
+/* Call for 64 bit integer return values.
+   See call_main for explanation. */
+TEXT dcCall_x86_plan9_ll(SB), $0
+
+    MOVL 16(SP), DX  /* Copy pointer to variable for return value. */
+    JMP call_main

data/dyncall/dyncall/dyncall_call_x86_generic_masm.asm

@@ -0,0 +1,136 @@
+; auto-generated by gen-masm.sh
+.386
+.MODEL FLAT
+.CODE
+
+_dcCall_x86_cdecl PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+ mov EBP,ESP
+ push ESI
+ push EDI
+ mov ESI,dword ptr [EBP+12]
+ mov ECX,dword ptr [EBP+16]
+ add ECX,15
+ and ECX,-16
+ mov dword ptr [EBP+16],ECX
+ sub ESP,ECX
+ mov EDI,ESP
+ rep movsb
+ call dword ptr [EBP+8]
+ add ESP,dword ptr [EBP+16]
+ pop EDI
+ pop ESI
+ mov ESP,EBP
+ pop EBP
+ ret
+_dcCall_x86_cdecl ENDP
+_dcCall_x86_win32_msthis PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+ mov EBP,ESP
+ push ESI
+ push EDI
+ mov ESI,dword ptr [EBP+12]
+ mov ECX,dword ptr [EBP+16]
+ mov EAX,dword ptr [ESI+0]
+ add ESI,4
+ sub ECX,4
+ sub ESP,ECX
+ mov EDI,ESP
+ rep movsb
+ mov ECX,EAX
+ call dword ptr [EBP+8]
+ pop EDI
+ pop ESI
+ mov ESP,EBP
+ pop EBP
+ ret
+_dcCall_x86_win32_msthis ENDP
+_dcCall_x86_win32_std PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+ mov EBP,ESP
+ push ESI
+ push EDI
+ mov ESI,dword ptr [EBP+12]
+ mov ECX,dword ptr [EBP+16]
+ sub ESP,ECX
+ mov EDI,ESP
+ rep movsb
+ call dword ptr [EBP+8]
+ pop EDI
+ pop ESI
+ mov ESP,EBP
+ pop EBP
+ ret
+_dcCall_x86_win32_std ENDP
+_dcCall_x86_win32_fast PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+ mov EBP,ESP
+ push ESI
+ push EDI
+ mov ESI,dword ptr [EBP+12]
+ mov ECX,dword ptr [EBP+16]
+ mov EAX,dword ptr [ESI+0]
+ mov EDX,dword ptr [ESI+4]
+ add ESI,8
+ sub ECX,8
+ mov dword ptr [EBP+16],ECX
+ sub ESP,ECX
+ mov EDI,ESP
+ rep movsb
+ mov ECX,EAX
+ call dword ptr [EBP+8]
+ pop EDI
+ pop ESI
+ mov ESP,EBP
+ pop EBP
+ ret
+_dcCall_x86_win32_fast ENDP
+_dcCall_x86_sys_int80h_linux PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+  mov EBP,ESP
+ push EBX
+ push ESI
+ push EDI
+ mov EAX,dword ptr [EBP+12]
+ mov EBX,dword ptr [EAX+0]
+ mov ECX,dword ptr [EAX+4]
+ mov EDX,dword ptr [EAX+8]
+ mov ESI,dword ptr [EAX+12]
+ mov EDI,dword ptr [EAX+16]
+ mov EAX,dword ptr [EBP+8]
+ int 80h
+ pop EDI
+ pop ESI
+ pop EBX
+ mov ESP,EBP
+ pop EBP
+ ret
+_dcCall_x86_sys_int80h_linux ENDP
+_dcCall_x86_sys_int80h_bsd PROC
+OPTION PROLOGUE:NONE, EPILOGUE:NONE
+ push EBP
+  mov EBP,ESP
+ push ESI
+ push EDI
+ mov ESI,dword ptr [EBP+12]
+ mov ECX,dword ptr [EBP+16]
+ sub ESP,ECX
+ mov EDI,ESP
+ rep movsb
+ mov EAX,dword ptr [EBP+8]
+ call _do_int
+ pop EDI
+ pop ESI
+ mov ESP,EBP
+ pop EBP
+ ret
+_do_int:
+ int 80h
+ ret
+_dcCall_x86_sys_int80h_bsd ENDP
+END

data/dyncall/dyncall/dyncall_call_x86_nasm.asm

@@ -0,0 +1,234 @@
+;//////////////////////////////////////////////////////////////////////////////
+;
+; Copyright (c) 2007,2009 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_call_x86_nasm.nasm
+;
+;	X86 Calls for nasm assembler
+;
+;///////////////////////////////////////////////////////////////////////
+
+
+    BITS 32
+    section .text
+
+;///////////////////////////////////////////////////////////////////////
+; CSYM macro
+;///////////////////////////////////////////////////////////////////////
+
+%ifdef BUILD_OS_windows
+
+%macro EXPORT_C 1
+  global _%1
+_%1:
+%endmacro
+
+%else
+
+%macro EXPORT_C 1
+  global %1
+%1:
+%endmacro
+
+%endif
+
+; -----------------------------------------------------------------------------
+; Calling Convention x86 standard C
+; - all arguments are on the stack
+; - caller cleans up stack
+;
+; C proto 
+;   dcCallC(DCptr funptr, DCptr args, DCsize size)
+; -----------------------------------------------------------------------------
+
+EXPORT_C dcCall_x86_cdecl
+
+	push ebp              ; prolog 
+	mov  ebp, esp         
+
+	; arguments:
+	;
+	; funptr  ebp+8
+	; args    ebp+12
+	; size    ebp+16
+	; result  ebp+20
+
+	push esi              ; save esi, edi
+	push edi
+
+	mov  esi, [ebp+12]    ; esi = pointer on args
+	mov  ecx, [ebp+16]    ; ecx = size
+
+	sub  esp, ecx         ; cdecl call: allocate 'size' bytes on stack
+	mov  edi, esp         ; edi = stack args
+
+	rep movsb             ; copy arguments
+
+	call [ebp+8]          ; call function
+
+	add  esp, [ebp+16]    ; cdecl call: cleanup stack
+
+	pop  edi              ; restore edi, esi
+	pop  esi
+
+	mov  esp, ebp         ; epilog
+	pop  ebp
+
+	ret
+
+; -----------------------------------------------------------------------------
+; Calling Convention x86 microsoft thiscall
+; - thispointer is in ECX, rest is on the stack
+; - callee cleans up stack
+;  
+; C proto
+;   dcCallThisMS(DCptr funptr, DCptr args, DCsize size)
+; -----------------------------------------------------------------------------
+EXPORT_C dcCall_x86_win32_msthis
+    
+	push ebp              ; prolog 
+	mov  ebp, esp         
+
+	; arguments:
+	;
+	; funptr  ebp+8
+	; args    ebp+12
+	; size    ebp+16
+
+	push esi              ; save esi, edi
+	push edi
+
+	mov  esi, [ebp+12]    ; esi = pointer on args
+	mov  ecx, [ebp+16]    ; ecx = size
+
+	mov  eax, [esi]       ; eax = this pointer
+	add  esi, 4           ; increment args pointer by thisptr
+	sub  ecx, 4           ; decrement size by sizeof(thisptr)
+
+	sub  esp, ecx         ; allocate argument-block on stack
+	mov  edi, esp         ; edi = stack args
+
+	rep movsb             ; copy arguments
+
+	mov  ecx, eax         ; ecx = this pointer
+
+	call [ebp+8]          ; call function (thiscall: cleanup by callee)
+
+	pop  edi              ; restore edi, esi
+	pop  esi
+
+	mov  esp, ebp         ; epilog
+	pop  ebp
+
+	ret    
+
+; -----------------------------------------------------------------------------
+; Calling Convention x86 win32 stdcall
+; - all arguments are passed by stack
+; - callee cleans up stack
+; 
+; C proto
+;   dcCallStd(DCptr funptr, DCptr args, DCsize size)
+; -----------------------------------------------------------------------------
+EXPORT_C dcCall_x86_win32_std
+
+	push ebp              ; prolog 
+	mov  ebp, esp         
+
+	; arguments:
+	;
+	; funptr  ebp+8
+	; args    ebp+12
+	; size    ebp+16
+
+	push esi              ; save esi, edi
+	push edi
+
+	mov  esi, [ebp+12]    ; esi = pointer on args
+	mov  ecx, [ebp+16]    ; ecx = size
+
+	sub  esp, ecx         ; stdcall: allocate 'size'-8 bytes on stack
+	mov  edi, esp         ; edi = stack args
+
+	rep movsb             ; copy arguments
+
+	call [ebp+8]          ; call function (stdcall: cleanup by callee)
+
+	pop  edi              ; restore edi, esi
+	pop  esi
+
+	mov  esp, ebp         ; epilog
+	pop  ebp
+
+	ret
+
+; -----------------------------------------------------------------------------
+; Calling Convention x86 win32 fastcall
+; - first two integer (up to 32bits) are passed in ECX and EDX
+; - others are passed on the stack
+; - callee cleans up stack
+; 
+; C proto
+;   dcCallFast(DCptr funptr, DCptr args, DCsize size)
+; -----------------------------------------------------------------------------
+EXPORT_C dcCall_x86_win32_fast
+
+	push ebp              ; prolog 
+	mov  ebp, esp
+
+	; arguments:
+	;
+	; funptr  ebp+8
+	; args    ebp+12
+	; size    ebp+16
+
+	push esi              ; save esi, edi
+	push edi
+
+	mov  esi, [ebp+12]    ; esi = pointer on args
+	mov  ecx, [ebp+16]    ; ecx = size
+	mov  eax, [esi]       ; eax = first argument
+	mov  edx, [esi+4]     ; edx = second argument
+	add  esi, 8           ; increment source pointer
+	sub  ecx, 8           ; decrement size by 8
+
+	sub  esp, ecx         ; fastcall: allocate 'size'-8 bytes on stack
+	mov  edi, esp         ; edi = stack args
+
+	rep movsb             ; copy arguments
+
+	mov  ecx, eax         ; ecx = first argument
+
+	call [ebp+8]          ; call function (fastcall: cleanup by callee)
+
+	pop  edi              ; restore edi, esi
+	pop  esi
+
+	mov  esp, ebp         ; epilog
+	pop  ebp
+
+	ret    
+
+; Stack markings for ELF/GNU to specify no executable stack */
+
+%ifidn __OUTPUT_FORMAT__,elf
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif
+