NSPR and XPTC support for arm32.

6 files changed, 357 insertions, 11 deletions

diff --git a/www/mozilla/Makefile b/www/mozilla/Makefile
index 98814c5c0f3..f5db1a7c489 100644
--- a/www/mozilla/Makefile
+++ b/www/mozilla/Makefile
@@ -1,4 +1,4 @@
-# $NetBSD: Makefile,v 1.44 2000/10/26 07:53:37 mycroft Exp $
+# $NetBSD: Makefile,v 1.45 2000/10/28 18:55:24 mycroft Exp $
 
 DISTNAME=	mozilla-source-M18
 PKGNAME=	mozilla-0.m18
@@ -47,10 +47,11 @@ SCRIPTS_ENV+=	BINGRP=${BINGRP}
 SCRIPTS_ENV+=	BINMODE=${BINMODE}
 SHAREMODE?=	644
 
-XPTCFILES+=	xptcinvoke_asm_ppc_netbsd.s xptcinvoke_ppc_netbsd.cpp
-XPTCFILES+=	xptcstubs_asm_ppc_netbsd.s xptcstubs_ppc_netbsd.cpp
-XPTCFILES+=	xptcinvoke_asm_sparc_netbsd.s xptcinvoke_sparc_netbsd.cpp
-XPTCFILES+=	xptcstubs_asm_sparc_netbsd.s xptcstubs_sparc_netbsd.cpp
+XPTCFILES+=	xptcinvoke_asm_ppc_netbsd.s xptcstubs_asm_ppc_netbsd.s
+XPTCFILES+=	xptcinvoke_ppc_netbsd.cpp xptcstubs_ppc_netbsd.cpp
+XPTCFILES+=	xptcinvoke_asm_sparc_netbsd.s xptcstubs_asm_sparc_netbsd.s
+XPTCFILES+=	xptcinvoke_sparc_netbsd.cpp xptcstubs_sparc_netbsd.cpp
+XPTCFILES+=	xptcinvoke_arm_netbsd.cpp xptcstubs_arm_netbsd.cpp
 
 post-extract:
 .for F in ${XPTCFILES}
diff --git a/www/mozilla/files/patch-sum b/www/mozilla/files/patch-sum
index 38d678a9011..0e3f8694402 100644
--- a/www/mozilla/files/patch-sum
+++ b/www/mozilla/files/patch-sum
@@ -1,8 +1,8 @@
-$NetBSD: patch-sum,v 1.18 2000/10/27 04:38:27 mycroft Exp $
+$NetBSD: patch-sum,v 1.19 2000/10/28 18:55:25 mycroft Exp $
 
 MD5 (patch-aa) = a07a4956a8c6a91fce0ef653b59c902f
 MD5 (patch-ab) = dfa8ac0ffaac96293904adb6372c5b8d
 MD5 (patch-ac) = e06e6cb1261f97e6fec8b04cdf4cb0a1
-MD5 (patch-ad) = 6b1244e070c60c2030e0520552df31e9
+MD5 (patch-ad) = 3bab27aefd274a609c901049f722bb41
 MD5 (patch-ae) = 925a6dc3b7354f0c82a7e2411463617e
