Adjustor.c 37.6 KB
Newer Older
1
2
3
4
5
6
/* -----------------------------------------------------------------------------
 * Foreign export adjustor thunks
 *
 * Copyright (c) 1998.
 *
 * ---------------------------------------------------------------------------*/
sof's avatar
sof committed
7

8
9
10
/* A little bit of background...

An adjustor thunk is a dynamically allocated code snippet that allows
sof's avatar
sof committed
11
12
13
Haskell closures to be viewed as C function pointers. 

Stable pointers provide a way for the outside world to get access to,
14
15
and evaluate, Haskell heap objects, with the RTS providing a small
range of ops for doing so. So, assuming we've got a stable pointer in
sof's avatar
sof committed
16
17
18
19
20
21
our hand in C, we can jump into the Haskell world and evaluate a callback
procedure, say. This works OK in some cases where callbacks are used, but
does require the external code to know about stable pointers and how to deal
with them. We'd like to hide the Haskell-nature of a callback and have it
be invoked just like any other C function pointer. 

22
23
24
25
26
27
Enter adjustor thunks. An adjustor thunk is a little piece of code
that's generated on-the-fly (one per Haskell closure being exported)
that, when entered using some 'universal' calling convention (e.g., the
C calling convention on platform X), pushes an implicit stable pointer
(to the Haskell callback) before calling another (static) C function stub
which takes care of entering the Haskell code via its stable pointer.
sof's avatar
sof committed
28
29
30
31
32

An adjustor thunk is allocated on the C heap, and is called from within
Haskell just before handing out the function pointer to the Haskell (IO)
action. User code should never have to invoke it explicitly.

33
An adjustor thunk differs from a C function pointer in one respect: when
sof's avatar
sof committed
34
35
36
the code is through with it, it has to be freed in order to release Haskell
and C resources. Failure to do so result in memory leaks on both the C and
Haskell side.
37
*/
38

39
#include "PosixSource.h"
40
#include "Rts.h"
41
#include "RtsExternal.h"
42
#include "RtsUtils.h"
sof's avatar
sof committed
43
#include <stdlib.h>
sof's avatar
sof committed
44

sof's avatar
sof committed
45
46
47
48
#if defined(_WIN32)
#include <windows.h>
#endif

49
#if defined(openbsd_HOST_OS) || defined(linux_HOST_OS)
dons's avatar
dons committed
50
#include <unistd.h>
51
#include <sys/types.h>
dons's avatar
dons committed
52
#include <sys/mman.h>
53
54

/* no C99 header stdint.h on OpenBSD? */
55
#if defined(openbsd_HOST_OS)
56
typedef unsigned long my_uintptr_t;
57
58
59
60
#else
#include <stdint.h>
typedef uintptr_t my_uintptr_t;
#endif
dons's avatar
dons committed
61
62
#endif

63
#if defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
64
65
66
#include <string.h>
#endif

67
68
69
/* Heavily arch-specific, I'm afraid.. */

/*
70
 * Allocate len bytes which are readable, writable, and executable.
71
 *
72
73
74
 * 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.
75
 */
76
77
static void*
mallocBytesRWX(int len)
78
{
79
  void *addr = stgMallocBytes(len, "mallocBytesRWX");
80
#if defined(i386_HOST_ARCH) && defined(_WIN32)
81
82
83
84
85
86
87
  /* 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);
  }
88
#elif defined(openbsd_HOST_OS) || defined(linux_HOST_OS)
89
90
91
92
93
94
95
96
97
  /* 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);
  }
sof's avatar
sof committed
98
#endif
99
  return addr;
100
}
sof's avatar
sof committed
101

102
103
104
105
106
#ifdef LEADING_UNDERSCORE
#define UNDERSCORE "_"
#else 
#define UNDERSCORE ""
#endif
107
#if defined(i386_HOST_ARCH)
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/* 
  Now here's something obscure for you:

  When generating an adjustor thunk that uses the C calling
  convention, we have to make sure that the thunk kicks off
  the process of jumping into Haskell with a tail jump. Why?
  Because as a result of jumping in into Haskell we may end
  up freeing the very adjustor thunk we came from using
  freeHaskellFunctionPtr(). Hence, we better not return to
  the adjustor code on our way  out, since it could by then
  point to junk.
  
  The fix is readily at hand, just include the opcodes
  for the C stack fixup code that we need to perform when
  returning in some static piece of memory and arrange
  to return to it before tail jumping from the adjustor thunk.
*/
dons's avatar
dons committed
125
126
127
128
129
130
131
132
133
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"
   );
}
134
extern void obscure_ccall_ret_code(void);
dons's avatar
dons committed
135
136
137
138
139

#if defined(openbsd_HOST_OS)
static unsigned char *obscure_ccall_ret_code_dyn;
#endif

ken's avatar
ken committed
140
#endif
141

142
#if defined(x86_64_HOST_ARCH)
dons's avatar
dons committed
143
144
145
static void GNUC3_ATTRIBUTE(used) obscure_ccall_wrapper(void)
{
  __asm__ (
146
147
   ".globl " UNDERSCORE "obscure_ccall_ret_code\n"
   UNDERSCORE "obscure_ccall_ret_code:\n\t"
148
149
150
   "addq $0x8, %rsp\n\t"
   "ret"
  );
dons's avatar
dons committed
151
}
152
153
154
extern void obscure_ccall_ret_code(void);
#endif

