#include <windows.h>
#endif
-#if defined(openbsd_HOST_OS) || defined(linux_HOST_OS)
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-
-/* no C99 header stdint.h on OpenBSD? */
-#if defined(openbsd_HOST_OS)
-typedef unsigned long my_uintptr_t;
-#else
-#include <stdint.h>
-typedef uintptr_t my_uintptr_t;
-#endif
-#endif
-
#if defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
#include <string.h>
#endif
-/* Heavily arch-specific, I'm afraid.. */
-
-/*
- * Allocate len bytes which are readable, writable, and executable.
- *
- * ToDo: If this turns out to be a performance bottleneck, one could
- * e.g. cache the last VirtualProtect/mprotect-ed region and do
- * nothing in case of a cache hit.
- */
-static void*
-mallocBytesRWX(int len)
-{
- void *addr = stgMallocBytes(len, "mallocBytesRWX");
-#if defined(i386_HOST_ARCH) && defined(_WIN32)
- /* This could be necessary for processors which distinguish between READ and
- EXECUTE memory accesses, e.g. Itaniums. */
- DWORD dwOldProtect = 0;
- if (VirtualProtect (addr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect) == 0) {
- barf("mallocBytesRWX: failed to protect 0x%p; error=%lu; old protection: %lu\n",
- addr, (unsigned long)GetLastError(), (unsigned long)dwOldProtect);
- }
-#elif defined(openbsd_HOST_OS) || defined(linux_HOST_OS)
- /* malloced memory isn't executable by default on OpenBSD */
- my_uintptr_t pageSize = sysconf(_SC_PAGESIZE);
- my_uintptr_t mask = ~(pageSize - 1);
- my_uintptr_t startOfFirstPage = ((my_uintptr_t)addr ) & mask;
- my_uintptr_t startOfLastPage = ((my_uintptr_t)addr + len - 1) & mask;
- my_uintptr_t size = startOfLastPage - startOfFirstPage + pageSize;
- if (mprotect((void*)startOfFirstPage, (size_t)size, PROT_EXEC | PROT_READ | PROT_WRITE) != 0) {
- barf("mallocBytesRWX: failed to protect 0x%p\n", addr);
- }
-#endif
- return addr;
-}
-
#ifdef LEADING_UNDERSCORE
#define UNDERSCORE "_"
#else
#define UNDERSCORE ""
#endif
-#if defined(i386_HOST_ARCH)
+#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
/*
Now here's something obscure for you:
returning in some static piece of memory and arrange
to return to it before tail jumping from the adjustor thunk.
*/
-__asm__ (
- ".globl " UNDERSCORE "obscure_ccall_ret_code\n"
- UNDERSCORE "obscure_ccall_ret_code:\n\t"
- "addl $0x4, %esp\n\t"
- "ret"
- );
+static void GNUC3_ATTRIBUTE(used) obscure_ccall_wrapper(void)
+{
+ __asm__ (
+ ".globl " UNDERSCORE "obscure_ccall_ret_code\n"
+ UNDERSCORE "obscure_ccall_ret_code:\n\t"
+ "addl $0x4, %esp\n\t"
+ "ret"
+ );
+}
extern void obscure_ccall_ret_code(void);
+
+#if defined(openbsd_HOST_OS)
+static unsigned char *obscure_ccall_ret_code_dyn;
+#endif
+
#endif
#if defined(x86_64_HOST_ARCH)
-__asm__ (
+static void GNUC3_ATTRIBUTE(used) obscure_ccall_wrapper(void)
+{
+ __asm__ (
".globl " UNDERSCORE "obscure_ccall_ret_code\n"
UNDERSCORE "obscure_ccall_ret_code:\n\t"
"addq $0x8, %rsp\n\t"
"ret"
);
+}
extern void obscure_ccall_ret_code(void);
#endif
*stable = getStablePtr((StgPtr)arr);
/* and return a ptr to the goods inside the array */
- return(BYTE_ARR_CTS(arr));
+ return(&(arr->payload));
}
#endif
#endif
#endif
+#if defined(i386_HOST_ARCH) && defined(darwin_HOST_OS)
+
+/* !!! !!! WARNING: !!! !!!
+ * This structure is accessed from AdjustorAsm.s
+ * Any changes here have to be mirrored in the offsets there.
+ */
+
+typedef struct AdjustorStub {
+ unsigned char call[8];
+ StgStablePtr hptr;
+ StgFunPtr wptr;
+ StgInt frame_size;
+ StgInt argument_size;
+} AdjustorStub;
+#endif
+
+#if defined(darwin_HOST_OS) || defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
+static int totalArgumentSize(char *typeString)
+{
+ int sz = 0;
+ while(*typeString)
+ {
+ char t = *typeString++;
+
+ switch(t)
+ {
+ // on 32-bit platforms, Double and Int64 occupy two words.
+ case 'd':
+ case 'l':
+ if(sizeof(void*) == 4)
+ {
+ sz += 2;
+ break;
+ }
+ // everything else is one word.
+ default:
+ sz += 1;
+ }
+ }
+ return sz;
+}
+#endif
+
void*
createAdjustor(int cconv, StgStablePtr hptr,
StgFunPtr wptr,
switch (cconv)
{
case 0: /* _stdcall */
-#if defined(i386_HOST_ARCH)
+#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
/* Magic constant computed by inspecting the code length of
the following assembly language snippet
(offset and machine code prefixed):
<c>: ff e0 jmp %eax # and jump to it.
# the callee cleans up the stack
*/
- adjustor = mallocBytesRWX(14);
+ adjustor = stgMallocBytesRWX(14);
{
unsigned char *const adj_code = (unsigned char *)adjustor;
adj_code[0x00] = (unsigned char)0x58; /* popl %eax */
break;
case 1: /* _ccall */
-#if defined(i386_HOST_ARCH)
+#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
/* Magic constant computed by inspecting the code length of
the following assembly language snippet
(offset and machine code prefixed):
That's (thankfully) the case here with the restricted set of
return types that we support.
*/
- adjustor = mallocBytesRWX(17);
+ adjustor = stgMallocBytesRWX(17);
{
unsigned char *const adj_code = (unsigned char *)adjustor;
*((StgFunPtr*)(adj_code + 0x06)) = (StgFunPtr)wptr;
adj_code[0x0a] = (unsigned char)0x68; /* pushl obscure_ccall_ret_code */
- *((StgFunPtr*)(adj_code + 0x0b)) = (StgFunPtr)obscure_ccall_ret_code;
+ *((StgFunPtr*)(adj_code + 0x0b)) =
+#if !defined(openbsd_HOST_OS)
+ (StgFunPtr)obscure_ccall_ret_code;
+#else
+ (StgFunPtr)obscure_ccall_ret_code_dyn;
+#endif
adj_code[0x0f] = (unsigned char)0xff; /* jmp *%eax */
adj_code[0x10] = (unsigned char)0xe0;
}
+#elif defined(i386_HOST_ARCH) && defined(darwin_HOST_OS)
+ {
+ /*
+ What's special about Darwin/Mac OS X on i386?
+ It wants the stack to stay 16-byte aligned.
+
+ We offload most of the work to AdjustorAsm.S.
+ */
+ AdjustorStub *adjustorStub = stgMallocBytesRWX(sizeof(AdjustorStub));
+ adjustor = adjustorStub;
+
+ extern void adjustorCode(void);
+ int sz = totalArgumentSize(typeString);
+
+ adjustorStub->call[0] = 0xe8;
+ *(long*)&adjustorStub->call[1] = ((char*)&adjustorCode) - ((char*)adjustorStub + 5);
+ adjustorStub->hptr = hptr;
+ adjustorStub->wptr = wptr;
+
+ // The adjustor puts the following things on the stack:
+ // 1.) %ebp link
+ // 2.) padding and (a copy of) the arguments
+ // 3.) a dummy argument
+ // 4.) hptr
+ // 5.) return address (for returning to the adjustor)
+ // All these have to add up to a multiple of 16.
+
+ // first, include everything in frame_size
+ adjustorStub->frame_size = sz * 4 + 16;
+ // align to 16 bytes
+ adjustorStub->frame_size = (adjustorStub->frame_size + 15) & ~15;
+ // only count 2.) and 3.) as part of frame_size
+ adjustorStub->frame_size -= 12;
+ adjustorStub->argument_size = sz;
+ }
+
#elif defined(x86_64_HOST_ARCH)
/*
stack at call:
9: 48 89 f2 mov %rsi,%rdx
c: 48 89 fe mov %rdi,%rsi
f: 48 8b 3d 0a 00 00 00 mov 10(%rip),%rdi
- 16: e9 00 00 00 00 jmpq stub_function
+ 16: ff 25 0c 00 00 00 jmpq *12(%rip)
...
20: .quad 0 # aligned on 8-byte boundary
+ 28: .quad 0 # aligned on 8-byte boundary
And the version for >=6 integer arguments:
0: 41 51 push %r9
- 2: 68 00 00 00 00 pushq $obscure_ccall_ret_code
- 7: 4d 89 c1 mov %r8,%r9
- a: 49 89 c8 mov %rcx,%r8
- d: 48 89 d1 mov %rdx,%rcx
- 10: 48 89 f2 mov %rsi,%rdx
- 13: 48 89 fe mov %rdi,%rsi
- 16: 48 8b 3d 0b 00 00 00 mov 11(%rip),%rdi
- 1d: e9 00 00 00 00 jmpq stub_function
+ 2: ff 35 20 00 00 00 pushq 32(%rip) # 28 <ccall_adjustor+0x28>
+ 8: 4d 89 c1 mov %r8,%r9
+ b: 49 89 c8 mov %rcx,%r8
+ e: 48 89 d1 mov %rdx,%rcx
+ 11: 48 89 f2 mov %rsi,%rdx
+ 14: 48 89 fe mov %rdi,%rsi
+ 17: 48 8b 3d 12 00 00 00 mov 18(%rip),%rdi # 30 <ccall_adjustor+0x30>
+ 1e: ff 25 14 00 00 00 jmpq *20(%rip) # 38 <ccall_adjustor+0x38>
...
28: .quad 0 # aligned on 8-byte boundary
+ 30: .quad 0 # aligned on 8-byte boundary
+ 38: .quad 0 # aligned on 8-byte boundary
*/
/* we assume the small code model (gcc -mcmmodel=small) where
}
if (i < 6) {
- adjustor = mallocBytesRWX(40);
-
- *(StgInt32 *)adjustor = 0x49c1894d;
- *(StgInt32 *)(adjustor+4) = 0x8948c889;
- *(StgInt32 *)(adjustor+8) = 0xf28948d1;
- *(StgInt32 *)(adjustor+12) = 0x48fe8948;
- *(StgInt32 *)(adjustor+16) = 0x000a3d8b;
- *(StgInt32 *)(adjustor+20) = 0x00e90000;
-
- *(StgInt32 *)(adjustor+23) =
- (StgInt32)((StgInt64)wptr - (StgInt64)adjustor - 27);
- *(StgInt64 *)(adjustor+32) = (StgInt64)hptr;
+ adjustor = stgMallocBytesRWX(0x30);
+
+ *(StgInt32 *)adjustor = 0x49c1894d;
+ *(StgInt32 *)(adjustor+0x4) = 0x8948c889;
+ *(StgInt32 *)(adjustor+0x8) = 0xf28948d1;
+ *(StgInt32 *)(adjustor+0xc) = 0x48fe8948;
+ *(StgInt32 *)(adjustor+0x10) = 0x000a3d8b;
+ *(StgInt32 *)(adjustor+0x14) = 0x25ff0000;
+ *(StgInt32 *)(adjustor+0x18) = 0x0000000c;
+ *(StgInt64 *)(adjustor+0x20) = (StgInt64)hptr;
+ *(StgInt64 *)(adjustor+0x28) = (StgInt64)wptr;
}
else
{
- adjustor = mallocBytesRWX(48);
-
- *(StgInt32 *)adjustor = 0x00685141;
- *(StgInt32 *)(adjustor+4) = 0x4d000000;
- *(StgInt32 *)(adjustor+8) = 0x8949c189;
- *(StgInt32 *)(adjustor+12) = 0xd18948c8;
- *(StgInt32 *)(adjustor+16) = 0x48f28948;
- *(StgInt32 *)(adjustor+20) = 0x8b48fe89;
- *(StgInt32 *)(adjustor+24) = 0x00000b3d;
- *(StgInt32 *)(adjustor+28) = 0x0000e900;
+ adjustor = stgMallocBytesRWX(0x40);
+
+ *(StgInt32 *)adjustor = 0x35ff5141;
+ *(StgInt32 *)(adjustor+0x4) = 0x00000020;
+ *(StgInt32 *)(adjustor+0x8) = 0x49c1894d;
+ *(StgInt32 *)(adjustor+0xc) = 0x8948c889;
+ *(StgInt32 *)(adjustor+0x10) = 0xf28948d1;
+ *(StgInt32 *)(adjustor+0x14) = 0x48fe8948;
+ *(StgInt32 *)(adjustor+0x18) = 0x00123d8b;
+ *(StgInt32 *)(adjustor+0x1c) = 0x25ff0000;
+ *(StgInt32 *)(adjustor+0x20) = 0x00000014;
- *(StgInt32 *)(adjustor+3) =
- (StgInt32)(StgInt64)obscure_ccall_ret_code;
- *(StgInt32 *)(adjustor+30) =
- (StgInt32)((StgInt64)wptr - (StgInt64)adjustor - 34);
- *(StgInt64 *)(adjustor+40) = (StgInt64)hptr;
+ *(StgInt64 *)(adjustor+0x28) = (StgInt64)obscure_ccall_ret_code;
+ *(StgInt64 *)(adjustor+0x30) = (StgInt64)hptr;
+ *(StgInt64 *)(adjustor+0x38) = (StgInt64)wptr;
}
}
#elif defined(sparc_HOST_ARCH)
similarly, and local variables should be accessed via %fp, not %sp. In a
nutshell: This should work! (Famous last words! :-)
*/
- adjustor = mallocBytesRWX(4*(11+1));
+ adjustor = stgMallocBytesRWX(4*(11+1));
{
unsigned long *const adj_code = (unsigned long *)adjustor;
4 bytes (getting rid of the nop), hence saving memory. [ccshan]
*/
ASSERT(((StgWord64)wptr & 3) == 0);
- adjustor = mallocBytesRWX(48);
+ adjustor = stgMallocBytesRWX(48);
{
StgWord64 *const code = (StgWord64 *)adjustor;
*/
// allocate space for at most 4 insns per parameter
// plus 14 more instructions.
- adjustor = mallocBytesRWX(4 * (4*n + 14));
+ adjustor = stgMallocBytesRWX(4 * (4*n + 14));
code = (unsigned*)adjustor;
*code++ = 0x48000008; // b *+8
#ifdef FUNDESCS
adjustorStub = stgMallocBytes(sizeof(AdjustorStub), "createAdjustor");
#else
- adjustorStub = mallocBytesRWX(sizeof(AdjustorStub));
+ adjustorStub = stgMallocBytesRWX(sizeof(AdjustorStub));
#endif
adjustor = adjustorStub;
#endif
// Calculate the size of the stack frame, in words.
- while(*typeString)
- {
- char t = *typeString++;
-
- switch(t)
- {
-#if defined(powerpc_HOST_ARCH)
- // on 32-bit platforms, Double and Int64 occupy two words.
- case 'd':
- case 'l':
- sz += 2;
- break;
-#endif
- // everything else is one word.
- default:
- sz += 1;
- }
- }
+ sz = totalArgumentSize(typeString);
+
// The first eight words of the parameter area
// are just "backing store" for the parameters passed in
// the GPRs. extra_sz is the number of words beyond those first
void
freeHaskellFunctionPtr(void* ptr)
{
-#if defined(i386_HOST_ARCH)
+#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
if ( *(unsigned char*)ptr != 0x68 &&
*(unsigned char*)ptr != 0x58 ) {
errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
} else {
freeStablePtr(*((StgStablePtr*)((unsigned char*)ptr + 0x02)));
}
+#elif defined(x86_TARGET_ARCH) && defined(darwin_HOST_OS)
+if ( *(unsigned char*)ptr != 0xe8 ) {
+ errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
+ return;
+ }
+ freeStablePtr(((AdjustorStub*)ptr)->hptr);
#elif defined(x86_64_HOST_ARCH)
if ( *(StgWord16 *)ptr == 0x894d ) {
- freeStablePtr(*(StgStablePtr*)(ptr+32));
+ freeStablePtr(*(StgStablePtr*)(ptr+0x20));
} else if ( *(StgWord16 *)ptr == 0x5141 ) {
- freeStablePtr(*(StgStablePtr*)(ptr+40));
+ freeStablePtr(*(StgStablePtr*)(ptr+0x30));
} else {
errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
return;
void
initAdjustor(void)
{
+#if defined(i386_HOST_ARCH) && defined(openbsd_HOST_OS)
+ obscure_ccall_ret_code_dyn = stgMallocBytesRWX(4);
+ obscure_ccall_ret_code_dyn[0] = ((unsigned char *)obscure_ccall_ret_code)[0];
+ obscure_ccall_ret_code_dyn[1] = ((unsigned char *)obscure_ccall_ret_code)[1];
+ obscure_ccall_ret_code_dyn[2] = ((unsigned char *)obscure_ccall_ret_code)[2];
+ obscure_ccall_ret_code_dyn[3] = ((unsigned char *)obscure_ccall_ret_code)[3];
+#endif
}