diff --git a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_ppc_linux.s b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_ppc_linux.s
index 2b30d5d4214..c2b31d1242d 100644
--- a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_ppc_linux.s
+++ b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_ppc_linux.s
@@ -1,128 +1,93 @@
- #
- # -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- #
- # The contents of this file are subject to the Netscape Public
- # License Version 1.1 (the "License"); you may not use this file
- # except in compliance with the License. You may obtain a copy of
- # the License at http://www.mozilla.org/NPL/
- #
- # Software distributed under the License is distributed on an "AS
- # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- # implied. See the License for the specific language governing
- # rights and limitations under the License.
- #
- # The Original Code is mozilla.org code.
- #
- # The Initial Developer of the Original Code is Netscape
- # Communications Corporation.  Portions created by Netscape are
- # Copyright (C) 1999 Netscape Communications Corporation. All
- # Rights Reserved.
- #
- # Contributor(s): 
- #
-
-.set r0,0; .set sp,1; .set RTOC,2; .set r3,3; .set r4,4
-.set r5,5; .set r6,6; .set r7,7; .set r8,8; .set r9,9
-.set r10,10; .set r11,11; .set r12,12; .set r13,13; .set r14,14
-.set r15,15; .set r16,16; .set r17,17; .set r18,18; .set r19,19
-.set r20,20; .set r21,21; .set r22,22; .set r23,23; .set r24,24
-.set r25,25; .set r26,26; .set r27,27; .set r28,28; .set r29,29
-.set r30,30; .set r31,31
-.set f0,0; .set f1,1; .set f2,2; .set f3,3; .set f4,4
-.set f5,5; .set f6,6; .set f7,7; .set f8,8; .set f9,9
-.set f10,10; .set f11,11; .set f12,12; .set f13,13; .set f14,14
-.set f15,15; .set f16,16; .set f17,17; .set f18,18; .set f19,19
-.set f20,20; .set f21,21; .set f22,22; .set f23,23; .set f24,24
-.set f25,25; .set f26,26; .set f27,27; .set f28,28; .set f29,29
-.set f30,30; .set f31,31
-
-
-
-
-
-# .text section
-
-        .globl  XPTC_InvokeByIndex
-        .extern invoke_count_words
-        .extern invoke_copy_to_stack
-
+#
+# -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1999 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s):
+#
+		      
+        .section ".text"
+	.align 2
+	.globl XPTC_InvokeByIndex
+	.type  XPTC_InvokeByIndex,@function
 
 #
-#   XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
-#                   PRUint32 paramCount, nsXPTCVariant* params)
+# XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
+#                    PRUint32 paramCount, nsXPTCVariant* params)
 #
 
 XPTC_InvokeByIndex:
-		mflr	r0
-		stw	r31,-4(sp)
-#
-# save off the incoming values in the caller's parameter area
-#		
-		stw	r3,24(sp)		# that
-		stw	r4,28(sp)		# methodIndex
-		stw	r5,32(sp)		# paramCount
-		stw	r6,36(sp)		# params
-		stw	r0,8(sp)
-		stwu	sp,-136(sp)		#  = 24 for linkage area,  8 * 13 for fprData area, 8 for saved registers
+	stwu 1,-32(1)
+	mflr 0
+	stw 3,8(1)        # that
+	stw 4,12(1)       # methodIndex
+	stw 30,16(1)
+	stw 31,20(1)
 
-# set up for and call 'invoke_count_words' to get new stack size
-#	
-		mr	r3,r5
-		mr	r4,r6
-		bl	invoke_count_words
-		nop
+	stw 0,36(1)
+	mr 31,1
 
