diff --git a/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c b/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
index 66c6a3b..501035d 100644
--- a/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
+++ b/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
@@ -59,24 +59,24 @@
 
    The stack layout we want looks like this:
 
-   |   Return address from ffi_call_DARWIN      |       higher addresses
+   |   Return address from ffi_call_DARWIN      |	higher addresses
    |--------------------------------------------|
-   |   Previous backchain pointer       4       |       stack pointer here
-   |--------------------------------------------|<+ <<< on entry to
-   |   Saved r28-r31                    4*4     | |     ffi_call_DARWIN
+   |   Previous backchain pointer	4	|	stack pointer here
+   |--------------------------------------------|<+ <<<	on entry to
+   |   Saved r28-r31			4*4	| |	ffi_call_DARWIN
    |--------------------------------------------| |
    |   Parameters             (at least 8*4=32) | |
    |--------------------------------------------| |
    |   Space for GPR2                   4       | |
-   |--------------------------------------------| |     stack   |
-   |   Reserved                       2*4       | |     grows   |
-   |--------------------------------------------| |     down    V
-   |   Space for callee's LR            4       | |
-   |--------------------------------------------| |     lower addresses
+   |--------------------------------------------| |	stack	|
+   |   Reserved                       2*4       | |	grows	|
+   |--------------------------------------------| |	down	V
+   |   Space for callee's LR		4	| |
+   |--------------------------------------------| |	lower addresses
    |   Saved CR                         4       | |
    |--------------------------------------------| |     stack pointer here
-   |   Current backchain pointer        4       |-/     during
-   |--------------------------------------------|   <<< ffi_call_DARWIN
+   |   Current backchain pointer	4	|-/	during
+   |--------------------------------------------|   <<<	ffi_call_DARWIN
 
    */
 
@@ -123,106 +123,106 @@
        i--, ptr++, p_argv++)
     {
       switch ((*ptr)->type)
-        {
-        /* If a floating-point parameter appears before all of the general-
-           purpose registers are filled, the corresponding GPRs that match
-           the size of the floating-point parameter are skipped.  */
-        case FFI_TYPE_FLOAT:
-          double_tmp = *(float *)*p_argv;
-          if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-            *(double *)next_arg = double_tmp;
-          else
-            *fpr_base++ = double_tmp;
-          next_arg++;
-          fparg_count++;
-          FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
-          break;
+	{
+	/* If a floating-point parameter appears before all of the general-
+	   purpose registers are filled, the corresponding GPRs that match
+	   the size of the floating-point parameter are skipped.  */
+	case FFI_TYPE_FLOAT:
+	  double_tmp = *(float *)*p_argv;
+	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+	    *(double *)next_arg = double_tmp;
+	  else
+	    *fpr_base++ = double_tmp;
+	  next_arg++;
+	  fparg_count++;
+	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+	  break;
 
-        case FFI_TYPE_DOUBLE:
-          double_tmp = *(double *)*p_argv;
-          if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-            *(double *)next_arg = double_tmp;
-          else
-            *fpr_base++ = double_tmp;
-          next_arg += 2;
-          fparg_count++;
-          FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
-          break;
+	case FFI_TYPE_DOUBLE:
+	  double_tmp = *(double *)*p_argv;
+	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+	    *(double *)next_arg = double_tmp;
+	  else
+	    *fpr_base++ = double_tmp;
+	  next_arg += 2;
+	  fparg_count++;
+	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+	  break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-        case FFI_TYPE_LONGDOUBLE:
-          double_tmp = ((double *)*p_argv)[0];
-          if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-            *(double *)next_arg = double_tmp;
-          else
-            *fpr_base++ = double_tmp;
-          next_arg += 2;
-          fparg_count++;
-          double_tmp = ((double *)*p_argv)[1];
-          if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-            *(double *)next_arg = double_tmp;
-          else
-            *fpr_base++ = double_tmp;
-          next_arg += 2;
-          fparg_count++;
-          FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
-          break;
+	case FFI_TYPE_LONGDOUBLE:
+	  double_tmp = ((double *)*p_argv)[0];
+	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+	    *(double *)next_arg = double_tmp;
+	  else
+	    *fpr_base++ = double_tmp;
+	  next_arg += 2;
+	  fparg_count++;
+	  double_tmp = ((double *)*p_argv)[1];
+	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+	    *(double *)next_arg = double_tmp;
+	  else
+	    *fpr_base++ = double_tmp;
+	  next_arg += 2;
+	  fparg_count++;
+	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+	  break;
 #endif
-        case FFI_TYPE_UINT64:
-        case FFI_TYPE_SINT64:
-          *(long long *)next_arg = *(long long *)*p_argv;
-          next_arg+=2;
-          break;
-        case FFI_TYPE_UINT8:
-          gprvalue = *(unsigned char *)*p_argv;
-          goto putgpr;
-        case FFI_TYPE_SINT8:
-          gprvalue = *(signed char *)*p_argv;
-          goto putgpr;
-        case FFI_TYPE_UINT16:
-          gprvalue = *(unsigned short *)*p_argv;
-          goto putgpr;
-        case FFI_TYPE_SINT16:
-          gprvalue = *(signed short *)*p_argv;
-          goto putgpr;
+	case FFI_TYPE_UINT64:
+	case FFI_TYPE_SINT64:
+	  *(long long *)next_arg = *(long long *)*p_argv;
+	  next_arg+=2;
+	  break;
+	case FFI_TYPE_UINT8:
+	  gprvalue = *(unsigned char *)*p_argv;
+	  goto putgpr;
+	case FFI_TYPE_SINT8:
+	  gprvalue = *(signed char *)*p_argv;
+	  goto putgpr;
+	case FFI_TYPE_UINT16:
+	  gprvalue = *(unsigned short *)*p_argv;
+	  goto putgpr;
+	case FFI_TYPE_SINT16:
+	  gprvalue = *(signed short *)*p_argv;
+	  goto putgpr;
 
-        case FFI_TYPE_STRUCT:
-          dest_cpy = (char *) next_arg;
+	case FFI_TYPE_STRUCT:
+	  dest_cpy = (char *) next_arg;
 
-          /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
-             SI 4 bytes) are aligned as if they were those modes.
-             Structures with 3 byte in size are padded upwards.  */
-          size_al = (*ptr)->size;
-          /* If the first member of the struct is a double, then align
-             the struct to double-word.
-             Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
-          if ((*ptr)->elements[0]->type == 3)
-            size_al = ALIGN((*ptr)->size, 8);
-          if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
-            dest_cpy += 4 - size_al;
+	  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+	     SI 4 bytes) are aligned as if they were those modes.
+	     Structures with 3 byte in size are padded upwards.  */
+	  size_al = (*ptr)->size;
+	  /* If the first member of the struct is a double, then align
+	     the struct to double-word.
+	     Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
+	  if ((*ptr)->elements[0]->type == 3)
+	    size_al = ALIGN((*ptr)->size, 8);
+	  if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
+	    dest_cpy += 4 - size_al;
 
-          memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
-          next_arg += (size_al + 3) / 4;
-          break;
+	  memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
+	  next_arg += (size_al + 3) / 4;
+	  break;
 
-        case FFI_TYPE_INT:
-        case FFI_TYPE_UINT32:
-        case FFI_TYPE_SINT32:
-        case FFI_TYPE_POINTER:
-          gprvalue = *(unsigned *)*p_argv;
-        putgpr:
-          *next_arg++ = gprvalue;
-          break;
-        default:
-          break;
-        }
+	case FFI_TYPE_INT:
+	case FFI_TYPE_UINT32:
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_POINTER:
+	  gprvalue = *(unsigned *)*p_argv;
+	putgpr:
+	  *next_arg++ = gprvalue;
+	  break;
+	default:
+	  break;
+	}
     }
 
   /* Check that we didn't overrun the stack...  */
   //FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
   //FFI_ASSERT((unsigned *)fpr_base
-  //         <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
+  //	     <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
   //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
 }
 
@@ -246,15 +246,15 @@
       p = s->elements[i];
       darwin_adjust_aggregate_sizes (p);
       if (i == 0
-          && (p->type == FFI_TYPE_UINT64
-              || p->type == FFI_TYPE_SINT64
-              || p->type == FFI_TYPE_DOUBLE
-              || p->alignment == 8))
-        align = 8;
+	  && (p->type == FFI_TYPE_UINT64
+	      || p->type == FFI_TYPE_SINT64
+	      || p->type == FFI_TYPE_DOUBLE
+	      || p->alignment == 8))
+	align = 8;
       else if (p->alignment == 16 || p->alignment < 4)
-        align = p->alignment;
+	align = p->alignment;
       else
-        align = 4;
+	align = 4;
       s->size = ALIGN(s->size, align) + p->size;
     }
   
@@ -287,7 +287,7 @@
     {
       darwin_adjust_aggregate_sizes (cif->rtype);
       for (i = 0; i < cif->nargs; i++)
-        darwin_adjust_aggregate_sizes (cif->arg_types[i]);
+	darwin_adjust_aggregate_sizes (cif->arg_types[i]);
     }
 
   /* Space for the frame pointer, callee's LR, CR, etc, and for
@@ -348,58 +348,58 @@
   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
     {
       switch ((*ptr)->type)
-        {
-        case FFI_TYPE_FLOAT:
-        case FFI_TYPE_DOUBLE:
-          fparg_count++;
-          /* If this FP arg is going on the stack, it must be
-             8-byte-aligned.  */
-          if (fparg_count > NUM_FPR_ARG_REGISTERS
-              && intarg_count%2 != 0)
-            intarg_count++;
-          break;
+	{
+	case FFI_TYPE_FLOAT:
+	case FFI_TYPE_DOUBLE:
+	  fparg_count++;
+	  /* If this FP arg is going on the stack, it must be
+	     8-byte-aligned.  */
+	  if (fparg_count > NUM_FPR_ARG_REGISTERS
+	      && intarg_count%2 != 0)
+	    intarg_count++;
+	  break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-        case FFI_TYPE_LONGDOUBLE:
-          fparg_count += 2;
-          /* If this FP arg is going on the stack, it must be
-             8-byte-aligned.  */
-          if (fparg_count > NUM_FPR_ARG_REGISTERS
-              && intarg_count%2 != 0)
-            intarg_count++;
-          intarg_count +=2;
-          break;
+	case FFI_TYPE_LONGDOUBLE:
+	  fparg_count += 2;
+	  /* If this FP arg is going on the stack, it must be
+	     8-byte-aligned.  */
+	  if (fparg_count > NUM_FPR_ARG_REGISTERS
+	      && intarg_count%2 != 0)
+	    intarg_count++;
+	  intarg_count +=2;
+	  break;
 #endif
 
-        case FFI_TYPE_UINT64:
-        case FFI_TYPE_SINT64:
-          /* 'long long' arguments are passed as two words, but
-             either both words must fit in registers or both go
-             on the stack.  If they go on the stack, they must
-             be 8-byte-aligned.  */
-          if (intarg_count == NUM_GPR_ARG_REGISTERS-1
-              || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
-            intarg_count++;
-          intarg_count += 2;
-          break;
+	case FFI_TYPE_UINT64:
+	case FFI_TYPE_SINT64:
+	  /* 'long long' arguments are passed as two words, but
+	     either both words must fit in registers or both go
+	     on the stack.  If they go on the stack, they must
+	     be 8-byte-aligned.  */
+	  if (intarg_count == NUM_GPR_ARG_REGISTERS-1
+	      || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
+	    intarg_count++;
+	  intarg_count += 2;
+	  break;
 
-        case FFI_TYPE_STRUCT:
-          size_al = (*ptr)->size;
-          /* If the first member of the struct is a double, then align
-             the struct to double-word.
-             Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
-          if ((*ptr)->elements[0]->type == 3)
-            size_al = ALIGN((*ptr)->size, 8);
-          intarg_count += (size_al + 3) / 4;
-          break;
+	case FFI_TYPE_STRUCT:
+	  size_al = (*ptr)->size;
+	  /* If the first member of the struct is a double, then align
+	     the struct to double-word.
+	     Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
+	  if ((*ptr)->elements[0]->type == 3)
+	    size_al = ALIGN((*ptr)->size, 8);
+	  intarg_count += (size_al + 3) / 4;
+	  break;
 
-        default:
-          /* Everything else is passed as a 4-byte word in a GPR, either
-             the object itself or a pointer to it.  */
-          intarg_count++;
-          break;
-        }
+	default:
+	  /* Everything else is passed as a 4-byte word in a GPR, either
+	     the object itself or a pointer to it.  */
+	  intarg_count++;
+	  break;
+	}
     }
 
   if (fparg_count != 0)
@@ -425,9 +425,9 @@
 }
 
 extern void ffi_call_AIX(extended_cif *, unsigned, unsigned, unsigned *,
-                         void (*fn)(void), void (*fn2)(void));
+			 void (*fn)(void), void (*fn2)(void));
 extern void ffi_call_DARWIN(extended_cif *, unsigned, unsigned, unsigned *,
-                            void (*fn)(void), void (*fn2)(void));
+			    void (*fn)(void), void (*fn2)(void));
 
 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 {
@@ -451,11 +451,11 @@
     {
     case FFI_AIX:
       ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
-                   ffi_prep_args);
+		   ffi_prep_args);
       break;
     case FFI_DARWIN:
       ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
-                      ffi_prep_args);
+		      ffi_prep_args);
       break;
     default:
       FFI_ASSERT(0);
@@ -478,61 +478,61 @@
    and aix_clsoure.S
 
    SP previous -> +---------------------------------------+ <--- child frame
-                  | back chain to caller 4                |
-                  +---------------------------------------+ 4
-                  | saved CR 4                            |
-                  +---------------------------------------+ 8
-                  | saved LR 4                            |
-                  +---------------------------------------+ 12
-                  | reserved for compilers 4              |
-                  +---------------------------------------+ 16
-                  | reserved for binders 4                |
-                  +---------------------------------------+ 20
-                  | saved TOC pointer 4                   |
-                  +---------------------------------------+ 24
-                  | always reserved 8*4=32 (previous GPRs)|
-                  | according to the linkage convention   |
-                  | from AIX                              |
-                  +---------------------------------------+ 56
-                  | our FPR area 13*8=104                 |
-                  | f1                                    |
-                  | .                                     |
-                  | f13                                   |
-                  +---------------------------------------+ 160
-                  | result area 8                         |
-                  +---------------------------------------+ 168
-                  | alignment to the next multiple of 16  |
+		  | back chain to caller 4                |
+		  +---------------------------------------+ 4
+		  | saved CR 4                            |
+		  +---------------------------------------+ 8
+		  | saved LR 4                            |
+		  +---------------------------------------+ 12
+		  | reserved for compilers 4              |
+		  +---------------------------------------+ 16
+		  | reserved for binders 4                |
+		  +---------------------------------------+ 20
+		  | saved TOC pointer 4                   |
+		  +---------------------------------------+ 24
+		  | always reserved 8*4=32 (previous GPRs)|
+		  | according to the linkage convention   |
+		  | from AIX                              |
+		  +---------------------------------------+ 56
+		  | our FPR area 13*8=104                 |
+		  | f1                                    |
+		  | .                                     |
+		  | f13                                   |
+		  +---------------------------------------+ 160
+		  | result area 8                         |
+		  +---------------------------------------+ 168
+		  | alignement to the next multiple of 16 |
 SP current -->    +---------------------------------------+ 176 <- parent frame
