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

8
/* A little bit of background...
9
   
10
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
the code is through with it, it has to be freed in order to release Haskell
35
and C resources. Failure to do so will result in memory leaks on both the C and
sof's avatar
sof committed
36
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

45
#if defined(USE_LIBFFI_FOR_ADJUSTORS)
46

47
#include "ffi.h"
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <string.h>

void
freeHaskellFunctionPtr(void* ptr)
{
    ffi_closure *cl;

    cl = (ffi_closure*)ptr;
    freeStablePtr(cl->user_data);
    stgFree(cl->cif->arg_types);
    stgFree(cl->cif);
    freeExec(cl);
}

static ffi_type * char_to_ffi_type(char c)
{
    switch (c) {
    case 'v':  return &ffi_type_void;
    case 'f':  return &ffi_type_float;
    case 'd':  return &ffi_type_double;
    case 'L':  return &ffi_type_sint64;
    case 'l':  return &ffi_type_uint64;
    case 'W':  return &ffi_type_sint32;
    case 'w':  return &ffi_type_uint32;
    case 'S':  return &ffi_type_sint16;
    case 's':  return &ffi_type_uint16;
    case 'B':  return &ffi_type_sint8;
    case 'b':  return &ffi_type_uint8;
76
    case 'p':  return &ffi_type_pointer;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
    default:   barf("char_to_ffi_type: unknown type '%c'", c);
    }
}

void*
createAdjustor (int cconv, 
                StgStablePtr hptr,
                StgFunPtr wptr,
                char *typeString)
{
    ffi_cif *cif;
    ffi_type **arg_types;
    nat n_args, i;
    ffi_type *result_type;
    ffi_closure *cl;
    int r, abi;
93
    void *code;
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

    n_args = strlen(typeString) - 1;
    cif = stgMallocBytes(sizeof(ffi_cif), "createAdjustor");
    arg_types = stgMallocBytes(n_args * sizeof(ffi_type*), "createAdjustor");

    result_type = char_to_ffi_type(typeString[0]);
    for (i=0; i < n_args; i++) {
        arg_types[i] = char_to_ffi_type(typeString[i+1]);
    }
    switch (cconv) {
#ifdef mingw32_TARGET_OS
    case 0: /* stdcall */
        abi = FFI_STDCALL;
        break;
#endif
    case 1: /* ccall */
        abi = FFI_DEFAULT_ABI;
        break;
    default:
        barf("createAdjustor: convention %d not supported on this platform", cconv);
    }

    r = ffi_prep_cif(cif, abi, n_args, result_type, arg_types);
    if (r != FFI_OK) barf("ffi_prep_cif failed: %d", r);
    
119
120
121
122
    cl = allocateExec(sizeof(ffi_closure), &code);
    if (cl == NULL) {
        barf("createAdjustor: failed to allocate memory");
    }
123
124
125
126

    r = ffi_prep_closure(cl, cif, (void*)wptr, hptr/*userdata*/);
    if (r != FFI_OK) barf("ffi_prep_closure failed: %d", r);

127
    return (void*)code;
128
129
130
131
}

#else // To end of file...

sof's avatar
sof committed
132
133
134
135
#if defined(_WIN32)
#include <windows.h>
#endif

136
#if defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
137
138
139
#include <string.h>
#endif

140
141
142
143
144
#ifdef LEADING_UNDERSCORE
#define UNDERSCORE "_"
#else 
#define UNDERSCORE ""
#endif
145
#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/* 
  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
163
164
165
166
167
168
169
170
171
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"
   );
}
172
extern void obscure_ccall_ret_code(void);
dons's avatar
dons committed
173

ken's avatar
ken committed
174
#endif
175

176
#if defined(x86_64_HOST_ARCH)
dons's avatar
dons committed
177
178
179
static void GNUC3_ATTRIBUTE(used) obscure_ccall_wrapper(void)
{
  __asm__ (
180
181
   ".globl " UNDERSCORE "obscure_ccall_ret_code\n"
   UNDERSCORE "obscure_ccall_ret_code:\n\t"
182
183
184
   "addq $0x8, %rsp\n\t"
   "ret"
  );
dons's avatar
dons committed
185
}
186
187
188
extern void obscure_ccall_ret_code(void);
#endif