155
#if defined(alpha_HOST_ARCH)
ken's avatar
ken committed
156
/* To get the definition of PAL_imb: */
157
# if defined(linux_HOST_OS)
158
159
160
161
#  include <asm/pal.h>
# else
#  include <machine/pal.h>
# endif
ken's avatar
ken committed
162
163
#endif

164
#if defined(ia64_HOST_ARCH)
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
#include "Storage.h"

/* Layout of a function descriptor */
typedef struct _IA64FunDesc {
    StgWord64 ip;
    StgWord64 gp;
} IA64FunDesc;

static void *
stgAllocStable(size_t size_in_bytes, StgStablePtr *stable)
{
  StgArrWords* arr;
  nat data_size_in_words, total_size_in_words;
  
  /* round up to a whole number of words */
  data_size_in_words  = (size_in_bytes + sizeof(W_) + 1) / sizeof(W_);
  total_size_in_words = sizeofW(StgArrWords) + data_size_in_words;
  
  /* allocate and fill it in */
  arr = (StgArrWords *)allocate(total_size_in_words);
  SET_ARR_HDR(arr, &stg_ARR_WORDS_info, CCCS, data_size_in_words);
 
  /* obtain a stable ptr */
  *stable = getStablePtr((StgPtr)arr);

  /* and return a ptr to the goods inside the array */
191
  return(&(arr->payload));
192
193
194
}
#endif

195
#if defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
196
197
198
199
200
201
202
203
__asm__("obscure_ccall_ret_code:\n\t"
        "lwz 1,0(1)\n\t"
        "lwz 0,4(1)\n\t"
        "mtlr 0\n\t"
        "blr");
extern void obscure_ccall_ret_code(void);
#endif

204
205
#if defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
#if !(defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS))
206
207
208
209
210
211
212

/* !!! !!! WARNING: !!! !!!
 * This structure is accessed from AdjustorAsm.s
 * Any changes here have to be mirrored in the offsets there.
 */

typedef struct AdjustorStub {
213
#if defined(powerpc_HOST_ARCH) && defined(darwin_HOST_OS)
214
215
216
217
218
219
    unsigned        lis;
    unsigned        ori;
    unsigned        lwz;
    unsigned        mtctr;
    unsigned        bctr;
    StgFunPtr       code;
220
#elif defined(powerpc64_HOST_ARCH) && defined(darwin_HOST_OS)
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
        /* powerpc64-darwin: just guessing that it won't use fundescs. */
    unsigned        lis;
    unsigned        ori;
    unsigned        rldimi;
    unsigned        oris;
    unsigned        ori2;
    unsigned        lwz;
    unsigned        mtctr;
    unsigned        bctr;
    StgFunPtr       code;
#else
        /* fundesc-based ABIs */
#define         FUNDESCS
    StgFunPtr       code;
    struct AdjustorStub
                    *toc;
    void            *env;
#endif
    StgStablePtr    hptr;
    StgFunPtr       wptr;
    StgInt          negative_framesize;
    StgInt          extrawords_plus_one;
} AdjustorStub;
244

245
#endif
246
247
#endif

sof's avatar
sof committed
248
void*
249
250
251
createAdjustor(int cconv, StgStablePtr hptr,
	       StgFunPtr wptr,
	       char *typeString
252
#if !defined(powerpc_HOST_ARCH) && !defined(powerpc64_HOST_ARCH) && !defined(x86_64_HOST_ARCH)
253
254
255
	          STG_UNUSED
#endif
              )
sof's avatar
sof committed
256
{
ken's avatar
ken committed
257
  void *adjustor = NULL;
258

ken's avatar
ken committed
259
260
261
  switch (cconv)
  {
  case 0: /* _stdcall */
262
#if defined(i386_HOST_ARCH)
sof's avatar
sof committed
263
264
265
266
267
    /* Magic constant computed by inspecting the code length of
       the following assembly language snippet
       (offset and machine code prefixed):

     <0>:	58	          popl   %eax              # temp. remove ret addr..
sof's avatar
sof committed
268
     <1>:	68 fd fc fe fa    pushl  0xfafefcfd  	   # constant is large enough to
sof's avatar
sof committed
269
270
271
272
        			   	           	   # hold a StgStablePtr
     <6>:	50	          pushl  %eax		   # put back ret. addr
     <7>:	b8 fa ef ff 00	  movl   $0x00ffeffa, %eax # load up wptr
     <c>: 	ff e0             jmp    %eax        	   # and jump to it.
sof's avatar
sof committed
273
		# the callee cleans up the stack
sof's avatar
sof committed
274
    */
275
    adjustor = mallocBytesRWX(14);
276
277
278
    {
	unsigned char *const adj_code = (unsigned char *)adjustor;
	adj_code[0x00] = (unsigned char)0x58;  /* popl %eax  */
sof's avatar
sof committed
279

280
281
	adj_code[0x01] = (unsigned char)0x68;  /* pushl hptr (which is a dword immediate ) */
	*((StgStablePtr*)(adj_code + 0x02)) = (StgStablePtr)hptr;
sof's avatar
sof committed
282

283
	adj_code[0x06] = (unsigned char)0x50; /* pushl %eax */
sof's avatar
sof committed
284

285
286
	adj_code[0x07] = (unsigned char)0xb8; /* movl  $wptr, %eax */
	*((StgFunPtr*)(adj_code + 0x08)) = (StgFunPtr)wptr;
sof's avatar
sof committed
287

288
289
290
	adj_code[0x0c] = (unsigned char)0xff; /* jmp %eax */
	adj_code[0x0d] = (unsigned char)0xe0;
    }
ken's avatar
ken committed
291
292
#endif
    break;
sof's avatar
sof committed
293

ken's avatar
ken committed
294
  case 1: /* _ccall */
295
#if defined(i386_HOST_ARCH)
sof's avatar
sof committed
296
297
298
299
  /* Magic constant computed by inspecting the code length of
     the following assembly language snippet
     (offset and machine code prefixed):

sof's avatar
sof committed
300
  <00>: 68 ef be ad de     pushl  $0xdeadbeef  	   # constant is large enough to
sof's avatar
sof committed
301
        			   	           # hold a StgStablePtr
sof's avatar
sof committed
302
  <05>:	b8 fa ef ff 00	   movl   $0x00ffeffa, %eax # load up wptr
303
  <0a>: 68 ef be ad de     pushl  $obscure_ccall_ret_code # push the return address
sof's avatar
sof committed
304
  <0f>: ff e0              jmp    *%eax            # jump to wptr
sof's avatar
sof committed
305
306
307

    The ccall'ing version is a tad different, passing in the return
    address of the caller to the auto-generated C stub (which enters
sof's avatar
sof committed
308
    via the stable pointer.) (The auto-generated C stub is in on this
sof's avatar
sof committed
309
310
    game, don't worry :-)

311
    See the comment next to obscure_ccall_ret_code why we need to
sof's avatar
sof committed
312
313
314
315
    perform a tail jump instead of a call, followed by some C stack
    fixup.

    Note: The adjustor makes the assumption that any return value
sof's avatar
sof committed
316
317
318
    coming back from the C stub is not stored on the stack.
    That's (thankfully) the case here with the restricted set of 
    return types that we support.
sof's avatar
sof committed
319
  */
320
    adjustor = mallocBytesRWX(17);
321
322
    {
	unsigned char *const adj_code = (unsigned char *)adjustor;
sof's avatar
sof committed
323

324
325
	adj_code[0x00] = (unsigned char)0x68;  /* pushl hptr (which is a dword immediate ) */
	*((StgStablePtr*)(adj_code+0x01)) = (StgStablePtr)hptr;
sof's avatar
sof committed
326

327
328
	adj_code[0x05] = (unsigned char)0xb8;  /* movl  $wptr, %eax */
	*((StgFunPtr*)(adj_code + 0x06)) = (StgFunPtr)wptr;
sof's avatar
sof committed
329

330
	adj_code[0x0a] = (unsigned char)0x68;  /* pushl obscure_ccall_ret_code */
dons's avatar
dons committed
331
332
333
334
335
336
	*((StgFunPtr*)(adj_code + 0x0b)) = 
#if !defined(openbsd_HOST_OS)
			(StgFunPtr)obscure_ccall_ret_code;
#else
			(StgFunPtr)obscure_ccall_ret_code_dyn;
#endif
337

338
339
340
	adj_code[0x0f] = (unsigned char)0xff; /* jmp *%eax */
	adj_code[0x10] = (unsigned char)0xe0; 
    }
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
#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:   e9 00 00 00 00          jmpq   stub_function
  ... 
  20: .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
  ...
  28: .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 = 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;
	}
	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;
	    
	    *(StgInt32 *)(adjustor+3) = 
		(StgInt32)(StgInt64)obscure_ccall_ret_code;
	    *(StgInt32 *)(adjustor+30) = 
		(StgInt32)((StgInt64)wptr - (StgInt64)adjustor - 34);
	    *(StgInt64 *)(adjustor+40) = (StgInt64)hptr;
	}
    }
446
#elif defined(sparc_HOST_ARCH)
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
  /* Magic constant computed by inspecting the code length of the following
     assembly language snippet (offset and machine code prefixed):

     <00>: 9C23A008   sub   %sp, 8, %sp         ! make room for %o4/%o5 in caller's frame
     <04>: DA23A060   st    %o5, [%sp + 96]     ! shift registers by 2 positions
     <08>: D823A05C   st    %o4, [%sp + 92]
     <0C>: 9A10000B   mov   %o3, %o5
     <10>: 9810000A   mov   %o2, %o4
     <14>: 96100009   mov   %o1, %o3
     <18>: 94100008   mov   %o0, %o2
     <1C>: 13000000   sethi %hi(wptr), %o1      ! load up wptr (1 of 2)
     <20>: 11000000   sethi %hi(hptr), %o0      ! load up hptr (1 of 2)
     <24>: 81C26000   jmp   %o1 + %lo(wptr)     ! jump to wptr (load 2 of 2)
     <28>: 90122000   or    %o0, %lo(hptr), %o0 ! load up hptr (2 of 2, delay slot)
     <2C>  00000000                             ! place for getting hptr back easily

     ccall'ing on SPARC is easy, because we are quite lucky to push a
     multiple of 8 bytes (1 word hptr + 1 word dummy arg) in front of the
     existing arguments (note that %sp must stay double-word aligned at
     all times, see ABI spec at http://www.sparc.org/standards/psABI3rd.pdf).
     To do this, we extend the *caller's* stack frame by 2 words and shift
     the output registers used for argument passing (%o0 - %o5, we are a *leaf*
     procedure because of the tail-jump) by 2 positions. This makes room in
     %o0 and %o1 for the additinal arguments, namely  hptr and a dummy (used
     for destination addr of jump on SPARC, return address on x86, ...). This
     shouldn't cause any problems for a C-like caller: alloca is implemented
     similarly, and local variables should be accessed via %fp, not %sp. In a
     nutshell: This should work! (Famous last words! :-)
475
  */
