--- ffi.h.in.prev	Thu Feb  8 14:53:54 2001
+++ ffi.h.in	Thu Feb  8 14:53:48 2001
@@ -374,6 +374,12 @@
 #define FFI_TRAMPOLINE_SIZE 24
 #define FFI_NATIVE_RAW_API 0
 
+#elif defined(POWERPC)
+
+#define FFI_CLOSURES 1
+#define FFI_TRAMPOLINE_SIZE 40
+#define FFI_NATIVE_RAW_API 0
+
 #else 
 
 #define FFI_CLOSURES 0
--- ffi.c.prev	Thu Feb  8 14:53:26 2001
+++ ffi.c	Fri Feb  9 10:44:02 2001
@@ -30,6 +30,8 @@
 
 #include <stdlib.h>
 
+extern void ffi_closure_SYSV(void);
+
 enum {
   /* The assembly depends on these exact flags.  */
   FLAG_RETURNS_NOTHING  = 1 << (31-30), /* These go in cr7 */
@@ -420,4 +422,223 @@
       FFI_ASSERT(0);
       break;
     }
+}
+
+
+static void flush_icache(char *, int);
+
+ffi_status
+ffi_prep_closure (ffi_closure* closure,
+		  ffi_cif* cif,
+		  void (*fun)(ffi_cif*, void*, void**, void*),
+		  void *user_data)
+{
+  unsigned int *tramp;
+
+  FFI_ASSERT (cif->abi == FFI_GCC_SYSV);
+
+  tramp = (unsigned int *) &closure->tramp[0];
+  tramp[0] = 0x7c0802a6;  /*   mflr    r0 */
+  tramp[1] = 0x4800000d;  /*   bl      10 <trampoline_initial+0x10> */
+  tramp[4] = 0x7d6802a6;  /*   mflr    r11 */
+  tramp[5] = 0x7c0803a6;  /*   mtlr    r0 */
+  tramp[6] = 0x800b0000;  /*   lwz     r0,0(r11) */
+  tramp[7] = 0x816b0004;  /*   lwz     r11,4(r11) */
+  tramp[8] = 0x7c0903a6;  /*   mtctr   r0 */
+  tramp[9] = 0x4e800420;  /*   bctr */
+  *(void **) &tramp[2] = (void *)ffi_closure_SYSV; /* function */
+  *(void **) &tramp[3] = (void *)closure;          /* context */
+
+  closure->cif = cif;
+  closure->fun = fun;
+  closure->user_data = user_data;
+
+  /* Flush the icache.  */
+  flush_icache(&closure->tramp[0],FFI_TRAMPOLINE_SIZE);
+
+  return FFI_OK;
+}
+
+
+#define MIN_CACHE_LINE_SIZE 8
+
+static void flush_icache(char * addr1, int size)
+{
+  int i;
+  char * addr;
+  for (i = 0; i < size; i += MIN_CACHE_LINE_SIZE) {
+     addr = addr1 + i;
+     __asm__ volatile ("icbi 0,%0;" "dcbf 0,%0;" : : "r"(addr) : "memory");
+  }
+  addr = addr1 + size - 1;
+  __asm__ volatile ("icbi 0,%0;" "dcbf 0,%0;" "sync;" "isync;" : : "r"(addr) : "memory");
+}
+
+
+static int ffi_closure_helper_SYSV (ffi_closure*, void*, unsigned long*, 
+                                     unsigned long*, unsigned long*);
+
+/* Basically the trampoline invokes ffi_closure_SYSV, and on 
+ * entry, r11 holds the address of the closure.
+ * After storing the registers that could possibly contain
+ * parameters to be passed into the stack frame and setting
+ * up space for a return value, ffi_closure_SYSV invokes the 
+ * following helper function to do most of the work
+ */
+
+int
+ffi_closure_helper_SYSV (ffi_closure* closure, void * rvalue, 
+            unsigned long * pgr, unsigned long * pfr, 
+            unsigned long * pst)
+{
+  /* rvalue is the pointer to space for return value in closure assembly */
+  /* pgr is the pointer to where r3-r10 are stored in ffi_closure_SYSV */
+  /* pfr is the pointer to where f1-f8 are stored in ffi_closure_SYSV  */
+  /* pst is the pointer to outgoing parameter stack in original caller */
+
+  void **          avalue;
+  ffi_type **      arg_types;
+  long             i, avn;
+  long             nf;   /* number of floating registers already used */
+  long             ng;   /* number of general registers already used */
+  ffi_cif *        cif; 
+  double           temp; 
+
+  cif = closure->cif;
+  avalue = alloca(cif->nargs * sizeof(void *));
+
+  nf = 0;
+  ng = 0;
+
+  /* Copy the caller's structure return value address so that the closure
+     returns the data directly to the caller.  */
+  if (cif->flags == FFI_TYPE_STRUCT)
+    {
+      rvalue = (void *) *pgr;
+      ng++;
+      pgr++;
+    }
+
+  i = 0;
+  avn = cif->nargs;
+  arg_types = cif->arg_types;
+  
+  /* Grab the addresses of the arguments from the stack frame.  */
+  while (i < avn)
+    {
+      switch (arg_types[i]->type)
+	{
+	case FFI_TYPE_SINT8:
+	case FFI_TYPE_UINT8:
+	case FFI_TYPE_SINT16:
+	case FFI_TYPE_UINT16:
+	  /* FIXME?, should we pass pointer to promoted 
+           * types only or should the pointer point to 
+           * a specific non-promoted type
+	   * / 
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_UINT32:
+	case FFI_TYPE_POINTER:
+	case FFI_TYPE_STRUCT:
+	/* there are 8 gpr registers used to pass values */
+          if (ng < 8) {
+	     avalue[i] = pgr;
+             ng++;
+             pgr++;
+          } else {
+             avalue[i] = pst;
+             pst++;
+          }
+	  break;
+
+	case FFI_TYPE_SINT64:
+	case FFI_TYPE_UINT64:
+	  /* passing long long ints are complex, they must
+           * be passed in suitable register pairs such as
+           * (r3,r4) or (r5,r6) or (r6,r7), or (r7,r8) or (r9,r10)
+           * and if the entire pair aren't available then the outgoing
+           * parameter stack is used for both but an alignment of 8
+           * must will be kept.  So we must either look in pgr
+           * or pst to find the correct address for this type
+           * of parameter.
+           */
+           if (ng < 7) {
+              if (ng & 0x01) {
+		/* skip r4, r6, r8 as starting points */
+                  ng++;
+                  pgr++;
+              }
+              avalue[i] = pgr;
+              ng+=2;
+              pgr+=2;
+           } else {
+              if (((long)pst) & 4) pst++;
+              avalue[i] = pst;
+              pst+=2;
+           }
+           break;
+
+	case FFI_TYPE_FLOAT:
+	    /* unfortunately float values are stored as doubles
+             * in the ffi_closure_SYSV code (since we don't check
+             * the type in that routine).  This is also true
+             * of floats passed on the outgoing parameter stack.
+             * Also, on the outgoing stack all values are aligned
+             * to 8
+             *
+             * Don't you just love the simplicity of this ABI!
+             */
+
+          /* there are 8 64bit floating point registers */
+
+          if (nf < 8) {
+	     temp = *(double*)pfr;
+             *(float*)pfr = (float)temp;
+	     avalue[i] = pfr;
+             nf++;
+             pfr+=2;
+          } else {
+	    /* FIXME? here we are really changing the values
+             * stored in the original calling routines outgoing
+             * parameter stack.  This is probably a really
+             * naughty thing to do but...
+             */
+	     if (((long)pst) & 4) pst++;
+	     temp = *(double*)pst;
+             *(float*)pst = (float)temp;
+	     avalue[i] = pst;
+             nf++;
+             pst+=2;
+          }
+	  break;
+
+	case FFI_TYPE_DOUBLE:
+	  /* On the outgoing stack all values are aligned to 8 */
+          /* there are 8 64bit floating point registers */
+
+          if (nf < 8) {
+	     avalue[i] = pfr;
+             nf++;
+             pfr+=2;
+          } else {
+	     if (((long)pst) & 4) pst++;
+	     avalue[i] = pst;
+             nf++;
+             pst+=2;
+          }
+	  break;
+
+	default:
+	  FFI_ASSERT(0);
+	}
+
+      i++;
+    }
+
+
+  (closure->fun) (cif, rvalue, avalue, closure->user_data);
+
+  /* Tell ffi_closure_osf how to perform return type promotions.  */
+  return cif->rtype->type;
+
 }