-                  | back chain to caller 4                |
-                  +---------------------------------------+ 180
-                  | saved CR 4                            |
-                  +---------------------------------------+ 184
-                  | saved LR 4                            |
-                  +---------------------------------------+ 188
-                  | reserved for compilers 4              |
-                  +---------------------------------------+ 192
-                  | reserved for binders 4                |
-                  +---------------------------------------+ 196
-                  | saved TOC pointer 4                   |
-                  +---------------------------------------+ 200
-                  | always reserved 8*4=32  we store our  |
-                  | GPRs here                             |
-                  | r3                                    |
-                  | .                                     |
-                  | r10                                   |
-                  +---------------------------------------+ 232
-                  | overflow part                         |
-                  +---------------------------------------+ xxx
-                  | ????                                  |
-                  +---------------------------------------+ xxx
+		  | back chain to caller 4                |
+		  +---------------------------------------+ 180
+		  | saved CR 4                            |
+		  +---------------------------------------+ 184
+		  | saved LR 4                            |
+		  +---------------------------------------+ 188
+		  | reserved for compilers 4              |
+		  +---------------------------------------+ 192
+		  | reserved for binders 4                |
+		  +---------------------------------------+ 196
+		  | saved TOC pointer 4                   |
+		  +---------------------------------------+ 200
+		  | always reserved 8*4=32  we store our  |
+		  | GPRs here                             |
+		  | r3                                    |
+		  | .                                     |
+		  | r10                                   |
+		  +---------------------------------------+ 232
+		  | overflow part                         |
+		  +---------------------------------------+ xxx
+		  | ????                                  |
+		  +---------------------------------------+ xxx
 
 */
 ffi_status
 ffi_prep_closure_loc (ffi_closure* closure,
-                      ffi_cif* cif,
-                      void (*fun)(ffi_cif*, void*, void**, void*),
-                      void *user_data,
-                      void *codeloc)
+		      ffi_cif* cif,
+		      void (*fun)(ffi_cif*, void*, void**, void*),
+		      void *user_data,
+		      void *codeloc)
 {
   unsigned int *tramp;
   struct ffi_aix_trampoline_struct *tramp_aix;
@@ -592,12 +592,12 @@
 {
 #ifndef _AIX
   __asm__ volatile (
-                "dcbf 0,%0\n"
-                "\tsync\n"
-                "\ticbi 0,%0\n"
-                "\tsync\n"
-                "\tisync"
-                : : "r"(addr) : "memory");
+		"dcbf 0,%0\n"
+		"\tsync\n"
+		"\ticbi 0,%0\n"
+		"\tsync\n"
+		"\tisync"
+		: : "r"(addr) : "memory");
 #endif
 }
 
@@ -618,7 +618,7 @@
 } ffi_dblfl;
 
 int ffi_closure_helper_DARWIN (ffi_closure*, void*,
-                               unsigned long*, ffi_dblfl*);
+			       unsigned long*, ffi_dblfl*);
 
 /* Basically the trampoline invokes ffi_closure_ASM, and on
    entry, r11 holds the address of the closure.
@@ -628,7 +628,7 @@
    following helper function to do most of the work.  */
 
 int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
-                               unsigned long * pgr, ffi_dblfl * pfr)
+			       unsigned long * pgr, ffi_dblfl * pfr)
 {
   /* 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_ASM
@@ -675,121 +675,121 @@
   while (i < avn)
     {
       switch (arg_types[i]->type)
-        {
-        case FFI_TYPE_SINT8:
-        case FFI_TYPE_UINT8:
-          avalue[i] = (char *) pgr + 3;
-          ng++;
-          pgr++;
-          break;
+	{
+	case FFI_TYPE_SINT8:
+	case FFI_TYPE_UINT8:
+	  avalue[i] = (char *) pgr + 3;
+	  ng++;
+	  pgr++;
+	  break;
 
-        case FFI_TYPE_SINT16:
-        case FFI_TYPE_UINT16:
-          avalue[i] = (char *) pgr + 2;
-          ng++;
-          pgr++;
-          break;
+	case FFI_TYPE_SINT16:
+	case FFI_TYPE_UINT16:
+	  avalue[i] = (char *) pgr + 2;
+	  ng++;
+	  pgr++;
+	  break;
 
-        case FFI_TYPE_SINT32:
-        case FFI_TYPE_UINT32:
-        case FFI_TYPE_POINTER:
-          avalue[i] = pgr;
-          ng++;
-          pgr++;
-          break;
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_UINT32:
+	case FFI_TYPE_POINTER:
+	  avalue[i] = pgr;
+	  ng++;
+	  pgr++;
+	  break;
 
-        case FFI_TYPE_STRUCT:
-          /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
-             SI 4 bytes) are aligned as if they were those modes.  */
-          size_al = arg_types[i]->size;
-          /* If the first member of the struct is a double, then align
-             the struct to double-word.
-             Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
-          if (arg_types[i]->elements[0]->type == 3)
-            size_al = ALIGN(arg_types[i]->size, 8);
-          if (size_al < 3 && cif->abi == FFI_DARWIN)
-            avalue[i] = (void*) pgr + 4 - size_al;
-          else
-            avalue[i] = (void*) pgr;
-          ng += (size_al + 3) / 4;
-          pgr += (size_al + 3) / 4;
-          break;
+	case FFI_TYPE_STRUCT:
+	  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+	     SI 4 bytes) are aligned as if they were those modes.  */
+	  size_al = arg_types[i]->size;
+	  /* If the first member of the struct is a double, then align
+	     the struct to double-word.
+	     Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
+	  if (arg_types[i]->elements[0]->type == 3)
+	    size_al = ALIGN(arg_types[i]->size, 8);
+	  if (size_al < 3 && cif->abi == FFI_DARWIN)
+	    avalue[i] = (void*) pgr + 4 - size_al;
+	  else
+	    avalue[i] = (void*) pgr;
+	  ng += (size_al + 3) / 4;
+	  pgr += (size_al + 3) / 4;
+	  break;
 
-        case FFI_TYPE_SINT64:
-        case FFI_TYPE_UINT64:
-          /* Long long ints are passed in two gpr's.  */
-          avalue[i] = pgr;
-          ng += 2;
-          pgr += 2;
-          break;
+	case FFI_TYPE_SINT64:
+	case FFI_TYPE_UINT64:
+	  /* Long long ints are passed in two gpr's.  */
+	  avalue[i] = pgr;
+	  ng += 2;
+	  pgr += 2;
+	  break;
 
-        case FFI_TYPE_FLOAT:
-          /* A float value consumes a GPR.
-             There are 13 64bit floating point registers.  */
-          if (nf < NUM_FPR_ARG_REGISTERS)
-            {
-              temp = pfr->d;
-              pfr->f = (float)temp;
-              avalue[i] = pfr;
-              pfr++;
-            }
-          else
-            {
-              avalue[i] = pgr;
-            }
-          nf++;
-          ng++;
-          pgr++;
-          break;
+	case FFI_TYPE_FLOAT:
+	  /* A float value consumes a GPR.
+	     There are 13 64bit floating point registers.  */
+	  if (nf < NUM_FPR_ARG_REGISTERS)
+	    {
+	      temp = pfr->d;
+	      pfr->f = (float)temp;
+	      avalue[i] = pfr;
+	      pfr++;
+	    }
+	  else
+	    {
+	      avalue[i] = pgr;
+	    }
+	  nf++;
+	  ng++;
+	  pgr++;
+	  break;
 
-        case FFI_TYPE_DOUBLE:
-          /* A double value consumes two GPRs.
-             There are 13 64bit floating point registers.  */
-          if (nf < NUM_FPR_ARG_REGISTERS)
-            {
-              avalue[i] = pfr;
-              pfr++;
-            }
-          else
-            {
-              avalue[i] = pgr;
-            }
-          nf++;
-          ng += 2;
-          pgr += 2;
-          break;
+	case FFI_TYPE_DOUBLE:
+	  /* A double value consumes two GPRs.
+	     There are 13 64bit floating point registers.  */
+	  if (nf < NUM_FPR_ARG_REGISTERS)
+	    {
+	      avalue[i] = pfr;
+	      pfr++;
+	    }
+	  else
+	    {
+	      avalue[i] = pgr;
+	    }
+	  nf++;
+	  ng += 2;
+	  pgr += 2;
+	  break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-        case FFI_TYPE_LONGDOUBLE:
-          /* A long double value consumes four GPRs and two FPRs.
-             There are 13 64bit floating point registers.  */
-          if (nf < NUM_FPR_ARG_REGISTERS - 1)
-            {
-              avalue[i] = pfr;
-              pfr += 2;
-            }
-          /* Here we have the situation where one part of the long double
-             is stored in fpr13 and the other part is already on the stack.
-             We use a union to pass the long double to avalue[i].  */
-          else if (nf == NUM_FPR_ARG_REGISTERS - 1)
-            {
-              memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
-              memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
-              avalue[i] = &temp_ld.ld;
-            }
-          else
-            {
-              avalue[i] = pgr;
-            }
-          nf += 2;
-          ng += 4;
-          pgr += 4;
-          break;
+	case FFI_TYPE_LONGDOUBLE:
+	  /* A long double value consumes four GPRs and two FPRs.
+	     There are 13 64bit floating point registers.  */
+	  if (nf < NUM_FPR_ARG_REGISTERS - 1)
+	    {
+	      avalue[i] = pfr;
+	      pfr += 2;
+	    }
+	  /* Here we have the situation where one part of the long double
+	     is stored in fpr13 and the other part is already on the stack.
+	     We use a union to pass the long double to avalue[i].  */
+	  else if (nf == NUM_FPR_ARG_REGISTERS - 1)
+	    {
+	      memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
+	      memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
+	      avalue[i] = &temp_ld.ld;
+	    }
+	  else
+	    {
+	      avalue[i] = pgr;
+	    }
+	  nf += 2;
+	  ng += 4;
+	  pgr += 4;
+	  break;
 #endif
-        default:
-          FFI_ASSERT(0);
-        }
+	default:
+	  FFI_ASSERT(0);
+	}
       i++;
     }
 
diff --git a/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c b/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
index e00f153..8953d5f 100644
--- a/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
+++ b/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
@@ -39,7 +39,7 @@
 
 #if 0
 #if defined(POWERPC_DARWIN)
-#include <libkern/OSCacheControl.h>     // for sys_icache_invalidate()
+#include <libkern/OSCacheControl.h>	// for sys_icache_invalidate()
 #endif
 
 #else