189
#if defined(alpha_HOST_ARCH)
ken's avatar
ken committed
190
/* To get the definition of PAL_imb: */
191
# if defined(linux_HOST_OS)
192
193
194
195
#  include <asm/pal.h>
# else
#  include <machine/pal.h>
# endif
ken's avatar
ken committed
196
197
#endif

198
#if defined(ia64_HOST_ARCH)
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

/* 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 */
224
  return(&(arr->payload));
225
226
227
}
#endif

228
#if defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
229
230
231
232
233
234
235
236
__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

237
238
#if defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
#if !(defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS))
239
240
241
242
243
244
245

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

typedef struct AdjustorStub {
246
#if defined(powerpc_HOST_ARCH) && defined(darwin_HOST_OS)
247
248
249
250
251
252
    unsigned        lis;
    unsigned        ori;
    unsigned        lwz;
    unsigned        mtctr;
    unsigned        bctr;
    StgFunPtr       code;
253
#elif defined(powerpc64_HOST_ARCH) && defined(darwin_HOST_OS)
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
        /* 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;
277

278
#endif
279
280
#endif

281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
#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

Ian Lynagh's avatar
Ian Lynagh committed
297
#if (defined(i386_HOST_ARCH) && defined(darwin_HOST_OS)) || defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
298
299
300
301
302
303
304
305
306
307
308
309
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':
310
            case 'L':
311
312
313
314
315
316
317
318
319
320
321
322
323
324
                if(sizeof(void*) == 4)
                {
                    sz += 2;
                    break;
                }
                // everything else is one word.
            default:
                sz += 1;
        }
    }
    return sz;
}
#endif

sof's avatar
sof committed
325
void*
326
327
328
createAdjustor(int cconv, StgStablePtr hptr,
	       StgFunPtr wptr,
	       char *typeString
329
#if !defined(powerpc_HOST_ARCH) && !defined(powerpc64_HOST_ARCH) && !defined(x86_64_HOST_ARCH)
330
331
332
	          STG_UNUSED
#endif
              )
sof's avatar
sof committed
333
{
ken's avatar
ken committed
334
  void *adjustor = NULL;
335
  void *code;
336

ken's avatar
ken committed
337
338
339
  switch (cconv)
  {
  case 0: /* _stdcall */
340
#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
sof's avatar
sof committed
341
342
343
344
345
    /* 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
346
     <1>:	68 fd fc fe fa    pushl  0xfafefcfd  	   # constant is large enough to
sof's avatar
sof committed
347
348
349
350
        			   	           	   # 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
351
		# the callee cleans up the stack
sof's avatar
sof committed
352
    */
353
    adjustor = allocateExec(14,&code);
354
355
356
    {
	unsigned char *const adj_code = (unsigned char *)adjustor;
	adj_code[0x00] = (unsigned char)0x58;  /* popl %eax  */
sof's avatar
sof committed
357

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

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

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

366
367
368
	adj_code[0x0c] = (unsigned char)0xff; /* jmp %eax */
	adj_code[0x0d] = (unsigned char)0xe0;
    }
ken's avatar
ken committed
369
370
#endif
    break;
sof's avatar
sof committed
371

ken's avatar
ken committed
372
  case 1: /* _ccall */
373
#if defined(i386_HOST_ARCH) && !defined(darwin_HOST_OS)
sof's avatar
sof committed
374
375
376
377
  /* Magic constant computed by inspecting the code length of
     the following assembly language snippet
     (offset and machine code prefixed):

sof's avatar
sof committed
378
  <00>: 68 ef be ad de     pushl  $0xdeadbeef  	   # constant is large enough to
sof's avatar
sof committed
379
        			   	           # hold a StgStablePtr
sof's avatar
sof committed
380
  <05>:	b8 fa ef ff 00	   movl   $0x00ffeffa, %eax # load up wptr
381
  <0a>: 68 ef be ad de     pushl  $obscure_ccall_ret_code # push the return address
sof's avatar
sof committed
382
  <0f>: ff e0              jmp    *%eax            # jump to wptr
sof's avatar
sof committed
383
384
385

    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
386
    via the stable pointer.) (The auto-generated C stub is in on this
sof's avatar
sof committed
387
388
    game, don't worry :-)

389
    See the comment next to obscure_ccall_ret_code why we need to
sof's avatar
sof committed
390
391
392
393
    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
394
395
396
    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
397
  */
398
    adjustor = allocateExec(17,&code);
399
400
    {
	unsigned char *const adj_code = (unsigned char *)adjustor;
sof's avatar
sof committed
401

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

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

408
	adj_code[0x0a] = (unsigned char)0x68;  /* pushl obscure_ccall_ret_code */
dons's avatar
dons committed
409
410
	*((StgFunPtr*)(adj_code + 0x0b)) = 
			(StgFunPtr)obscure_ccall_ret_code;
411

412
413
414
	adj_code[0x0f] = (unsigned char)0xff; /* jmp *%eax */
	adj_code[0x10] = (unsigned char)0xe0; 
    }
415
416
417
418
419
420
421
422
#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.
        */
423
        AdjustorStub *adjustorStub = allocateExec(sizeof(AdjustorStub),&code);
424
425
426
427
428
429
430
431
432
        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;
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
        
            // 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; 
448
449
450
        adjustorStub->argument_size = sz;
    }
    
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
#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
486
  16:   ff 25 0c 00 00 00       jmpq   *12(%rip)
