зеркало из https://github.com/mozilla/gecko-dev.git
Fixing bug 232742 (patch by mozilla@rosenauer.org). Make Mozilla build and run on Linux/x86-64. r+sr=darin@meer.net, jst@mozilla.jstenback.com
This commit is contained in:
jst%mozilla.jstenback.com
Родитель
90dc121899
Коммит
fb995ba45f
|
|
@ -277,6 +277,9 @@ char *cpp_argv[ARGUMENTS] = {
|
|||
# ifdef __i386__
|
||||
"-D__i386__",
|
||||
# endif
|
||||
# ifdef __x86_64__
|
||||
"-D__x86_64__",
|
||||
# endif
|
||||
# ifdef __GNUC__
|
||||
"-traditional",
|
||||
# endif
|
||||
|
|
|
|||
|
|
@ -71,10 +71,15 @@ endif
|
|||
# Migrate other platforms here after testing
|
||||
#
|
||||
ifneq (,$(filter Linux,$(OS_ARCH)))
|
||||
# Linux/x86-64
|
||||
ifeq (x86_64,$(OS_TEST))
|
||||
CPPSRCS := xptcinvoke_x86_64_linux.cpp xptcstubs_x86_64_linux.cpp
|
||||
else
|
||||
ifeq (86,$(findstring 86,$(OS_TEST)))
|
||||
CPPSRCS := xptcinvoke_gcc_x86_unix.cpp xptcstubs_gcc_x86_unix.cpp
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
# IA64 Linux
|
||||
ifneq (,$(filter Linux,$(OS_ARCH)))
|
||||
ifneq (,$(findstring ia64,$(OS_TEST)))
|
||||
|
|
|
|||
|
|
@ -0,0 +1,211 @@
|
|||
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla 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/MPL/
|
||||
*
|
||||
* 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 the Initial Developer are Copyright (C) 1999
|
||||
* the Initial Developer. All Rights Reserved.
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of
|
||||
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
||||
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||||
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||||
* of those above. If you wish to allow use of your version of this file only
|
||||
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||||
* use your version of this file under the terms of the MPL, indicate your
|
||||
* decision by deleting the provisions above and replace them with the notice
|
||||
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||||
* the provisions above, a recipient may use your version of this file under
|
||||
* the terms of any one of the MPL, the GPL or the LGPL.
|
||||
*
|
||||
* ***** END LICENSE BLOCK ***** */
|
||||
|
||||
// Platform specific code to invoke XPCOM methods on native objects
|
||||
|
||||
#include "xptcprivate.h"
|
||||
|
||||
// 6 integral parameters are passed in registers
|
||||
const PRUint32 GPR_COUNT = 6;
|
||||
|
||||
// 8 floating point parameters are passed in SSE registers
|
||||
const PRUint32 FPR_COUNT = 8;
|
||||
|
||||
// Remember that these 'words' are 64-bit long
|
||||
static inline void
|
||||
invoke_count_words(PRUint32 paramCount, nsXPTCVariant * s,
|
||||
PRUint32 & nr_gpr, PRUint32 & nr_fpr, PRUint32 & nr_stack)
|
||||
{
|
||||
nr_gpr = 1; // skip one GP register for 'that'
|
||||
nr_fpr = 0;
|
||||
nr_stack = 0;
|
||||
|
||||
/* Compute number of eightbytes of class MEMORY. */
|
||||
for (uint32 i = 0; i < paramCount; i++, s++) {
|
||||
if (!s->IsPtrData()
|
||||
&& (s->type == nsXPTType::T_FLOAT || s->type == nsXPTType::T_DOUBLE)) {
|
||||
if (nr_fpr < FPR_COUNT)
|
||||
nr_fpr++;
|
||||
else
|
||||
nr_stack++;
|
||||
}
|
||||
else {
|
||||
if (nr_gpr < GPR_COUNT)
|
||||
nr_gpr++;
|
||||
else
|
||||
nr_stack++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
invoke_copy_to_stack(PRUint64 * d, PRUint32 paramCount, nsXPTCVariant * s,
|
||||
PRUint64 * gpregs, double * fpregs)
|
||||
{
|
||||
PRUint32 nr_gpr = 1; // skip one GP register for 'that'
|
||||
PRUint32 nr_fpr = 0;
|
||||
PRUint64 value;
|
||||
|
||||
for (uint32 i = 0; i < paramCount; i++, s++) {
|
||||
if (s->IsPtrData())
|
||||
value = (PRUint64) s->ptr;
|
||||
else {
|
||||
switch (s->type) {
|
||||
case nsXPTType::T_FLOAT: break;
|
||||
case nsXPTType::T_DOUBLE: break;
|
||||
case nsXPTType::T_I8: value = s->val.i8; break;
|
||||
case nsXPTType::T_I16: value = s->val.i16; break;
|
||||
case nsXPTType::T_I32: value = s->val.i32; break;
|
||||
case nsXPTType::T_I64: value = s->val.i64; break;
|
||||
case nsXPTType::T_U8: value = s->val.u8; break;
|
||||
case nsXPTType::T_U16: value = s->val.u16; break;
|
||||
case nsXPTType::T_U32: value = s->val.u32; break;
|
||||
case nsXPTType::T_U64: value = s->val.u64; break;
|
||||
case nsXPTType::T_BOOL: value = s->val.b; break;
|
||||
case nsXPTType::T_CHAR: value = s->val.c; break;
|
||||
case nsXPTType::T_WCHAR: value = s->val.wc; break;
|
||||
default: value = (PRUint64) s->val.p; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!s->IsPtrData() && s->type == nsXPTType::T_DOUBLE) {
|
||||
if (nr_fpr < FPR_COUNT)
|
||||
fpregs[nr_fpr++] = s->val.d;
|
||||
else {
|
||||
*((double *)d) = s->val.d;
|
||||
d++;
|
||||
}
|
||||
}
|
||||
else if (!s->IsPtrData() && s->type == nsXPTType::T_FLOAT) {
|
||||
if (nr_fpr < FPR_COUNT)
|
||||
// The value in %xmm register is already prepared to
|
||||
// be retrieved as a float. Therefore, we pass the
|
||||
// value verbatim, as a double without conversion.
|
||||
fpregs[nr_fpr++] = s->val.d;
|
||||
else {
|
||||
*((float *)d) = s->val.f;
|
||||
d++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (nr_gpr < GPR_COUNT)
|
||||
gpregs[nr_gpr++] = value;
|
||||
else
|
||||
*d++ = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C"
|
||||
XPTC_PUBLIC_API(nsresult)
|
||||
XPTC_InvokeByIndex(nsISupports * that, PRUint32 methodIndex,
|
||||
PRUint32 paramCount, nsXPTCVariant * params)
|
||||
{
|
||||
PRUint32 nr_gpr, nr_fpr, nr_stack;
|
||||
invoke_count_words(paramCount, params, nr_gpr, nr_fpr, nr_stack);
|
||||
|
||||
// Stack, if used, must be 16-bytes aligned
|
||||
if (nr_stack)
|
||||
nr_stack = (nr_stack + 1) & ~1;
|
||||
|
||||
// Load parameters to stack, if necessary
|
||||
PRUint64 *stack = (PRUint64 *) __builtin_alloca(nr_stack * 8);
|
||||
PRUint64 gpregs[GPR_COUNT];
|
||||
double fpregs[FPR_COUNT];
|
||||
invoke_copy_to_stack(stack, paramCount, params, gpregs, fpregs);
|
||||
|
||||
// Load FPR registers from fpregs[]
|
||||
register double d0 asm("xmm0");
|
||||
register double d1 asm("xmm1");
|
||||
register double d2 asm("xmm2");
|
||||
register double d3 asm("xmm3");
|
||||
register double d4 asm("xmm4");
|
||||
register double d5 asm("xmm5");
|
||||
register double d6 asm("xmm6");
|
||||
register double d7 asm("xmm7");
|
||||
|
||||
switch (nr_fpr) {
|
||||
#define ARG_FPR(N) \
|
||||
case N+1: d##N = fpregs[N];
|
||||
ARG_FPR(7);
|
||||
ARG_FPR(6);
|
||||
ARG_FPR(5);
|
||||
ARG_FPR(4);
|
||||
ARG_FPR(3);
|
||||
ARG_FPR(2);
|
||||
ARG_FPR(1);
|
||||
ARG_FPR(0);
|
||||
case 0:;
|
||||
#undef ARG_FPR
|
||||
}
|
||||
|
||||
// Load GPR registers from gpregs[]
|
||||
register PRUint64 a0 asm("rdi");
|
||||
register PRUint64 a1 asm("rsi");
|
||||
register PRUint64 a2 asm("rdx");
|
||||
register PRUint64 a3 asm("rcx");
|
||||
register PRUint64 a4 asm("r8");
|
||||
register PRUint64 a5 asm("r9");
|
||||
|
||||
switch (nr_gpr) {
|
||||
#define ARG_GPR(N) \
|
||||
case N+1: a##N = gpregs[N];
|
||||
ARG_GPR(5);
|
||||
ARG_GPR(4);
|
||||
ARG_GPR(3);
|
||||
ARG_GPR(2);
|
||||
ARG_GPR(1);
|
||||
case 1: a0 = (PRUint64) that;
|
||||
case 0:;
|
||||
#undef ARG_GPR
|
||||
}
|
||||
|
||||
// Ensure that assignments to SSE registers won't be optimized away
|
||||
asm("" ::
|
||||
"x" (d0), "x" (d1), "x" (d2), "x" (d3),
|
||||
"x" (d4), "x" (d5), "x" (d6), "x" (d7));
|
||||
|
||||
// Get pointer to method
|
||||
PRUint64 methodAddress = *((PRUint64 *)that);
|
||||
methodAddress += 8 * methodIndex;
|
||||
methodAddress = *((PRUint64 *)methodAddress);
|
||||
|
||||
typedef PRUint32 (*Method)(PRUint64, PRUint64, PRUint64, PRUint64, PRUint64, PRUint64);
|
||||
PRUint32 result = ((Method)methodAddress)(a0, a1, a2, a3, a4, a5);
|
||||
return result;
|
||||
}
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla 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/MPL/
|
||||
*
|
||||
* 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 the Initial Developer are Copyright (C) 1999
|
||||
* the Initial Developer. All Rights Reserved.
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of
|
||||
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
||||
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||||
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||||
* of those above. If you wish to allow use of your version of this file only
|
||||
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||||
* use your version of this file under the terms of the MPL, indicate your
|
||||
* decision by deleting the provisions above and replace them with the notice
|
||||
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||||
* the provisions above, a recipient may use your version of this file under
|
||||
* the terms of any one of the MPL, the GPL or the LGPL.
|
||||
*
|
||||
* ***** END LICENSE BLOCK ***** */
|
||||
|
||||
// Implement shared vtbl methods.
|
||||
|
||||
#include "xptcprivate.h"
|
||||
|
||||
// The Linux/x86-64 ABI passes the first 6 integer parameters and the
|
||||
// first 8 floating point parameters in registers (rdi, rsi, rdx, rcx,
|
||||
// r8, r9 and xmm0-xmm7), no stack space is allocated for these by the
|
||||
// caller. The rest of the parameters are passed in the callers stack
|
||||
// area.
|
||||
|
||||
const PRUint32 PARAM_BUFFER_COUNT = 16;
|
||||
const PRUint32 GPR_COUNT = 6;
|
||||
const PRUint32 FPR_COUNT = 8;
|
||||
|
||||
// PrepareAndDispatch() is called by SharedStub() and calls the actual method.
|
||||
//
|
||||
// - 'args[]' contains the arguments passed on stack
|
||||
// - 'gpregs[]' contains the arguments passed in integer registers
|
||||
// - 'fpregs[]' contains the arguments passed in floating point registers
|
||||
//
|
||||
// The parameters are mapped into an array of type 'nsXPTCMiniVariant'
|
||||
// and then the method gets called.
|
||||
|
||||
extern "C" nsresult
|
||||
PrepareAndDispatch(nsXPTCStubBase * self, PRUint32 methodIndex,
|
||||
PRUint64 * args, PRUint64 * gpregs, double *fpregs)
|
||||
{
|
||||
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
|
||||
nsXPTCMiniVariant* dispatchParams = NULL;
|
||||
nsIInterfaceInfo* iface_info = NULL;
|
||||
const nsXPTMethodInfo* info;
|
||||
PRUint32 paramCount;
|
||||
PRUint32 i;
|
||||
nsresult result = NS_ERROR_FAILURE;
|
||||
|
||||
NS_ASSERTION(self,"no self");
|
||||
|
||||
self->GetInterfaceInfo(&iface_info);
|
||||
NS_ASSERTION(iface_info,"no interface info");
|
||||
if (!iface_info)
|
||||
return NS_ERROR_UNEXPECTED;
|
||||
|
||||
iface_info->GetMethodInfo(PRUint16(methodIndex), &info);
|
||||
NS_ASSERTION(info,"no method info");
|
||||
if (!info)
|
||||
return NS_ERROR_UNEXPECTED;
|
||||
|
||||
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");
|
||||
if (!dispatchParams)
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
|
||||
PRUint64* ap = args;
|
||||
PRUint32 nr_gpr = 1; // skip one GPR register for 'that'
|
||||
PRUint32 nr_fpr = 0;
|
||||
PRUint64 value;
|
||||
|
||||
for (i = 0; i < paramCount; i++) {
|
||||
const nsXPTParamInfo& param = info->GetParam(i);
|
||||
const nsXPTType& type = param.GetType();
|
||||
nsXPTCMiniVariant* dp = &dispatchParams[i];
|
||||
|
||||
if (!param.IsOut() && type == nsXPTType::T_DOUBLE) {
|
||||
if (nr_fpr < FPR_COUNT)
|
||||
dp->val.d = fpregs[nr_fpr++];
|
||||
else
|
||||
dp->val.d = *(double*) ap++;
|
||||
continue;
|
||||
}
|
||||
else if (!param.IsOut() && type == nsXPTType::T_FLOAT) {
|
||||
if (nr_fpr < FPR_COUNT)
|
||||
// The value in %xmm register is already prepared to
|
||||
// be retrieved as a float. Therefore, we pass the
|
||||
// value verbatim, as a double without conversion.
|
||||
dp->val.d = *(double*) ap++;
|
||||
else
|
||||
dp->val.f = *(float*) ap++;
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if (nr_gpr < GPR_COUNT)
|
||||
value = gpregs[nr_gpr++];
|
||||
else
|
||||
value = *ap++;
|
||||
}
|
||||
|
||||
if (param.IsOut() || !type.IsArithmetic()) {
|
||||
dp->val.p = (void*) value;
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case nsXPTType::T_I8: dp->val.i8 = (PRInt8) value; break;
|
||||
case nsXPTType::T_I16: dp->val.i16 = (PRInt16) value; break;
|
||||
case nsXPTType::T_I32: dp->val.i32 = (PRInt32) value; break;
|
||||
case nsXPTType::T_I64: dp->val.i64 = (PRInt64) value; break;
|
||||
case nsXPTType::T_U8: dp->val.u8 = (PRUint8) value; break;
|
||||
case nsXPTType::T_U16: dp->val.u16 = (PRUint16) value; break;
|
||||
case nsXPTType::T_U32: dp->val.u32 = (PRUint32) value; break;
|
||||
case nsXPTType::T_U64: dp->val.u64 = (PRUint64) value; break;
|
||||
case nsXPTType::T_BOOL: dp->val.b = (PRBool) value; break;
|
||||
case nsXPTType::T_CHAR: dp->val.c = (char) value; break;
|
||||
case nsXPTType::T_WCHAR: dp->val.wc = (wchar_t) value; 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;
|
||||
}
|
||||
|
||||
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */
|
||||
// Linux/x86-64 uses gcc >= 3.1
|
||||
#define STUB_ENTRY(n) \
|
||||
asm(".section \".text\"\n\t" \
|
||||
".align 2\n\t" \
|
||||
".if " #n " < 10\n\t" \
|
||||
".globl _ZN14nsXPTCStubBase5Stub" #n "Ev\n\t" \
|
||||
".type _ZN14nsXPTCStubBase5Stub" #n "Ev,@function\n" \
|
||||
"_ZN14nsXPTCStubBase5Stub" #n "Ev:\n\t" \
|
||||
".elseif " #n " < 100\n\t" \
|
||||
".globl _ZN14nsXPTCStubBase6Stub" #n "Ev\n\t" \
|
||||
".type _ZN14nsXPTCStubBase6Stub" #n "Ev,@function\n" \
|
||||
"_ZN14nsXPTCStubBase6Stub" #n "Ev:\n\t" \
|
||||
".elseif " #n " < 1000\n\t" \
|
||||
".globl _ZN14nsXPTCStubBase7Stub" #n "Ev\n\t" \
|
||||
".type _ZN14nsXPTCStubBase7Stub" #n "Ev,@function\n" \
|
||||
"_ZN14nsXPTCStubBase7Stub" #n "Ev:\n\t" \
|
||||
".else\n\t" \
|
||||
".err \"stub number " #n " >= 1000 not yet supported\"\n\t" \
|
||||
".endif\n\t" \
|
||||
"movl $" #n ", %eax\n\t" \
|
||||
"jmp SharedStub\n\t" \
|
||||
".if " #n " < 10\n\t" \
|
||||
".size _ZN14nsXPTCStubBase5Stub" #n "Ev,.-_ZN14nsXPTCStubBase5Stub" #n "Ev\n\t" \
|
||||
".elseif " #n " < 100\n\t" \
|
||||
".size _ZN14nsXPTCStubBase6Stub" #n "Ev,.-_ZN14nsXPTCStubBase6Stub" #n "Ev\n\t" \
|
||||
".else\n\t" \
|
||||
".size _ZN14nsXPTCStubBase7Stub" #n "Ev,.-_ZN14nsXPTCStubBase7Stub" #n "Ev\n\t" \
|
||||
".endif");
|
||||
|
||||
// static nsresult SharedStub(PRUint32 methodIndex)
|
||||
asm(".section \".text\"\n\t"
|
||||
".align 2\n\t"
|
||||
".type SharedStub,@function\n\t"
|
||||
"SharedStub:\n\t"
|
||||
// make room for gpregs (48), fpregs (64)
|
||||
"pushq %rbp\n\t"
|
||||
"movq %rsp,%rbp\n\t"
|
||||
"subq $112,%rsp\n\t"
|
||||
// save GP registers
|
||||
"movq %rdi,-112(%rbp)\n\t"
|
||||
"movq %rsi,-104(%rbp)\n\t"
|
||||
"movq %rdx, -96(%rbp)\n\t"
|
||||
"movq %rcx, -88(%rbp)\n\t"
|
||||
"movq %r8 , -80(%rbp)\n\t"
|
||||
"movq %r9 , -72(%rbp)\n\t"
|
||||
"leaq -112(%rbp),%rcx\n\t"
|
||||
// save FP registers
|
||||
"movsd %xmm0,-64(%rbp)\n\t"
|
||||
"movsd %xmm1,-56(%rbp)\n\t"
|
||||
"movsd %xmm2,-48(%rbp)\n\t"
|
||||
"movsd %xmm3,-40(%rbp)\n\t"
|
||||
"movsd %xmm4,-32(%rbp)\n\t"
|
||||
"movsd %xmm5,-24(%rbp)\n\t"
|
||||
"movsd %xmm6,-16(%rbp)\n\t"
|
||||
"movsd %xmm7, -8(%rbp)\n\t"
|
||||
"leaq -64(%rbp),%r8\n\t"
|
||||
// rdi has the 'self' pointer already
|
||||
"movl %eax,%esi\n\t"
|
||||
"leaq 16(%rbp),%rdx\n\t"
|
||||
"call PrepareAndDispatch@plt\n\t"
|
||||
"leave\n\t"
|
||||
"ret\n\t"
|
||||
".size SharedStub,.-SharedStub");
|
||||
|
||||
#define SENTINEL_ENTRY(n) \
|
||||
nsresult nsXPTCStubBase::Sentinel##n() \
|
||||
{ \
|
||||
NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
|
||||
return NS_ERROR_NOT_IMPLEMENTED; \
|
||||
}
|
||||
|
||||
#include "xptcstubsdef.inc"
|
||||
|
||||
#else
|
||||
#error "Unsupported compiler. Use gcc >= 3.1 for Linux/x86-64."
|
||||
#endif /* __GNUC__ */
|
||||
|
|
@ -87,6 +87,19 @@ public:
|
|||
float p17, float p18, float p19, float p20,
|
||||
float *retval) = 0;
|
||||
|
||||
NS_IMETHOD AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4,
|
||||
PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8,
|
||||
PRInt64 p9, PRInt32 p10, PRInt64* retval) = 0;
|
||||
|
||||
NS_IMETHOD AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4,
|
||||
PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8,
|
||||
PRInt32 p9, PRInt64 p10, PRInt64* retval) = 0;
|
||||
|
||||
NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4,
|
||||
float p5, float p6, double p7, double p8,
|
||||
float p9, double p10, float p11,
|
||||
double *retval) = 0;
|
||||
|
||||
NS_IMETHOD PassTwoStrings(const char* s1, const char* s2, char** retval) = 0;
|
||||
|
||||
};
|
||||
|
|
@ -114,6 +127,19 @@ public:
|
|||
float p5, float p6, float p7, float p8,
|
||||
float p9, float p10, float* retval);
|
||||
|
||||
NS_IMETHOD AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4,
|
||||
PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8,
|
||||
PRInt64 p9, PRInt32 p10, PRInt64* retval);
|
||||
|
||||
NS_IMETHOD AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4,
|
||||
PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8,
|
||||
PRInt32 p9, PRInt64 p10, PRInt64* retval);
|
||||
|
||||
NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4,
|
||||
float p5, float p6, double p7, double p8,
|
||||
float p9, double p10, float p11,
|
||||
double *retval);
|
||||
|
||||
NS_IMETHOD AddManyManyFloats(float p1, float p2, float p3, float p4,
|
||||
float p5, float p6, float p7, float p8,
|
||||
float p9, float p10, float p11, float p12,
|
||||
|
|
@ -210,6 +236,20 @@ InvokeTestTarget::AddManyFloats(float p1, float p2, float p3, float p4,
|
|||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
InvokeTestTarget::AddMixedFloats(float p1, float p2, double p3, double p4,
|
||||
float p5, float p6, double p7, double p8,
|
||||
float p9, double p10, float p11,
|
||||
double *retval)
|
||||
{
|
||||
#ifdef DEBUG_TESTINVOKE
|
||||
printf("%f, %f, %lf, %lf, %f, %f, %lf, %lf, %f, %lf, %f\n",
|
||||
p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
|
||||
#endif
|
||||
*retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10 + p11;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
InvokeTestTarget::AddManyManyFloats(float p1, float p2, float p3, float p4,
|
||||
float p5, float p6, float p7, float p8,
|
||||
|
|
@ -229,6 +269,24 @@ InvokeTestTarget::AddManyManyFloats(float p1, float p2, float p3, float p4,
|
|||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
InvokeTestTarget::AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4,
|
||||
PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8,
|
||||
PRInt64 p9, PRInt32 p10, PRInt64* retval)
|
||||
{
|
||||
*retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
InvokeTestTarget::AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4,
|
||||
PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8,
|
||||
PRInt32 p9, PRInt64 p10, PRInt64* retval)
|
||||
{
|
||||
*retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
InvokeTestTarget::PassTwoStrings(const char* s1, const char* s2, char** retval)
|
||||
{
|
||||
|
|
@ -309,14 +367,33 @@ int main()
|
|||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
if(NS_SUCCEEDED(test->AddMixedInts(1,2,3,4,5,6,7,8,9,10,&out64)))
|
||||
{
|
||||
LL_L2I(tmp32, out64);
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", (int)tmp32);
|
||||
}
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
if(NS_SUCCEEDED(test->AddMixedInts2(1,2,3,4,5,6,7,8,9,10,&out64)))
|
||||
{
|
||||
LL_L2I(tmp32, out64);
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", (int)tmp32);
|
||||
}
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
if(NS_SUCCEEDED(test->AddMixedFloats(1,2,3,4,5,6,7,8,9,10,11,&outD)))
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n", (double)outD);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
if (NS_SUCCEEDED(test->PassTwoStrings("moo","cow",&outS))) {
|
||||
printf(" = %s\n", outS);
|
||||
nsMemory::Free(outS);
|
||||
} else
|
||||
printf("\tFAILED");
|
||||
|
||||
|
||||
|
||||
printf("calling via invoke:\n");
|
||||
|
||||
nsXPTCVariant var[21];
|
||||
|
|
@ -559,6 +636,8 @@ int main()
|
|||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 10, 11, var)))
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %ff\n",
|
||||
(double) var[10].val.f);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
var[0].val.f = 1.0f;
|
||||
var[0].type = nsXPTType::T_FLOAT;
|
||||
|
|
@ -649,6 +728,163 @@ int main()
|
|||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 = %ff\n",
|
||||
(double) var[20].val.f);
|
||||
|
||||
var[0].val.i64 = 1;
|
||||
var[0].type = nsXPTType::T_I64;
|
||||
var[0].flags = 0;
|
||||
|
||||
var[1].val.i32 = 2;
|
||||
var[1].type = nsXPTType::T_I32;
|
||||
var[1].flags = 0;
|
||||
|
||||
var[2].val.i64 = 3;
|
||||
var[2].type = nsXPTType::T_I64;
|
||||
var[2].flags = 0;
|
||||
|
||||
var[3].val.i32 = 4;
|
||||
var[3].type = nsXPTType::T_I32;
|
||||
var[3].flags = 0;
|
||||
|
||||
var[4].val.i32 = 5;
|
||||
var[4].type = nsXPTType::T_I32;
|
||||
var[4].flags = 0;
|
||||
|
||||
var[5].val.i64 = 6;
|
||||
var[5].type = nsXPTType::T_I64;
|
||||
var[5].flags = 0;
|
||||
|
||||
var[6].val.i32 = 7;
|
||||
var[6].type = nsXPTType::T_I32;
|
||||
var[6].flags = 0;
|
||||
|
||||
var[7].val.i32 = 8;
|
||||
var[7].type = nsXPTType::T_I32;
|
||||
var[7].flags = 0;
|
||||
|
||||
var[8].val.i64 = 9;
|
||||
var[8].type = nsXPTType::T_I64;
|
||||
var[8].flags = 0;
|
||||
|
||||
var[9].val.i32 = 10;
|
||||
var[9].type = nsXPTType::T_I32;
|
||||
var[9].flags = 0;
|
||||
|
||||
var[10].val.i64 = 0;
|
||||
var[10].type = nsXPTType::T_I64;
|
||||
var[10].flags = nsXPTCVariant::PTR_IS_DATA;
|
||||
var[10].ptr = &var[10].val.i64;
|
||||
|
||||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 12, 11, var)))
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n",
|
||||
(int)var[10].val.i64);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
var[0].val.i32 = 1;
|
||||
var[0].type = nsXPTType::T_I32;
|
||||
var[0].flags = 0;
|
||||
|
||||
var[1].val.i64 = 2;
|
||||
var[1].type = nsXPTType::T_I64;
|
||||
var[1].flags = 0;
|
||||
|
||||
var[2].val.i32 = 3;
|
||||
var[2].type = nsXPTType::T_I32;
|
||||
var[2].flags = 0;
|
||||
|
||||
var[3].val.i64 = 4;
|
||||
var[3].type = nsXPTType::T_I64;
|
||||
var[3].flags = 0;
|
||||
|
||||
var[4].val.i64 = 5;
|
||||
var[4].type = nsXPTType::T_I64;
|
||||
var[4].flags = 0;
|
||||
|
||||
var[5].val.i32 = 6;
|
||||
var[5].type = nsXPTType::T_I32;
|
||||
var[5].flags = 0;
|
||||
|
||||
var[6].val.i64 = 7;
|
||||
var[6].type = nsXPTType::T_I64;
|
||||
var[6].flags = 0;
|
||||
|
||||
var[7].val.i64 = 8;
|
||||
var[7].type = nsXPTType::T_I64;
|
||||
var[7].flags = 0;
|
||||
|
||||
var[8].val.i32 = 9;
|
||||
var[8].type = nsXPTType::T_I32;
|
||||
var[8].flags = 0;
|
||||
|
||||
var[9].val.i64 = 10;
|
||||
var[9].type = nsXPTType::T_I64;
|
||||
var[9].flags = 0;
|
||||
|
||||
var[10].val.i64 = 0;
|
||||
var[10].type = nsXPTType::T_I64;
|
||||
var[10].flags = nsXPTCVariant::PTR_IS_DATA;
|
||||
var[10].ptr = &var[10].val.i64;
|
||||
|
||||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 13, 11, var)))
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n",
|
||||
(int)var[10].val.i64);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
var[0].val.f = 1.0f;
|
||||
var[0].type = nsXPTType::T_FLOAT;
|
||||
var[0].flags = 0;
|
||||
|
||||
var[1].val.f = 2.0f;
|
||||
var[1].type = nsXPTType::T_FLOAT;
|
||||
var[1].flags = 0;
|
||||
|
||||
var[2].val.d = 3.0;
|
||||
var[2].type = nsXPTType::T_DOUBLE;
|
||||
var[2].flags = 0;
|
||||
|
||||
var[3].val.d = 4.0;
|
||||
var[3].type = nsXPTType::T_DOUBLE;
|
||||
var[3].flags = 0;
|
||||
|
||||
var[4].val.f = 5.0f;
|
||||
var[4].type = nsXPTType::T_FLOAT;
|
||||
var[4].flags = 0;
|
||||
|
||||
var[5].val.f = 6.0f;
|
||||
var[5].type = nsXPTType::T_FLOAT;
|
||||
var[5].flags = 0;
|
||||
|
||||
var[6].val.d = 7.0;
|
||||
var[6].type = nsXPTType::T_DOUBLE;
|
||||
var[6].flags = 0;
|
||||
|
||||
var[7].val.d = 8.0;
|
||||
var[7].type = nsXPTType::T_DOUBLE;
|
||||
var[7].flags = 0;
|
||||
|
||||
var[8].val.f = 9.0f;
|
||||
var[8].type = nsXPTType::T_FLOAT;
|
||||
var[8].flags = 0;
|
||||
|
||||
var[9].val.d = 10.0;
|
||||
var[9].type = nsXPTType::T_DOUBLE;
|
||||
var[9].flags = 0;
|
||||
|
||||
var[10].val.f = 11.0f;
|
||||
var[10].type = nsXPTType::T_FLOAT;
|
||||
var[10].flags = 0;
|
||||
|
||||
var[11].val.d = 0.0;
|
||||
var[11].type = nsXPTType::T_DOUBLE;
|
||||
var[11].flags = nsXPTCVariant::PTR_IS_DATA;
|
||||
var[11].ptr = &var[11].val.d;
|
||||
|
||||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 14, 12, var)))
|
||||
printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n",
|
||||
var[11].val.d);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
var[0].val.p = (void*)"moo";
|
||||
var[0].type = nsXPTType::T_CHAR_STR;
|
||||
var[0].flags = 0;
|
||||
|
|
@ -662,12 +898,11 @@ int main()
|
|||
var[2].flags = nsXPTCVariant::PTR_IS_DATA;
|
||||
var[2].ptr = &var[2].val.p;
|
||||
|
||||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 12, 3, var)))
|
||||
if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 15, 3, var)))
|
||||
printf(" = %s\n", var[2].val.p);
|
||||
else
|
||||
printf("\tFAILED");
|
||||
|
||||
|
||||
DoMultipleInheritenceTest();
|
||||
DoMultipleInheritenceTest2();
|
||||
// Disabled by default - takes too much time on slow machines
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче