michael@0: /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
michael@0:  *
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: // 6 integral parameters are passed in registers
michael@0: const uint32_t GPR_COUNT = 6;
michael@0: 
michael@0: // 8 floating point parameters are passed in SSE registers
michael@0: const uint32_t FPR_COUNT = 8;
michael@0: 
michael@0: // Remember that these 'words' are 64-bit long
michael@0: static inline void
michael@0: invoke_count_words(uint32_t paramCount, nsXPTCVariant * s,
michael@0:                    uint32_t & nr_gpr, uint32_t & nr_fpr, uint32_t & nr_stack)
michael@0: {
michael@0:     nr_gpr = 1; // skip one GP register for 'that'
michael@0:     nr_fpr = 0;
michael@0:     nr_stack = 0;
michael@0: 
michael@0:     /* Compute number of eightbytes of class MEMORY.  */
michael@0:     for (uint32_t i = 0; i < paramCount; i++, s++) {
michael@0:         if (!s->IsPtrData()
michael@0:             && (s->type == nsXPTType::T_FLOAT || s->type == nsXPTType::T_DOUBLE)) {
michael@0:             if (nr_fpr < FPR_COUNT)
michael@0:                 nr_fpr++;
michael@0:             else
michael@0:                 nr_stack++;
michael@0:         }
michael@0:         else {
michael@0:             if (nr_gpr < GPR_COUNT)
michael@0:                 nr_gpr++;
michael@0:             else
michael@0:                 nr_stack++;
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void
michael@0: invoke_copy_to_stack(uint64_t * d, uint32_t paramCount, nsXPTCVariant * s,
michael@0:                      uint64_t * gpregs, double * fpregs)
michael@0: {
michael@0:     uint32_t nr_gpr = 1; // skip one GP register for 'that'
michael@0:     uint32_t nr_fpr = 0;
michael@0:     uint64_t value;
michael@0: 
michael@0:     for (uint32_t i = 0; i < paramCount; i++, s++) {
michael@0:         if (s->IsPtrData())
michael@0:             value = (uint64_t) s->ptr;
michael@0:         else {
michael@0:             switch (s->type) {
michael@0:             case nsXPTType::T_FLOAT:                                break;
michael@0:             case nsXPTType::T_DOUBLE:                               break;
michael@0:             case nsXPTType::T_I8:     value = s->val.i8;            break;
michael@0:             case nsXPTType::T_I16:    value = s->val.i16;           break;
michael@0:             case nsXPTType::T_I32:    value = s->val.i32;           break;
michael@0:             case nsXPTType::T_I64:    value = s->val.i64;           break;
michael@0:             case nsXPTType::T_U8:     value = s->val.u8;            break;
michael@0:             case nsXPTType::T_U16:    value = s->val.u16;           break;
michael@0:             case nsXPTType::T_U32:    value = s->val.u32;           break;
michael@0:             case nsXPTType::T_U64:    value = s->val.u64;           break;
michael@0:             case nsXPTType::T_BOOL:   value = s->val.b;             break;
michael@0:             case nsXPTType::T_CHAR:   value = s->val.c;             break;
michael@0:             case nsXPTType::T_WCHAR:  value = s->val.wc;            break;
michael@0:             default:                  value = (uint64_t) s->val.p;  break;
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         if (!s->IsPtrData() && s->type == nsXPTType::T_DOUBLE) {
michael@0:             if (nr_fpr < FPR_COUNT)
michael@0:                 fpregs[nr_fpr++] = s->val.d;
michael@0:             else {
michael@0:                 *((double *)d) = s->val.d;
michael@0:                 d++;
michael@0:             }
michael@0:         }
michael@0:         else if (!s->IsPtrData() && s->type == nsXPTType::T_FLOAT) {
michael@0:             if (nr_fpr < FPR_COUNT)
michael@0:                 // The value in %xmm register is already prepared to
michael@0:                 // be retrieved as a float. Therefore, we pass the
michael@0:                 // value verbatim, as a double without conversion.
michael@0:                 fpregs[nr_fpr++] = s->val.d;
michael@0:             else {
michael@0:                 *((float *)d) = s->val.f;
michael@0:                 d++;
michael@0:             }
michael@0:         }
michael@0:         else {
michael@0:             if (nr_gpr < GPR_COUNT)
michael@0:                 gpregs[nr_gpr++] = value;
michael@0:             else
michael@0:                 *d++ = value;
michael@0:         }
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 nr_gpr, nr_fpr, nr_stack;
michael@0:     invoke_count_words(paramCount, params, nr_gpr, nr_fpr, nr_stack);
michael@0:     
michael@0:     // Stack, if used, must be 16-bytes aligned
michael@0:     if (nr_stack)
michael@0:         nr_stack = (nr_stack + 1) & ~1;
michael@0: 
michael@0:     // Load parameters to stack, if necessary
michael@0:     uint64_t *stack = (uint64_t *) __builtin_alloca(nr_stack * 8);
michael@0:     uint64_t gpregs[GPR_COUNT];
michael@0:     double fpregs[FPR_COUNT];
michael@0:     invoke_copy_to_stack(stack, paramCount, params, gpregs, fpregs);
michael@0: 
michael@0:     // Load FPR registers from fpregs[]
michael@0:     register double d0 asm("xmm0");
michael@0:     register double d1 asm("xmm1");
michael@0:     register double d2 asm("xmm2");
michael@0:     register double d3 asm("xmm3");
michael@0:     register double d4 asm("xmm4");
michael@0:     register double d5 asm("xmm5");
michael@0:     register double d6 asm("xmm6");
michael@0:     register double d7 asm("xmm7");
michael@0: 
michael@0:     switch (nr_fpr) {
michael@0: #define ARG_FPR(N) \
michael@0:     case N+1: d##N = fpregs[N];
michael@0:         ARG_FPR(7);
michael@0:         ARG_FPR(6);
michael@0:         ARG_FPR(5);
michael@0:         ARG_FPR(4);
michael@0:         ARG_FPR(3);
michael@0:         ARG_FPR(2);
michael@0:         ARG_FPR(1);
michael@0:         ARG_FPR(0);
michael@0:     case 0:;
michael@0: #undef ARG_FPR
michael@0:     }
michael@0:     
michael@0:     // Load GPR registers from gpregs[]
michael@0:     register uint64_t a0 asm("rdi");
michael@0:     register uint64_t a1 asm("rsi");
michael@0:     register uint64_t a2 asm("rdx");
michael@0:     register uint64_t a3 asm("rcx");
michael@0:     register uint64_t a4 asm("r8");
michael@0:     register uint64_t a5 asm("r9");
michael@0:     
michael@0:     switch (nr_gpr) {
michael@0: #define ARG_GPR(N) \
michael@0:     case N+1: a##N = gpregs[N];
michael@0:         ARG_GPR(5);
michael@0:         ARG_GPR(4);
michael@0:         ARG_GPR(3);
michael@0:         ARG_GPR(2);
michael@0:         ARG_GPR(1);
michael@0:     case 1: a0 = (uint64_t) that;
michael@0:     case 0:;
michael@0: #undef ARG_GPR
michael@0:     }
michael@0: 
michael@0:     // Ensure that assignments to SSE registers won't be optimized away
michael@0:     asm("" ::
michael@0:         "x" (d0), "x" (d1), "x" (d2), "x" (d3),
michael@0:         "x" (d4), "x" (d5), "x" (d6), "x" (d7));
michael@0:     
michael@0:     // Get pointer to method
michael@0:     uint64_t methodAddress = *((uint64_t *)that);
michael@0:     methodAddress += 8 * methodIndex;
michael@0:     methodAddress = *((uint64_t *)methodAddress);
michael@0:     
michael@0:     typedef nsresult (*Method)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
michael@0:     nsresult result = ((Method)methodAddress)(a0, a1, a2, a3, a4, a5);
michael@0:     return result;
michael@0: }