476
    adjustor = mallocBytesRWX(4*(11+1));
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
    {
        unsigned long *const adj_code = (unsigned long *)adjustor;

        adj_code[ 0]  = 0x9C23A008UL;   /* sub   %sp, 8, %sp         */
        adj_code[ 1]  = 0xDA23A060UL;   /* st    %o5, [%sp + 96]     */
        adj_code[ 2]  = 0xD823A05CUL;   /* st    %o4, [%sp + 92]     */
        adj_code[ 3]  = 0x9A10000BUL;   /* mov   %o3, %o5            */
        adj_code[ 4]  = 0x9810000AUL;   /* mov   %o2, %o4            */
        adj_code[ 5]  = 0x96100009UL;   /* mov   %o1, %o3            */
        adj_code[ 6]  = 0x94100008UL;   /* mov   %o0, %o2            */
        adj_code[ 7]  = 0x13000000UL;   /* sethi %hi(wptr), %o1      */
        adj_code[ 7] |= ((unsigned long)wptr) >> 10;
        adj_code[ 8]  = 0x11000000UL;   /* sethi %hi(hptr), %o0      */
        adj_code[ 8] |= ((unsigned long)hptr) >> 10;
        adj_code[ 9]  = 0x81C26000UL;   /* jmp   %o1 + %lo(wptr)     */
        adj_code[ 9] |= ((unsigned long)wptr) & 0x000003FFUL;
        adj_code[10]  = 0x90122000UL;   /* or    %o0, %lo(hptr), %o0 */
        adj_code[10] |= ((unsigned long)hptr) & 0x000003FFUL;

        adj_code[11]  = (unsigned long)hptr;

        /* flush cache */
        asm("flush %0" : : "r" (adj_code     ));
        asm("flush %0" : : "r" (adj_code +  2));
        asm("flush %0" : : "r" (adj_code +  4));
        asm("flush %0" : : "r" (adj_code +  6));
        asm("flush %0" : : "r" (adj_code + 10));

        /* max. 5 instructions latency, and we need at >= 1 for returning */
        asm("nop");
        asm("nop");
        asm("nop");
        asm("nop");
    }
511
#elif defined(alpha_HOST_ARCH)
ken's avatar
ken committed
512
513
514
515
516
  /* Magic constant computed by inspecting the code length of
     the following assembly language snippet
     (offset and machine code prefixed; note that the machine code
     shown is longwords stored in little-endian order):

ken's avatar
ken committed
517
518
519
520
  <00>: 46520414	mov	a2, a4
  <04>: 46100412	mov	a0, a2
  <08>: a61b0020	ldq     a0, 0x20(pv)	# load up hptr
  <0c>: 46730415	mov	a3, a5
ken's avatar
ken committed
521
  <10>: a77b0028	ldq     pv, 0x28(pv)	# load up wptr
ken's avatar
ken committed
522
523
524
525
526
  <14>: 46310413	mov	a1, a3
  <18>: 6bfb----	jmp     (pv), <hint>	# jump to wptr (with hint)
  <1c>: 00000000				# padding for alignment
  <20>: [8 bytes for hptr quadword]
  <28>: [8 bytes for wptr quadword]
ken's avatar
ken committed
527
528
529
530
531
532

     The "computed" jump at <08> above is really a jump to a fixed
     location.  Accordingly, we place an always-correct hint in the
     jump instruction, namely the address offset from <0c> to wptr,
     divided by 4, taking the lowest 14 bits.

ken's avatar
ken committed
533
     We only support passing 4 or fewer argument words, for the same
534
     reason described under sparc_HOST_ARCH above by JRS, 21 Aug 01.
ken's avatar
ken committed
535
536
537
538
539
540
541
542
543
544
545
546
     On the Alpha the first 6 integer arguments are in a0 through a5,
     and the rest on the stack.  Hence we want to shuffle the original
     caller's arguments by two.

     On the Alpha the calling convention is so complex and dependent
     on the callee's signature -- for example, the stack pointer has
     to be a multiple of 16 -- that it seems impossible to me [ccshan]
     to handle the general case correctly without changing how the
     adjustor is called from C.  For now, our solution of shuffling
     registers only and ignoring the stack only works if the original
     caller passed 4 or fewer argument words.

ken's avatar
ken committed
547
548
549
550
551
552
TODO: Depending on how much allocation overhead stgMallocBytes uses for
      header information (more precisely, if the overhead is no more than
      4 bytes), we should move the first three instructions above down by
      4 bytes (getting rid of the nop), hence saving memory. [ccshan]
  */
    ASSERT(((StgWord64)wptr & 3) == 0);
553
    adjustor = mallocBytesRWX(48);
554
555
    {
	StgWord64 *const code = (StgWord64 *)adjustor;
556

557
558
559
560
561
	code[0] = 0x4610041246520414L;
	code[1] = 0x46730415a61b0020L;
	code[2] = 0x46310413a77b0028L;
	code[3] = 0x000000006bfb0000L
		| (((StgWord32*)(wptr) - (StgWord32*)(code) - 3) & 0x3fff);
ken's avatar
ken committed
562

563
564
	code[4] = (StgWord64)hptr;
	code[5] = (StgWord64)wptr;
ken's avatar
ken committed
565

566
567
568
	/* Ensure that instruction cache is consistent with our new code */
	__asm__ volatile("call_pal %0" : : "i" (PAL_imb));
    }
569
#elif defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776

#define OP_LO(op,lo)  ((((unsigned)(op)) << 16) | (((unsigned)(lo)) & 0xFFFF))
#define OP_HI(op,hi)  ((((unsigned)(op)) << 16) | (((unsigned)(hi)) >> 16))
    {
        /* The PowerPC Linux (32-bit) calling convention is annoyingly complex.
           We need to calculate all the details of the stack frame layout,
           taking into account the types of all the arguments, and then
           generate code on the fly. */
    
        int src_gpr = 3, dst_gpr = 5;
        int fpr = 3;
        int src_offset = 0, dst_offset = 0;
        int n = strlen(typeString),i;
        int src_locs[n], dst_locs[n];
        int frameSize;
        unsigned *code;
      
            /* Step 1:
               Calculate where the arguments should go.
               src_locs[] will contain the locations of the arguments in the
               original stack frame passed to the adjustor.
               dst_locs[] will contain the locations of the arguments after the
               adjustor runs, on entry to the wrapper proc pointed to by wptr.

               This algorithm is based on the one described on page 3-19 of the
               System V ABI PowerPC Processor Supplement.
            */
        for(i=0;typeString[i];i++)
        {
            char t = typeString[i];
            if((t == 'f' || t == 'd') && fpr <= 8)
                src_locs[i] = dst_locs[i] = -32-(fpr++);
            else
            {
                if(t == 'l' && src_gpr <= 9)
                {
                    if((src_gpr & 1) == 0)
                        src_gpr++;
                    src_locs[i] = -src_gpr;
                    src_gpr += 2;
                }
                else if(t == 'i' && src_gpr <= 10)
                {
                    src_locs[i] = -(src_gpr++);
                }
                else
                {
                    if(t == 'l' || t == 'd')
                    {
                        if(src_offset % 8)
                            src_offset += 4;
                    }
                    src_locs[i] = src_offset;
                    src_offset += (t == 'l' || t == 'd') ? 8 : 4;
                }

                if(t == 'l' && dst_gpr <= 9)
                {
                    if((dst_gpr & 1) == 0)
                        dst_gpr++;
                    dst_locs[i] = -dst_gpr;
                    dst_gpr += 2;
                }
                else if(t == 'i' && dst_gpr <= 10)
                {
                    dst_locs[i] = -(dst_gpr++);
                }
                else
                {
                    if(t == 'l' || t == 'd')
                    {
                        if(dst_offset % 8)
                            dst_offset += 4;
                    }
                    dst_locs[i] = dst_offset;
                    dst_offset += (t == 'l' || t == 'd') ? 8 : 4;
                }
            }
        }

        frameSize = dst_offset + 8;
        frameSize = (frameSize+15) & ~0xF;

            /* Step 2:
               Build the adjustor.
            */
                    // allocate space for at most 4 insns per parameter
                    // plus 14 more instructions.
        adjustor = mallocBytesRWX(4 * (4*n + 14));
        code = (unsigned*)adjustor;
        
        *code++ = 0x48000008; // b *+8
            // * Put the hptr in a place where freeHaskellFunctionPtr
            //   can get at it.
        *code++ = (unsigned) hptr;

            // * save the link register
        *code++ = 0x7c0802a6; // mflr r0;
        *code++ = 0x90010004; // stw r0, 4(r1);
            // * and build a new stack frame
        *code++ = OP_LO(0x9421, -frameSize); // stwu r1, -frameSize(r1)

            // * now generate instructions to copy arguments
            //   from the old stack frame into the new stack frame.
        for(i=n-1;i>=0;i--)
        {
            if(src_locs[i] < -32)
                ASSERT(dst_locs[i] == src_locs[i]);
            else if(src_locs[i] < 0)
            {
                // source in GPR.
                ASSERT(typeString[i] != 'f' && typeString[i] != 'd');
                if(dst_locs[i] < 0)
                {
                    ASSERT(dst_locs[i] > -32);
                        // dst is in GPR, too.

                    if(typeString[i] == 'l')
                    {
                            // mr dst+1, src+1
                        *code++ = 0x7c000378
                                | ((-dst_locs[i]+1) << 16)
                                | ((-src_locs[i]+1) << 11)
                                | ((-src_locs[i]+1) << 21);
                    }
                    // mr dst, src
                    *code++ = 0x7c000378
                            | ((-dst_locs[i]) << 16)
                            | ((-src_locs[i]) << 11)
                            | ((-src_locs[i]) << 21);
                }
                else
                {
                    if(typeString[i] == 'l')
                    {
                            // stw src+1, dst_offset+4(r1)
                        *code++ = 0x90010000
                                | ((-src_locs[i]+1) << 21)
                                | (dst_locs[i] + 4);
                    }
                    
                        // stw src, dst_offset(r1)
                    *code++ = 0x90010000
                            | ((-src_locs[i]) << 21)
                            | (dst_locs[i] + 8);
                }
            }
            else
            {
                ASSERT(dst_locs[i] >= 0);
                ASSERT(typeString[i] != 'f' && typeString[i] != 'd');

                if(typeString[i] == 'l')
                {
                    // lwz r0, src_offset(r1)
                        *code++ = 0x80010000
                                | (src_locs[i] + frameSize + 8 + 4);
                    // stw r0, dst_offset(r1)
                        *code++ = 0x90010000
                                | (dst_locs[i] + 8 + 4);
                    }
                // lwz r0, src_offset(r1)
                    *code++ = 0x80010000
                            | (src_locs[i] + frameSize + 8);
                // stw r0, dst_offset(r1)
                    *code++ = 0x90010000
                            | (dst_locs[i] + 8);
           }
        }

            // * hptr will be the new first argument.
            // lis r3, hi(hptr)
        *code++ = OP_HI(0x3c60, hptr);
            // ori r3,r3,lo(hptr)
        *code++ = OP_LO(0x6063, hptr);

            // * we need to return to a piece of code
            //   which will tear down the stack frame.
            // lis r11,hi(obscure_ccall_ret_code)
        *code++ = OP_HI(0x3d60, obscure_ccall_ret_code);
            // ori r11,r11,lo(obscure_ccall_ret_code)
        *code++ = OP_LO(0x616b, obscure_ccall_ret_code);
            // mtlr r11
        *code++ = 0x7d6803a6;

            // * jump to wptr
            // lis r11,hi(wptr)
        *code++ = OP_HI(0x3d60, wptr);
            // ori r11,r11,lo(wptr)
        *code++ = OP_LO(0x616b, wptr);
            // mtctr r11
        *code++ = 0x7d6903a6;
            // bctr
        *code++ = 0x4e800420;

        // Flush the Instruction cache:
        {
            unsigned *p = adjustor;
            while(p < code)
            {
                __asm__ volatile ("dcbf 0,%0\n\tsync\n\ticbi 0,%0"
                                 : : "r" (p));
                p++;
            }
            __asm__ volatile ("sync\n\tisync");
        }
    }
777

778
#elif defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
779
780
781
        
#define OP_LO(op,lo)  ((((unsigned)(op)) << 16) | (((unsigned)(lo)) & 0xFFFF))
#define OP_HI(op,hi)  ((((unsigned)(op)) << 16) | (((unsigned)(hi)) >> 16))
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
    {
        /* The following code applies to all PowerPC and PowerPC64 platforms
           whose stack layout is based on the AIX ABI.

           Besides (obviously) AIX, this includes
            Mac OS 9 and BeOS/PPC (may they rest in peace),
                which use the 32-bit AIX ABI
            powerpc64-linux,
                which uses the 64-bit AIX ABI
            and Darwin (Mac OS X),
                which uses the same stack layout as AIX,
                but no function descriptors.

           The actual stack-frame shuffling is implemented out-of-line
           in the function adjustorCode, in AdjustorAsm.S.
           Here, we set up an AdjustorStub structure, which
           is a function descriptor (on platforms that have function
           descriptors) or a short piece of stub code (on Darwin) to call
           adjustorCode with a pointer to the AdjustorStub struct loaded
           into register r2.

           One nice thing about this is that there is _no_ code generated at
           runtime on the platforms that have function descriptors.
        */
        AdjustorStub *adjustorStub;
        int sz = 0, extra_sz, total_sz;

            // from AdjustorAsm.s
            // not declared as a function so that AIX-style
            // fundescs can never get in the way.
        extern void *adjustorCode;
        
814
#ifdef FUNDESCS
815
        adjustorStub = stgMallocBytes(sizeof(AdjustorStub), "createAdjustor");
816
#else
817
        adjustorStub = mallocBytesRWX(sizeof(AdjustorStub));
818
#endif
819
820
821
        adjustor = adjustorStub;
            
        adjustorStub->code = (void*) &adjustorCode;
822
823

#ifdef FUNDESCS
824
825
826
            // function descriptors are a cool idea.
            // We don't need to generate any code at runtime.
        adjustorStub->toc = adjustorStub;
827
828
#else

829
830
            // no function descriptors :-(
            // We need to do things "by hand".
831
#if defined(powerpc_HOST_ARCH)
832
833
834
835
836
837
838
839
840
841
842
            // lis  r2, hi(adjustorStub)
        adjustorStub->lis = OP_HI(0x3c40, adjustorStub);
            // ori  r2, r2, lo(adjustorStub)
        adjustorStub->ori = OP_LO(0x6042, adjustorStub);
            // lwz r0, code(r2)
        adjustorStub->lwz = OP_LO(0x8002, (char*)(&adjustorStub->code)
                                        - (char*)adjustorStub);
            // mtctr r0
        adjustorStub->mtctr = 0x7c0903a6;
            // bctr
        adjustorStub->bctr = 0x4e800420;
843
#else
844
        barf("adjustor creation not supported on this platform");
845
846
#endif

847
848
849
850
851
        // Flush the Instruction cache:
        {
            int n = sizeof(AdjustorStub)/sizeof(unsigned);
            unsigned *p = (unsigned*)adjustor;
            while(n--)
852
            {
853
854
855
                __asm__ volatile ("dcbf 0,%0\n\tsync\n\ticbi 0,%0"
                                    : : "r" (p));
                p++;
856
            }
857
858
            __asm__ volatile ("sync\n\tisync");
        }
859
860
#endif

861
862
863
864
            // Calculate the size of the stack frame, in words.
        while(*typeString)
        {
            char t = *typeString++;
865

866
867
            switch(t)
            {
868
#if defined(powerpc_HOST_ARCH)
869
870
871
872
873
                    // on 32-bit platforms, Double and Int64 occupy two words.
                case 'd':
                case 'l':
                    sz += 2;
                    break;
874
#endif
875
876
877
                    // everything else is one word.
                default:
                    sz += 1;
878
879
            }
        }
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
            // 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
            // 8 words.
        extra_sz = sz - 8;
        if(extra_sz < 0)
            extra_sz = 0;

            // Calculate the total size of the stack frame.
        total_sz = (6 /* linkage area */
                  + 8 /* minimum parameter area */
                  + 2 /* two extra arguments */
                  + extra_sz)*sizeof(StgWord);
       
            // align to 16 bytes.
            // AIX only requires 8 bytes, but who cares?
        total_sz = (total_sz+15) & ~0xF;
       
            // Fill in the information that adjustorCode in AdjustorAsm.S
            // will use to create a new stack frame with the additional args.
        adjustorStub->hptr = hptr;
        adjustorStub->wptr = wptr;
        adjustorStub->negative_framesize = -total_sz;
        adjustorStub->extrawords_plus_one = extra_sz + 1;
    }