-# prepare args for 'invoke_copy_to_stack' call
-#		
-		lwz	r4,168(sp)		# paramCount
-		lwz	r5,172(sp)		# params
-		mr	r6,sp			# fprData
-		slwi	r3,r3,2			# number of bytes of stack required
-		addi	r3,r3,28		# linkage area
-		mr	r31,sp			# save original stack top
-		subfc	sp,r3,sp		# bump the stack
-		addi	r3,sp,28		# parameter pointer excludes linkage area size + 'this'
-		
-		bl	invoke_copy_to_stack
-		nop
-		
-		lfd	f1,0(r31)		# Restore floating point registers	
-		lfd	f2,8(r31)				
-		lfd	f3,16(r31)				
-		lfd	f4,24(r31)				
-		lfd	f5,32(r31)				
-		lfd	f6,40(r31)				
-		lfd	f7,48(r31)				
-		lfd	f8,56(r31)				
-		lfd	f9,64(r31)				
-		lfd	f10,72(r31)				
-		lfd	f11,80(r31)				
-		lfd	f12,88(r31)				
-		lfd	f13,96(r31)				
-		
-		lwz	r3,160(r31)		# that
-		lwz	r4,0(r3)		# get vTable from 'that'
-		lwz	r5,164(r31)		# methodIndex
-		slwi	r5,r5,3			# methodIndex * 8
-		addi	r5,r5,8			# step over junk at start of vTable !
-		lwzx	r11,r5,r4		# get function pointer
-		
-		lwz	r4,28(sp)
-		lwz	r5,32(sp)
-		lwz	r6,36(sp)
-		lwz	r7,40(sp)
-		lwz	r8,44(sp)
-		lwz	r9,48(sp)
-		lwz	r10,52(sp)
+	slwi 10,5,3       # reserve stack for ParamCount *2 *4
+	addi 0,10,128     # reserve stack for GPR and FPR
+	lwz 9,0(1)
+	neg 0,0
+	stwux 9,1,0
+	addi 3,1,8        # args
+	mr 4,5            # paramCount
+	mr 5,6            # params
+	add 6,3,10        # gpregs
+	mr 30,6
+	addi 7,6,32       # fpregs
 
-                mtlr    r11
-		blrl
-		
-		mr      sp,r31
-		lwz	r0,144(sp)
-		addi    sp,sp,136
-		mtlr    r0
-		lwz     r31,-4(sp)
-	        blr
+	bl invoke_copy_to_stack # (args, paramCount, params, gpregs, fpregs)
 
+	lfd 1,32(30)      # load FP registers
+	lfd 2,40(30)   
+	lfd 3,48(30)  
+	lfd 4,56(30)  
+	lfd 5,64(30)  
+	lfd 6,72(30)  
+	lfd 7,80(30)  
+	lfd 8,88(30)
 
+	lwz 3,8(31)       # that
+	lwz 4,12(31)      # methodIndex
+
+	lwz 5,0(3)        # vtable
+	slwi 4,4,2        # temp = methodIndex * 4
+	addi 4,4,8        # temp += 8
+	lwzx 0,4,5        # dest = vtable+temp
+
+        lwz 4,0(30)       # load GP regs
+	lwz 5,4(30)   
+	lwz 6,8(30)  
+	lwz 7,12(30)  
+	lwz 8,16(30)  
+	lwz 9,20(30)  
+	lwz 10,24(30)
+
+	mtlr 0         
+	blrl              # call
+	
+	lwz 30,16(31)     # clean up stack
+	lwz 31,20(31)
+	lwz 11,0(1)
+	lwz 0,4(11)
+	mtlr 0
+	mr 1,11
+	blr
diff --git a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ppc_linux.cpp b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ppc_linux.cpp
index 2d502839e80..34ac65fbd5d 100644
--- a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ppc_linux.cpp
+++ b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ppc_linux.cpp
@@ -26,106 +26,190 @@
 
 typedef unsigned nsXPCVariant;
 
+#define FIRST_GP_REG  3
+#define MAX_GP_REG   10
+#define FIRST_FP_REG  1
+#define MAX_FP_REG    8
+
 extern "C" PRUint32
 invoke_count_words(PRUint32 paramCount, nsXPTCVariant* s)
 {
-    PRUint32 result = 0;
-    for(PRUint32 i = 0; i < paramCount; i++, s++)
-    {
-        if(s->IsPtrData())
-        {
-            result++;
-            continue;
-        }
-        switch(s->type)
-        {
-            case nsXPTType::T_I8     :
-            case nsXPTType::T_I16    :
-            case nsXPTType::T_I32    :
-                result++;
-                break;
-            case nsXPTType::T_I64    :
-                result+=2;
-                break;
-            case nsXPTType::T_U8     :
-            case nsXPTType::T_U16    :
-            case nsXPTType::T_U32    :
-                result++;
-                break;
-            case nsXPTType::T_U64    :
-                result+=2;
-                break;
-            case nsXPTType::T_FLOAT  :
-                result++;
-                break;
-            case nsXPTType::T_DOUBLE :
-                result+=2;
-                break;
-            case nsXPTType::T_BOOL   :
-            case nsXPTType::T_CHAR   :
-            case nsXPTType::T_WCHAR  :
-                result++;
-                break;
-            default:
-                // all the others are plain pointer types
-                result++;
-                break;
-        }
-    }
-    // nuts, I know there's a cooler way of doing this, but it's late
-    // now and it'll probably come to me in the morning.
-    if (result & 0x3) 
-        result += 4 - (result & 0x3);     // ensure q-word alignment
-    return result;
+  return (PRUint32)(((paramCount * 2) + 3) & ~3);
 }
 
 extern "C" void