-MD5 (patch-af) = 919c4da464918e676c90349ca9bb3b1d
+MD5 (patch-af) = 316103ca86d2a079d940cff8102849f1
diff --git a/www/mozilla/files/xptcinvoke_arm_netbsd.cpp b/www/mozilla/files/xptcinvoke_arm_netbsd.cpp
new file mode 100644
index 00000000000..c917aff616f
--- /dev/null
+++ b/www/mozilla/files/xptcinvoke_arm_netbsd.cpp
@@ -0,0 +1,198 @@
+/* -*- 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) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/* Platform specific code to invoke XPCOM methods on native objects */
+
+#include "xptcprivate.h"
+
+// Remember that these 'words' are 32bit DWORDS
+
+static 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;
+        }
+    }
+    return result;
+}
+
+static void
+invoke_copy_to_stack(PRUint32* d, PRUint32 paramCount, nsXPTCVariant* s)
+{
+    for(PRUint32 i = 0; i < paramCount; i++, d++, s++)
+    {
+        if(s->IsPtrData())
+        {
+            *((void**)d) = s->ptr;
+            continue;
+        }
+        switch(s->type)
+        {
+        case nsXPTType::T_I8     : *((PRInt8*)  d) = s->val.i8;          break;
+        case nsXPTType::T_I16    : *((PRInt16*) d) = s->val.i16;         break;
+        case nsXPTType::T_I32    : *((PRInt32*) d) = s->val.i32;         break;
+        case nsXPTType::T_I64    : *((PRInt64*) d) = s->val.i64; d++;    break;
+        case nsXPTType::T_U8     : *((PRUint8*) d) = s->val.u8;          break;
+        case nsXPTType::T_U16    : *((PRUint16*)d) = s->val.u16;         break;
+        case nsXPTType::T_U32    : *((PRUint32*)d) = s->val.u32;         break;
+        case nsXPTType::T_U64    : *((PRUint64*)d) = s->val.u64; d++;    break;
+        case nsXPTType::T_FLOAT  : *((float*)   d) = s->val.f;           break;
+        case nsXPTType::T_DOUBLE : *((double*)  d) = s->val.d;   d++;    break;
+        case nsXPTType::T_BOOL   : *((PRBool*)  d) = s->val.b;           break;
+        case nsXPTType::T_CHAR   : *((char*)    d) = s->val.c;           break;
+        case nsXPTType::T_WCHAR  : *((wchar_t*) d) = s->val.wc;          break;
+        default:
+            // all the others are plain pointer types
+            *((void**)d) = s->val.p;
+            break;
+        }
+    }
+}
+
+extern "C" 
+struct my_params_struct {
+    nsISupports* that;      
+    PRUint32 Index;         
+    PRUint32 Count;         
+    nsXPTCVariant* params;  
+    PRUint32 fn_count;     
+    PRUint32 fn_copy;      
+};
+
+XPTC_PUBLIC_API(nsresult)
+XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
+                   PRUint32 paramCount, nsXPTCVariant* params)
+{
+    PRUint32 result;
+    struct my_params_struct my_params;
+    my_params.that = that;
+    my_params.Index = methodIndex;
+    my_params.Count = paramCount;
+    my_params.params = params;
+    my_params.fn_copy = (PRUint32) &invoke_copy_to_stack;
+    my_params.fn_count = (PRUint32) &invoke_count_words;
+
+/* This is to call a given method of class that.
+ * The parameters are in params, the number is in paramCount.
+ * The routine will issue calls to count the number of words
+ * required for argument passing and to copy the arguments to
+ * the stack.
+ * Since APCS passes the first 3 params in r1-r3, we need to
+ * load the first three words from the stack and correct the stack
+ * pointer (sp) in the appropriate way. This means:
+ *
+ * 1.) more than 3 arguments: load r1-r3, correct sp and remember No.
+ *			      of bytes left on the stack in r4
+ *
+ * 2.) <= 2 args: load r1-r3 (we won't be causing a stack overflow I hope),
+ *		  restore sp as if nothing had happened and set the marker r4 to zero.
+ *
+ * Afterwards sp will be restored using the value in r4 (which is not a temporary register
+ * and will be preserved by the function/method called according to APCS [ARM Procedure
+ * Calling Standard]).
+ *
+ * !!! IMPORTANT !!!
+ * This routine makes assumptions about the vtable layout of the c++ compiler. It's implemented
+ * for arm-linux GNU g++ >= 2.8.1 (including egcs and gcc-2.95.[1-3])!
+ *
+ */
+ 
+  __asm__ __volatile__(
+    "ldr	r1, [%1, #12]	\n\t"	/* prepare to call invoke_count_words	*/
+    "ldr	ip, [%1, #16]	\n\t"	/* r0=paramCount, r1=params		*/
+    "ldr	r0, [%1,  #8]	\n\t"
+    "mov	lr, pc		\n\t"	/* call it...				*/
+    "mov	pc, ip		\n\t"
+    "mov	r4, r0, lsl #2	\n\t"	/* This is the amount of bytes needed.	*/
+    "sub	sp, sp, r4	\n\t"	/* use stack space for the args...	*/
+    "mov	r0, sp		\n\t"	/* prepare a pointer an the stack	*/
+    "ldr	r1, [%1,  #8]	\n\t"	/* =paramCount				*/
+    "ldr	r2, [%1, #12]	\n\t"	/* =params				*/
+    "ldr	ip, [%1, #20]	\n\t"	/* =invoke_copy_to_stack		*/
+    "mov	lr, pc		\n\t"	/* copy args to the stack like the	*/
+    "mov	pc, ip		\n\t"	/* compiler would.			*/
+    "ldr	r0, [%1]	\n\t"	/* =that				*/
+    "ldr	r1, [r0, #0]	\n\t"	/* get that->vtable offset		*/
+    "ldr	r2, [%1, #4]	\n\t"
+    "add	r2, r1, r2, lsl #3\n\t"	/* a vtable_entry(x)=8 + (8 bytes * x)	*/
+    "add	r2, r2, #8	\n\t"	/* with this compilers			*/
+    "ldr	r3, [r2]	\n\t"	/* get virtual offset from vtable	*/
+    "mov	r3, r3, lsl #16	\n\t"
+    "add	r0, r0, r3, asr #16\n\t"
+    "ldr	ip, [r2, #4]	\n\t"	/* get method address from vtable	*/
+    "cmp	r4, #12		\n\t"	/* more than 3 arguments???		*/
+    "ldmgtia	sp!, {r1, r2, r3}\n\t"	/* yes: load arguments for r1-r3	*/
+    "subgt	r4, r4, #12	\n\t"	/*      and correct the stack pointer	*/
+    "ldmleia	sp, {r1, r2, r3}\n\t"	/* no:  load r1-r3 from stack		*/ 
+    "addle	sp, sp, r4	\n\t"	/*      and restore stack pointer	*/
+    "movle	r4, #0		\n\t"	/*	a mark for restoring sp		*/
+    "mov	lr, pc		\n\t"	/* call mathod				*/
+    "mov	pc, ip		\n\t"
+    "add	sp, sp, r4	\n\t"	/* restore stack pointer		*/
+    "mov	%0, r0		\n\t"	/* the result...			*/
+    : "=r" (result)
+    : "r" (&my_params)
+    : "r0", "r1", "r2", "r3", "r4", "ip", "lr"
+    );
+    
+  return result;
+}    
diff --git a/www/mozilla/files/xptcstubs_arm_netbsd.cpp b/www/mozilla/files/xptcstubs_arm_netbsd.cpp
new file mode 100644
index 00000000000..28a68bcdf3f
--- /dev/null
+++ b/www/mozilla/files/xptcstubs_arm_netbsd.cpp
@@ -0,0 +1,130 @@
+/* -*- 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): 
+ */
+
+/* Implement shared vtbl methods. */
+
+#include "xptcprivate.h"
+
+nsresult
+PrepareAndDispatch(nsXPTCStubBase* self, uint32 methodIndex, PRUint32* args)
+{
+#define PARAM_BUFFER_COUNT     16
+
+    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");
+
+    self->GetInterfaceInfo(&iface_info);
+    NS_ASSERTION(iface_info,"no interface info");
+
+    iface_info->GetMethodInfo(PRUint16(methodIndex), &info);
+    NS_ASSERTION(info,"no interface info");
+
+    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");
+
+    PRUint32* ap = args;
+    for(i = 0; i < paramCount; i++, ap++)
+    {
+        const nsXPTParamInfo& param = info->GetParam(i);
+        const nsXPTType& type = param.GetType();
+        nsXPTCMiniVariant* dp = &dispatchParams[i];
+
+        if(param.IsOut() || !type.IsArithmetic())
+        {
+            dp->val.p = (void*) *ap;
+            continue;
+        }
+        // else
+        switch(type)
+        {
+        case nsXPTType::T_I8     : dp->val.i8  = *((PRInt8*)  ap);       break;
+        case nsXPTType::T_I16    : dp->val.i16 = *((PRInt16*) ap);       break;
+        case nsXPTType::T_I32    : dp->val.i32 = *((PRInt32*) ap);       break;
+        case nsXPTType::T_I64    : dp->val.i64 = *((PRInt64*) ap); ap++; break;
+        case nsXPTType::T_U8     : dp->val.u8  = *((PRUint8*) ap);       break;
+        case nsXPTType::T_U16    : dp->val.u16 = *((PRUint16*)ap);       break;
+        case nsXPTType::T_U32    : dp->val.u32 = *((PRUint32*)ap);       break;
+        case nsXPTType::T_U64    : dp->val.u64 = *((PRUint64*)ap); ap++; break;
+        case nsXPTType::T_FLOAT  : dp->val.f   = *((float*)   ap);       break;
+        case nsXPTType::T_DOUBLE : dp->val.d   = *((double*)  ap); ap++; break;
+        case nsXPTType::T_BOOL   : dp->val.b   = *((PRBool*)  ap);       break;
+        case nsXPTType::T_CHAR   : dp->val.c   = *((char*)    ap);       break;
+        case nsXPTType::T_WCHAR  : dp->val.wc  = *((wchar_t*) ap);       break;
+        default:
+            NS_ASSERTION(0, "bad type");
+            break;
+        }
+    }
+
+    result = self->CallMethod((PRUint16)methodIndex, info, dispatchParams);
+
+    NS_RELEASE(iface_info);
+
+    if(dispatchParams != paramBuffer)
+        delete [] dispatchParams;
+
+    return result;
+}
+
+/*
+ * These stubs move just move the values passed in registers onto the stack,
+ * so they are contiguous with values passed on the stack, and then calls
+ * PrepareAndDispatch() to do the dirty work.
+ */
+
+#define STUB_ENTRY(n)							\
+__asm__(								\
+    ".global	_Stub"#n"__14nsXPTCStubBase\n\t"			\
+"_Stub"#n"__14nsXPTCStubBase:\n\t"					\
+    "stmfd	sp!, {r1, r2, r3}	\n\t"				\
+    "mov	ip, sp			\n\t"				\
+    "stmfd	sp!, {fp, ip, lr, pc}	\n\t"				\
+    "sub	fp, ip, #4		\n\t"				\
+    "mov	r1, #"#n"		\n\t"    /* = methodIndex 	*/ \
+    "add	r2, sp, #16		\n\t"				\
+    "bl		_PrepareAndDispatch__FP14nsXPTCStubBaseUiPUi   \n\t"	\
+    "ldmea	fp, {fp, sp, lr}	\n\t"				\
+    "add	sp, sp, #12		\n\t"				\
+    "mov	pc, lr			\n\t"				\
+);
+
+#define SENTINEL_ENTRY(n) \
+nsresult nsXPTCStubBase::Sentinel##n() \
+{ \
+    NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
+    return NS_ERROR_NOT_IMPLEMENTED; \
+}
+
+#include "xptcstubsdef.inc"
diff --git a/www/mozilla/patches/patch-ad b/www/mozilla/patches/patch-ad
index 14d820e8008..352ac815611 100644
--- a/www/mozilla/patches/patch-ad
+++ b/www/mozilla/patches/patch-ad
@@ -1,4 +1,4 @@
-$NetBSD: patch-ad,v 1.13 2000/10/27 04:38:27 mycroft Exp $
+$NetBSD: patch-ad,v 1.14 2000/10/28 18:55:25 mycroft Exp $
 
 --- nsprpub/pr/include/md/_netbsd.h.orig	Thu Jul  6 20:46:02 2000
 +++ nsprpub/pr/include/md/_netbsd.h	Thu Oct 26 07:32:35 2000
