From 89849e806246b94a62fea98e46dd91addadaebae Mon Sep 17 00:00:00 2001 From: "jband%netscape.com" Date: Mon, 19 Jul 1999 02:57:59 +0000 Subject: [PATCH] adding Linux ARM code contributed by Stefan Hanske --- xpcom/reflect/xptcall/src/md/unix/Makefile.in | 15 ++ .../xptcall/src/md/unix/xptcinvoke_arm.cpp | 171 ++++++++++++++++++ .../xptcall/src/md/unix/xptcstubs_arm.cpp | 148 +++++++++++++++ 3 files changed, 334 insertions(+) create mode 100644 xpcom/reflect/xptcall/src/md/unix/xptcinvoke_arm.cpp create mode 100644 xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp diff --git a/xpcom/reflect/xptcall/src/md/unix/Makefile.in b/xpcom/reflect/xptcall/src/md/unix/Makefile.in index edbb279a976..0154be9b007 100644 --- a/xpcom/reflect/xptcall/src/md/unix/Makefile.in +++ b/xpcom/reflect/xptcall/src/md/unix/Makefile.in @@ -138,6 +138,21 @@ ASFILES = \ endif endif +# Linux ARM +ifeq ($(OS_ARCH),Linux) +ifeq (arm,$(findstring arm,$(OS_TEST))) +CPPSRCS = \ + xptcinvoke_arm.cpp \ + xptcstubs_arm.cpp \ + $(NULL) +endif +ifeq (sa110,$(findstring sa110,$(OS_TEST))) +CPPSRCS = \ + xptcinvoke_arm.cpp \ + xptcstubs_arm.cpp \ + $(NULL) +endif +endif # we don't want the shared lib, but we want to force the creation of a static lib. override NO_SHARED_LIB=1 diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_arm.cpp b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_arm.cpp new file mode 100644 index 00000000000..5699855ddb2 --- /dev/null +++ b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_arm.cpp @@ -0,0 +1,171 @@ +/* -*- 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.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +/* Platform specific code to invoke XPCOM methods on native objects */ + +#include "xptcprivate.h" + +#if !defined(LINUX) || !defined(__arm) +#error "this code is for Linux ARM only" +#endif + +// 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; + + __asm__ __volatile__( + "ldr r1, [%1, #12] \n\t" + "ldr ip, [%1, #16] \n\t" + "ldr r0, [%1, #8] \n\t" + "mov lr, pc \n\t" + "mov pc, ip \n\t" + "mov r4, r0, lsl #2 \n\t" + "sub sp, sp, r4 \n\t" + "mov r0, sp \n\t" + "ldr r1, [%1, #8] \n\t" + "ldr r2, [%1, #12] \n\t" + "ldr ip, [%1, #20] \n\t" + "mov lr, pc \n\t" + "mov pc, ip \n\t" + "ldr r0, [%1] \n\t" + "ldr r1, [r0, #0] \n\t" + "ldr r2, [%1, #4] \n\t" + "mov r2, r2, lsl #2 \n\t" + "add r2, r2, #8 \n\t" + "ldr ip, [r1, r2] \n\t" + "cmp r4, #12 \n\t" + "ldmgtia sp!, {r1, r2, r3}\n\t" + "subgt r4, r4, #12 \n\t" + "ldmleia sp, {r1, r2, r3}\n\t" + "addle sp, sp, r4 \n\t" + "movle r4, #0 \n\t" + "ldr r0, [%1, #0] \n\t" + "mov lr, pc \n\t" + "mov pc, ip \n\t" + "add sp, sp, r4 \n\t" + "mov %0, r0 \n\t" + : "=r" (result) + : "r" (&my_params) + : "r0", "r1", "r2", "r3", "r4", "ip", "lr" + ); + + return result; +} diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp new file mode 100644 index 00000000000..4062fc058e4 --- /dev/null +++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp @@ -0,0 +1,148 @@ +/* -*- 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.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1999 Netscape Communications Corporation. All Rights + * Reserved. + */ + +/* Implement shared vtbl methods. */ + +#include "xptcprivate.h" + +#if !defined(LINUX) || !defined(__arm) +#error "this code is for Linux ARM only" +#endif + +static 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; +} + +#define STUB_ENTRY(n) \ +nsresult nsXPTCStubBase::Stub##n() \ +{ \ + register void* method = &PrepareAndDispatch; \ + register nsresult result; \ + __asm__ __volatile__( \ + "sub sp, sp, #32 \n\t" /* correct stack for pushing all args */ \ + "str r1, [sp] \n\t" /* push all args in r1-r3 to stack */ \ + "str r2, [sp, #4] \n\t" /* to make a PRUint32 array of */ \ + "str r3, [sp, #8] \n\t" /* functin parameters */ \ + "add r1, sp, #32 \n\t" /* copy saved registers: */ \ + "ldr r2, [r1] \n\t" /* The scene is as follows - */ \ + "str r2, [sp, #12] \n\t" /* sl, fp, ip, lr, pc get saved to the */ \ + "ldr r2, [r1, # 4] \n\t" /* stack, and behind that is the rest */ \ + "str r2, [sp, #16] \n\t" /* of our function parameters. */ \ + "ldr r2, [r1, # 8] \n\t" /* So we make some room and copy r1-r3 */ \ + "str r2, [sp, #20] \n\t" /* right in place. */ \ + "ldr r2, [r1, #12] \n\t" \ + "str r2, [sp, #24] \n\t" \ + "ldr r2, [r1, #16] \n\t" \ + "str r2, [sp, #28] \n\t" \ + "ldmia sp, {r1, r2, r3}\n\t" \ + "add lr, sp, #40 \n\t" \ + "stmia lr, {r1, r2, r3}\n\t" \ + "add sp, sp, #12 \n\t" \ + "mov r1, #"#n" \n\t" /* methodIndex */ \ + "mov r2, lr \n\t" /* &args */ \ + "bl PrepareAndDispatch__FP14nsXPTCStubBaseUiPUi \n\t" /*PrepareAndDispatch*/ \ + "mov %0, r0 \n\t" /* Result */ \ + "add r0, sp, #20 \n\t" \ + "ldmia sp!, {r1,r2,r3} \n\t" \ + "stmia r0!, {r1,r2,r3} \n\t" \ + "ldmia sp!, {r1, r2} \n\t" \ + "stmia r0, {r1, r2} \n\t" \ + : "=r" (result) \ + : \ + : "r0", "r1", "r2", "r3", "lr" ); \ + return result; \ +} + +#define SENTINEL_ENTRY(n) \ +nsresult nsXPTCStubBase::Sentinel##n() \ +{ \ + NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \ + return NS_ERROR_NOT_IMPLEMENTED; \ +} + +#include "xptcstubsdef.inc"