487
488
  ... 
  20: .quad 0  # aligned on 8-byte boundary
489
  28: .quad 0  # aligned on 8-byte boundary
490
491
492
493
494


  And the version for >=6 integer arguments:

   0:   41 51                   push   %r9
495
496
497
498
499
500
501
502
   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>
503
504
  ...
  28: .quad 0  # aligned on 8-byte boundary
505
506
  30: .quad 0  # aligned on 8-byte boundary
  38: .quad 0  # aligned on 8-byte boundary
507
508
509
510
511
512
513
514
515
    */

    {  
	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++) {
516
	    if (*c != 'f' && *c != 'd') i++;
517
518
519
520
	    if (i == 6) break;
	}

	if (i < 6) {
521
	    adjustor = allocateExec(0x30,&code);
522
523
524
525
526
527
528
529
530
531

	    *(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;
532
533
534
	}
	else
	{
535
	    adjustor = allocateExec(0x40,&code);
536
537
538
539
540
541
542
543
544
545

	    *(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;
546
	    
547
548
549
	    *(StgInt64 *)(adjustor+0x28) = (StgInt64)obscure_ccall_ret_code;
	    *(StgInt64 *)(adjustor+0x30) = (StgInt64)hptr;
	    *(StgInt64 *)(adjustor+0x38) = (StgInt64)wptr;
550
551
	}
    }
552
#elif defined(sparc_HOST_ARCH)
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
  /* 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! :-)
581
  */
582
    adjustor = allocateExec(4*(11+1),&code);
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
    {
        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");
    }
617
#elif defined(alpha_HOST_ARCH)
ken's avatar
ken committed
618
619
620
621
622
  /* 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
623
624
625
626
  <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
627
  <10>: a77b0028	ldq     pv, 0x28(pv)	# load up wptr
ken's avatar
ken committed
628
629
630
631
632
  <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
633
634
635
636
637
638

     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
639
     We only support passing 4 or fewer argument words, for the same
640
     reason described under sparc_HOST_ARCH above by JRS, 21 Aug 01.
ken's avatar
ken committed
641
642
643
644
645
646
647
648
649
650
651
652
     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
653
654
655
656
657
658
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);
659
    adjustor = allocateExec(48,&code);
660
661
    {
	StgWord64 *const code = (StgWord64 *)adjustor;
662

663
664
665
666
667
	code[0] = 0x4610041246520414L;
	code[1] = 0x46730415a61b0020L;
	code[2] = 0x46310413a77b0028L;
	code[3] = 0x000000006bfb0000L
		| (((StgWord32*)(wptr) - (StgWord32*)(code) - 3) & 0x3fff);
ken's avatar
ken committed
668

669
670
	code[4] = (StgWord64)hptr;
	code[5] = (StgWord64)wptr;
ken's avatar
ken committed
671

672
673
674
	/* Ensure that instruction cache is consistent with our new code */
	__asm__ volatile("call_pal %0" : : "i" (PAL_imb));
    }