-invoke_copy_to_stack(PRUint32* d, PRUint32 paramCount, nsXPTCVariant* s)
+invoke_copy_to_stack(PRUint32* d, PRUint32 paramCount, nsXPTCVariant* s, 
+		     PRUint32* gpregs, double* fpregs)
 {
-/*
-    We need to copy the parameters for this function to locals and use them
-    from there since the parameters occupy the same stack space as the stack
-    we're trying to populate.
-*/
-    uint32 *l_d = d;
-    nsXPTCVariant *l_s = s;
-    uint32 l_paramCount = paramCount;
+  uint32 gpr = FIRST_GP_REG + 1; // skip one GP reg for 'this'
+  uint32 fpr = FIRST_FP_REG;
 
-    typedef struct {
-        uint32 hi;
-        uint32 lo;
-    } DU;               // have to move 64 bit entities as 32 bit halves since
-                        // stack slots are not guaranteed 16 byte aligned
-
-    for(uint32 i = 0; i < l_paramCount; i++, l_d++, l_s++)
+  for(uint32 i = 0; i < paramCount; i++, s++)
     {
-        if(l_s->IsPtrData())
+      if(s->IsPtrData())
         {
-            *((void**)l_d) = l_s->ptr;
-            continue;
+	  if (gpr > MAX_GP_REG)
+	    *((void**) d++)        = s->ptr;
+	  else
+	    {
+	      *((void**) gpregs++) = s->ptr;
+	      gpr++;
+	    }
+	  continue;
         }
-        switch(l_s->type)
+      switch(s->type)
         {
-        case nsXPTType::T_I8     : *((int32*)  l_d) = l_s->val.i8;          break;
-        case nsXPTType::T_I16    : *((int32*)  l_d) = l_s->val.i16;         break;
-        case nsXPTType::T_I32    : *((int32*)  l_d) = l_s->val.i32;         break;
-        case nsXPTType::T_I64    : 
-        case nsXPTType::T_U64    : 
-        case nsXPTType::T_DOUBLE : *((uint32*) l_d++) = ((DU *)l_s)->hi;
-                                   *((uint32*) l_d) = ((DU *)l_s)->lo;
-                                   break;
-        case nsXPTType::T_U8     : *((uint32*) l_d) = l_s->val.u8;          break;
-        case nsXPTType::T_U16    : *((uint32*) l_d) = l_s->val.u16;         break;
-        case nsXPTType::T_U32    : *((uint32*) l_d) = l_s->val.u32;         break;
-        case nsXPTType::T_FLOAT  : *((float*)  l_d) = l_s->val.f;           break;
-        case nsXPTType::T_BOOL   : *((PRBool*) l_d) = l_s->val.b;           break;
-        case nsXPTType::T_CHAR   : *((uint32*) l_d) = l_s->val.c;           break;
-        case nsXPTType::T_WCHAR  : *((int32*)  l_d) = l_s->val.wc;          break;
+	case nsXPTType::T_I8:
+	  if (gpr > MAX_GP_REG)
+	    *((PRInt32*) d++)        = s->val.i8;
+	  else
+	    {
+	      *((PRInt32*) gpregs++) = s->val.i8;
+	      gpr++;
+	    }
+          break;
+	case nsXPTType::T_I16:
+	  if (gpr > MAX_GP_REG)
+	    *((PRInt32*) d++)        = s->val.i16;
+	  else
+	    {
+	      *((PRInt32*) gpregs++) = s->val.i16;
+	      gpr++;
+	    }
+	  break;
+        case nsXPTType::T_I32:
+	  if (gpr > MAX_GP_REG)
+	    *((PRInt32*) d++)        = s->val.i32;
+	  else
+	    {
+	      *((PRInt32*) gpregs++) = s->val.i32;
+	      gpr++;
+	    }
+	  break;
+        case nsXPTType::T_I64:
+	  if ((gpr + 1) > MAX_GP_REG)
+	    {
+	      if (((PRUint32) d) & 4 != 0) d++;
+	      *(((PRInt64*) d)++)      = s->val.i64;
+	    }
+	  else
+	    {
+	      if ((gpr & 1) == 0)
+		{
+		  gpr++;
+		  gpregs++;
+		}
+	      *(((PRInt64*) gpregs)++) = s->val.i64;
+	      gpr += 2;
+	    }
+	  break;
+	case nsXPTType::T_U8:
+	  if (gpr > MAX_GP_REG)
+	    *d++        = s->val.u8;
+	  else
+	    {
+	      *gpregs++ = s->val.u8;
+	      gpr++;
+	    }
+          break;
+	case nsXPTType::T_U16:
+	  if (gpr > MAX_GP_REG)
+	    *d++        = s->val.u16;
+	  else
+	    {
+	      *gpregs++ = s->val.u16;
+	      gpr++;
+	    }
+	  break;
+        case nsXPTType::T_U32:
+	  if (gpr > MAX_GP_REG)
+	    *d++        = s->val.u32;
+	  else
+	    {
+	      *gpregs++ = s->val.u32;
+	      gpr++;
+	    }
+	  break;
+        case nsXPTType::T_U64:
+	  if ((gpr + 1) > MAX_GP_REG)
+	    {
+	      if (((PRUint32) d) & 4 != 0) d++;
+	      *(((PRUint64*) d)++)      = s->val.u64;
+	    }
+	  else
+	    {
+	      if ((gpr & 1) == 0)
+		{
+		  gpr++;
+		  gpregs++;
+		}
+	      *(((PRUint64*) gpregs)++) = s->val.u64;
+	      gpr    += 2;
+	    }
+	  break;
+        case nsXPTType::T_FLOAT:
+	  if (fpr > MAX_FP_REG)
+	      *((float*) d++) = s->val.f;
+	  else
+	    {
+	      *fpregs++       = s->val.f;
+	      fpr++;
+	    }
+	  break;
+        case nsXPTType::T_DOUBLE:
+	  if (fpr > MAX_FP_REG)
+	    {
+	      if (((PRUint32) d) & 4 != 0) d++;
+	      *(((double*) d)++) = s->val.d;
+	    }
+	  else
+	    {
+	      *fpregs++          = s->val.d;
+	      fpr++;
+	    }
+	  break;
+        case nsXPTType::T_BOOL:
+	  if (gpr > MAX_GP_REG)
+	    *((PRBool*) d++)        = s->val.b;
+	  else
+	    {
+	      *((PRBool*) gpregs++) = s->val.b;
+	      gpr++;
+	    }
+          break;
+        case nsXPTType::T_CHAR:
+	  if (gpr > MAX_GP_REG)
+	    *d++        = s->val.c;
+	  else
+	    {
+	      *gpregs++ = s->val.c;
+	      gpr++;
+	    }
+          break;
+        case nsXPTType::T_WCHAR:
+	  if (gpr > MAX_GP_REG)
+	    *((PRInt32*) d++)        = s->val.wc;
+	  else
+	    {
+	      *((PRInt32*) gpregs++) = s->val.wc;
+	      gpr++;
+	    }
+          break;
         default:
-            // all the others are plain pointer types
-            *((void**)l_d) = l_s->val.p;
-            break;
+	  // all the others are plain pointer types
+	  if (gpr > MAX_GP_REG)
+	    *((void**) d++)        = s->val.p;
+	  else
+	    {
+	      *((void**) gpregs++) = s->val.p;
+	      gpr++;
+	    }
+          break;
         }
     }
 }
 