905

906
#elif defined(ia64_HOST_ARCH)
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
/*
    Up to 8 inputs are passed in registers.  We flush the last two inputs to
    the stack, initially into the 16-byte scratch region left by the caller.
    We then shuffle the others along by 4 (taking 2 registers for ourselves
    to save return address and previous function state - we need to come back
    here on the way out to restore the stack, so this is a real function
    rather than just a trampoline).
    
    The function descriptor we create contains the gp of the target function
    so gp is already loaded correctly.

	[MLX]       alloc r16=ar.pfs,10,2,0
		    movl r17=wptr
	[MII]       st8.spill [r12]=r38,8		// spill in6 (out4)
		    mov r41=r37				// out7 = in5 (out3)
		    mov r40=r36;;			// out6 = in4 (out2)
	[MII]       st8.spill [r12]=r39			// spill in7 (out5)
		    mov.sptk b6=r17,50
		    mov r38=r34;;			// out4 = in2 (out0)
	[MII]       mov r39=r35				// out5 = in3 (out1)
		    mov r37=r33				// out3 = in1 (loc1)
		    mov r36=r32				// out2 = in0 (loc0)
	[MLX]       adds r12=-24,r12			// update sp
		    movl r34=hptr;;			// out0 = hptr
	[MIB]       mov r33=r16				// loc1 = ar.pfs
		    mov r32=b0				// loc0 = retaddr
		    br.call.sptk.many b0=b6;;

	[MII]       adds r12=-16,r12
		    mov b0=r32
		    mov.i ar.pfs=r33
	[MFB]       nop.m 0x0
		    nop.f 0x0
		    br.ret.sptk.many b0;;
*/

/* These macros distribute a long constant into the two words of an MLX bundle */
#define BITS(val,start,count)	(((val) >> (start)) & ((1 << (count))-1))
#define MOVL_LOWORD(val)	(BITS(val,22,18) << 46)
#define MOVL_HIWORD(val)	(BITS(val,40,23) | (BITS(val,0,7) << 36) | (BITS(val,7,9) << 50) \
				| (BITS(val,16,5) << 55) | (BITS(val,21,1) << 44) | BITS(val,63,1) << 59)

    {
	StgStablePtr stable;
	IA64FunDesc *wdesc = (IA64FunDesc *)wptr;
	StgWord64 wcode = wdesc->ip;
	IA64FunDesc *fdesc;
	StgWord64 *code;

	/* we allocate on the Haskell heap since malloc'd memory isn't executable - argh */
	adjustor = stgAllocStable(sizeof(IA64FunDesc)+18*8, &stable);

	fdesc = (IA64FunDesc *)adjustor;
	code = (StgWord64 *)(fdesc + 1);
	fdesc->ip = (StgWord64)code;
	fdesc->gp = wdesc->gp;

	code[0]  = 0x0000058004288004 | MOVL_LOWORD(wcode);
	code[1]  = 0x6000000220000000 | MOVL_HIWORD(wcode);
	code[2]  = 0x029015d818984001;
	code[3]  = 0x8401200500420094;
	code[4]  = 0x886011d8189c0001;
	code[5]  = 0x84011004c00380c0;
	code[6]  = 0x0250210046013800;
	code[7]  = 0x8401000480420084;
	code[8]  = 0x0000233f19a06005 | MOVL_LOWORD((StgWord64)hptr);
	code[9]  = 0x6000000440000000 | MOVL_HIWORD((StgWord64)hptr);
	code[10] = 0x0200210020010811;
	code[11] = 0x1080006800006200;
	code[12] = 0x0000210018406000;
	code[13] = 0x00aa021000038005;
	code[14] = 0x000000010000001d;
	code[15] = 0x0084000880000200;

	/* save stable pointers in convenient form */
	code[16] = (StgWord64)hptr;
	code[17] = (StgWord64)stable;
    }