@@ -55,8 +55,8 @@
 // The layout of a function descriptor.  A C function pointer really
 // points to one of these.
 typedef struct aix_fd_struct {
-  void* code_pointer;
-  void* toc;
+  void*	code_pointer;
+  void*	toc;
 } aix_fd;
 
 /* ffi_prep_args is called by the assembly routine once stack space
@@ -64,241 +64,241 @@
 
    The stack layout we want looks like this:
 
-   |   Return address from ffi_call_DARWIN      |       higher addresses
+   |   Return address from ffi_call_DARWIN      |	higher addresses
    |--------------------------------------------|
-   |   Previous backchain pointer      4/8      |           stack pointer here
+   |   Previous backchain pointer      4/8      |	    stack pointer here
    |--------------------------------------------|-\ <<< on entry to
-   |   Saved r28-r31                 (4/8)*4    | |         ffi_call_DARWIN
+   |   Saved r28-r31                 (4/8)*4    | |	    ffi_call_DARWIN
    |--------------------------------------------| |
    |   Parameters      (at least 8*(4/8)=32/64) | | (176) +112 - +288
    |--------------------------------------------| |
    |   Space for GPR2                  4/8      | |
-   |--------------------------------------------| |     stack   |
-   |   Reserved                                          (4/8)*2    | | grows   |
-   |--------------------------------------------| |     down    V
+   |--------------------------------------------| |	stack	|
+   |   Reserved						 (4/8)*2    | |	grows	|
+   |--------------------------------------------| |	down	V
    |   Space for callee's LR           4/8      | |
-   |--------------------------------------------| |     lower addresses
+   |--------------------------------------------| |	lower addresses
    |   Saved CR                        4/8      | |
    |--------------------------------------------| |     stack pointer here
    |   Current backchain pointer       4/8      | |     during
    |--------------------------------------------|-/ <<< ffi_call_DARWIN
 
-        Note: ppc64 CR is saved in the low word of a long on the stack.
+	Note: ppc64 CR is saved in the low word of a long on the stack.
 */
 
 /*@-exportheader@*/
 void
 ffi_prep_args(
-        extended_cif*   inEcif,
-        unsigned *const stack)
+	extended_cif*	inEcif,
+	unsigned *const	stack)
 /*@=exportheader@*/
 {
-        /*      Copy the ecif to a local var so we can trample the arg.
-                BC note: test this with GP later for possible problems...       */
-        volatile extended_cif*  ecif    = inEcif;
+	/*	Copy the ecif to a local var so we can trample the arg.
+		BC note: test this with GP later for possible problems...	*/
+	volatile extended_cif*	ecif	= inEcif;
 
-        const unsigned bytes    = ecif->cif->bytes;
-        const unsigned flags    = ecif->cif->flags;
+	const unsigned bytes	= ecif->cif->bytes;
+	const unsigned flags	= ecif->cif->flags;
 
-        /*      Cast the stack arg from int* to long*. sizeof(long) == 4 in 32-bit mode
-                and 8 in 64-bit mode.   */
-        unsigned long *const longStack  = (unsigned long *const)stack;
+	/*	Cast the stack arg from int* to long*. sizeof(long) == 4 in 32-bit mode
+		and 8 in 64-bit mode.	*/
+	unsigned long *const longStack	= (unsigned long *const)stack;
 
-        /* 'stacktop' points at the previous backchain pointer. */
+	/* 'stacktop' points at the previous backchain pointer.	*/
 #if defined(__ppc64__)
-        //      In ppc-darwin.s, an extra 96 bytes is reserved for the linkage area,
-        //      saved registers, and an extra FPR.
-        unsigned long *const stacktop   =
-                (unsigned long *)(unsigned long)((char*)longStack + bytes + 96);
+	//	In ppc-darwin.s, an extra 96 bytes is reserved for the linkage area,
+	//	saved registers, and an extra FPR.
+	unsigned long *const stacktop	=
+		(unsigned long *)(unsigned long)((char*)longStack + bytes + 96);
 #elif defined(__ppc__)
-        unsigned long *const stacktop   = longStack + (bytes / sizeof(long));
+	unsigned long *const stacktop	= longStack + (bytes / sizeof(long));
 #else
 #error undefined architecture
 #endif
 
-        /* 'fpr_base' points at the space for fpr1, and grows upwards as
-                we use FPR registers.  */
-        double*         fpr_base = (double*)(stacktop - ASM_NEEDS_REGISTERS) -
-                NUM_FPR_ARG_REGISTERS;
+	/* 'fpr_base' points at the space for fpr1, and grows upwards as
+		we use FPR registers.  */
+	double*		fpr_base = (double*)(stacktop - ASM_NEEDS_REGISTERS) -
+		NUM_FPR_ARG_REGISTERS;
 
 #if defined(__ppc64__)
-        //      64-bit saves an extra register, and uses an extra FPR. Knock fpr_base
-        //      down a couple pegs.
-        fpr_base -= 2;
+	//	64-bit saves an extra register, and uses an extra FPR. Knock fpr_base
+	//	down a couple pegs.
+	fpr_base -= 2;
 #endif
 
-        unsigned int    fparg_count = 0;
+	unsigned int	fparg_count = 0;
 
-        /* 'next_arg' grows up as we put parameters in it.  */
-        unsigned long*  next_arg = longStack + 6; /* 6 reserved positions.  */
+	/* 'next_arg' grows up as we put parameters in it.  */
+	unsigned long*	next_arg = longStack + 6; /* 6 reserved positions.  */
 
-        int                             i;
-        double                  double_tmp;
-        void**                  p_argv = ecif->avalue;
-        unsigned long   gprvalue;
-        ffi_type**              ptr = ecif->cif->arg_types;
+	int				i;
+	double			double_tmp;
+	void**			p_argv = ecif->avalue;
+	unsigned long	gprvalue;
+	ffi_type**		ptr = ecif->cif->arg_types;
 
-        /* Check that everything starts aligned properly.  */
-        FFI_ASSERT(stack == SF_ROUND(stack));
-        FFI_ASSERT(stacktop == SF_ROUND(stacktop));
-        FFI_ASSERT(bytes == SF_ROUND(bytes));
+	/* Check that everything starts aligned properly.  */
+	FFI_ASSERT(stack == SF_ROUND(stack));
+	FFI_ASSERT(stacktop == SF_ROUND(stacktop));
+	FFI_ASSERT(bytes == SF_ROUND(bytes));
 
-        /*      Deal with return values that are actually pass-by-reference.
-                Rule:
-                Return values are referenced by r3, so r4 is the first parameter.  */
+	/*	Deal with return values that are actually pass-by-reference.
+		Rule:
+		Return values are referenced by r3, so r4 is the first parameter.  */
 
-        if (flags & FLAG_RETVAL_REFERENCE)
-                *next_arg++ = (unsigned long)(char*)ecif->rvalue;
+	if (flags & FLAG_RETVAL_REFERENCE)
+		*next_arg++ = (unsigned long)(char*)ecif->rvalue;
 
-        /* Now for the arguments.  */
-        for (i = ecif->cif->nargs; i > 0; i--, ptr++, p_argv++)
+	/* Now for the arguments.  */
+	for (i = ecif->cif->nargs; i > 0; i--, ptr++, p_argv++)
     {
-                switch ((*ptr)->type)
-                {
-                        /*      If a floating-point parameter appears before all of the general-
-                                purpose registers are filled, the corresponding GPRs that match
-                                the size of the floating-point parameter are shadowed for the
-                                benefit of vararg and pre-ANSI functions.       */
-                        case FFI_TYPE_FLOAT:
-                                double_tmp = *(float*)*p_argv;
+		switch ((*ptr)->type)
+		{
+			/*	If a floating-point parameter appears before all of the general-
+				purpose registers are filled, the corresponding GPRs that match
+				the size of the floating-point parameter are shadowed for the
+				benefit of vararg and pre-ANSI functions.	*/
+			case FFI_TYPE_FLOAT:
+				double_tmp = *(float*)*p_argv;
 
-                                if (fparg_count < NUM_FPR_ARG_REGISTERS)
-                                        *fpr_base++ = double_tmp;
+				if (fparg_count < NUM_FPR_ARG_REGISTERS)
+					*fpr_base++ = double_tmp;
 
-                                *(double*)next_arg = double_tmp;
+				*(double*)next_arg = double_tmp;
 
-                                next_arg++;
-                                fparg_count++;
-                                FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+				next_arg++;
+				fparg_count++;
+				FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_DOUBLE:
-                                double_tmp = *(double*)*p_argv;
+			case FFI_TYPE_DOUBLE:
+				double_tmp = *(double*)*p_argv;
 
-                                if (fparg_count < NUM_FPR_ARG_REGISTERS)
-                                        *fpr_base++ = double_tmp;
+				if (fparg_count < NUM_FPR_ARG_REGISTERS)
+					*fpr_base++ = double_tmp;
 
-                                *(double*)next_arg = double_tmp;
+				*(double*)next_arg = double_tmp;
 
-                                next_arg += MODE_CHOICE(2,1);
-                                fparg_count++;
-                                FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+				next_arg += MODE_CHOICE(2,1);
+				fparg_count++;
+				FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
 
-                                break;
+				break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-                        case FFI_TYPE_LONGDOUBLE:
+			case FFI_TYPE_LONGDOUBLE:
 #if defined(__ppc64__)
-                                if (fparg_count < NUM_FPR_ARG_REGISTERS)
-                                        *(long double*)fpr_base = *(long double*)*p_argv;
+				if (fparg_count < NUM_FPR_ARG_REGISTERS)
+					*(long double*)fpr_base	= *(long double*)*p_argv;
 #elif defined(__ppc__)
-                                if (fparg_count < NUM_FPR_ARG_REGISTERS - 1)
-                                        *(long double*)fpr_base = *(long double*)*p_argv;
-                                else if (fparg_count == NUM_FPR_ARG_REGISTERS - 1)
-                                        *(double*)fpr_base      = *(double*)*p_argv;
+				if (fparg_count < NUM_FPR_ARG_REGISTERS - 1)
+					*(long double*)fpr_base	= *(long double*)*p_argv;
+				else if (fparg_count == NUM_FPR_ARG_REGISTERS - 1)
+					*(double*)fpr_base	= *(double*)*p_argv;
 #else
 #error undefined architecture
 #endif
 
-                                *(long double*)next_arg = *(long double*)*p_argv;
-                                fparg_count += 2;
-                                fpr_base += 2;
-                                next_arg += MODE_CHOICE(4,2);
-                                FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+				*(long double*)next_arg	= *(long double*)*p_argv;
+				fparg_count += 2;
+				fpr_base += 2;
+				next_arg += MODE_CHOICE(4,2);
+				FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
 
-                                break;
-#endif  //      FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+				break;
+#endif	//	FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-                        case FFI_TYPE_UINT64:
-                        case FFI_TYPE_SINT64:
+			case FFI_TYPE_UINT64:
+			case FFI_TYPE_SINT64:
 #if defined(__ppc64__)
-                                gprvalue = *(long long*)*p_argv;
-                                goto putgpr;
+				gprvalue = *(long long*)*p_argv;
+				goto putgpr;
 #elif defined(__ppc__)
-                                *(long long*)next_arg = *(long long*)*p_argv;
-                                next_arg += 2;
-                                break;
+				*(long long*)next_arg = *(long long*)*p_argv;
+				next_arg += 2;
+				break;
 #else
 #error undefined architecture
 #endif
 
-                        case FFI_TYPE_POINTER:
-                                gprvalue = *(unsigned long*)*p_argv;
-                                goto putgpr;
+			case FFI_TYPE_POINTER:
+				gprvalue = *(unsigned long*)*p_argv;
+				goto putgpr;
 
-                        case FFI_TYPE_UINT8:
-                                gprvalue = *(unsigned char*)*p_argv;
-                                goto putgpr;
+			case FFI_TYPE_UINT8:
+				gprvalue = *(unsigned char*)*p_argv;
+				goto putgpr;
 
-                        case FFI_TYPE_SINT8:
-                                gprvalue = *(signed char*)*p_argv;
-                                goto putgpr;
+			case FFI_TYPE_SINT8:
+				gprvalue = *(signed char*)*p_argv;
+				goto putgpr;
 
-                        case FFI_TYPE_UINT16:
-                                gprvalue = *(unsigned short*)*p_argv;
-                                goto putgpr;
+			case FFI_TYPE_UINT16:
+				gprvalue = *(unsigned short*)*p_argv;
+				goto putgpr;
 
-                        case FFI_TYPE_SINT16:
-                                gprvalue = *(signed short*)*p_argv;
-                                goto putgpr;
+			case FFI_TYPE_SINT16:
+				gprvalue = *(signed short*)*p_argv;
+				goto putgpr;
 
-                        case FFI_TYPE_STRUCT:
-                        {
+			case FFI_TYPE_STRUCT:
+			{
 #if defined(__ppc64__)
-                                unsigned int    gprSize = 0;
-                                unsigned int    fprSize = 0;
+				unsigned int	gprSize = 0;
+				unsigned int	fprSize = 0;
 
-                                ffi64_struct_to_reg_form(*ptr, (char*)*p_argv, NULL, &fparg_count,
-                                        (char*)next_arg, &gprSize, (char*)fpr_base, &fprSize);
-                                next_arg += gprSize / sizeof(long);
-                                fpr_base += fprSize / sizeof(double);
+				ffi64_struct_to_reg_form(*ptr, (char*)*p_argv, NULL, &fparg_count,
+					(char*)next_arg, &gprSize, (char*)fpr_base, &fprSize);
+				next_arg += gprSize / sizeof(long);
+				fpr_base += fprSize / sizeof(double);
 
 #elif defined(__ppc__)
-                                char*   dest_cpy = (char*)next_arg;
+				char*	dest_cpy = (char*)next_arg;
 
-                        /*      Structures that match the basic modes (QI 1 byte, HI 2 bytes,
-                                SI 4 bytes) are aligned as if they were those modes.
-                                Structures with 3 byte in size are padded upwards.  */
-                                unsigned size_al = (*ptr)->size;
+			/*	Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+				SI 4 bytes) are aligned as if they were those modes.
+				Structures with 3 byte in size are padded upwards.  */
+				unsigned size_al = (*ptr)->size;
 
-                        /*      If the first member of the struct is a double, then align
-                                the struct to double-word.  */
-                                if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
-                                        size_al = ALIGN((*ptr)->size, 8);
+			/*	If the first member of the struct is a double, then align
+				the struct to double-word.  */
+				if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
+					size_al = ALIGN((*ptr)->size, 8);
 
-                                if (ecif->cif->abi == FFI_DARWIN)
-                                {
-                                        if (size_al < 3)
-                                                dest_cpy += 4 - size_al;
-                                }
+				if (ecif->cif->abi == FFI_DARWIN)
+				{
+					if (size_al < 3)
+						dest_cpy += 4 - size_al;
+				}
 
-                                memcpy((char*)dest_cpy, (char*)*p_argv, size_al);
-                                next_arg += (size_al + 3) / 4;
+				memcpy((char*)dest_cpy, (char*)*p_argv, size_al);
+				next_arg += (size_al + 3) / 4;
 #else
 #error undefined architecture
 #endif
-                                break;
-                        }
+				break;
+			}
 
-                        case FFI_TYPE_INT:
-                        case FFI_TYPE_UINT32:
-                        case FFI_TYPE_SINT32:
-                                gprvalue = *(unsigned*)*p_argv;
+			case FFI_TYPE_INT:
+			case FFI_TYPE_UINT32:
+			case FFI_TYPE_SINT32:
+				gprvalue = *(unsigned*)*p_argv;
 
 putgpr:
-                                *next_arg++ = gprvalue;
-                                break;
+				*next_arg++ = gprvalue;
+				break;
 
-                        default:
-                                break;
-                }
-        }
+			default:
+				break;
+		}
+	}
 
   /* Check that we didn't overrun the stack...  */
   //FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
   //FFI_ASSERT((unsigned *)fpr_base
-  //         <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
+  //	     <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
   //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
 }
 
@@ -306,320 +306,320 @@
 
 bool
 ffi64_struct_contains_fp(
-        const ffi_type* inType)
+	const ffi_type*	inType)
 {
-        bool                    containsFP      = false;
-        unsigned int    i;
+	bool			containsFP	= false;
+	unsigned int	i;
 
-        for (i = 0; inType->elements[i] != NULL && !containsFP; i++)
-        {
-                if (inType->elements[i]->type == FFI_TYPE_FLOAT         ||
-                        inType->elements[i]->type == FFI_TYPE_DOUBLE    ||
-                        inType->elements[i]->type == FFI_TYPE_LONGDOUBLE)
-                        containsFP = true;
-                else if (inType->elements[i]->type == FFI_TYPE_STRUCT)
-                        containsFP = ffi64_struct_contains_fp(inType->elements[i]);
-        }
+	for (i = 0; inType->elements[i] != NULL && !containsFP; i++)
+	{
+		if (inType->elements[i]->type == FFI_TYPE_FLOAT		||
+			inType->elements[i]->type == FFI_TYPE_DOUBLE	||
+			inType->elements[i]->type == FFI_TYPE_LONGDOUBLE)
+			containsFP = true;
+		else if (inType->elements[i]->type == FFI_TYPE_STRUCT)
+			containsFP = ffi64_struct_contains_fp(inType->elements[i]);
+	}
 
-        return containsFP;
+	return containsFP;
 }
 