+extern "C"
+XPTC_PUBLIC_API(nsresult)
+XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
+		   PRUint32 paramCount, nsXPTCVariant* params);
diff --git a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_ppc_linux.s b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_ppc_linux.s
index 7bb9e8d463e..6a92e61efbc 100644
--- a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_ppc_linux.s
+++ b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_ppc_linux.s
@@ -21,75 +21,48 @@
  # Contributor(s): 
  #
 
-.set r0,0; .set sp,1; .set RTOC,2; .set r3,3; .set r4,4
-.set r5,5; .set r6,6; .set r7,7; .set r8,8; .set r9,9
-.set r10,10; .set r11,11; .set r12,12; .set r13,13; .set r14,14
-.set r15,15; .set r16,16; .set r17,17; .set r18,18; .set r19,19
-.set r20,20; .set r21,21; .set r22,22; .set r23,23; .set r24,24
-.set r25,25; .set r26,26; .set r27,27; .set r28,28; .set r29,29
-.set r30,30; .set r31,31
-.set f0,0; .set f1,1; .set f2,2; .set f3,3; .set f4,4
-.set f5,5; .set f6,6; .set f7,7; .set f8,8; .set f9,9
-.set f10,10; .set f11,11; .set f12,12; .set f13,13; .set f14,14
-.set f15,15; .set f16,16; .set f17,17; .set f18,18; .set f19,19
-.set f20,20; .set f21,21; .set f22,22; .set f23,23; .set f24,24
-.set f25,25; .set f26,26; .set f27,27; .set f28,28; .set f29,29
-.set f30,30; .set f31,31
-
-
-
-
-
-# .text section
-
-        .globl  SharedStub
-        .extern PrepareAndDispatch
-
-
-#
-# on entry SharedStub has the method selector in r12, the rest of the original
-# parameters are in r3 thru r10 and f1 thru f13
-#
-        
+        .section ".text"
+        .align 2
+	.globl SharedStub
+	.type  SharedStub,@function
+				
 SharedStub:
