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_stack) michael@0: { michael@0: uint32_t nr_gpr; michael@0: uint32_t nr_fpr; 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_stack; michael@0: invoke_count_words(paramCount, params, 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: // We used to have switches to make sure we would only load the registers michael@0: // that are needed for this call. That produced larger code that was michael@0: // not faster in practice. It also caused compiler warnings about the michael@0: // variables being used uninitialized. michael@0: // We now just load every every register. There could still be a warning michael@0: // from a memory analysis tools that we are loading uninitialized stack michael@0: // positions. michael@0: michael@0: // FIXME: this function depends on the above __builtin_alloca placing michael@0: // the array in the correct spot for the ABI. michael@0: michael@0: // Load FPR registers from fpregs[] michael@0: double d0, d1, d2, d3, d4, d5, d6, d7; michael@0: michael@0: d7 = fpregs[7]; michael@0: d6 = fpregs[6]; michael@0: d5 = fpregs[5]; michael@0: d4 = fpregs[4]; michael@0: d3 = fpregs[3]; michael@0: d2 = fpregs[2]; michael@0: d1 = fpregs[1]; michael@0: d0 = fpregs[0]; michael@0: michael@0: // Load GPR registers from gpregs[] michael@0: uint64_t a0, a1, a2, a3, a4, a5; michael@0: michael@0: a5 = gpregs[5]; michael@0: a4 = gpregs[4]; michael@0: a3 = gpregs[3]; michael@0: a2 = gpregs[2]; michael@0: a1 = gpregs[1]; michael@0: a0 = (uint64_t) that; 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, michael@0: uint64_t, uint64_t, double, double, double, michael@0: double, double, double, double, double); michael@0: nsresult result = ((Method)methodAddress)(a0, a1, a2, a3, a4, a5, michael@0: d0, d1, d2, d3, d4, d5, michael@0: d6, d7); michael@0: return result; michael@0: }