-#endif  // defined(__ppc64__)
+#endif	// defined(__ppc64__)
 
 /* Perform machine dependent cif processing.  */
 ffi_status
 ffi_prep_cif_machdep(
-        ffi_cif*        cif)
+	ffi_cif*	cif)
 {
-        /* All this is for the DARWIN ABI.  */
-        int                             i;
-        ffi_type**              ptr;
-        int                             intarg_count = 0;
-        int                             fparg_count = 0;
-        unsigned int    flags = 0;
-        unsigned int    size_al = 0;
+	/* All this is for the DARWIN ABI.  */
+	int				i;
+	ffi_type**		ptr;
+	int				intarg_count = 0;
+	int				fparg_count = 0;
+	unsigned int	flags = 0;
+	unsigned int	size_al = 0;
 
-        /*      All the machine-independent calculation of cif->bytes will be wrong.
-                Redo the calculation for DARWIN.  */
+	/*	All the machine-independent calculation of cif->bytes will be wrong.
+		Redo the calculation for DARWIN.  */
 
-        /*      Space for the frame pointer, callee's LR, CR, etc, and for
-                the asm's temp regs.  */
-        unsigned int    bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
+	/*	Space for the frame pointer, callee's LR, CR, etc, and for
+		the asm's temp regs.  */
+	unsigned int	bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
 
-        /*      Return value handling.  The rules are as follows:
-                - 32-bit (or less) integer values are returned in gpr3;
-                - Structures of size <= 4 bytes also returned in gpr3;
-                - 64-bit integer values and structures between 5 and 8 bytes are
-                        returned in gpr3 and gpr4;
-                - Single/double FP values are returned in fpr1;
-                - Long double FP (if not equivalent to double) values are returned in
-                        fpr1 and fpr2;
-                - Larger structures values are allocated space and a pointer is passed
-                        as the first argument.  */
-        switch (cif->rtype->type)
-        {
+	/*	Return value handling.  The rules are as follows:
+		- 32-bit (or less) integer values are returned in gpr3;
+		- Structures of size <= 4 bytes also returned in gpr3;
+		- 64-bit integer values and structures between 5 and 8 bytes are
+			returned in gpr3 and gpr4;
+		- Single/double FP values are returned in fpr1;
+		- Long double FP (if not equivalent to double) values are returned in
+			fpr1 and fpr2;
+		- Larger structures values are allocated space and a pointer is passed
+			as the first argument.  */
+	switch (cif->rtype->type)
+	{
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-                case FFI_TYPE_LONGDOUBLE:
-                        flags |= FLAG_RETURNS_128BITS;
-                        flags |= FLAG_RETURNS_FP;
-                        break;
-#endif  // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+		case FFI_TYPE_LONGDOUBLE:
+			flags |= FLAG_RETURNS_128BITS;
+			flags |= FLAG_RETURNS_FP;
+			break;
+#endif	// FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-                case FFI_TYPE_DOUBLE:
-                        flags |= FLAG_RETURNS_64BITS;
-                        /* Fall through.  */
-                case FFI_TYPE_FLOAT:
-                        flags |= FLAG_RETURNS_FP;
-                        break;
+		case FFI_TYPE_DOUBLE:
+			flags |= FLAG_RETURNS_64BITS;
+			/* Fall through.  */
+		case FFI_TYPE_FLOAT:
+			flags |= FLAG_RETURNS_FP;
+			break;
 
 #if defined(__ppc64__)
-                case FFI_TYPE_POINTER:
+		case FFI_TYPE_POINTER:
 #endif
-                case FFI_TYPE_UINT64:
-                case FFI_TYPE_SINT64:
-                        flags |= FLAG_RETURNS_64BITS;
-                        break;
+		case FFI_TYPE_UINT64:
+		case FFI_TYPE_SINT64:
+			flags |= FLAG_RETURNS_64BITS;
+			break;
 
-                case FFI_TYPE_STRUCT:
-                {
+		case FFI_TYPE_STRUCT:
+		{
 #if defined(__ppc64__)
 
-                        if (ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
-                        {
-                                flags |= FLAG_RETVAL_REFERENCE;
-                                flags |= FLAG_RETURNS_NOTHING;
-                                intarg_count++;
-                        }
-                        else
-                        {
-                                flags |= FLAG_RETURNS_STRUCT;
+			if (ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
+			{
+				flags |= FLAG_RETVAL_REFERENCE;
+				flags |= FLAG_RETURNS_NOTHING;
+				intarg_count++;
+			}
+			else
+			{
+				flags |= FLAG_RETURNS_STRUCT;
 
-                                if (ffi64_struct_contains_fp(cif->rtype))
-                                        flags |= FLAG_STRUCT_CONTAINS_FP;
-                        }
+				if (ffi64_struct_contains_fp(cif->rtype))
+					flags |= FLAG_STRUCT_CONTAINS_FP;
+			}
 
 #elif defined(__ppc__)
 
-                        flags |= FLAG_RETVAL_REFERENCE;
-                        flags |= FLAG_RETURNS_NOTHING;
-                        intarg_count++;
+			flags |= FLAG_RETVAL_REFERENCE;
+			flags |= FLAG_RETURNS_NOTHING;
+			intarg_count++;
 
 #else
 #error undefined architecture
 #endif
-                        break;
-                }
+			break;
+		}
 
-                case FFI_TYPE_VOID:
-                        flags |= FLAG_RETURNS_NOTHING;
-                        break;
+		case FFI_TYPE_VOID:
+			flags |= FLAG_RETURNS_NOTHING;
+			break;
 
-                default:
-                        /* Returns 32-bit integer, or similar.  Nothing to do here.  */
-                        break;
-        }
+		default:
+			/* Returns 32-bit integer, or similar.  Nothing to do here.  */
+			break;
+	}
 
-        /*      The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
-                first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
-                goes on the stack.  Structures are passed as a pointer to a copy of
-                the structure. Stuff on the stack needs to keep proper alignment.  */
-        for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
-        {
-                switch ((*ptr)->type)
-                {
-                        case FFI_TYPE_FLOAT:
-                        case FFI_TYPE_DOUBLE:
-                                fparg_count++;
-                                /*      If this FP arg is going on the stack, it must be
-                                        8-byte-aligned.  */
-                                if (fparg_count > NUM_FPR_ARG_REGISTERS
-                                        && intarg_count % 2 != 0)
-                                        intarg_count++;
-                                break;
+	/*	The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
+		first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
+		goes on the stack.  Structures are passed as a pointer to a copy of
+		the structure. Stuff on the stack needs to keep proper alignment.  */
+	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
+	{
+		switch ((*ptr)->type)
+		{
+			case FFI_TYPE_FLOAT:
+			case FFI_TYPE_DOUBLE:
+				fparg_count++;
+				/*	If this FP arg is going on the stack, it must be
+					8-byte-aligned.  */
+				if (fparg_count > NUM_FPR_ARG_REGISTERS
+					&& intarg_count % 2 != 0)
+					intarg_count++;
+				break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-                        case FFI_TYPE_LONGDOUBLE:
-                                fparg_count += 2;
-                                /*      If this FP arg is going on the stack, it must be
-                                        8-byte-aligned.  */
+			case FFI_TYPE_LONGDOUBLE:
+				fparg_count += 2;
+				/*	If this FP arg is going on the stack, it must be
+					8-byte-aligned.  */
 
-                                if (
+				if (
 #if defined(__ppc64__)
-                                        fparg_count > NUM_FPR_ARG_REGISTERS + 1
+					fparg_count > NUM_FPR_ARG_REGISTERS + 1
 #elif defined(__ppc__)
-                                        fparg_count > NUM_FPR_ARG_REGISTERS
+					fparg_count > NUM_FPR_ARG_REGISTERS
 #else
 #error undefined architecture
 #endif
-                                        && intarg_count % 2 != 0)
-                                        intarg_count++;
+					&& intarg_count % 2 != 0)
+					intarg_count++;
 
-                                intarg_count += 2;
-                                break;
-#endif  // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+				intarg_count += 2;
+				break;
+#endif	// FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-                        case FFI_TYPE_UINT64:
-                        case FFI_TYPE_SINT64:
-                                /*      'long long' arguments are passed as two words, but
-                                        either both words must fit in registers or both go
-                                        on the stack.  If they go on the stack, they must
-                                        be 8-byte-aligned.  */
-                                if (intarg_count == NUM_GPR_ARG_REGISTERS - 1
-                                        || (intarg_count >= NUM_GPR_ARG_REGISTERS
-                                        && intarg_count % 2 != 0))
-                                        intarg_count++;
+			case FFI_TYPE_UINT64:
+			case FFI_TYPE_SINT64:
+				/*	'long long' arguments are passed as two words, but
+					either both words must fit in registers or both go
+					on the stack.  If they go on the stack, they must
+					be 8-byte-aligned.  */
+				if (intarg_count == NUM_GPR_ARG_REGISTERS - 1
+					|| (intarg_count >= NUM_GPR_ARG_REGISTERS
+					&& intarg_count % 2 != 0))
+					intarg_count++;
 
-                                intarg_count += MODE_CHOICE(2,1);
+				intarg_count += MODE_CHOICE(2,1);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_STRUCT:
-                                size_al = (*ptr)->size;
-                                /*      If the first member of the struct is a double, then align
-                                        the struct to double-word.  */
-                                if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
-                                        size_al = ALIGN((*ptr)->size, 8);
+			case FFI_TYPE_STRUCT:
+				size_al = (*ptr)->size;
+				/*	If the first member of the struct is a double, then align
+					the struct to double-word.  */
+				if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
+					size_al = ALIGN((*ptr)->size, 8);
 
 #if defined(__ppc64__)
-                                // Look for FP struct members.
-                                unsigned int    j;
+				// Look for FP struct members.
+				unsigned int	j;
 
-                                for (j = 0; (*ptr)->elements[j] != NULL; j++)
-                                {
-                                        if ((*ptr)->elements[j]->type == FFI_TYPE_FLOAT ||
-                                                (*ptr)->elements[j]->type == FFI_TYPE_DOUBLE)
-                                        {
-                                                fparg_count++;
+				for (j = 0; (*ptr)->elements[j] != NULL; j++)
+				{
+					if ((*ptr)->elements[j]->type == FFI_TYPE_FLOAT	||
+						(*ptr)->elements[j]->type == FFI_TYPE_DOUBLE)
+					{
+						fparg_count++;
 
-                                                if (fparg_count > NUM_FPR_ARG_REGISTERS)
-                                                        intarg_count++;
-                                        }
-                                        else if ((*ptr)->elements[j]->type == FFI_TYPE_LONGDOUBLE)
-                                        {
-                                                fparg_count += 2;
+						if (fparg_count > NUM_FPR_ARG_REGISTERS)
+							intarg_count++;
+					}
+					else if ((*ptr)->elements[j]->type == FFI_TYPE_LONGDOUBLE)
+					{
+						fparg_count += 2;
 
-                                                if (fparg_count > NUM_FPR_ARG_REGISTERS + 1)
-                                                        intarg_count += 2;
-                                        }
-                                        else
-                                                intarg_count++;
-                                }
+						if (fparg_count > NUM_FPR_ARG_REGISTERS + 1)
+							intarg_count += 2;
+					}
+					else
+						intarg_count++;
+				}
 #elif defined(__ppc__)
-                                intarg_count += (size_al + 3) / 4;
+				intarg_count += (size_al + 3) / 4;
 #else
 #error undefined architecture
 #endif
 
-                                break;
+				break;
 
-                        default:
-                                /*      Everything else is passed as a 4/8-byte word in a GPR, either
-                                        the object itself or a pointer to it.  */
-                                intarg_count++;
-                                break;
-                }
-        }
+			default:
+				/*	Everything else is passed as a 4/8-byte word in a GPR, either
+					the object itself or a pointer to it.  */
+				intarg_count++;
+				break;
+		}
+	}
 
-        /* Space for the FPR registers, if needed.  */
-        if (fparg_count != 0)
-        {
-                flags |= FLAG_FP_ARGUMENTS;
+	/* Space for the FPR registers, if needed.  */
+	if (fparg_count != 0)
+	{
+		flags |= FLAG_FP_ARGUMENTS;
 #if defined(__ppc64__)
-                bytes += (NUM_FPR_ARG_REGISTERS + 1) * sizeof(double);
+		bytes += (NUM_FPR_ARG_REGISTERS + 1) * sizeof(double);
 #elif defined(__ppc__)
-                bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
+		bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
 #else
 #error undefined architecture
 #endif
-        }
+	}
 
-        /* Stack space.  */
+	/* Stack space.  */
 #if defined(__ppc64__)
-        if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
-                bytes += (intarg_count + fparg_count) * sizeof(long);
+	if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
+		bytes += (intarg_count + fparg_count) * sizeof(long);
 #elif defined(__ppc__)
-        if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
-                bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
+	if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
+		bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
 #else
 #error undefined architecture
 #endif
-        else
-                bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
+	else
+		bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
 
-        /* The stack space allocated needs to be a multiple of 16/32 bytes.  */
-        bytes = SF_ROUND(bytes);
+	/* The stack space allocated needs to be a multiple of 16/32 bytes.  */
+	bytes = SF_ROUND(bytes);
 
-        cif->flags = flags;
-        cif->bytes = bytes;
+	cif->flags = flags;
+	cif->bytes = bytes;
 
-        return FFI_OK;
+	return FFI_OK;
 }
 
 /*@-declundef@*/
 /*@-exportheader@*/
 extern void
 ffi_call_AIX(
-/*@out@*/       extended_cif*,
-                        unsigned,
-                        unsigned,
-/*@out@*/       unsigned*,
-                        void (*fn)(void),
-                        void (*fn2)(extended_cif*, unsigned *const));
+/*@out@*/	extended_cif*,
+			unsigned,
+			unsigned,
+/*@out@*/	unsigned*,
+			void (*fn)(void),
+			void (*fn2)(extended_cif*, unsigned *const));
 
 extern void
 ffi_call_DARWIN(
-/*@out@*/       extended_cif*,
-                        unsigned long,
-                        unsigned,
-/*@out@*/       unsigned*,
-                        void (*fn)(void),
-                        void (*fn2)(extended_cif*, unsigned *const));
+/*@out@*/	extended_cif*,
+			unsigned long,
+			unsigned,
+/*@out@*/	unsigned*,
+			void (*fn)(void),
+			void (*fn2)(extended_cif*, unsigned *const));
 /*@=declundef@*/
 /*@=exportheader@*/
 
 void
 ffi_call(
-/*@dependent@*/ ffi_cif*        cif,
-                                void            (*fn)(void),
-/*@out@*/               void*           rvalue,
-/*@dependent@*/ void**          avalue)
+/*@dependent@*/	ffi_cif*	cif,
+				void		(*fn)(void),
+/*@out@*/		void*		rvalue,
+/*@dependent@*/	void**		avalue)
 {
-        extended_cif ecif;
+	extended_cif ecif;
 
-        ecif.cif = cif;
-        ecif.avalue = avalue;
+	ecif.cif = cif;
+	ecif.avalue = avalue;
 
-        /*      If the return value is a struct and we don't have a return
-                value address then we need to make one.  */
-        if ((rvalue == NULL) &&
-                (cif->rtype->type == FFI_TYPE_STRUCT))
-        {
-                /*@-sysunrecog@*/
-                ecif.rvalue = alloca(cif->rtype->size);
-                /*@=sysunrecog@*/
-        }
-        else
-                ecif.rvalue = rvalue;
+	/*	If the return value is a struct and we don't have a return
+		value address then we need to make one.  */
+	if ((rvalue == NULL) &&
+		(cif->rtype->type == FFI_TYPE_STRUCT))
+	{
+		/*@-sysunrecog@*/
+		ecif.rvalue = alloca(cif->rtype->size);
+		/*@=sysunrecog@*/
+	}
+	else
+		ecif.rvalue = rvalue;
 
-        switch (cif->abi)
-        {
-                case FFI_AIX:
-                        /*@-usedef@*/
-                        ffi_call_AIX(&ecif, -cif->bytes,
-                                cif->flags, ecif.rvalue, fn, ffi_prep_args);
-                        /*@=usedef@*/
-                        break;
+	switch (cif->abi)
+	{
+		case FFI_AIX:
+			/*@-usedef@*/
+			ffi_call_AIX(&ecif, -cif->bytes,
+				cif->flags, ecif.rvalue, fn, ffi_prep_args);
+			/*@=usedef@*/
+			break;
 
-                case FFI_DARWIN:
-                        /*@-usedef@*/
-                        ffi_call_DARWIN(&ecif, -(long)cif->bytes,
-                                cif->flags, ecif.rvalue, fn, ffi_prep_args);
-                        /*@=usedef@*/
-                        break;
+		case FFI_DARWIN:
+			/*@-usedef@*/
+			ffi_call_DARWIN(&ecif, -(long)cif->bytes,
+				cif->flags, ecif.rvalue, fn, ffi_prep_args);
+			/*@=usedef@*/
+			break;
 
-                default:
-                        FFI_ASSERT(0);
-                        break;
+		default:
+			FFI_ASSERT(0);
+			break;
     }
 }
 
@@ -627,53 +627,53 @@
    and aix_clsoure.S
 
    SP previous -> +---------------------------------------+ <--- child frame
-                  | back chain to caller 4                |
-                  +---------------------------------------+ 4
-                  | saved CR 4                            |
-                  +---------------------------------------+ 8
-                  | saved LR 4                            |
-                  +---------------------------------------+ 12
-                  | reserved for compilers 4              |
-                  +---------------------------------------+ 16
-                  | reserved for binders 4                |
-                  +---------------------------------------+ 20
-                  | saved TOC pointer 4                   |
-                  +---------------------------------------+ 24
-                  | always reserved 8*4=32 (previous GPRs)|
-                  | according to the linkage convention   |
-                  | from AIX                              |
-                  +---------------------------------------+ 56
-                  | our FPR area 13*8=104                 |
-                  | f1                                    |
-                  | .                                     |
-                  | f13                                   |
-                  +---------------------------------------+ 160
-                  | result area 8                         |
-                  +---------------------------------------+ 168
-                  | alignment to the next multiple of 16  |
+		  | back chain to caller 4                |
+		  +---------------------------------------+ 4
+		  | saved CR 4                            |
+		  +---------------------------------------+ 8
+		  | saved LR 4                            |
+		  +---------------------------------------+ 12
+		  | reserved for compilers 4              |
+		  +---------------------------------------+ 16
+		  | reserved for binders 4                |
+		  +---------------------------------------+ 20
+		  | saved TOC pointer 4                   |
+		  +---------------------------------------+ 24
+		  | always reserved 8*4=32 (previous GPRs)|
+		  | according to the linkage convention   |
+		  | from AIX                              |
+		  +---------------------------------------+ 56
+		  | our FPR area 13*8=104                 |
+		  | f1                                    |
+		  | .                                     |
+		  | f13                                   |
+		  +---------------------------------------+ 160
+		  | result area 8                         |
+		  +---------------------------------------+ 168
+		  | alignement to the next multiple of 16 |
 SP current -->    +---------------------------------------+ 176 <- parent frame
-                  | back chain to caller 4                |
-                  +---------------------------------------+ 180
-                  | saved CR 4                            |
-                  +---------------------------------------+ 184
-                  | saved LR 4                            |
-                  +---------------------------------------+ 188
-                  | reserved for compilers 4              |
-                  +---------------------------------------+ 192
-                  | reserved for binders 4                |
-                  +---------------------------------------+ 196
-                  | saved TOC pointer 4                   |
-                  +---------------------------------------+ 200
-                  | always reserved 8*4=32  we store our  |
-                  | GPRs here                             |
-                  | r3                                    |
-                  | .                                     |
-                  | r10                                   |
-                  +---------------------------------------+ 232
-                  | overflow part                         |
-                  +---------------------------------------+ xxx
-                  | ????                                  |
-                  +---------------------------------------+ xxx
+		  | back chain to caller 4                |
+		  +---------------------------------------+ 180
+		  | saved CR 4                            |
+		  +---------------------------------------+ 184
+		  | saved LR 4                            |
+		  +---------------------------------------+ 188
+		  | reserved for compilers 4              |
+		  +---------------------------------------+ 192
+		  | reserved for binders 4                |
+		  +---------------------------------------+ 196
+		  | saved TOC pointer 4                   |
+		  +---------------------------------------+ 200
+		  | always reserved 8*4=32  we store our  |
+		  | GPRs here                             |
+		  | r3                                    |
+		  | .                                     |
+		  | r10                                   |
+		  +---------------------------------------+ 232
+		  | overflow part                         |
+		  +---------------------------------------+ xxx
+		  | ????                                  |
+		  +---------------------------------------+ xxx
 */
 
 #if !defined(POWERPC_DARWIN)
@@ -682,1095 +682,1095 @@
 
 static void
 flush_icache(
-        char*   addr)
+	char*	addr)
 {
 #ifndef _AIX
-        __asm__ volatile (
-                "dcbf 0,%0\n"
-                "sync\n"
-                "icbi 0,%0\n"
-                "sync\n"
-                "isync"
-                : : "r" (addr) : "memory");
+	__asm__ volatile (
+		"dcbf 0,%0\n"
+		"sync\n"
+		"icbi 0,%0\n"
+		"sync\n"
+		"isync"
+		: : "r" (addr) : "memory");
 #endif
 }
 
 static void
 flush_range(
-        char*   addr,
-        int             size)
+	char*	addr,
+	int		size)
 {
-        int i;
+	int i;
 
-        for (i = 0; i < size; i += MIN_LINE_SIZE)
-                flush_icache(addr + i);
+	for (i = 0; i < size; i += MIN_LINE_SIZE)
+		flush_icache(addr + i);
 
-        flush_icache(addr + size - 1);
+	flush_icache(addr + size - 1);
 }
 