--- ppc_closure.S.prev	Fri Feb  9 10:48:36 2001
+++ ppc_closure.S	Fri Feb  9 10:37:29 2001
@@ -0,0 +1,148 @@
+
+	.file	"ppc_closure.s"
+gcc2_compiled.:
+	.section	".text"
+	.align 2
+	.type	 ffi_closure_SYSV,@function
+ffi_closure_SYSV:
+	stwu 1,-144(1)
+	mflr 0
+	stw 31,140(1)
+	stw 0,148(1)
+
+# we want to build up an areas for the parameters passed
+# in registers (both floating point and integer)
+	
+	# so first save gpr 3 to gpr 10 (aligned to 4)
+	stw   3, 16(1)
+	stw   4, 20(1)
+	stw   5, 24(1) 
+	stw   6, 28(1)
+	stw   7, 32(1)
+	stw   8, 36(1) 
+	stw   9, 40(1)
+	stw   10,44(1)
+
+	# next save fpr 1 to fpr 8 (aligned to 8)
+	stfd  1, 48(1)
+	stfd  2, 56(1)
+	stfd  3, 64(1)
+	stfd  4, 72(1)
+	stfd  5, 80(1)
+	stfd  6, 88(1)
+	stfd  7, 96(1)
+	stfd  8, 104(1)
+
+	# set up registers for the routine that actually does the work
+	# get the context pointer from the trampoline
+	mr 3,11
+	
+        # now load up the pointer to the result storage
+	addi 4,1,112
+	
+	# now load up the pointer to the saved gpr registers
+        addi 5,1,16
+
+        # now load up the pointer to the saved fpr registers */
+        addi 6,1,48
+
+	# now load up the pointer to the outgoing parameter 
+	# stack in the previous frame
+	# i.e. the previous frame pointer + 8
+	addi 7,1,152
+	
+        # make the call
+	bl ffi_closure_helper_SYSV
+
+	# now r3 contains the return type
+	# so use it to look up in a table
+	# so we know how to deal with each type
+
+        # look up the proper starting point in table 
+	# by using return type as offset
+	addi 5,1,112       # get pointer to results area
+	addis 4,0,.L60@ha  # get address of jump table
+	addi 4,4,.L60@l
+	slwi 3,3,2         # now multiply return type by 4
+	lwzx 3,4,3         # get the contents of that table value
+	add 3,3,4          # add contents of table to table address
+	mtctr 3
+	bctr               # jump to it
+	.align 2
+.L60:
+	.long .L44-.L60    # FFI_TYPE_VOID
+	.long .L50-.L60    # FFI_TYPE_INT
+	.long .L47-.L60    # FFI_TYPE_FLOAT
+	.long .L46-.L60    # FFI_TYPE_DOUBLE
+	.long .L46-.L60    # FFI_TYPE_LONGDOUBLE
+	.long .L56-.L60    # FFI_TYPE_UINT8
+	.long .L55-.L60    # FFI_TYPE_SINT8
+	.long .L58-.L60    # FFI_TYPE_UINT16
+	.long .L57-.L60    # FFI_TYPE_SINT16
+	.long .L50-.L60    # FFI_TYPE_UINT32
+	.long .L50-.L60    # FFI_TYPE_SINT32
+	.long .L48-.L60    # FFI_TYPE_UINT64
+	.long .L48-.L60    # FFI_TYPE_SINT64
+	.long .L44-.L60    # FFI_TYPE_STRUCT
+	.long .L50-.L60    # FFI_TYPE_POINTER
+
+
+# case double
+.L46:   
+        lfd 1,0(5)
+	b .L44
+
+# case float
+.L47:
+	lfs 1,0(5)
+	b .L44
+	
+# case long long
+.L48:
+	lwz 3,0(5)
+	lwz 4,4(5)
+	b .L44
+	
+# case default / int32 / pointer
+.L50:
+	lwz 3,0(5)
+	b .L44
+	
+# case signed int8	
+.L55:
+        lbz 3,0(5)
+	extsb 3,3
+	b .L44
+
+# case unsigned int8	
+.L56:
+        lbz 3,0(5)
+	b .L44
+
+# case signed int16
+.L57:
+	lhz 3,0(5)
+	extsh 3,3
+	b .L44
+
+#case unsigned int16
+.L58:	
+	lhz 3,0(5)
+
+# case void / done	
+.L44:
+	
+	lwz 11,0(1)
+	lwz 0,4(11)
+	mtlr 0
+	lwz 31,-4(11)
+	mr 1,11
+	blr
+.Lfe1:
+	.size	 ffi_closure_SYSV,.Lfe1-ffi_closure_SYSV
+	.ident	"GCC: (GNU) 2.95.3 20001205 (prerelease/franzo/20001217)"
+
+
+
+	
+	
