+#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:
+ argn
+ ...
+ arg7
+ return address
+ %rdi,%rsi,%rdx,%rcx,%r8,%r9 = arg0..arg6
+
+ if there are <6 integer args, then we can just push the
+ StablePtr into %edi and shuffle the other args up.
+
+ If there are >=6 integer args, then we have to flush one arg
+ to the stack, and arrange to adjust the stack ptr on return.
+ The stack will be rearranged to this:
+
+ argn
+ ...
+ arg7
+ return address *** <-- dummy arg in stub fn.
+ arg6
+ obscure_ccall_ret_code
+
+ This unfortunately means that the type of the stub function
+ must have a dummy argument for the original return address
+ pointer inserted just after the 6th integer argument.
+
+ Code for the simple case:
+
+ 0: 4d 89 c1 mov %r8,%r9
+ 3: 49 89 c8 mov %rcx,%r8
+ 6: 48 89 d1 mov %rdx,%rcx
+ 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: 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: 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
+ * all symbols are <2^32, so hence wptr should fit into 32 bits.
+ */
+ ASSERT(((long)wptr >> 32) == 0);
+
+ {
+ int i = 0;
+ char *c;
+
+ // determine whether we have 6 or more integer arguments,
+ // and therefore need to flush one to the stack.
+ for (c = typeString; *c != '\0'; c++) {
+ if (*c == 'i' || *c == 'l') i++;
+ if (i == 6) break;
+ }
+
+ if (i < 6) {
+ 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 = 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;
+
+ *(StgInt64 *)(adjustor+0x28) = (StgInt64)obscure_ccall_ret_code;
+ *(StgInt64 *)(adjustor+0x30) = (StgInt64)hptr;
+ *(StgInt64 *)(adjustor+0x38) = (StgInt64)wptr;
+ }
+ }