michael@0: /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /* Platform specific code to invoke XPCOM methods on native objects */
michael@0: 
michael@0: #include "xptcprivate.h"
michael@0: 
michael@0: // Remember that these 'words' are 32bit DWORDS
michael@0: 
michael@0: static uint32_t
michael@0: invoke_count_words(uint32_t paramCount, nsXPTCVariant* s)
michael@0: {
michael@0:     uint32_t result = 0;
michael@0:     for(uint32_t i = 0; i < paramCount; i++, s++)
michael@0:     {
michael@0:         if(s->IsPtrData())
michael@0:         {
michael@0:             result++;
michael@0:             continue;
michael@0:         }
michael@0:         switch(s->type)
michael@0:         {
michael@0:         case nsXPTType::T_I8     :
michael@0:         case nsXPTType::T_I16    :
michael@0:         case nsXPTType::T_I32    :
michael@0:             result++;
michael@0:             break;
michael@0:         case nsXPTType::T_I64    :
michael@0:             result+=2;
michael@0:             break;
michael@0:         case nsXPTType::T_U8     :
michael@0:         case nsXPTType::T_U16    :
michael@0:         case nsXPTType::T_U32    :
michael@0:             result++;
michael@0:             break;
michael@0:         case nsXPTType::T_U64    :
michael@0:             result+=2;
michael@0:             break;
michael@0:         case nsXPTType::T_FLOAT  :
michael@0:             result++;
michael@0:             break;
michael@0:         case nsXPTType::T_DOUBLE :
michael@0:             result+=2;
michael@0:             break;
michael@0:         case nsXPTType::T_BOOL   :
michael@0:         case nsXPTType::T_CHAR   :
michael@0:         case nsXPTType::T_WCHAR  :
michael@0:             result++;
michael@0:             break;
michael@0:         default:
michael@0:             // all the others are plain pointer types
michael@0:             result++;
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0:     return result;
michael@0: }
michael@0: 
michael@0: static void
michael@0: invoke_copy_to_stack(uint32_t* d, uint32_t paramCount, nsXPTCVariant* s)
michael@0: {
michael@0:     for(uint32_t i = 0; i < paramCount; i++, d++, s++)
michael@0:     {
michael@0:         if(s->IsPtrData())
michael@0:         {
michael@0:             *((void**)d) = s->ptr;
michael@0:             continue;
michael@0:         }
michael@0:         switch(s->type)
michael@0:         {
michael@0:         case nsXPTType::T_I8     : *((int8_t*)  d) = s->val.i8;          break;
michael@0:         case nsXPTType::T_I16    : *((int16_t*) d) = s->val.i16;         break;
michael@0:         case nsXPTType::T_I32    : *((int32_t*) d) = s->val.i32;         break;
michael@0:         case nsXPTType::T_I64    : *((int64_t*) d) = s->val.i64; d++;    break;
michael@0:         case nsXPTType::T_U8     : *((uint8_t*) d) = s->val.u8;          break;
michael@0:         case nsXPTType::T_U16    : *((uint16_t*)d) = s->val.u16;         break;
michael@0:         case nsXPTType::T_U32    : *((uint32_t*)d) = s->val.u32;         break;
michael@0:         case nsXPTType::T_U64    : *((uint64_t*)d) = s->val.u64; d++;    break;
michael@0:         case nsXPTType::T_FLOAT  : *((float*)   d) = s->val.f;           break;
michael@0:         case nsXPTType::T_DOUBLE : *((double*)  d) = s->val.d;   d++;    break;
michael@0:         case nsXPTType::T_BOOL   : *((bool*)  d) = s->val.b;           break;
michael@0:         case nsXPTType::T_CHAR   : *((char*)    d) = s->val.c;           break;
michael@0:         case nsXPTType::T_WCHAR  : *((wchar_t*) d) = s->val.wc;          break;
michael@0:         default:
michael@0:             // all the others are plain pointer types
michael@0:             *((void**)d) = s->val.p;
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: extern "C" {
michael@0:     struct my_params_struct {
michael@0:         nsISupports* that;      
michael@0:         uint32_t Index;         
michael@0:         uint32_t Count;         
michael@0:         nsXPTCVariant* params;  
michael@0:         uint32_t fn_count;     
michael@0:         uint32_t fn_copy;      
michael@0:     };
michael@0: }
michael@0: 
michael@0: EXPORT_XPCOM_API(nsresult)
michael@0: NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
michael@0:                    uint32_t paramCount, nsXPTCVariant* params)
michael@0: {
michael@0:     uint32_t result;
michael@0:     struct my_params_struct my_params;
michael@0:     my_params.that = that;
michael@0:     my_params.Index = methodIndex;
michael@0:     my_params.Count = paramCount;
michael@0:     my_params.params = params;
michael@0:     my_params.fn_copy = (uint32_t) &invoke_copy_to_stack;
michael@0:     my_params.fn_count = (uint32_t) &invoke_count_words;
michael@0: 
michael@0: /* This is to call a given method of class that.
michael@0:  * The parameters are in params, the number is in paramCount.
michael@0:  * The routine will issue calls to count the number of words
michael@0:  * required for argument passing and to copy the arguments to
michael@0:  * the stack.
michael@0:  * Since APCS passes the first 3 params in r1-r3, we need to
michael@0:  * load the first three words from the stack and correct the stack
michael@0:  * pointer (sp) in the appropriate way. This means:
michael@0:  *
michael@0:  * 1.) more than 3 arguments: load r1-r3, correct sp and remember No.
michael@0:  *			      of bytes left on the stack in r4
michael@0:  *
michael@0:  * 2.) <= 2 args: load r1-r3 (we won't be causing a stack overflow I hope),
michael@0:  *		  restore sp as if nothing had happened and set the marker r4 to zero.
michael@0:  *
michael@0:  * Afterwards sp will be restored using the value in r4 (which is not a temporary register
michael@0:  * and will be preserved by the function/method called according to APCS [ARM Procedure
michael@0:  * Calling Standard]).
michael@0:  *
michael@0:  * !!! IMPORTANT !!!
michael@0:  * This routine makes assumptions about the vtable layout of the c++ compiler. It's implemented
michael@0:  * for arm-linux GNU g++ >= 2.8.1 (including egcs and gcc-2.95.[1-3])!
michael@0:  *
michael@0:  */
michael@0: 
michael@0: #ifdef __GNUC__
michael@0:   __asm__ __volatile__(
michael@0:     "ldr	r1, [%1, #12]	\n\t"	/* prepare to call invoke_count_words	*/
michael@0:     "ldr	ip, [%1, #16]	\n\t"	/* r0=paramCount, r1=params		*/
michael@0:     "ldr	r0, [%1,  #8]	\n\t"
michael@0:     "mov	lr, pc		\n\t"	/* call it...				*/
michael@0:     "mov	pc, ip		\n\t"
michael@0:     "mov	r4, r0, lsl #2	\n\t"	/* This is the amount of bytes needed.	*/
michael@0:     "sub	sp, sp, r4	\n\t"	/* use stack space for the args...	*/
michael@0:     "mov	r0, sp		\n\t"	/* prepare a pointer an the stack	*/
michael@0:     "ldr	r1, [%1,  #8]	\n\t"	/* =paramCount				*/
michael@0:     "ldr	r2, [%1, #12]	\n\t"	/* =params				*/
michael@0:     "ldr	ip, [%1, #20]	\n\t"	/* =invoke_copy_to_stack		*/
michael@0:     "mov	lr, pc		\n\t"	/* copy args to the stack like the	*/
michael@0:     "mov	pc, ip		\n\t"	/* compiler would.			*/
michael@0:     "ldr	r0, [%1]	\n\t"	/* =that				*/
michael@0:     "ldr	r1, [r0, #0]	\n\t"	/* get that->vtable offset		*/
michael@0:     "ldr	r2, [%1, #4]	\n\t"
michael@0:     "mov	r2, r2, lsl #2	\n\t"	/* a vtable_entry(x)=8 + (4 bytes * x)	*/
michael@0:     "ldr        ip, [r1, r2]    \n\t"	/* get method adress from vtable        */
michael@0:     "cmp	r4, #12		\n\t"	/* more than 3 arguments???		*/
michael@0:     "ldmgtia	sp!, {r1, r2, r3}\n\t"	/* yes: load arguments for r1-r3	*/
michael@0:     "subgt	r4, r4, #12	\n\t"	/*      and correct the stack pointer	*/
michael@0:     "ldmleia	sp, {r1, r2, r3}\n\t"	/* no:  load r1-r3 from stack		*/ 
michael@0:     "addle	sp, sp, r4	\n\t"	/*      and restore stack pointer	*/
michael@0:     "movle	r4, #0		\n\t"	/*	a mark for restoring sp		*/
michael@0:     "ldr	r0, [%1, #0]	\n\t"	/* get (self)				*/
michael@0:     "mov	lr, pc		\n\t"	/* call mathod				*/
michael@0:     "mov	pc, ip		\n\t"
michael@0:     "add	sp, sp, r4	\n\t"	/* restore stack pointer		*/
michael@0:     "mov	%0, r0		\n\t"	/* the result...			*/
michael@0:     : "=r" (result)
michael@0:     : "r" (&my_params), "m" (my_params)
michael@0:     : "r0", "r1", "r2", "r3", "r4", "ip", "lr", "sp"
michael@0:     );
michael@0: #else
michael@0: #error "Unsupported compiler. Use g++ >= 2.8 for OpenBSD/arm."
michael@0: #endif /* G++ >= 2.8 */
michael@0: 
michael@0:   return result;
michael@0: }