PageRenderTime 75ms CodeModel.GetById 16ms app.highlight 53ms RepoModel.GetById 1ms app.codeStats 0ms

/Modules/_ctypes/libffi/src/pa/ffi.c

http://unladen-swallow.googlecode.com/
C | 709 lines | 477 code | 92 blank | 140 comment | 59 complexity | 7584ecb991cb652c6935e9f0069dfda3 MD5 | raw file
  1/* -----------------------------------------------------------------------
  2   ffi.c - (c) 2003-2004 Randolph Chung <tausq@debian.org>
  3           (c) 2008 Red Hat, Inc.
  4
  5   HPPA Foreign Function Interface
  6   HP-UX PA ABI support (c) 2006 Free Software Foundation, Inc.
  7
  8   Permission is hereby granted, free of charge, to any person obtaining
  9   a copy of this software and associated documentation files (the
 10   ``Software''), to deal in the Software without restriction, including
 11   without limitation the rights to use, copy, modify, merge, publish,
 12   distribute, sublicense, and/or sell copies of the Software, and to
 13   permit persons to whom the Software is furnished to do so, subject to
 14   the following conditions:
 15
 16   The above copyright notice and this permission notice shall be included
 17   in all copies or substantial portions of the Software.
 18
 19   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
 20   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 21   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 23   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 24   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 25   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 26   DEALINGS IN THE SOFTWARE.
 27   ----------------------------------------------------------------------- */
 28
 29#include <ffi.h>
 30#include <ffi_common.h>
 31
 32#include <stdlib.h>
 33#include <stdio.h>
 34
 35#define ROUND_UP(v, a)  (((size_t)(v) + (a) - 1) & ~((a) - 1))
 36
 37#define MIN_STACK_SIZE  64
 38#define FIRST_ARG_SLOT  9
 39#define DEBUG_LEVEL   0
 40
 41#define fldw(addr, fpreg) \
 42  __asm__ volatile ("fldw 0(%0), %%" #fpreg "L" : : "r"(addr) : #fpreg)
 43#define fstw(fpreg, addr) \
 44  __asm__ volatile ("fstw %%" #fpreg "L, 0(%0)" : : "r"(addr))
 45#define fldd(addr, fpreg) \
 46  __asm__ volatile ("fldd 0(%0), %%" #fpreg : : "r"(addr) : #fpreg)
 47#define fstd(fpreg, addr) \
 48  __asm__ volatile ("fstd %%" #fpreg "L, 0(%0)" : : "r"(addr))
 49
 50#define debug(lvl, x...) do { if (lvl <= DEBUG_LEVEL) { printf(x); } } while (0)
 51
 52static inline int ffi_struct_type(ffi_type *t)
 53{
 54  size_t sz = t->size;
 55
 56  /* Small structure results are passed in registers,
 57     larger ones are passed by pointer.  Note that
 58     small structures of size 2, 4 and 8 differ from
 59     the corresponding integer types in that they have
 60     different alignment requirements.  */
 61
 62  if (sz <= 1)
 63    return FFI_TYPE_UINT8;
 64  else if (sz == 2)
 65    return FFI_TYPE_SMALL_STRUCT2;
 66  else if (sz == 3)
 67    return FFI_TYPE_SMALL_STRUCT3;
 68  else if (sz == 4)
 69    return FFI_TYPE_SMALL_STRUCT4;
 70  else if (sz == 5)
 71    return FFI_TYPE_SMALL_STRUCT5;
 72  else if (sz == 6)
 73    return FFI_TYPE_SMALL_STRUCT6;
 74  else if (sz == 7)
 75    return FFI_TYPE_SMALL_STRUCT7;
 76  else if (sz <= 8)
 77    return FFI_TYPE_SMALL_STRUCT8;
 78  else
 79    return FFI_TYPE_STRUCT; /* else, we pass it by pointer.  */
 80}
 81
 82/* PA has a downward growing stack, which looks like this:
 83
 84   Offset
 85	[ Variable args ]
 86   SP = (4*(n+9))       arg word N
 87   ...
 88   SP-52                arg word 4
 89	[ Fixed args ]
 90   SP-48                arg word 3
 91   SP-44                arg word 2
 92   SP-40                arg word 1
 93   SP-36                arg word 0
 94	[ Frame marker ]
 95   ...
 96   SP-20                RP
 97   SP-4                 previous SP
 98
 99   The first four argument words on the stack are reserved for use by
100   the callee.  Instead, the general and floating registers replace
101   the first four argument slots.  Non FP arguments are passed solely
102   in the general registers.  FP arguments are passed in both general
103   and floating registers when using libffi.
104
105   Non-FP 32-bit args are passed in gr26, gr25, gr24 and gr23.
106   Non-FP 64-bit args are passed in register pairs, starting
107   on an odd numbered register (i.e. r25+r26 and r23+r24).
108   FP 32-bit arguments are passed in fr4L, fr5L, fr6L and fr7L.
109   FP 64-bit arguments are passed in fr5 and fr7.
110
111   The registers are allocated in the same manner as stack slots.
112   This allows the callee to save its arguments on the stack if
113   necessary:
114
115   arg word 3 -> gr23 or fr7L
116   arg word 2 -> gr24 or fr6L or fr7R
117   arg word 1 -> gr25 or fr5L
118   arg word 0 -> gr26 or fr4L or fr5R
119
120   Note that fr4R and fr6R are never used for arguments (i.e.,
121   doubles are not passed in fr4 or fr6).
122
123   The rest of the arguments are passed on the stack starting at SP-52,
124   but 64-bit arguments need to be aligned to an 8-byte boundary
125
126   This means we can have holes either in the register allocation,
127   or in the stack.  */
128
129/* ffi_prep_args is called by the assembly routine once stack space
130   has been allocated for the function's arguments
131
132   The following code will put everything into the stack frame
133   (which was allocated by the asm routine), and on return
134   the asm routine will load the arguments that should be
135   passed by register into the appropriate registers
136
137   NOTE: We load floating point args in this function... that means we
138   assume gcc will not mess with fp regs in here.  */
139
140void ffi_prep_args_pa32(UINT32 *stack, extended_cif *ecif, unsigned bytes)
141{
142  register unsigned int i;
143  register ffi_type **p_arg;
144  register void **p_argv;
145  unsigned int slot = FIRST_ARG_SLOT;
146  char *dest_cpy;
147  size_t len;
148
149  debug(1, "%s: stack = %p, ecif = %p, bytes = %u\n", __FUNCTION__, stack,
150	ecif, bytes);
151
152  p_arg = ecif->cif->arg_types;
153  p_argv = ecif->avalue;
154
155  for (i = 0; i < ecif->cif->nargs; i++)
156    {
157      int type = (*p_arg)->type;
158
159      switch (type)
160	{
161	case FFI_TYPE_SINT8:
162	  *(SINT32 *)(stack - slot) = *(SINT8 *)(*p_argv);
163	  break;
164
165	case FFI_TYPE_UINT8:
166	  *(UINT32 *)(stack - slot) = *(UINT8 *)(*p_argv);
167	  break;
168
169	case FFI_TYPE_SINT16:
170	  *(SINT32 *)(stack - slot) = *(SINT16 *)(*p_argv);
171	  break;
172
173	case FFI_TYPE_UINT16:
174	  *(UINT32 *)(stack - slot) = *(UINT16 *)(*p_argv);
175	  break;
176
177	case FFI_TYPE_UINT32:
178	case FFI_TYPE_SINT32:
179	case FFI_TYPE_POINTER:
180	  debug(3, "Storing UINT32 %u in slot %u\n", *(UINT32 *)(*p_argv),
181		slot);
182	  *(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
183	  break;
184
185	case FFI_TYPE_UINT64:
186	case FFI_TYPE_SINT64:
187	  /* Align slot for 64-bit type.  */
188	  slot += (slot & 1) ? 1 : 2;
189	  *(UINT64 *)(stack - slot) = *(UINT64 *)(*p_argv);
190	  break;
191
192	case FFI_TYPE_FLOAT:
193	  /* First 4 args go in fr4L - fr7L.  */
194	  debug(3, "Storing UINT32(float) in slot %u\n", slot);
195	  *(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
196	  switch (slot - FIRST_ARG_SLOT)
197	    {
198	    /* First 4 args go in fr4L - fr7L.  */
199	    case 0: fldw(stack - slot, fr4); break;
200	    case 1: fldw(stack - slot, fr5); break;
201	    case 2: fldw(stack - slot, fr6); break;
202	    case 3: fldw(stack - slot, fr7); break;
203	    }
204	  break;
205
206	case FFI_TYPE_DOUBLE:
207	  /* Align slot for 64-bit type.  */
208	  slot += (slot & 1) ? 1 : 2;
209	  debug(3, "Storing UINT64(double) at slot %u\n", slot);
210	  *(UINT64 *)(stack - slot) = *(UINT64 *)(*p_argv);
211	  switch (slot - FIRST_ARG_SLOT)
212	    {
213	      /* First 2 args go in fr5, fr7.  */
214	      case 1: fldd(stack - slot, fr5); break;
215	      case 3: fldd(stack - slot, fr7); break;
216	    }
217	  break;
218
219#ifdef PA_HPUX
220	case FFI_TYPE_LONGDOUBLE:
221	  /* Long doubles are passed in the same manner as structures
222	     larger than 8 bytes.  */
223	  *(UINT32 *)(stack - slot) = (UINT32)(*p_argv);
224	  break;
225#endif
226
227	case FFI_TYPE_STRUCT:
228
229	  /* Structs smaller or equal than 4 bytes are passed in one
230	     register. Structs smaller or equal 8 bytes are passed in two
231	     registers. Larger structures are passed by pointer.  */
232
233	  len = (*p_arg)->size;
234	  if (len <= 4)
235	    {
236	      dest_cpy = (char *)(stack - slot) + 4 - len;
237	      memcpy(dest_cpy, (char *)*p_argv, len);
238	    }
239	  else if (len <= 8)
240	    {
241	      slot += (slot & 1) ? 1 : 2;
242	      dest_cpy = (char *)(stack - slot) + 8 - len;
243	      memcpy(dest_cpy, (char *)*p_argv, len);
244	    }
245	  else
246	    *(UINT32 *)(stack - slot) = (UINT32)(*p_argv);
247	  break;
248
249	default:
250	  FFI_ASSERT(0);
251	}
252
253      slot++;
254      p_arg++;
255      p_argv++;
256    }
257
258  /* Make sure we didn't mess up and scribble on the stack.  */
259  {
260    unsigned int n;
261
262    debug(5, "Stack setup:\n");
263    for (n = 0; n < (bytes + 3) / 4; n++)
264      {
265	if ((n%4) == 0) { debug(5, "\n%08x: ", (unsigned int)(stack - n)); }
266	debug(5, "%08x ", *(stack - n));
267      }
268    debug(5, "\n");
269  }
270
271  FFI_ASSERT(slot * 4 <= bytes);
272
273  return;
274}
275
276static void ffi_size_stack_pa32(ffi_cif *cif)
277{
278  ffi_type **ptr;
279  int i;
280  int z = 0; /* # stack slots */
281
282  for (ptr = cif->arg_types, i = 0; i < cif->nargs; ptr++, i++)
283    {
284      int type = (*ptr)->type;
285
286      switch (type)
287	{
288	case FFI_TYPE_DOUBLE:
289	case FFI_TYPE_UINT64:
290	case FFI_TYPE_SINT64:
291	  z += 2 + (z & 1); /* must start on even regs, so we may waste one */
292	  break;
293
294#ifdef PA_HPUX
295	case FFI_TYPE_LONGDOUBLE:
296#endif
297	case FFI_TYPE_STRUCT:
298	  z += 1; /* pass by ptr, callee will copy */
299	  break;
300
301	default: /* <= 32-bit values */
302	  z++;
303	}
304    }
305
306  /* We can fit up to 6 args in the default 64-byte stack frame,
307     if we need more, we need more stack.  */
308  if (z <= 6)
309    cif->bytes = MIN_STACK_SIZE; /* min stack size */
310  else
311    cif->bytes = 64 + ROUND_UP((z - 6) * sizeof(UINT32), MIN_STACK_SIZE);
312
313  debug(3, "Calculated stack size is %u bytes\n", cif->bytes);
314}
315
316/* Perform machine dependent cif processing.  */
317ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
318{
319  /* Set the return type flag */
320  switch (cif->rtype->type)
321    {
322    case FFI_TYPE_VOID:
323    case FFI_TYPE_FLOAT:
324    case FFI_TYPE_DOUBLE:
325      cif->flags = (unsigned) cif->rtype->type;
326      break;
327
328#ifdef PA_HPUX
329    case FFI_TYPE_LONGDOUBLE:
330      /* Long doubles are treated like a structure.  */
331      cif->flags = FFI_TYPE_STRUCT;
332      break;
333#endif
334
335    case FFI_TYPE_STRUCT:
336      /* For the return type we have to check the size of the structures.
337	 If the size is smaller or equal 4 bytes, the result is given back
338	 in one register. If the size is smaller or equal 8 bytes than we
339	 return the result in two registers. But if the size is bigger than
340	 8 bytes, we work with pointers.  */
341      cif->flags = ffi_struct_type(cif->rtype);
342      break;
343
344    case FFI_TYPE_UINT64:
345    case FFI_TYPE_SINT64:
346      cif->flags = FFI_TYPE_UINT64;
347      break;
348
349    default:
350      cif->flags = FFI_TYPE_INT;
351      break;
352    }
353
354  /* Lucky us, because of the unique PA ABI we get to do our
355     own stack sizing.  */
356  switch (cif->abi)
357    {
358    case FFI_PA32:
359      ffi_size_stack_pa32(cif);
360      break;
361
362    default:
363      FFI_ASSERT(0);
364      break;
365    }
366
367  return FFI_OK;
368}
369
370extern void ffi_call_pa32(void (*)(UINT32 *, extended_cif *, unsigned),
371			  extended_cif *, unsigned, unsigned, unsigned *,
372			  void (*fn)(void));
373
374void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
375{
376  extended_cif ecif;
377
378  ecif.cif = cif;
379  ecif.avalue = avalue;
380
381  /* If the return value is a struct and we don't have a return
382     value address then we need to make one.  */
383
384  if (rvalue == NULL
385#ifdef PA_HPUX
386      && (cif->rtype->type == FFI_TYPE_STRUCT
387	  || cif->rtype->type == FFI_TYPE_LONGDOUBLE))
388#else
389      && cif->rtype->type == FFI_TYPE_STRUCT)
390#endif
391    {
392      ecif.rvalue = alloca(cif->rtype->size);
393    }
394  else
395    ecif.rvalue = rvalue;
396
397
398  switch (cif->abi)
399    {
400    case FFI_PA32:
401      debug(3, "Calling ffi_call_pa32: ecif=%p, bytes=%u, flags=%u, rvalue=%p, fn=%p\n", &ecif, cif->bytes, cif->flags, ecif.rvalue, (void *)fn);
402      ffi_call_pa32(ffi_prep_args_pa32, &ecif, cif->bytes,
403		     cif->flags, ecif.rvalue, fn);
404      break;
405
406    default:
407      FFI_ASSERT(0);
408      break;
409    }
410}
411
412#if FFI_CLOSURES
413/* This is more-or-less an inverse of ffi_call -- we have arguments on
414   the stack, and we need to fill them into a cif structure and invoke
415   the user function. This really ought to be in asm to make sure
416   the compiler doesn't do things we don't expect.  */
417ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack)
418{
419  ffi_cif *cif;
420  void **avalue;
421  void *rvalue;
422  UINT32 ret[2]; /* function can return up to 64-bits in registers */
423  ffi_type **p_arg;
424  char *tmp;
425  int i, avn;
426  unsigned int slot = FIRST_ARG_SLOT;
427  register UINT32 r28 asm("r28");
428
429  cif = closure->cif;
430
431  /* If returning via structure, callee will write to our pointer.  */
432  if (cif->flags == FFI_TYPE_STRUCT)
433    rvalue = (void *)r28;
434  else
435    rvalue = &ret[0];
436
437  avalue = (void **)alloca(cif->nargs * FFI_SIZEOF_ARG);
438  avn = cif->nargs;
439  p_arg = cif->arg_types;
440
441  for (i = 0; i < avn; i++)
442    {
443      int type = (*p_arg)->type;
444
445      switch (type)
446	{
447	case FFI_TYPE_SINT8:
448	case FFI_TYPE_UINT8:
449	case FFI_TYPE_SINT16:
450	case FFI_TYPE_UINT16:
451	case FFI_TYPE_SINT32:
452	case FFI_TYPE_UINT32:
453	case FFI_TYPE_POINTER:
454	  avalue[i] = (char *)(stack - slot) + sizeof(UINT32) - (*p_arg)->size;
455	  break;
456
457	case FFI_TYPE_SINT64:
458	case FFI_TYPE_UINT64:
459	  slot += (slot & 1) ? 1 : 2;
460	  avalue[i] = (void *)(stack - slot);
461	  break;
462
463	case FFI_TYPE_FLOAT:
464#ifdef PA_LINUX
465	  /* The closure call is indirect.  In Linux, floating point
466	     arguments in indirect calls with a prototype are passed
467	     in the floating point registers instead of the general
468	     registers.  So, we need to replace what was previously
469	     stored in the current slot with the value in the
470	     corresponding floating point register.  */
471	  switch (slot - FIRST_ARG_SLOT)
472	    {
473	    case 0: fstw(fr4, (void *)(stack - slot)); break;
474	    case 1: fstw(fr5, (void *)(stack - slot)); break;
475	    case 2: fstw(fr6, (void *)(stack - slot)); break;
476	    case 3: fstw(fr7, (void *)(stack - slot)); break;
477	    }
478#endif
479	  avalue[i] = (void *)(stack - slot);
480	  break;
481
482	case FFI_TYPE_DOUBLE:
483	  slot += (slot & 1) ? 1 : 2;
484#ifdef PA_LINUX
485	  /* See previous comment for FFI_TYPE_FLOAT.  */
486	  switch (slot - FIRST_ARG_SLOT)
487	    {
488	    case 1: fstd(fr5, (void *)(stack - slot)); break;
489	    case 3: fstd(fr7, (void *)(stack - slot)); break;
490	    }
491#endif
492	  avalue[i] = (void *)(stack - slot);
493	  break;
494
495	case FFI_TYPE_STRUCT:
496	  /* Structs smaller or equal than 4 bytes are passed in one
497	     register. Structs smaller or equal 8 bytes are passed in two
498	     registers. Larger structures are passed by pointer.  */
499	  if((*p_arg)->size <= 4)
500	    {
501	      avalue[i] = (void *)(stack - slot) + sizeof(UINT32) -
502		(*p_arg)->size;
503	    }
504	  else if ((*p_arg)->size <= 8)
505	    {
506	      slot += (slot & 1) ? 1 : 2;
507	      avalue[i] = (void *)(stack - slot) + sizeof(UINT64) -
508		(*p_arg)->size;
509	    }
510	  else
511	    avalue[i] = (void *) *(stack - slot);
512	  break;
513
514	default:
515	  FFI_ASSERT(0);
516	}
517
518      slot++;
519      p_arg++;
520    }
521
522  /* Invoke the closure.  */
523  (closure->fun) (cif, rvalue, avalue, closure->user_data);
524
525  debug(3, "after calling function, ret[0] = %08x, ret[1] = %08x\n", ret[0],
526	ret[1]);
527
528  /* Store the result using the lower 2 bytes of the flags.  */
529  switch (cif->flags)
530    {
531    case FFI_TYPE_UINT8:
532      *(stack - FIRST_ARG_SLOT) = (UINT8)(ret[0] >> 24);
533      break;
534    case FFI_TYPE_SINT8:
535      *(stack - FIRST_ARG_SLOT) = (SINT8)(ret[0] >> 24);
536      break;
537    case FFI_TYPE_UINT16:
538      *(stack - FIRST_ARG_SLOT) = (UINT16)(ret[0] >> 16);
539      break;
540    case FFI_TYPE_SINT16:
541      *(stack - FIRST_ARG_SLOT) = (SINT16)(ret[0] >> 16);
542      break;
543    case FFI_TYPE_INT:
544    case FFI_TYPE_SINT32:
545    case FFI_TYPE_UINT32:
546      *(stack - FIRST_ARG_SLOT) = ret[0];
547      break;
548    case FFI_TYPE_SINT64:
549    case FFI_TYPE_UINT64:
550      *(stack - FIRST_ARG_SLOT) = ret[0];
551      *(stack - FIRST_ARG_SLOT - 1) = ret[1];
552      break;
553
554    case FFI_TYPE_DOUBLE:
555      fldd(rvalue, fr4);
556      break;
557
558    case FFI_TYPE_FLOAT:
559      fldw(rvalue, fr4);
560      break;
561
562    case FFI_TYPE_STRUCT:
563      /* Don't need a return value, done by caller.  */
564      break;
565
566    case FFI_TYPE_SMALL_STRUCT2:
567    case FFI_TYPE_SMALL_STRUCT3:
568    case FFI_TYPE_SMALL_STRUCT4:
569      tmp = (void*)(stack -  FIRST_ARG_SLOT);
570      tmp += 4 - cif->rtype->size;
571      memcpy((void*)tmp, &ret[0], cif->rtype->size);
572      break;
573
574    case FFI_TYPE_SMALL_STRUCT5:
575    case FFI_TYPE_SMALL_STRUCT6:
576    case FFI_TYPE_SMALL_STRUCT7:
577    case FFI_TYPE_SMALL_STRUCT8:
578      {
579	unsigned int ret2[2];
580	int off;
581
582	/* Right justify ret[0] and ret[1] */
583	switch (cif->flags)
584	  {
585	    case FFI_TYPE_SMALL_STRUCT5: off = 3; break;
586	    case FFI_TYPE_SMALL_STRUCT6: off = 2; break;
587	    case FFI_TYPE_SMALL_STRUCT7: off = 1; break;
588	    default: off = 0; break;
589	  }
590
591	memset (ret2, 0, sizeof (ret2));
592	memcpy ((char *)ret2 + off, ret, 8 - off);
593
594	*(stack - FIRST_ARG_SLOT) = ret2[0];
595	*(stack - FIRST_ARG_SLOT - 1) = ret2[1];
596      }
597      break;
598
599    case FFI_TYPE_POINTER:
600    case FFI_TYPE_VOID:
601      break;
602
603    default:
604      debug(0, "assert with cif->flags: %d\n",cif->flags);
605      FFI_ASSERT(0);
606      break;
607    }
608  return FFI_OK;
609}
610
611/* Fill in a closure to refer to the specified fun and user_data.
612   cif specifies the argument and result types for fun.
613   The cif must already be prep'ed.  */
614
615extern void ffi_closure_pa32(void);
616
617ffi_status
618ffi_prep_closure_loc (ffi_closure* closure,
619		      ffi_cif* cif,
620		      void (*fun)(ffi_cif*,void*,void**,void*),
621		      void *user_data,
622		      void *codeloc)
623{
624  UINT32 *tramp = (UINT32 *)(closure->tramp);
625#ifdef PA_HPUX
626  UINT32 *tmp;
627#endif
628
629  FFI_ASSERT (cif->abi == FFI_PA32);
630
631  /* Make a small trampoline that will branch to our
632     handler function. Use PC-relative addressing.  */
633
634#ifdef PA_LINUX
635  tramp[0] = 0xeaa00000; /* b,l .+8,%r21        ; %r21 <- pc+8 */
636  tramp[1] = 0xd6a01c1e; /* depi 0,31,2,%r21    ; mask priv bits */
637  tramp[2] = 0x4aa10028; /* ldw 20(%r21),%r1    ; load plabel */
638  tramp[3] = 0x36b53ff1; /* ldo -8(%r21),%r21   ; get closure addr */
639  tramp[4] = 0x0c201096; /* ldw 0(%r1),%r22     ; address of handler */
640  tramp[5] = 0xeac0c000; /* bv%r0(%r22)         ; branch to handler */
641  tramp[6] = 0x0c281093; /* ldw 4(%r1),%r19     ; GP of handler */
642  tramp[7] = ((UINT32)(ffi_closure_pa32) & ~2);
643
644  /* Flush d/icache -- have to flush up 2 two lines because of
645     alignment.  */
646  __asm__ volatile(
647		   "fdc 0(%0)\n\t"
648		   "fdc %1(%0)\n\t"
649		   "fic 0(%%sr4, %0)\n\t"
650		   "fic %1(%%sr4, %0)\n\t"
651		   "sync\n\t"
652		   "nop\n\t"
653		   "nop\n\t"
654		   "nop\n\t"
655		   "nop\n\t"
656		   "nop\n\t"
657		   "nop\n\t"
658		   "nop\n"
659		   :
660		   : "r"((unsigned long)tramp & ~31),
661		     "r"(32 /* stride */)
662		   : "memory");
663#endif
664
665#ifdef PA_HPUX
666  tramp[0] = 0xeaa00000; /* b,l .+8,%r21        ; %r21 <- pc+8  */
667  tramp[1] = 0xd6a01c1e; /* depi 0,31,2,%r21    ; mask priv bits  */
668  tramp[2] = 0x4aa10038; /* ldw 28(%r21),%r1    ; load plabel  */
669  tramp[3] = 0x36b53ff1; /* ldo -8(%r21),%r21   ; get closure addr  */
670  tramp[4] = 0x0c201096; /* ldw 0(%r1),%r22     ; address of handler  */
671  tramp[5] = 0x02c010b4; /* ldsid (%r22),%r20   ; load space id  */
672  tramp[6] = 0x00141820; /* mtsp %r20,%sr0      ; into %sr0  */
673  tramp[7] = 0xe2c00000; /* be 0(%sr0,%r22)     ; branch to handler  */
674  tramp[8] = 0x0c281093; /* ldw 4(%r1),%r19     ; GP of handler  */
675  tramp[9] = ((UINT32)(ffi_closure_pa32) & ~2);
676
677  /* Flush d/icache -- have to flush three lines because of alignment.  */
678  __asm__ volatile(
679		   "copy %1,%0\n\t"
680		   "fdc,m %2(%0)\n\t"
681		   "fdc,m %2(%0)\n\t"
682		   "fdc,m %2(%0)\n\t"
683		   "ldsid (%1),%0\n\t"
684		   "mtsp %0,%%sr0\n\t"
685		   "copy %1,%0\n\t"
686		   "fic,m %2(%%sr0,%0)\n\t"
687		   "fic,m %2(%%sr0,%0)\n\t"
688		   "fic,m %2(%%sr0,%0)\n\t"
689		   "sync\n\t"
690		   "nop\n\t"
691		   "nop\n\t"
692		   "nop\n\t"
693		   "nop\n\t"
694		   "nop\n\t"
695		   "nop\n\t"
696		   "nop\n"
697		   : "=&r" ((unsigned long)tmp)
698		   : "r" ((unsigned long)tramp & ~31),
699		     "r" (32/* stride */)
700		   : "memory");
701#endif
702
703  closure->cif  = cif;
704  closure->user_data = user_data;
705  closure->fun  = fun;
706
707  return FFI_OK;
708}
709#endif