-	mflr	r0
-	stw	r0,8(sp)
+        stwu	1,-112(1)	# room for 
+				# linkage (8),
+				# gprData (32),
+				# fprData (64), 
+				# stack alignment(8)
 
-        stwu	sp,-176(sp)	    # room for linkage (24), fprData (104), gprData(28)
-				    # outgoing params to PrepareAndDispatch (20)
+        mflr	0
+	stw	0,116(1)
 
-	stw	r4,44(sp)
-	stw	r5,48(sp)
-	stw	r6,52(sp)
-	stw	r7,56(sp)
-	stw	r8,60(sp)
-	stw	r9,64(sp)
-	stw	r10,68(sp)
-	stfd	f1,72(sp)
-	stfd	f2,80(sp)
-	stfd	f3,88(sp)
-	stfd	f4,96(sp)
-	stfd	f5,104(sp)
-	stfd	f6,112(sp)
-	stfd	f7,120(sp)
-	stfd	f8,128(sp)
-	stfd	f9,136(sp)
-	stfd	f10,144(sp)
-	stfd	f11,152(sp)
-	stfd	f12,156(sp)
-	stfd	f13,164(sp)
+	stw	4,12(1)         # save GP registers
+	stw	5,16(1)
+	stw	6,20(1)
+	stw	7,24(1)
+	stw	8,28(1)
+	stw	9,32(1)
+	stw	10,36(1)
+
+	stfd	1,40(1)         # save FP registers
+	stfd	2,48(1)
+	stfd	3,56(1)
+	stfd	4,64(1)
+	stfd	5,72(1)
+	stfd	6,80(1)
+	stfd	7,88(1)
+	stfd	8,96(1)
 
-	addi	r6,sp,44	# gprData
-	addi	r7,sp,72	# fprData
 				# r3 has the 'self' pointer already
-#	mr	r4,r12		# methodIndex selector
-	addi	r5,sp,232	# pointer to callers args area, beyond r3-r10 mapped range
+				# r4 has the 'methodIndex' selector
+	addi	5,1,120		# pointer to callers args area, beyond r3-r10/f1-f8 mapped range
+	addi	6,1,12		# gprData+1
+	addi	7,1,40		# fprData
 
 	bl	PrepareAndDispatch
-	nop
     