@@ -73,7 +73,7 @@ $NetBSD: patch-ad,v 1.13 2000/10/27 04:38:27 mycroft Exp $
 +}
 +#define	_MD_GET_SP(_thread)	CONTEXT(_thread)[32]
 +#endif
-+#ifdef __arm32__	/* XXX UNTESTED */
++#ifdef __arm32__
 +#define _MD_INIT_CONTEXT(_thread, _sp, _main, status)			\
 +{									\
 +    sigsetjmp(CONTEXT(_thread), 1);					\
diff --git a/www/mozilla/patches/patch-af b/www/mozilla/patches/patch-af
index c5bb75f9371..8a8c446c058 100644
--- a/www/mozilla/patches/patch-af
+++ b/www/mozilla/patches/patch-af
@@ -1,7 +1,24 @@
-$NetBSD: patch-af,v 1.10 2000/10/26 07:50:00 mycroft Exp $
+$NetBSD: patch-af,v 1.11 2000/10/28 18:55:25 mycroft Exp $
 
 --- xpcom/reflect/xptcall/src/md/unix/Makefile.in.orig	Wed Jul 19 19:53:01 2000
 +++ xpcom/reflect/xptcall/src/md/unix/Makefile.in	Thu Oct 26 07:46:49 2000
+@@ -105,11 +105,11 @@
+ #
+ # NetBSD/ARM
+ #
+-#ifeq ($(OS_ARCH),NetBSD)
+-#ifneq (,$(filter arm32 armv4l sa110,$(OS_TEST)))
+-#CPPSRCS		:= xptcinvoke_arm.cpp xptcstubs_arm.cpp
+-#endif
+-#endif
++ifeq ($(OS_ARCH),NetBSD)
++ifneq (,$(filter arm32 armv4l sa110,$(OS_TEST)))
++CPPSRCS		:= xptcinvoke_arm_netbsd.cpp xptcstubs_arm_netbsd.cpp
++endif
++endif
+ 
+ ######################################################################
+ # HPPA
 @@ -181,6 +181,11 @@
  ASFILES		:= xptcinvoke_asm_ppc_linux.s xptcstubs_asm_ppc_linux.s
  endif