-#endif  // !defined(POWERPC_DARWIN)
+#endif	// !defined(POWERPC_DARWIN)
 
 ffi_status
 ffi_prep_closure(
-        ffi_closure*    closure,
-        ffi_cif*                cif,
-        void                    (*fun)(ffi_cif*, void*, void**, void*),
-        void*                   user_data)
+	ffi_closure*	closure,
+	ffi_cif*		cif,
+	void			(*fun)(ffi_cif*, void*, void**, void*),
+	void*			user_data)
 {
-        switch (cif->abi)
-        {
-                case FFI_DARWIN:
-                {
-                        FFI_ASSERT (cif->abi == FFI_DARWIN);
+	switch (cif->abi)
+	{
+		case FFI_DARWIN:
+		{
+			FFI_ASSERT (cif->abi == FFI_DARWIN);
 
-                        unsigned int*   tramp = (unsigned int*)&closure->tramp[0];
+			unsigned int*	tramp = (unsigned int*)&closure->tramp[0];
 
 #if defined(__ppc64__)
-                        tramp[0] = 0x7c0802a6;  //      mflr    r0
-                        tramp[1] = 0x429f0005;  //      bcl             20,31,+0x8
-                        tramp[2] = 0x7d6802a6;  //      mflr    r11
-                        tramp[3] = 0x7c0803a6;  //      mtlr    r0
-                        tramp[4] = 0xe98b0018;  //      ld              r12,24(r11)
-                        tramp[5] = 0x7d8903a6;  //      mtctr   r12
-                        tramp[6] = 0xe96b0020;  //      ld              r11,32(r11)
-                        tramp[7] = 0x4e800420;  //      bctr
-                        *(unsigned long*)&tramp[8] = (unsigned long)ffi_closure_ASM;
-                        *(unsigned long*)&tramp[10] = (unsigned long)closure;
+			tramp[0] = 0x7c0802a6;	//	mflr	r0
+			tramp[1] = 0x429f0005;	//	bcl		20,31,+0x8
+			tramp[2] = 0x7d6802a6;	//	mflr	r11
+			tramp[3] = 0x7c0803a6;	//	mtlr	r0
+			tramp[4] = 0xe98b0018;	//	ld		r12,24(r11)
+			tramp[5] = 0x7d8903a6;	//	mtctr	r12
+			tramp[6] = 0xe96b0020;	//	ld		r11,32(r11)
+			tramp[7] = 0x4e800420;	//	bctr
+			*(unsigned long*)&tramp[8] = (unsigned long)ffi_closure_ASM;
+			*(unsigned long*)&tramp[10] = (unsigned long)closure;
 #elif defined(__ppc__)
-                        tramp[0] = 0x7c0802a6;  //      mflr    r0
-                        tramp[1] = 0x429f0005;  //      bcl             20,31,+0x8
-                        tramp[2] = 0x7d6802a6;  //      mflr    r11
-                        tramp[3] = 0x7c0803a6;  //      mtlr    r0
-                        tramp[4] = 0x818b0018;  //      lwz             r12,24(r11)
-                        tramp[5] = 0x7d8903a6;  //      mtctr   r12
-                        tramp[6] = 0x816b001c;  //      lwz             r11,28(r11)
-                        tramp[7] = 0x4e800420;  //      bctr
-                        tramp[8] = (unsigned long)ffi_closure_ASM;
-                        tramp[9] = (unsigned long)closure;
+			tramp[0] = 0x7c0802a6;	//	mflr	r0
+			tramp[1] = 0x429f0005;	//	bcl		20,31,+0x8
+			tramp[2] = 0x7d6802a6;	//	mflr	r11
+			tramp[3] = 0x7c0803a6;	//	mtlr	r0
+			tramp[4] = 0x818b0018;	//	lwz		r12,24(r11)
+			tramp[5] = 0x7d8903a6;	//	mtctr	r12
+			tramp[6] = 0x816b001c;	//	lwz		r11,28(r11)
+			tramp[7] = 0x4e800420;	//	bctr
+			tramp[8] = (unsigned long)ffi_closure_ASM;
+			tramp[9] = (unsigned long)closure;
 #else
 #error undefined architecture
 #endif
 
-                        closure->cif = cif;
-                        closure->fun = fun;
-                        closure->user_data = user_data;
+			closure->cif = cif;
+			closure->fun = fun;
+			closure->user_data = user_data;
 
-                        // Flush the icache. Only necessary on Darwin.
+			// Flush the icache. Only necessary on Darwin.
 #if defined(POWERPC_DARWIN)
-                        sys_icache_invalidate(closure->tramp, FFI_TRAMPOLINE_SIZE);
+			sys_icache_invalidate(closure->tramp, FFI_TRAMPOLINE_SIZE);
 #else
-                        flush_range(closure->tramp, FFI_TRAMPOLINE_SIZE);
+			flush_range(closure->tramp, FFI_TRAMPOLINE_SIZE);
 #endif
 
-                        break;
-                }
+			break;
+		}
 
-                case FFI_AIX:
-                {
-                        FFI_ASSERT (cif->abi == FFI_AIX);
+		case FFI_AIX:
+		{
+			FFI_ASSERT (cif->abi == FFI_AIX);
 
-                        ffi_aix_trampoline_struct*      tramp_aix =
-                                (ffi_aix_trampoline_struct*)(closure->tramp);
-                        aix_fd* fd = (aix_fd*)(void*)ffi_closure_ASM;
+			ffi_aix_trampoline_struct*	tramp_aix =
+				(ffi_aix_trampoline_struct*)(closure->tramp);
+			aix_fd*	fd = (aix_fd*)(void*)ffi_closure_ASM;
 
-                        tramp_aix->code_pointer = fd->code_pointer;
-                        tramp_aix->toc = fd->toc;
-                        tramp_aix->static_chain = closure;
-                        closure->cif = cif;
-                        closure->fun = fun;
-                        closure->user_data = user_data;
-                        break;
-                }
+			tramp_aix->code_pointer = fd->code_pointer;
+			tramp_aix->toc = fd->toc;
+			tramp_aix->static_chain = closure;
+			closure->cif = cif;
+			closure->fun = fun;
+			closure->user_data = user_data;
+			break;
+		}
 
-                default:
-                        return FFI_BAD_ABI;
-        }
+		default:
+			return FFI_BAD_ABI;
+	}
 
-        return FFI_OK;
+	return FFI_OK;
 }
 
 #if defined(__ppc__)
-        typedef double ldbits[2];
+	typedef double ldbits[2];
 
-        typedef union
-        {
-                ldbits lb;
-                long double ld;
-        } ldu;
+	typedef union
+	{
+		ldbits lb;
+		long double ld;
+	} ldu;
 #endif
 
 typedef union
 {
-        float   f;
-        double  d;
+	float	f;
+	double	d;
 } ffi_dblfl;
 