ken's avatar
ken committed
985
#else
986
    barf("adjustor creation not supported on this platform");
987
#endif
ken's avatar
ken committed
988
    break;
sof's avatar
sof committed
989
  
ken's avatar
ken committed
990
991
992
  default:
    ASSERT(0);
    break;
sof's avatar
sof committed
993
994
995
  }

  /* Have fun! */
ken's avatar
ken committed
996
  return adjustor;
sof's avatar
sof committed
997
998
}

ken's avatar
ken committed
999

sof's avatar
sof committed
1000
void
1001
freeHaskellFunctionPtr(void* ptr)
sof's avatar
sof committed
1002
{
1003
#if defined(i386_HOST_ARCH)
sof's avatar
sof committed
1004
1005
 if ( *(unsigned char*)ptr != 0x68 &&
      *(unsigned char*)ptr != 0x58 ) {
1006
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
sof's avatar
sof committed
1007
1008
1009
   return;
 }

sof's avatar
sof committed
1010
 /* Free the stable pointer first..*/
sof's avatar
sof committed
1011
 if (*(unsigned char*)ptr == 0x68) { /* Aha, a ccall adjustor! */
1012
    freeStablePtr(*((StgStablePtr*)((unsigned char*)ptr + 0x01)));
sof's avatar
sof committed
1013
 } else {
1014
    freeStablePtr(*((StgStablePtr*)((unsigned char*)ptr + 0x02)));
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
 }
#elif defined(x86_64_HOST_ARCH)
 if ( *(StgWord16 *)ptr == 0x894d ) {
     freeStablePtr(*(StgStablePtr*)(ptr+32));
 } else if ( *(StgWord16 *)ptr == 0x5141 ) {
     freeStablePtr(*(StgStablePtr*)(ptr+40));
 } else {
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
   return;
 }
1025
#elif defined(sparc_HOST_ARCH)
1026
 if ( *(unsigned long*)ptr != 0x9C23A008UL ) {
1027
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
1028
1029
1030
1031
   return;
 }

 /* Free the stable pointer first..*/
1032
 freeStablePtr(*((StgStablePtr*)((unsigned long*)ptr + 11)));
1033
#elif defined(alpha_HOST_ARCH)
ken's avatar
ken committed
1034
 if ( *(StgWord64*)ptr != 0xa77b0018a61b0010L ) {
1035
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
ken's avatar
ken committed
1036
1037
1038
1039
1040
   return;
 }

 /* Free the stable pointer first..*/
 freeStablePtr(*((StgStablePtr*)((unsigned char*)ptr + 0x10)));
1041
#elif defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
1042
 if ( *(StgWord*)ptr != 0x48000008 ) {
1043
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
1044
1045
   return;
 }
1046
 freeStablePtr(((StgStablePtr*)ptr)[1]);
1047
#elif defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
1048
1049
1050
1051
1052
1053
 extern void* adjustorCode;
 if ( ((AdjustorStub*)ptr)->code != (StgFunPtr) &adjustorCode ) {
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
   return;
 }
 freeStablePtr(((AdjustorStub*)ptr)->hptr);
1054
#elif defined(ia64_HOST_ARCH)
1055
1056
1057
1058
 IA64FunDesc *fdesc = (IA64FunDesc *)ptr;
 StgWord64 *code = (StgWord64 *)(fdesc+1);

 if (fdesc->ip != (StgWord64)code) {
1059
   errorBelch("freeHaskellFunctionPtr: not for me, guv! %p\n", ptr);
1060
1061
1062
1063
1064
   return;
 }
 freeStablePtr((StgStablePtr)code[16]);
 freeStablePtr((StgStablePtr)code[17]);
 return;
ken's avatar
ken committed
1065
1066
#else
 ASSERT(0);
1067
#endif
sof's avatar
sof committed
1068
 *((unsigned char*)ptr) = '\0';
sof's avatar
sof committed
1069

sof's avatar
sof committed
1070
 stgFree(ptr);
sof's avatar
sof committed
1071
1072
}

sof's avatar
sof committed
1073
1074
1075
1076
1077
1078

/*
 * Function: initAdjustor()
 *
 * Perform initialisation of adjustor thunk layer (if needed.)
 */
1079
void
sof's avatar
sof committed
1080
1081
initAdjustor(void)
{
dons's avatar
dons committed
1082
1083
1084
1085
1086
1087
1088
#if defined(i386_HOST_ARCH) && defined(openbsd_HOST_OS)
    obscure_ccall_ret_code_dyn = mallocBytesRWX(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
sof's avatar
sof committed
1089
}