675
#elif defined(powerpc_HOST_ARCH) && defined(linux_HOST_OS)
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

#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
            {
710
                if((t == 'l' || t == 'L') && src_gpr <= 9)
711
712
713
714
715
716
                {
                    if((src_gpr & 1) == 0)
                        src_gpr++;
                    src_locs[i] = -src_gpr;
                    src_gpr += 2;
                }
717
                else if((t == 'w' || t == 'W') && src_gpr <= 10)
718
719
720
721
722
                {
                    src_locs[i] = -(src_gpr++);
                }
                else
                {
723
                    if(t == 'l' || t == 'L' || t == 'd')
724
725
726
727
728
                    {
                        if(src_offset % 8)
                            src_offset += 4;
                    }
                    src_locs[i] = src_offset;
729
                    src_offset += (t == 'l' || t == 'L' || t == 'd') ? 8 : 4;
730
731
                }

732
                    if((t == 'l' || t == 'L') && dst_gpr <= 9)
733
734
735
736
737
738
                {
                    if((dst_gpr & 1) == 0)
                        dst_gpr++;
                    dst_locs[i] = -dst_gpr;
                    dst_gpr += 2;
                }
739
                else if((t == 'w' || t == 'W') && dst_gpr <= 10)
740
741
742
743
744
                {
                    dst_locs[i] = -(dst_gpr++);
                }
                else
                {
745
                    if(t == 'l' || t == 'L' || t == 'd')
746
747
748
749
750
                    {
                        if(dst_offset % 8)
                            dst_offset += 4;
                    }
                    dst_locs[i] = dst_offset;
751
                    dst_offset += (t == 'l' || t == 'L' || t == 'd') ? 8 : 4;
752
753
754
755
756
757
758
759
760
761
762
763
                }
            }
        }

        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.
764
        adjustor = allocateExec(4 * (4*n + 14),&code);
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
        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.

793
                    if(typeString[i] == 'l' || typeString[i] == 'L')
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
                    {
                            // 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
                {
809
                    if(typeString[i] == 'l' || typeString[i] == 'L')
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
                    {
                            // 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');

828
                if(typeString[i] == 'l' || typeString[i] == 'L')
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
                {
                    // 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");
        }
    }
883

884
#elif defined(powerpc_HOST_ARCH) || defined(powerpc64_HOST_ARCH)
885
886
887
        
#define OP_LO(op,lo)  ((((unsigned)(op)) << 16) | (((unsigned)(lo)) & 0xFFFF))
#define OP_HI(op,hi)  ((((unsigned)(op)) << 16) | (((unsigned)(hi)) >> 16))
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
    {
        /* 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;
        
920
#ifdef FUNDESCS
921
        adjustorStub = stgMallocBytes(sizeof(AdjustorStub), "createAdjustor");
922
#else
923
        adjustorStub = allocateExec(sizeof(AdjustorStub),&code);
924
#endif
925
926
927
        adjustor = adjustorStub;
            
        adjustorStub->code = (void*) &adjustorCode;
928
929

#ifdef FUNDESCS
930
931
932
            // function descriptors are a cool idea.
            // We don't need to generate any code at runtime.
        adjustorStub->toc = adjustorStub;
933
934
#else

935
936
            // no function descriptors :-(
            // We need to do things "by hand".
937
#if defined(powerpc_HOST_ARCH)
938
939
940
941
942
943
944
945
946
947
948
            // 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;
949
#else
950
        barf("adjustor creation not supported on this platform");
951
952
#endif

953
954
955
956
957
        // Flush the Instruction cache:
        {
            int n = sizeof(AdjustorStub)/sizeof(unsigned);
            unsigned *p = (unsigned*)adjustor;
            while(n--)
958
            {
959
960
961
                __asm__ volatile ("dcbf 0,%0\n\tsync\n\ticbi 0,%0"
                                    : : "r" (p));
                p++;
962
            }
963
964
            __asm__ volatile ("sync\n\tisync");
        }
965
966
#endif

967
            // Calculate the size of the stack frame, in words.
968
969
        sz = totalArgumentSize(typeString);
        
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
            // 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;
    }
995

996
#elif defined(ia64_HOST_ARCH)
997
998
999
1000
/*
    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