-/*      The trampoline invokes ffi_closure_ASM, 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_ASM invokes the following helper function
-        to do most of the work.  */
+/*	The trampoline invokes ffi_closure_ASM, 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_ASM invokes the following helper function
+	to do most of the work.  */
 int
 ffi_closure_helper_DARWIN(
-        ffi_closure*    closure,
-        void*                   rvalue,
-        unsigned long*  pgr,
-        ffi_dblfl*              pfr)
+	ffi_closure*	closure,
+	void*			rvalue,
+	unsigned long*	pgr,
+	ffi_dblfl*		pfr)
 {
-        /*      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_ASM
-                pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM.  */
+	/*	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_ASM
+		pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM.  */
 
 #if defined(__ppc__)
-        ldu     temp_ld;
+	ldu	temp_ld;
 #endif
 
-        double                          temp;
-        unsigned int            i;
-        unsigned int            nf = 0; /* number of FPRs already used.  */
-        unsigned int            ng = 0; /* number of GPRs already used.  */
-        ffi_cif*                        cif = closure->cif;
-        long                            avn = cif->nargs;
-        void**                          avalue = alloca(cif->nargs * sizeof(void*));
-        ffi_type**                      arg_types = cif->arg_types;
+	double				temp;
+	unsigned int		i;
+	unsigned int		nf = 0;	/* number of FPRs already used.  */
+	unsigned int		ng = 0;	/* number of GPRs already used.  */
+	ffi_cif*			cif = closure->cif;
+	long				avn = cif->nargs;
+	void**				avalue = alloca(cif->nargs * sizeof(void*));
+	ffi_type**			arg_types = cif->arg_types;
 
-        /*      Copy the caller's structure return value address so that the closure
-                returns the data directly to the caller.  */
+	/*	Copy the caller's structure return value address so that the closure
+		returns the data directly to the caller.  */
 #if defined(__ppc64__)
-        if (cif->rtype->type == FFI_TYPE_STRUCT &&
-                ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
+	if (cif->rtype->type == FFI_TYPE_STRUCT &&
+		ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
 #elif defined(__ppc__)
-        if (cif->rtype->type == FFI_TYPE_STRUCT)
+	if (cif->rtype->type == FFI_TYPE_STRUCT)
 #else
 #error undefined architecture
 #endif
-        {
-                rvalue = (void*)*pgr;
-                pgr++;
-                ng++;
-        }
+	{
+		rvalue = (void*)*pgr;
+		pgr++;
+		ng++;
+	}
 
-        /* Grab the addresses of the arguments from the stack frame.  */
-        for (i = 0; i < avn; i++)
-        {
-                switch (arg_types[i]->type)
-                {
-                        case FFI_TYPE_SINT8:
-                        case FFI_TYPE_UINT8:
-                                avalue[i] = (char*)pgr + MODE_CHOICE(3,7);
-                                ng++;
-                                pgr++;
-                                break;
+	/* Grab the addresses of the arguments from the stack frame.  */
+	for (i = 0; i < avn; i++)
+	{
+		switch (arg_types[i]->type)
+		{
+			case FFI_TYPE_SINT8:
+			case FFI_TYPE_UINT8:
+				avalue[i] = (char*)pgr + MODE_CHOICE(3,7);
+				ng++;
+				pgr++;
+				break;
 
-                        case FFI_TYPE_SINT16:
-                        case FFI_TYPE_UINT16:
-                                avalue[i] = (char*)pgr + MODE_CHOICE(2,6);
-                                ng++;
-                                pgr++;
-                                break;
+			case FFI_TYPE_SINT16:
+			case FFI_TYPE_UINT16:
+				avalue[i] = (char*)pgr + MODE_CHOICE(2,6);
+				ng++;
+				pgr++;
+				break;
 
 #if defined(__ppc__)
-                        case FFI_TYPE_POINTER:
+			case FFI_TYPE_POINTER:
 #endif
-                        case FFI_TYPE_SINT32:
-                        case FFI_TYPE_UINT32:
-                                avalue[i] = (char*)pgr + MODE_CHOICE(0,4);
-                                ng++;
-                                pgr++;
+			case FFI_TYPE_SINT32:
+			case FFI_TYPE_UINT32:
+				avalue[i] = (char*)pgr + MODE_CHOICE(0,4);
+				ng++;
+				pgr++;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_STRUCT:
-                                if (cif->abi == FFI_DARWIN)
-                                {
+			case FFI_TYPE_STRUCT:
+				if (cif->abi == FFI_DARWIN)
+				{
 #if defined(__ppc64__)
-                                        unsigned int    gprSize = 0;
-                                        unsigned int    fprSize = 0;
-                                        unsigned int    savedFPRSize = fprSize;
+					unsigned int	gprSize = 0;
+					unsigned int	fprSize	= 0;
+					unsigned int	savedFPRSize = fprSize;
 
-                                        avalue[i] = alloca(arg_types[i]->size);
-                                        ffi64_struct_to_ram_form(arg_types[i], (const char*)pgr,
-                                                &gprSize, (const char*)pfr, &fprSize, &nf, avalue[i], NULL);
+					avalue[i] = alloca(arg_types[i]->size);
+					ffi64_struct_to_ram_form(arg_types[i], (const char*)pgr,
+						&gprSize, (const char*)pfr, &fprSize, &nf, avalue[i], NULL);
  
-                                        ng      += gprSize / sizeof(long);
-                                        pgr     += gprSize / sizeof(long);
-                                        pfr     += (fprSize - savedFPRSize) / sizeof(double);
+					ng	+= gprSize / sizeof(long);
+					pgr	+= gprSize / sizeof(long);
+					pfr	+= (fprSize - savedFPRSize) / sizeof(double);
 
 #elif defined(__ppc__)
-                                        /*      Structures that match the basic modes (QI 1 byte, HI 2 bytes,
-                                                SI 4 bytes) are aligned as if they were those modes.  */
-                                        unsigned int    size_al = size_al = arg_types[i]->size;
+					/*	Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+						SI 4 bytes) are aligned as if they were those modes.  */
+					unsigned int	size_al	= size_al = arg_types[i]->size;
 
-                                        /*      If the first member of the struct is a double, then align
-                                                the struct to double-word.  */
-                                        if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
-                                                size_al = ALIGN(arg_types[i]->size, 8);
+					/*	If the first member of the struct is a double, then align
+						the struct to double-word.  */
+					if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
+						size_al = ALIGN(arg_types[i]->size, 8);
 
-                                        if (size_al < 3)
-                                                avalue[i] = (void*)pgr + MODE_CHOICE(4,8) - size_al;
-                                        else
-                                                avalue[i] = (void*)pgr;
+					if (size_al < 3)
+						avalue[i] = (void*)pgr + MODE_CHOICE(4,8) - size_al;
+					else
+						avalue[i] = (void*)pgr;
 
-                                        ng      += (size_al + 3) / sizeof(long);
-                                        pgr += (size_al + 3) / sizeof(long);
+					ng	+= (size_al + 3) / sizeof(long);
+					pgr += (size_al + 3) / sizeof(long);
 #else
 #error undefined architecture
 #endif
-                                }
+				}
 
-                                break;
+				break;
 
 #if defined(__ppc64__)
-                        case FFI_TYPE_POINTER:
+			case FFI_TYPE_POINTER:
 #endif
-                        case FFI_TYPE_SINT64:
-                        case FFI_TYPE_UINT64:
-                                /* Long long ints are passed in 1 or 2 GPRs.  */
-                                avalue[i] = pgr;
-                                ng += MODE_CHOICE(2,1);
-                                pgr += MODE_CHOICE(2,1);
+			case FFI_TYPE_SINT64:
+			case FFI_TYPE_UINT64:
+				/* Long long ints are passed in 1 or 2 GPRs.  */
+				avalue[i] = pgr;
+				ng += MODE_CHOICE(2,1);
+				pgr += MODE_CHOICE(2,1);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_FLOAT:
-                                /*      A float value consumes a GPR.
-                                        There are 13 64-bit floating point registers.  */
-                                if (nf < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        temp = pfr->d;
-                                        pfr->f = (float)temp;
-                                        avalue[i] = pfr;
-                                        pfr++;
-                                }
-                                else
-                                        avalue[i] = pgr;
+			case FFI_TYPE_FLOAT:
+				/*	A float value consumes a GPR.
+					There are 13 64-bit floating point registers.  */
+				if (nf < NUM_FPR_ARG_REGISTERS)
+				{
+					temp = pfr->d;
+					pfr->f = (float)temp;
+					avalue[i] = pfr;
+					pfr++;
+				}
+				else
+					avalue[i] = pgr;
 
-                                nf++;
-                                ng++;
-                                pgr++;
-                                break;
+				nf++;
+				ng++;
+				pgr++;
+				break;
 
-                        case FFI_TYPE_DOUBLE:
-                                /*      A double value consumes one or two GPRs.
-                                        There are 13 64bit floating point registers.  */
-                                if (nf < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        avalue[i] = pfr;
-                                        pfr++;
-                                }
-                                else
-                                        avalue[i] = pgr;
+			case FFI_TYPE_DOUBLE:
+				/*	A double value consumes one or two GPRs.
+					There are 13 64bit floating point registers.  */
+				if (nf < NUM_FPR_ARG_REGISTERS)
+				{
+					avalue[i] = pfr;
+					pfr++;
+				}
+				else
+					avalue[i] = pgr;
 
-                                nf++;
-                                ng += MODE_CHOICE(2,1);
-                                pgr += MODE_CHOICE(2,1);
+				nf++;
+				ng += MODE_CHOICE(2,1);
+				pgr += MODE_CHOICE(2,1);
 
-                                break;
+				break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
-                        case FFI_TYPE_LONGDOUBLE:
+			case FFI_TYPE_LONGDOUBLE:
 #if defined(__ppc64__)
-                                if (nf < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        avalue[i] = pfr;
-                                        pfr += 2;
-                                }
+				if (nf < NUM_FPR_ARG_REGISTERS)
+				{
+					avalue[i] = pfr;
+					pfr += 2;
+				}
 #elif defined(__ppc__)
-                                /*      A long double value consumes 2/4 GPRs and 2 FPRs.
-                                        There are 13 64bit floating point registers.  */
-                                if (nf < NUM_FPR_ARG_REGISTERS - 1)
-                                {
-                                        avalue[i] = pfr;
-                                        pfr += 2;
-                                }
-                                /*      Here we have the situation where one part of the long double
-                                        is stored in fpr13 and the other part is already on the stack.
-                                        We use a union to pass the long double to avalue[i].  */
-                                else if (nf == NUM_FPR_ARG_REGISTERS - 1)
-                                {
-                                        memcpy (&temp_ld.lb[0], pfr, sizeof(temp_ld.lb[0]));
-                                        memcpy (&temp_ld.lb[1], pgr + 2, sizeof(temp_ld.lb[1]));
-                                        avalue[i] = &temp_ld.ld;
-                                }
+				/*	A long double value consumes 2/4 GPRs and 2 FPRs.
+					There are 13 64bit floating point registers.  */
+				if (nf < NUM_FPR_ARG_REGISTERS - 1)
+				{
+					avalue[i] = pfr;
+					pfr += 2;
+				}
+				/*	Here we have the situation where one part of the long double
+					is stored in fpr13 and the other part is already on the stack.
+					We use a union to pass the long double to avalue[i].  */
+				else if (nf == NUM_FPR_ARG_REGISTERS - 1)
+				{
+					memcpy (&temp_ld.lb[0], pfr, sizeof(temp_ld.lb[0]));
+					memcpy (&temp_ld.lb[1], pgr + 2, sizeof(temp_ld.lb[1]));
+					avalue[i] = &temp_ld.ld;
+				}
 #else
 #error undefined architecture
 #endif
-                                else
-                                        avalue[i] = pgr;
+				else
+					avalue[i] = pgr;
 
-                                nf += 2;
-                                ng += MODE_CHOICE(4,2);
-                                pgr += MODE_CHOICE(4,2);
+				nf += 2;
+				ng += MODE_CHOICE(4,2);
+				pgr += MODE_CHOICE(4,2);
 
-                                break;
+				break;
 
-#endif  /*      FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE  */
+#endif	/*	FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE	*/
 
-                        default:
-                                FFI_ASSERT(0);
-                                break;
-                }
-        }
+			default:
+				FFI_ASSERT(0);
+				break;
+		}
+	}
 
-        (closure->fun)(cif, rvalue, avalue, closure->user_data);
+	(closure->fun)(cif, rvalue, avalue, closure->user_data);
 
-        /* Tell ffi_closure_ASM to perform return type promotions.  */
-        return cif->rtype->type;
+	/* Tell ffi_closure_ASM to perform return type promotions.  */
+	return cif->rtype->type;
 }
 
 #if defined(__ppc64__)
 
-/*      ffi64_struct_to_ram_form
+/*	ffi64_struct_to_ram_form
 
-        Rebuild a struct's natural layout from buffers of concatenated registers.
-        Return the number of registers used.
-        inGPRs[0-7] == r3, inFPRs[0-7] == f1 ...
+	Rebuild a struct's natural layout from buffers of concatenated registers.
+	Return the number of registers used.
+	inGPRs[0-7] == r3, inFPRs[0-7] == f1 ...
 */
 void
 ffi64_struct_to_ram_form(
-        const ffi_type* inType,
-        const char*             inGPRs,
-        unsigned int*   ioGPRMarker,
-        const char*             inFPRs,
-        unsigned int*   ioFPRMarker,
-        unsigned int*   ioFPRsUsed,
-        char*                   outStruct,      // caller-allocated
-        unsigned int*   ioStructMarker)
+	const ffi_type*	inType,
+	const char*		inGPRs,
+	unsigned int*	ioGPRMarker,
+	const char*		inFPRs,
+	unsigned int*	ioFPRMarker,
+	unsigned int*	ioFPRsUsed,
+	char*			outStruct,	// caller-allocated
+	unsigned int*	ioStructMarker)
 {
-        unsigned int    srcGMarker              = 0;
-        unsigned int    srcFMarker              = 0;
-        unsigned int    savedFMarker    = 0;
-        unsigned int    fprsUsed                = 0;
-        unsigned int    savedFPRsUsed   = 0;
-        unsigned int    destMarker              = 0;
+	unsigned int	srcGMarker		= 0;
+	unsigned int	srcFMarker		= 0;
+	unsigned int	savedFMarker	= 0;
+	unsigned int	fprsUsed		= 0;
+	unsigned int	savedFPRsUsed	= 0;
+	unsigned int	destMarker		= 0;
 
-        static unsigned int     recurseCount    = 0;
+	static unsigned int	recurseCount	= 0;
 
-        if (ioGPRMarker)
-                srcGMarker      = *ioGPRMarker;
+	if (ioGPRMarker)
+		srcGMarker	= *ioGPRMarker;
 
-        if (ioFPRMarker)
-        {
-                srcFMarker              = *ioFPRMarker;
-                savedFMarker    = srcFMarker;
-        }
+	if (ioFPRMarker)
+	{
+		srcFMarker		= *ioFPRMarker;
+		savedFMarker	= srcFMarker;
+	}
 
-        if (ioFPRsUsed)
-        {
-                fprsUsed                = *ioFPRsUsed;
-                savedFPRsUsed   = fprsUsed;
-        }
+	if (ioFPRsUsed)
+	{
+		fprsUsed		= *ioFPRsUsed;
+		savedFPRsUsed	= fprsUsed;
+	}
 
-        if (ioStructMarker)
-                destMarker      = *ioStructMarker;
+	if (ioStructMarker)
+		destMarker	= *ioStructMarker;
 
-        size_t                  i;
+	size_t			i;
 
-        switch (inType->size)
-        {
-                case 1: case 2: case 4:
-                        srcGMarker += 8 - inType->size;
-                        break;
+	switch (inType->size)
+	{
+		case 1: case 2: case 4:
+			srcGMarker += 8 - inType->size;
+			break;
 
-                default:
-                        break;
-        }
+		default:
+			break;
+	}
 
-        for (i = 0; inType->elements[i] != NULL; i++)
-        {
-                switch (inType->elements[i]->type)
-                {
-                        case FFI_TYPE_FLOAT:
-                                srcFMarker = ALIGN(srcFMarker, 4);
-                                srcGMarker = ALIGN(srcGMarker, 4);
-                                destMarker = ALIGN(destMarker, 4);
+	for (i = 0; inType->elements[i] != NULL; i++)
+	{
+		switch (inType->elements[i]->type)
+		{
+			case FFI_TYPE_FLOAT:
+				srcFMarker = ALIGN(srcFMarker, 4);
+				srcGMarker = ALIGN(srcGMarker, 4);
+				destMarker = ALIGN(destMarker, 4);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        *(float*)&outStruct[destMarker] =
-                                                (float)*(double*)&inFPRs[srcFMarker];
-                                        srcFMarker += 8;
-                                        fprsUsed++;
-                                }
-                                else
-                                        *(float*)&outStruct[destMarker] =
-                                                (float)*(double*)&inGPRs[srcGMarker];
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					*(float*)&outStruct[destMarker]	=
+						(float)*(double*)&inFPRs[srcFMarker];
+					srcFMarker += 8;
+					fprsUsed++;
+				}
+				else
+					*(float*)&outStruct[destMarker]	=
+						(float)*(double*)&inGPRs[srcGMarker];
 
-                                srcGMarker += 4;
-                                destMarker += 4;
+				srcGMarker += 4;
+				destMarker += 4;
 
-                                // Skip to next GPR if next element won't fit and we're
-                                // not already at a register boundary.
-                                if (inType->elements[i + 1] != NULL && (destMarker % 8))
-                                {
-                                        if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
-                                                (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
-                                                (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
-                                                (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
-                                                (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
-                                                srcGMarker      = ALIGN(srcGMarker, 8);
-                                }
+				// Skip to next GPR if next element won't fit and we're
+				// not already at a register boundary.
+				if (inType->elements[i + 1] != NULL && (destMarker % 8))
+				{
+					if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+						(!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+						(ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
+						(!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+						(ALIGN(srcGMarker, 8) - srcGMarker) < 4))
+						srcGMarker	= ALIGN(srcGMarker, 8);
+				}
 
-                                break;
+				break;
 
-                        case FFI_TYPE_DOUBLE:
-                                srcFMarker = ALIGN(srcFMarker, 8);
-                                destMarker = ALIGN(destMarker, 8);
+			case FFI_TYPE_DOUBLE:
+				srcFMarker = ALIGN(srcFMarker, 8);
+				destMarker = ALIGN(destMarker, 8);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        *(double*)&outStruct[destMarker]        =
-                                                *(double*)&inFPRs[srcFMarker];
-                                        srcFMarker += 8;
-                                        fprsUsed++;
-                                }
-                                else
-                                        *(double*)&outStruct[destMarker]        =
-                                                *(double*)&inGPRs[srcGMarker];
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					*(double*)&outStruct[destMarker]	=
+						*(double*)&inFPRs[srcFMarker];
+					srcFMarker += 8;
+					fprsUsed++;
+				}
+				else
+					*(double*)&outStruct[destMarker]	=
+						*(double*)&inGPRs[srcGMarker];
 
-                                destMarker += 8;
+				destMarker += 8;
 
-                                // Skip next GPR
-                                srcGMarker += 8;
-                                srcGMarker = ALIGN(srcGMarker, 8);
+				// Skip next GPR
+				srcGMarker += 8;
+				srcGMarker = ALIGN(srcGMarker, 8);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_LONGDOUBLE:
-                                destMarker = ALIGN(destMarker, 16);
+			case FFI_TYPE_LONGDOUBLE:
+				destMarker = ALIGN(destMarker, 16);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        srcFMarker = ALIGN(srcFMarker, 8);
-                                        srcGMarker = ALIGN(srcGMarker, 8);
-                                        *(long double*)&outStruct[destMarker]   =
-                                                *(long double*)&inFPRs[srcFMarker];
-                                        srcFMarker += 16;
-                                        fprsUsed += 2;
-                                }
-                                else
-                                {
-                                        srcFMarker = ALIGN(srcFMarker, 16);
-                                        srcGMarker = ALIGN(srcGMarker, 16);
-                                        *(long double*)&outStruct[destMarker]   =
-                                                *(long double*)&inGPRs[srcGMarker];
-                                }
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					srcFMarker = ALIGN(srcFMarker, 8);
+					srcGMarker = ALIGN(srcGMarker, 8);
+					*(long double*)&outStruct[destMarker]	=
+						*(long double*)&inFPRs[srcFMarker];
+					srcFMarker += 16;
+					fprsUsed += 2;
+				}
+				else
+				{
+					srcFMarker = ALIGN(srcFMarker, 16);
+					srcGMarker = ALIGN(srcGMarker, 16);
+					*(long double*)&outStruct[destMarker]	=
+						*(long double*)&inGPRs[srcGMarker];
+				}
 
-                                destMarker += 16;
+				destMarker += 16;
 
-                                // Skip next 2 GPRs
-                                srcGMarker += 16;
-                                srcGMarker = ALIGN(srcGMarker, 8);
+				// Skip next 2 GPRs
+				srcGMarker += 16;
+				srcGMarker = ALIGN(srcGMarker, 8);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_UINT8:
-                        case FFI_TYPE_SINT8:
-                        {
-                                if (inType->alignment == 1)     // chars only
-                                {
-                                        if (inType->size == 1)
-                                                outStruct[destMarker++] = inGPRs[srcGMarker++];
-                                        else if (inType->size == 2)
-                                        {
-                                                outStruct[destMarker++] = inGPRs[srcGMarker++];
-                                                outStruct[destMarker++] = inGPRs[srcGMarker++];
-                                                i++;
-                                        }
-                                        else
-                                        {
-                                                memcpy(&outStruct[destMarker],
-                                                        &inGPRs[srcGMarker], inType->size);
-                                                srcGMarker += inType->size;
-                                                destMarker += inType->size;
-                                                i += inType->size - 1;
-                                        }
-                                }
-                                else    // chars and other stuff
-                                {
-                                        outStruct[destMarker++] = inGPRs[srcGMarker++];
+			case FFI_TYPE_UINT8:
+			case FFI_TYPE_SINT8:
+			{
+				if (inType->alignment == 1)	// chars only
+				{
+					if (inType->size == 1)
+						outStruct[destMarker++] = inGPRs[srcGMarker++];
+					else if (inType->size == 2)
+					{
+						outStruct[destMarker++] = inGPRs[srcGMarker++];
+						outStruct[destMarker++] = inGPRs[srcGMarker++];
+						i++;
+					}
+					else
+					{
+						memcpy(&outStruct[destMarker],
+							&inGPRs[srcGMarker], inType->size);
+						srcGMarker += inType->size;
+						destMarker += inType->size;
+						i += inType->size - 1;
+					}
+				}
+				else	// chars and other stuff
+				{
+					outStruct[destMarker++] = inGPRs[srcGMarker++];
 
-                                        // Skip to next GPR if next element won't fit and we're
-                                        // not already at a register boundary.
-                                        if (inType->elements[i + 1] != NULL && (srcGMarker % 8))
-                                        {
-                                                if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
-                                                        (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
-                                                        (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
-                                                        (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
-                                                        (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
-                                                        srcGMarker      = ALIGN(srcGMarker, inType->alignment); // was 8
-                                        }
-                                }
+					// Skip to next GPR if next element won't fit and we're
+					// not already at a register boundary.
+					if (inType->elements[i + 1] != NULL && (srcGMarker % 8))
+					{
+						if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+							(!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+							(ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
+							(!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+							(ALIGN(srcGMarker, 8) - srcGMarker) < 4))
+							srcGMarker	= ALIGN(srcGMarker, inType->alignment);	// was 8
+					}
+				}
 
-                                break;
-                        }
+				break;
+			}
 
-                        case FFI_TYPE_UINT16:
-                        case FFI_TYPE_SINT16:
-                                srcGMarker = ALIGN(srcGMarker, 2);
-                                destMarker = ALIGN(destMarker, 2);
+			case FFI_TYPE_UINT16:
+			case FFI_TYPE_SINT16:
+				srcGMarker = ALIGN(srcGMarker, 2);
+				destMarker = ALIGN(destMarker, 2);
 
-                                *(short*)&outStruct[destMarker] =
-                                        *(short*)&inGPRs[srcGMarker];
-                                srcGMarker += 2;
-                                destMarker += 2;
+				*(short*)&outStruct[destMarker] =
+					*(short*)&inGPRs[srcGMarker];
+				srcGMarker += 2;
+				destMarker += 2;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_INT:
-                        case FFI_TYPE_UINT32:
-                        case FFI_TYPE_SINT32:
-                                srcGMarker = ALIGN(srcGMarker, 4);
-                                destMarker = ALIGN(destMarker, 4);
+			case FFI_TYPE_INT:
+			case FFI_TYPE_UINT32:
+			case FFI_TYPE_SINT32:
+				srcGMarker = ALIGN(srcGMarker, 4);
+				destMarker = ALIGN(destMarker, 4);
 
-                                *(int*)&outStruct[destMarker] =
-                                        *(int*)&inGPRs[srcGMarker];
-                                srcGMarker += 4;
-                                destMarker += 4;
+				*(int*)&outStruct[destMarker] =
+					*(int*)&inGPRs[srcGMarker];
+				srcGMarker += 4;
+				destMarker += 4;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_POINTER:
-                        case FFI_TYPE_UINT64:
-                        case FFI_TYPE_SINT64:
-                                srcGMarker = ALIGN(srcGMarker, 8);
-                                destMarker = ALIGN(destMarker, 8);
+			case FFI_TYPE_POINTER:
+			case FFI_TYPE_UINT64:
+			case FFI_TYPE_SINT64:
+				srcGMarker = ALIGN(srcGMarker, 8);
+				destMarker = ALIGN(destMarker, 8);
 
-                                *(long long*)&outStruct[destMarker] =
-                                        *(long long*)&inGPRs[srcGMarker];
-                                srcGMarker += 8;
-                                destMarker += 8;
+				*(long long*)&outStruct[destMarker] =
+					*(long long*)&inGPRs[srcGMarker];
+				srcGMarker += 8;
+				destMarker += 8;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_STRUCT:
-                                recurseCount++;
-                                ffi64_struct_to_ram_form(inType->elements[i], inGPRs,
-                                        &srcGMarker, inFPRs, &srcFMarker, &fprsUsed,
-                                        outStruct, &destMarker);
-                                recurseCount--;
-                                break;
+			case FFI_TYPE_STRUCT:
+				recurseCount++;
+				ffi64_struct_to_ram_form(inType->elements[i], inGPRs,
+					&srcGMarker, inFPRs, &srcFMarker, &fprsUsed,
+					outStruct, &destMarker);
+				recurseCount--;
+				break;
 
-                        default:
-                                FFI_ASSERT(0);  // unknown element type
-                                break;
-                }
-        }
+			default:
+				FFI_ASSERT(0);	// unknown element type
+				break;
+		}
+	}
 
-        srcGMarker = ALIGN(srcGMarker, inType->alignment);
+	srcGMarker = ALIGN(srcGMarker, inType->alignment);
 
-        // Take care of the special case for 16-byte structs, but not for
-        // nested structs.
-        if (recurseCount == 0 && srcGMarker == 16)
-        {
-                *(long double*)&outStruct[0] = *(long double*)&inGPRs[0];
-                srcFMarker      = savedFMarker;
-                fprsUsed        = savedFPRsUsed;
-        }
+	// Take care of the special case for 16-byte structs, but not for
+	// nested structs.
+	if (recurseCount == 0 && srcGMarker == 16)
+	{
+		*(long double*)&outStruct[0] = *(long double*)&inGPRs[0];
+		srcFMarker	= savedFMarker;
+		fprsUsed	= savedFPRsUsed;
+	}
 
-        if (ioGPRMarker)
-                *ioGPRMarker = ALIGN(srcGMarker, 8);
+	if (ioGPRMarker)
+		*ioGPRMarker = ALIGN(srcGMarker, 8);
 
-        if (ioFPRMarker)
-                *ioFPRMarker = srcFMarker;
+	if (ioFPRMarker)
+		*ioFPRMarker = srcFMarker;
 
-        if (ioFPRsUsed)
-                *ioFPRsUsed     = fprsUsed;
+	if (ioFPRsUsed)
+		*ioFPRsUsed	= fprsUsed;
 
-        if (ioStructMarker)
-                *ioStructMarker = ALIGN(destMarker, 8);
+	if (ioStructMarker)
+		*ioStructMarker	= ALIGN(destMarker, 8);
 }
 
-/*      ffi64_struct_to_reg_form
+/*	ffi64_struct_to_reg_form
 
-        Copy a struct's elements into buffers that can be sliced into registers.
-        Return the sizes of the output buffers in bytes. Pass NULL buffer pointers
-        to calculate size only.
-        outGPRs[0-7] == r3, outFPRs[0-7] == f1 ...
+	Copy a struct's elements into buffers that can be sliced into registers.
+	Return the sizes of the output buffers in bytes. Pass NULL buffer pointers
+	to calculate size only.
+	outGPRs[0-7] == r3, outFPRs[0-7] == f1 ...
 */
 void
 ffi64_struct_to_reg_form(
-        const ffi_type* inType,
-        const char*             inStruct,
-        unsigned int*   ioStructMarker,
-        unsigned int*   ioFPRsUsed,
-        char*                   outGPRs,        // caller-allocated
-        unsigned int*   ioGPRSize,
-        char*                   outFPRs,        // caller-allocated
-        unsigned int*   ioFPRSize)
+	const ffi_type*	inType,
+	const char*		inStruct,
+	unsigned int*	ioStructMarker,
+	unsigned int*	ioFPRsUsed,
+	char*			outGPRs,	// caller-allocated
+	unsigned int*	ioGPRSize,
+	char*			outFPRs,	// caller-allocated
+	unsigned int*	ioFPRSize)
 {
-        size_t                  i;
-        unsigned int    srcMarker               = 0;
-        unsigned int    destGMarker             = 0;
-        unsigned int    destFMarker             = 0;
-        unsigned int    savedFMarker    = 0;
-        unsigned int    fprsUsed                = 0;
-        unsigned int    savedFPRsUsed   = 0;
+	size_t			i;
+	unsigned int	srcMarker		= 0;
+	unsigned int	destGMarker		= 0;
+	unsigned int	destFMarker		= 0;
+	unsigned int	savedFMarker	= 0;
+	unsigned int	fprsUsed		= 0;
+	unsigned int	savedFPRsUsed	= 0;
 
-        static unsigned int     recurseCount    = 0;
+	static unsigned int	recurseCount	= 0;
 
-        if (ioStructMarker)
-                srcMarker       = *ioStructMarker;
+	if (ioStructMarker)
+		srcMarker	= *ioStructMarker;
 
-        if (ioFPRsUsed)
-        {
-                fprsUsed                = *ioFPRsUsed;
-                savedFPRsUsed   = fprsUsed;
-        }
+	if (ioFPRsUsed)
+	{
+		fprsUsed		= *ioFPRsUsed;
+		savedFPRsUsed	= fprsUsed;
+	}
 
-        if (ioGPRSize)
-                destGMarker     = *ioGPRSize;
+	if (ioGPRSize)
+		destGMarker	= *ioGPRSize;
 
-        if (ioFPRSize)
-        {
-                destFMarker             = *ioFPRSize;
-                savedFMarker    = destFMarker;
-        }
+	if (ioFPRSize)
+	{
+		destFMarker		= *ioFPRSize;
+		savedFMarker	= destFMarker;
+	}
 
-        switch (inType->size)
-        {
-                case 1: case 2: case 4:
-                        destGMarker += 8 - inType->size;
-                        break;
+	switch (inType->size)
+	{
+		case 1: case 2: case 4:
+			destGMarker += 8 - inType->size;
+			break;
 
-                default:
-                        break;
-        }
+		default:
+			break;
+	}
 
-        for (i = 0; inType->elements[i] != NULL; i++)
-        {
-                switch (inType->elements[i]->type)
-                {
-                        // Shadow floating-point types in GPRs for vararg and pre-ANSI
-                        // functions.
-                        case FFI_TYPE_FLOAT:
-                                // Nudge markers to next 4/8-byte boundary
-                                srcMarker = ALIGN(srcMarker, 4);
-                                destGMarker = ALIGN(destGMarker, 4);
-                                destFMarker = ALIGN(destFMarker, 8);
+	for (i = 0; inType->elements[i] != NULL; i++)
+	{
+		switch (inType->elements[i]->type)
+		{
+			// Shadow floating-point types in GPRs for vararg and pre-ANSI
+			// functions.
+			case FFI_TYPE_FLOAT:
+				// Nudge markers to next 4/8-byte boundary
+				srcMarker = ALIGN(srcMarker, 4);
+				destGMarker = ALIGN(destGMarker, 4);
+				destFMarker = ALIGN(destFMarker, 8);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        if (outFPRs != NULL && inStruct != NULL)
-                                                *(double*)&outFPRs[destFMarker] =
-                                                        (double)*(float*)&inStruct[srcMarker];
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					if (outFPRs != NULL && inStruct != NULL)
+						*(double*)&outFPRs[destFMarker] =
+							(double)*(float*)&inStruct[srcMarker];
 
-                                        destFMarker += 8;
-                                        fprsUsed++;
-                                }
+					destFMarker += 8;
+					fprsUsed++;
+				}
 
-                                if (outGPRs != NULL && inStruct != NULL)
-                                        *(double*)&outGPRs[destGMarker] =
-                                                (double)*(float*)&inStruct[srcMarker];
+				if (outGPRs != NULL && inStruct != NULL)
+					*(double*)&outGPRs[destGMarker] =
+						(double)*(float*)&inStruct[srcMarker];
 
-                                srcMarker += 4;
-                                destGMarker += 4;
+				srcMarker += 4;
+				destGMarker += 4;
 
-                                // Skip to next GPR if next element won't fit and we're
-                                // not already at a register boundary.
-                                if (inType->elements[i + 1] != NULL && (srcMarker % 8))
-                                {
-                                        if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
-                                                (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
-                                                (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
-                                                (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
-                                                (ALIGN(destGMarker, 8) - destGMarker) < 4))
-                                                destGMarker     = ALIGN(destGMarker, 8);
-                                }
+				// Skip to next GPR if next element won't fit and we're
+				// not already at a register boundary.
+				if (inType->elements[i + 1] != NULL && (srcMarker % 8))
+				{
+					if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+						(!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+						(ALIGN(destGMarker, 8) - destGMarker) < 2) &&
+						(!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+						(ALIGN(destGMarker, 8) - destGMarker) < 4))
+						destGMarker	= ALIGN(destGMarker, 8);
+				}
 
-                                break;
+				break;
 
-                        case FFI_TYPE_DOUBLE:
-                                srcMarker = ALIGN(srcMarker, 8);
-                                destFMarker = ALIGN(destFMarker, 8);
+			case FFI_TYPE_DOUBLE:
+				srcMarker = ALIGN(srcMarker, 8);
+				destFMarker = ALIGN(destFMarker, 8);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        if (outFPRs != NULL && inStruct != NULL)
-                                                *(double*)&outFPRs[destFMarker] =
-                                                        *(double*)&inStruct[srcMarker];
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					if (outFPRs != NULL && inStruct != NULL)
+						*(double*)&outFPRs[destFMarker] =
+							*(double*)&inStruct[srcMarker];
 
-                                        destFMarker += 8;
-                                        fprsUsed++;
-                                }
+					destFMarker += 8;
+					fprsUsed++;
+				}
 
-                                if (outGPRs != NULL && inStruct != NULL)
-                                        *(double*)&outGPRs[destGMarker] =
-                                                *(double*)&inStruct[srcMarker];
+				if (outGPRs != NULL && inStruct != NULL)
+					*(double*)&outGPRs[destGMarker] =
+						*(double*)&inStruct[srcMarker];
 
-                                srcMarker += 8;
+				srcMarker += 8;
 
-                                // Skip next GPR
-                                destGMarker += 8;
-                                destGMarker = ALIGN(destGMarker, 8);
+				// Skip next GPR
+				destGMarker += 8;
+				destGMarker = ALIGN(destGMarker, 8);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_LONGDOUBLE:
-                                srcMarker = ALIGN(srcMarker, 16);
+			case FFI_TYPE_LONGDOUBLE:
+				srcMarker = ALIGN(srcMarker, 16);
 
-                                if (fprsUsed < NUM_FPR_ARG_REGISTERS)
-                                {
-                                        destFMarker = ALIGN(destFMarker, 8);
-                                        destGMarker = ALIGN(destGMarker, 8);
+				if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+				{
+					destFMarker = ALIGN(destFMarker, 8);
+					destGMarker = ALIGN(destGMarker, 8);
 
-                                        if (outFPRs != NULL && inStruct != NULL)
-                                                *(long double*)&outFPRs[destFMarker] =
-                                                        *(long double*)&inStruct[srcMarker];
+					if (outFPRs != NULL && inStruct != NULL)
+						*(long double*)&outFPRs[destFMarker] =
+							*(long double*)&inStruct[srcMarker];
 
-                                        if (outGPRs != NULL && inStruct != NULL)
-                                                *(long double*)&outGPRs[destGMarker] =
-                                                        *(long double*)&inStruct[srcMarker];
+					if (outGPRs != NULL && inStruct != NULL)
+						*(long double*)&outGPRs[destGMarker] =
+							*(long double*)&inStruct[srcMarker];
 
-                                        destFMarker += 16;
-                                        fprsUsed += 2;
-                                }
-                                else
-                                {
-                                        destGMarker = ALIGN(destGMarker, 16);
+					destFMarker += 16;
+					fprsUsed += 2;
+				}
+				else
+				{
+				 	destGMarker = ALIGN(destGMarker, 16);
 
-                                         if (outGPRs != NULL && inStruct != NULL)
-                                                *(long double*)&outGPRs[destGMarker] =
-                                                        *(long double*)&inStruct[srcMarker];
-                                }
+					 if (outGPRs != NULL && inStruct != NULL)
+						*(long double*)&outGPRs[destGMarker] =
+							*(long double*)&inStruct[srcMarker];
+				}
 
-                                srcMarker += 16;
-                                destGMarker += 16;      // Skip next 2 GPRs
-                                destGMarker = ALIGN(destGMarker, 8);    // was 16
+				srcMarker += 16;
+				destGMarker += 16;	// Skip next 2 GPRs
+				destGMarker = ALIGN(destGMarker, 8);	// was 16
 
-                                break;
+				break;
 
-                        case FFI_TYPE_UINT8:
-                        case FFI_TYPE_SINT8:
-                                if (inType->alignment == 1)     // bytes only
-                                {
-                                        if (inType->size == 1)
-                                        {
-                                                if (outGPRs != NULL && inStruct != NULL)
-                                                        outGPRs[destGMarker] = inStruct[srcMarker];
+			case FFI_TYPE_UINT8:
+			case FFI_TYPE_SINT8:
+				if (inType->alignment == 1)	// bytes only
+				{
+					if (inType->size == 1)
+					{
+						if (outGPRs != NULL && inStruct != NULL)
+							outGPRs[destGMarker] = inStruct[srcMarker];
 
-                                                srcMarker++;
-                                                destGMarker++;
-                                        }
-                                        else if (inType->size == 2)
-                                        {
-                                                if (outGPRs != NULL && inStruct != NULL)
-                                                {
-                                                        outGPRs[destGMarker] = inStruct[srcMarker];
-                                                        outGPRs[destGMarker + 1] = inStruct[srcMarker + 1];
-                                                }
+						srcMarker++;
+						destGMarker++;
+					}
+					else if (inType->size == 2)
+					{
+						if (outGPRs != NULL && inStruct != NULL)
+						{
+							outGPRs[destGMarker] = inStruct[srcMarker];
+							outGPRs[destGMarker + 1] = inStruct[srcMarker + 1];
+						}
 
-                                                srcMarker += 2;
-                                                destGMarker += 2;
+						srcMarker += 2;
+						destGMarker += 2;
 
-                                                i++;
-                                        }
-                                        else
-                                        {
-                                                if (outGPRs != NULL && inStruct != NULL)
-                                                {
-                                                        // Avoid memcpy for small chunks.
-                                                        if (inType->size <= sizeof(long))
-                                                                *(long*)&outGPRs[destGMarker] =
-                                                                        *(long*)&inStruct[srcMarker];
-                                                        else
-                                                                memcpy(&outGPRs[destGMarker],
-                                                                        &inStruct[srcMarker], inType->size);
-                                                }
-                                                
-                                                srcMarker += inType->size;
-                                                destGMarker += inType->size;
-                                                i += inType->size - 1;
-                                        }
-                                }
-                                else    // bytes and other stuff
-                                {
-                                        if (outGPRs != NULL && inStruct != NULL)
-                                                outGPRs[destGMarker] = inStruct[srcMarker];
+						i++;
+					}
+					else
+					{
+						if (outGPRs != NULL && inStruct != NULL)
+						{
+							// Avoid memcpy for small chunks.
+							if (inType->size <= sizeof(long))
+								*(long*)&outGPRs[destGMarker] =
+									*(long*)&inStruct[srcMarker];
+							else
+								memcpy(&outGPRs[destGMarker],
+									&inStruct[srcMarker], inType->size);
+						}
+						
+						srcMarker += inType->size;
+						destGMarker += inType->size;
+						i += inType->size - 1;
+					}
+				}
+				else	// bytes and other stuff
+				{
+					if (outGPRs != NULL && inStruct != NULL)
+						outGPRs[destGMarker] = inStruct[srcMarker];
 
-                                        srcMarker++;
-                                        destGMarker++;
+					srcMarker++;
+					destGMarker++;
 
-                                        // Skip to next GPR if next element won't fit and we're
-                                        // not already at a register boundary.
-                                        if (inType->elements[i + 1] != NULL && (destGMarker % 8))
-                                        {
-                                                if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
-                                                        (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
-                                                        (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
-                                                        (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
-                                                        (ALIGN(destGMarker, 8) - destGMarker) < 4))
-                                                        destGMarker     = ALIGN(destGMarker, inType->alignment);        // was 8
-                                        }
-                                }
+					// Skip to next GPR if next element won't fit and we're
+					// not already at a register boundary.
+					if (inType->elements[i + 1] != NULL && (destGMarker % 8))
+					{
+						if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+							(!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+							(ALIGN(destGMarker, 8) - destGMarker) < 2) &&
+							(!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+							(ALIGN(destGMarker, 8) - destGMarker) < 4))
+							destGMarker	= ALIGN(destGMarker, inType->alignment);	// was 8
+					}
+				}
 
-                                break;
+				break;
 
-                        case FFI_TYPE_UINT16:
-                        case FFI_TYPE_SINT16:
-                                srcMarker = ALIGN(srcMarker, 2);
-                                destGMarker = ALIGN(destGMarker, 2);
+			case FFI_TYPE_UINT16:
+			case FFI_TYPE_SINT16:
+				srcMarker = ALIGN(srcMarker, 2);
+				destGMarker = ALIGN(destGMarker, 2);
 
-                                if (outGPRs != NULL && inStruct != NULL)
-                                        *(short*)&outGPRs[destGMarker] =
-                                                *(short*)&inStruct[srcMarker];
+				if (outGPRs != NULL && inStruct != NULL)
+					*(short*)&outGPRs[destGMarker] =
+						*(short*)&inStruct[srcMarker];
 
-                                srcMarker += 2;
-                                destGMarker += 2;
+				srcMarker += 2;
+				destGMarker += 2;
 
-                                if (inType->elements[i + 1] == NULL)
-                                        destGMarker     = ALIGN(destGMarker, inType->alignment);
+				if (inType->elements[i + 1] == NULL)
+					destGMarker	= ALIGN(destGMarker, inType->alignment);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_INT:
-                        case FFI_TYPE_UINT32:
-                        case FFI_TYPE_SINT32:
-                                srcMarker = ALIGN(srcMarker, 4);
-                                destGMarker = ALIGN(destGMarker, 4);
+			case FFI_TYPE_INT:
+			case FFI_TYPE_UINT32:
+			case FFI_TYPE_SINT32:
+				srcMarker = ALIGN(srcMarker, 4);
+				destGMarker = ALIGN(destGMarker, 4);
 
-                                if (outGPRs != NULL && inStruct != NULL)
-                                        *(int*)&outGPRs[destGMarker] =
-                                                *(int*)&inStruct[srcMarker];
+				if (outGPRs != NULL && inStruct != NULL)
+					*(int*)&outGPRs[destGMarker] =
+						*(int*)&inStruct[srcMarker];
 
-                                srcMarker += 4;
-                                destGMarker += 4;
+				srcMarker += 4;
+				destGMarker += 4;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_POINTER:
-                        case FFI_TYPE_UINT64:
-                        case FFI_TYPE_SINT64:
-                                srcMarker = ALIGN(srcMarker, 8);
-                                destGMarker = ALIGN(destGMarker, 8);
+			case FFI_TYPE_POINTER:
+			case FFI_TYPE_UINT64:
+			case FFI_TYPE_SINT64:
+				srcMarker = ALIGN(srcMarker, 8);
+				destGMarker = ALIGN(destGMarker, 8);
 
-                                if (outGPRs != NULL && inStruct != NULL)
-                                        *(long long*)&outGPRs[destGMarker] =
-                                                *(long long*)&inStruct[srcMarker];
+				if (outGPRs != NULL && inStruct != NULL)
+					*(long long*)&outGPRs[destGMarker] =
+						*(long long*)&inStruct[srcMarker];
 
-                                srcMarker += 8;
-                                destGMarker += 8;
+				srcMarker += 8;
+				destGMarker += 8;
 
-                                if (inType->elements[i + 1] == NULL)
-                                        destGMarker     = ALIGN(destGMarker, inType->alignment);
+				if (inType->elements[i + 1] == NULL)
+					destGMarker	= ALIGN(destGMarker, inType->alignment);
 
-                                break;
+				break;
 
-                        case FFI_TYPE_STRUCT:
-                                recurseCount++;
-                                ffi64_struct_to_reg_form(inType->elements[i],
-                                        inStruct, &srcMarker, &fprsUsed, outGPRs, 
-                                        &destGMarker, outFPRs, &destFMarker);
-                                recurseCount--;
-                                break;
+			case FFI_TYPE_STRUCT:
+				recurseCount++;
+				ffi64_struct_to_reg_form(inType->elements[i],
+					inStruct, &srcMarker, &fprsUsed, outGPRs, 
+					&destGMarker, outFPRs, &destFMarker);
+				recurseCount--;
+				break;
 
-                        default:
-                                FFI_ASSERT(0);
-                                break;
-                }
-        }
+			default:
+				FFI_ASSERT(0);
+				break;
+		}
+	}
 
-        destGMarker     = ALIGN(destGMarker, inType->alignment);
+	destGMarker	= ALIGN(destGMarker, inType->alignment);
 
-        // Take care of the special case for 16-byte structs, but not for
-        // nested structs.
-        if (recurseCount == 0 && destGMarker == 16)
-        {
-                if (outGPRs != NULL && inStruct != NULL)
-                        *(long double*)&outGPRs[0] = *(long double*)&inStruct[0];
+	// Take care of the special case for 16-byte structs, but not for
+	// nested structs.
+	if (recurseCount == 0 && destGMarker == 16)
+	{
+		if (outGPRs != NULL && inStruct != NULL)
+			*(long double*)&outGPRs[0] = *(long double*)&inStruct[0];
 
-                destFMarker     = savedFMarker;
-                fprsUsed        = savedFPRsUsed;
-        }
+		destFMarker	= savedFMarker;
+		fprsUsed	= savedFPRsUsed;
+	}
 
-        if (ioStructMarker)
-                *ioStructMarker = ALIGN(srcMarker, 8);
+	if (ioStructMarker)
+		*ioStructMarker	= ALIGN(srcMarker, 8);
 
-        if (ioFPRsUsed)
-                *ioFPRsUsed     = fprsUsed;
+	if (ioFPRsUsed)
+		*ioFPRsUsed	= fprsUsed;
 
-        if (ioGPRSize)
-                *ioGPRSize = ALIGN(destGMarker, 8);
+	if (ioGPRSize)
+		*ioGPRSize = ALIGN(destGMarker, 8);
 
-        if (ioFPRSize)
-                *ioFPRSize = ALIGN(destFMarker, 8);
+	if (ioFPRSize)
+		*ioFPRSize = ALIGN(destFMarker, 8);
 }
 
