From 70c572334e7b5526a50407b6b7a01615782462d4 Mon Sep 17 00:00:00 2001 From: mycroft Date: Sat, 28 Oct 2000 18:55:24 +0000 Subject: NSPR and XPTC support for arm32. --- www/mozilla/Makefile | 11 +- www/mozilla/files/patch-sum | 6 +- www/mozilla/files/xptcinvoke_arm_netbsd.cpp | 198 ++++++++++++++++++++++++++++ www/mozilla/files/xptcstubs_arm_netbsd.cpp | 130 ++++++++++++++++++ www/mozilla/patches/patch-ad | 4 +- www/mozilla/patches/patch-af | 19 ++- 6 files changed, 357 insertions(+), 11 deletions(-) create mode 100644 www/mozilla/files/xptcinvoke_arm_netbsd.cpp create mode 100644 www/mozilla/files/xptcstubs_arm_netbsd.cpp (limited to 'www/mozilla') 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 -- cgit v1.2.3