-	lwz	r0,184(sp)
-	addi	sp,sp,176
-	mtlr	r0
+	lwz	0,116(1)
+	mtlr	0
+	la	1,112(1)
 	blr
 
diff --git a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp
index df367b08c71..8788802799f 100644
--- a/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp
+++ b/mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp
@@ -25,170 +25,228 @@
 #include "xptcprivate.h"
 
 /*
-        For PPC (AIX & MAC), the first 8 integral and the first 13 f.p. parameters 
+        For Linux/PPC, the first 8 integral and the first 8 f.p. parameters 
         arrive in a separate chunk of data that has been loaded from the registers. 
         The args pointer has been set to the start of the parameters BEYOND the ones
-        arriving in registers
+        arriving in registers.
 */
+
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, PRUint32 methodIndex, PRUint32* args, PRUint32 *gprData, double *fprData)
 {
-    typedef struct {
-        uint32 hi;
-        uint32 lo;      // have to move 64 bit entities as 32 bit halves since
-    } DU;               // stack slots are not guaranteed 16 byte aligned
 
 #define PARAM_BUFFER_COUNT     16
-#define PARAM_GPR_COUNT                 7
+#define PARAM_GPR_COUNT         8
+#define PARAM_FPR_COUNT         8
 
-    nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
-    const nsXPTMethodInfo* info;
-    PRUint8 paramCount;
-    PRUint8 i;
-    nsresult result = NS_ERROR_FAILURE;
+  nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
+  nsXPTCMiniVariant* dispatchParams = NULL;
+  nsIInterfaceInfo* iface_info = NULL;
+  const nsXPTMethodInfo* info;
+  PRUint8 paramCount;
+  PRUint8 i;
+  nsresult result = NS_ERROR_FAILURE;
 
-    NS_ASSERTION(self,"no self");
+  NS_ASSERTION(self,"no self");
 
-    self->GetInterfaceInfo(&iface_info);
-    NS_ASSERTION(iface_info,"no interface info");
+  self->GetInterfaceInfo(&iface_info);
+  NS_ASSERTION(iface_info,"no interface info");
 
-    iface_info->GetMethodInfo(PRUint16(methodIndex), &info);
-    NS_ASSERTION(info,"no interface info");
+  iface_info->GetMethodInfo(PRUint16(methodIndex), &info);
+  NS_ASSERTION(info,"no interface info");
 
-    paramCount = info->GetParamCount();
+  paramCount = info->GetParamCount();
 
-    // setup variant array pointer
-    if(paramCount > PARAM_BUFFER_COUNT)
-        dispatchParams = new nsXPTCMiniVariant[paramCount];
-    else
-        dispatchParams = paramBuffer;
-    NS_ASSERTION(dispatchParams,"no place for params");
+  // setup variant array pointer
+  if(paramCount > PARAM_BUFFER_COUNT)
+    dispatchParams = new nsXPTCMiniVariant[paramCount];
+  else
+    dispatchParams = paramBuffer;
+  NS_ASSERTION(dispatchParams,"no place for params");
 
-    PRUint32* ap = args;
-    PRUint32 iCount = 0;
-    PRUint32 fpCount = 0;
-    for(i = 0; i < paramCount; i++)
+  PRUint32* ap = args;
+  PRUint32 gprCount = 1; //skip one GPR reg
+  PRUint32 fprCount = 0;
+  for(i = 0; i < paramCount; i++)
     {
-        const nsXPTParamInfo& param = info->GetParam(i);
-        const nsXPTType& type = param.GetType();
-        nsXPTCMiniVariant* dp = &dispatchParams[i];
+      const nsXPTParamInfo& param = info->GetParam(i);
+      const nsXPTType& type = param.GetType();
+      nsXPTCMiniVariant* dp = &dispatchParams[i];
 
-        if(param.IsOut() || !type.IsArithmetic())
+      if(param.IsOut() || !type.IsArithmetic())
         {
-            if (iCount < PARAM_GPR_COUNT)
-                dp->val.p = (void*) gprData[iCount++];
-            else
-                dp->val.p = (void*) *ap++;
-            continue;
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.p = (void*) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.p   = (void*) *ap++;
+	  continue;
         }
-        // else
-        switch(type)
+      // else
+      switch(type)
         {
-        case nsXPTType::T_I8      :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i8  = (PRInt8) gprData[iCount++];
-                                     else
-                                         dp->val.i8  = (PRInt8)  *ap++;
-                                     break;
-        case nsXPTType::T_I16     :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i16  = (PRInt16) gprData[iCount++];
-                                     else
-                                         dp->val.i16  = (PRInt16)  *ap++;
-                                     break;
-        case nsXPTType::T_I32     :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i32  = (PRInt32) gprData[iCount++];
-                                     else
-                                         dp->val.i32  = (PRInt32)  *ap++;
-                                     break;
-        case nsXPTType::T_I64     :  if (iCount < PARAM_GPR_COUNT)
-                                         ((DU *)dp)->hi  = (PRInt32) gprData[iCount++];
-                                     else
-                                         ((DU *)dp)->hi  = (PRInt32)  *ap++;
-                                     if (iCount < PARAM_GPR_COUNT)
-                                         ((DU *)dp)->lo  = (PRUint32) gprData[iCount++];
-                                     else
-                                         ((DU *)dp)->lo  = (PRUint32)  *ap++;
-                                     break;
-        case nsXPTType::T_U8      :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i8  = (PRUint8) gprData[iCount++];
-                                     else
-                                         dp->val.i8  = (PRUint8)  *ap++;
-                                     break;
-        case nsXPTType::T_U16     :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i16  = (PRUint16) gprData[iCount++];
-                                     else
-                                         dp->val.i16  = (PRUint16)  *ap++;
-                                     break;
-        case nsXPTType::T_U32     :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.i32  = (PRUint32) gprData[iCount++];
-                                     else
-                                         dp->val.i32  = (PRUint32)  *ap++;
-                                     break;
-        case nsXPTType::T_U64     :  if (iCount < PARAM_GPR_COUNT)
-                                         ((DU *)dp)->hi  = (PRUint32) gprData[iCount++];
-                                     else
-                                         ((DU *)dp)->hi  = (PRUint32)  *ap++;
-                                     if (iCount < PARAM_GPR_COUNT)
-                                         ((DU *)dp)->lo  = (PRUint32) gprData[iCount++];
-                                     else
-                                         ((DU *)dp)->lo  = (PRUint32)  *ap++;
-                                     break;
-        case nsXPTType::T_FLOAT   :  if (fpCount < 13) {
-                                         dp->val.f  = (float) fprData[fpCount++];
-                                         if (iCount < PARAM_GPR_COUNT)
-                                             ++iCount;
-                                         else
-                                             ++ap;
-                                     }
-                                     else
-                                         dp->val.f   = *((float*)   ap++);
-                                     break;
-        case nsXPTType::T_DOUBLE  :  if (fpCount < 13) {
-                                         dp->val.d  = (double) fprData[fpCount++];
-                                         if (iCount < PARAM_GPR_COUNT)
-                                             ++iCount;
-                                         else
-                                             ++ap;
-                                         if (iCount < PARAM_GPR_COUNT)
-                                             ++iCount;
-                                         else
-                                             ++ap;
-                                     }
-                                     else {
-                                         dp->val.f   = *((double*)   ap);
-                                         ap += 2;
-                                     }
-                                     break;
-        case nsXPTType::T_BOOL    :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.b  = (PRBool) gprData[iCount++];
-                                     else
-                                         dp->val.b  = (PRBool)  *ap++;
-                                     break;
-        case nsXPTType::T_CHAR    :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.c  = (char) gprData[iCount++];
-                                     else
-                                         dp->val.c  = (char)  *ap++;
-                                     break;
-        case nsXPTType::T_WCHAR   :  if (iCount < PARAM_GPR_COUNT)
-                                         dp->val.wc  = (wchar_t) gprData[iCount++];
-                                     else
-                                         dp->val.wc  = (wchar_t)  *ap++;
-                                     break;
-        default:
-            NS_ASSERTION(0, "bad type");
-            break;
+	case nsXPTType::T_I8:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.i8 = (PRInt8) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.i8   = (PRInt8) *ap++;
+	  break;
+
+	case nsXPTType::T_I16:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.i16 = (PRInt16) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.i16   = (PRInt16) *ap++;
+	  break;
+
+	case nsXPTType::T_I32:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.i32 = (PRInt32) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.i32   = (PRInt32) *ap++;
+	  break;
+
+	case nsXPTType::T_I64:
+	  if (gprCount & 1) gprCount++;
+	  if ((gprCount + 1) < PARAM_GPR_COUNT)
+	    {
+	      dp->val.i64 = *(PRInt64*) gprData;
+	      gprData += 2;
+	      gprCount++;
+	    }
+	  else
+	    {
+	      if ((PRUint32) ap & 4) ap++;
+	      dp->val.i64 = *(PRInt64*) ap;
+	      ap += 2;
+	    }
+	  break;
+
+	case nsXPTType::T_U8:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.u8 = (PRUint8) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.u8   = (PRUint8) *ap++;
+	  break;
+
+	case nsXPTType::T_U16:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.u16 = (PRUint16) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.u16   = (PRUint16) *ap++;
+	  break;
+
+	case nsXPTType::T_U32:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.u32 = (PRUint32) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.u32   = (PRUint32) *ap++;
+	  break;
+
+	case nsXPTType::T_U64:
+	  if (gprCount & 1) gprCount++;
+	  if ((gprCount + 1) < PARAM_GPR_COUNT)
+	    {
+	      dp->val.u64 = *(PRUint64*) gprData;
+	      gprData += 2;
+	      gprCount++;
+	    }
+	  else
+	    {
+	      if ((PRUint32) ap & 4) ap++;
+	      dp->val.u64 = *(PRUint64*) ap;
+	      ap += 2;
+	    }
+	  break;
+
+	case nsXPTType::T_FLOAT:
+	  if (fprCount < PARAM_FPR_COUNT)
+	    {
+	      dp->val.f = (float) *fprData++;
+	      fprCount++;
+	    }
+	  else
+	    dp->val.f = *(float*) ap++;
+	  break;
+
+	case nsXPTType::T_DOUBLE:
+	  if (fprCount < PARAM_FPR_COUNT)
+	    {
+	      dp->val.d = *fprData++;
+	      fprCount++;
+	    }
+	  else
+	    {
+	      if ((PRUint32) ap & 4) ap++;
+	      dp->val.d = *(double*) ap;
+	      ap += 2;
+	    }
+	  break;
+
+	case nsXPTType::T_BOOL:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.b = (PRBool) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.b   = (PRBool) *ap++;
+	  break;
+
+	case nsXPTType::T_CHAR:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.c = (char) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.c   = (char) *ap++;
+	  break;
+
+	case nsXPTType::T_WCHAR:
+	  if (gprCount < PARAM_GPR_COUNT)
+	    {
+	      dp->val.wc = (wchar_t) *gprData++;
+	      gprCount++;
+	    }
+	  else
+	    dp->val.wc   = (wchar_t) *ap++;
+	  break;
+
+	default:
+	  NS_ASSERTION(0, "bad type");
+	  break;
         }
     }
 
-    result = self->CallMethod((PRUint16)methodIndex, info, dispatchParams);
+  result = self->CallMethod((PRUint16) methodIndex, info, dispatchParams);
 
-    NS_RELEASE(iface_info);
+  NS_RELEASE(iface_info);
 
-    if(dispatchParams != paramBuffer)
-        delete [] dispatchParams;
+  if(dispatchParams != paramBuffer)
+    delete [] dispatchParams;
 
-    return result;
+  return result;
 }
 
 extern "C" int SharedStub(void *, int);
@@ -196,14 +254,14 @@ extern "C" int SharedStub(void *, int);
 #define STUB_ENTRY(n)                \
 nsresult nsXPTCStubBase::Stub##n()   \
 {                                    \
-    return SharedStub(this, n);      \
-}                                    \
+  return SharedStub(this, n);        \
+}
 
-#define SENTINEL_ENTRY(n) \
-nsresult nsXPTCStubBase::Sentinel##n() \
-{ \
-    NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
-    return NS_ERROR_NOT_IMPLEMENTED; \
+#define SENTINEL_ENTRY(n)                            \
+nsresult nsXPTCStubBase::Sentinel##n()               \
+{                                                    \
+  NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
+  return NS_ERROR_NOT_IMPLEMENTED;                   \
 }
 
 #include "xptcstubsdef.inc"