-/*      ffi64_stret_needs_ptr
+/*	ffi64_stret_needs_ptr
 
-        Determine whether a returned struct needs a pointer in r3 or can fit
-        in registers.
+	Determine whether a returned struct needs a pointer in r3 or can fit
+	in registers.
 */
 
 bool
 ffi64_stret_needs_ptr(
-        const ffi_type* inType,
-        unsigned short* ioGPRCount,
-        unsigned short* ioFPRCount)
+	const ffi_type*	inType,
+	unsigned short*	ioGPRCount,
+	unsigned short*	ioFPRCount)
 {
-        // Obvious case first- struct is larger than combined FPR size.
-        if (inType->size > 14 * 8)
-                return true;
+	// Obvious case first- struct is larger than combined FPR size.
+	if (inType->size > 14 * 8)
+		return true;
 
-        // Now the struct can physically fit in registers, determine if it
-        // also fits logically.
-        bool                    needsPtr        = false;
-        unsigned short  gprsUsed        = 0;
-        unsigned short  fprsUsed        = 0;
-        size_t                  i;
+	// Now the struct can physically fit in registers, determine if it
+	// also fits logically.
+	bool			needsPtr	= false;
+	unsigned short	gprsUsed	= 0;
+	unsigned short	fprsUsed	= 0;
+	size_t			i;
 
-        if (ioGPRCount)
-                gprsUsed = *ioGPRCount;
+	if (ioGPRCount)
+		gprsUsed = *ioGPRCount;
 
-        if (ioFPRCount)
-                fprsUsed = *ioFPRCount;
+	if (ioFPRCount)
+		fprsUsed = *ioFPRCount;
 
-        for (i = 0; inType->elements[i] != NULL && !needsPtr; i++)
-        {
-                switch (inType->elements[i]->type)
-                {
-                        case FFI_TYPE_FLOAT:
-                        case FFI_TYPE_DOUBLE:
-                                gprsUsed++;
-                                fprsUsed++;
+	for (i = 0; inType->elements[i] != NULL && !needsPtr; i++)
+	{
+		switch (inType->elements[i]->type)
+		{
+			case FFI_TYPE_FLOAT:
+			case FFI_TYPE_DOUBLE:
+				gprsUsed++;
+				fprsUsed++;
 
-                                if (fprsUsed > 13)
-                                        needsPtr = true;
+				if (fprsUsed > 13)
+					needsPtr = true;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_LONGDOUBLE:
-                                gprsUsed += 2;
-                                fprsUsed += 2;
+			case FFI_TYPE_LONGDOUBLE:
+				gprsUsed += 2;
+				fprsUsed += 2;
 
-                                if (fprsUsed > 14)
-                                        needsPtr = true;
+				if (fprsUsed > 14)
+					needsPtr = true;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_UINT8:
-                        case FFI_TYPE_SINT8:
-                        {
-                                gprsUsed++;
+			case FFI_TYPE_UINT8:
+			case FFI_TYPE_SINT8:
+			{
+				gprsUsed++;
 
-                                if (gprsUsed > 8)
-                                {
-                                        needsPtr = true;
-                                        break;
-                                }
+				if (gprsUsed > 8)
+				{
+					needsPtr = true;
+					break;
+				}
 
-                                if (inType->elements[i + 1] == NULL)    // last byte in the struct
-                                        break;
+				if (inType->elements[i + 1] == NULL)	// last byte in the struct
+					break;
 
-                                // Count possible contiguous bytes ahead, up to 8.
-                                unsigned short j;
+				// Count possible contiguous bytes ahead, up to 8.
+				unsigned short j;
 
-                                for (j = 1; j < 8; j++)
-                                {
-                                        if (inType->elements[i + j] == NULL ||
-                                                !FFI_TYPE_1_BYTE(inType->elements[i + j]->type))
-                                                break;
-                                }
+				for (j = 1; j < 8; j++)
+				{
+					if (inType->elements[i + j] == NULL ||
+						!FFI_TYPE_1_BYTE(inType->elements[i + j]->type))
+						break;
+				}
 
-                                i += j - 1;     // allow for i++ before the test condition
+				i += j - 1;	// allow for i++ before the test condition
 
-                                break;
-                        }
+				break;
+			}
 
-                        case FFI_TYPE_UINT16:
-                        case FFI_TYPE_SINT16:
-                        case FFI_TYPE_INT:
-                        case FFI_TYPE_UINT32:
-                        case FFI_TYPE_SINT32:
-                        case FFI_TYPE_POINTER:
-                        case FFI_TYPE_UINT64:
-                        case FFI_TYPE_SINT64:
-                                gprsUsed++;
+			case FFI_TYPE_UINT16:
+			case FFI_TYPE_SINT16:
+			case FFI_TYPE_INT:
+			case FFI_TYPE_UINT32:
+			case FFI_TYPE_SINT32:
+			case FFI_TYPE_POINTER:
+			case FFI_TYPE_UINT64:
+			case FFI_TYPE_SINT64:
+				gprsUsed++;
 
-                                if (gprsUsed > 8)
-                                        needsPtr = true;
+				if (gprsUsed > 8)
+					needsPtr = true;
 
-                                break;
+				break;
 
-                        case FFI_TYPE_STRUCT:
-                                needsPtr = ffi64_stret_needs_ptr(
-                                        inType->elements[i], &gprsUsed, &fprsUsed);
+			case FFI_TYPE_STRUCT:
+				needsPtr = ffi64_stret_needs_ptr(
+					inType->elements[i], &gprsUsed, &fprsUsed);
 
-                                break;
+				break;
 
-                        default:
-                                FFI_ASSERT(0);
-                                break;
-                }
-        }
+			default:
+				FFI_ASSERT(0);
+				break;
+		}
+	}
 
-        if (ioGPRCount)
-                *ioGPRCount = gprsUsed;
+	if (ioGPRCount)
+		*ioGPRCount = gprsUsed;
 
-        if (ioFPRCount)
-                *ioFPRCount = fprsUsed;
+	if (ioFPRCount)
+		*ioFPRCount = fprsUsed;
 
-        return needsPtr;
+	return needsPtr;
 }
 
-/*      ffi64_data_size
+/*	ffi64_data_size
 
-        Calculate the size in bytes of an ffi type.
+	Calculate the size in bytes of an ffi type.
 */
 
 unsigned int
 ffi64_data_size(
-        const ffi_type* inType)
+	const ffi_type*	inType)
 {
-        unsigned int    size = 0;
+	unsigned int	size = 0;
 
-        switch (inType->type)
-        {
-                case FFI_TYPE_UINT8:
-                case FFI_TYPE_SINT8:
-                        size = 1;
-                        break;
+	switch (inType->type)
+	{
+		case FFI_TYPE_UINT8:
+		case FFI_TYPE_SINT8:
+			size = 1;
+			break;
 
-                case FFI_TYPE_UINT16:
-                case FFI_TYPE_SINT16:
-                        size = 2;
-                        break;
+		case FFI_TYPE_UINT16:
+		case FFI_TYPE_SINT16:
+			size = 2;
+			break;
 
-                case FFI_TYPE_INT:
-                case FFI_TYPE_UINT32:
-                case FFI_TYPE_SINT32:
-                case FFI_TYPE_FLOAT:
-                        size = 4;
-                        break;
+		case FFI_TYPE_INT:
+		case FFI_TYPE_UINT32:
+		case FFI_TYPE_SINT32:
+		case FFI_TYPE_FLOAT:
+			size = 4;
+			break;
 
-                case FFI_TYPE_POINTER:
-                case FFI_TYPE_UINT64:
-                case FFI_TYPE_SINT64:
-                case FFI_TYPE_DOUBLE:
-                        size = 8;
-                        break;
+		case FFI_TYPE_POINTER:
+		case FFI_TYPE_UINT64:
+		case FFI_TYPE_SINT64:
+		case FFI_TYPE_DOUBLE:
+			size = 8;
+			break;
 
-                case FFI_TYPE_LONGDOUBLE:
-                        size = 16;
-                        break;
+		case FFI_TYPE_LONGDOUBLE:
+			size = 16;
+			break;
 
-                case FFI_TYPE_STRUCT:
-                        ffi64_struct_to_reg_form(
-                                inType, NULL, NULL, NULL, NULL, &size, NULL, NULL);
-                        break;
+		case FFI_TYPE_STRUCT:
+			ffi64_struct_to_reg_form(
+				inType, NULL, NULL, NULL, NULL, &size, NULL, NULL);
+			break;
 
-                case FFI_TYPE_VOID:
-                        break;
+		case FFI_TYPE_VOID:
+			break;
 
-                default:
-                        FFI_ASSERT(0);
-                        break;
-        }
+		default:
+			FFI_ASSERT(0);
+			break;
+	}
 
-        return size;
+	return size;
 }
 
-#endif  /*      defined(__ppc64__)      */
-#endif  /* __ppc__ || __ppc64__ */
+#endif	/*	defined(__ppc64__)	*/
+#endif	/* __ppc__ || __ppc64__ */