nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1477048 - part 2 - remove non-ipc/chromium moz.build uses of OS_TEST; r=gps

Browse source 
The deletions in xptcall are when we don't even have support for the CPU
in moz.configure, so I assume that people haven't been compiling on
those architectures for quite some time.
This commit is contained in:
Nathan Froyd 2018-07-24 16:08:56 -04:00
parent 5158597854
commit 309ddc0be2
14 changed files with 43 additions and 1017 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
config/external/ffi/moz.build vendored
View file

@ -110,7 +110,7 @@ else:
SOURCES += ['!win64.asm']
elif CONFIG['FFI_TARGET'] == 'X86_DARWIN':
DEFINES['FFI_MMAP_EXEC_WRIT'] = True
if CONFIG['OS_TEST'] != 'x86_64':
if CONFIG['CPU_ARCH'] == 'x86':
ffi_srcs = ('ffi.c', 'darwin.S', 'ffi64.c', 'darwin64.S',
'win32.S')
DEFINES['SYMBOL_UNDERSCORE'] = True

6
gfx/cairo/libpixman/src/moz.build
View file

@ -84,19 +84,19 @@ use_arm_simd_gcc = False
use_arm_neon_gcc = False
if CONFIG['INTEL_ARCHITECTURE']:
use_sse2 = True
if '64' not in CONFIG['OS_TEST']:
if CONFIG['CPU_ARCH'] == 'x86':
if CONFIG['CC_TYPE'] in ('msvc', 'clang-cl'):
use_mmx = True
if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
use_mmx = True
elif 'ppc' in CONFIG['OS_TEST']:
elif CONFIG['CPU_ARCH'] in ('ppc', 'ppc64'):
if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
use_vmx = True
# Apple's arm assembler doesn't support the same syntax as
# the standard GNU assembler, so use the C fallback paths for now.
# This may be fixable if clang's ARM/iOS assembler improves into a
# viable solution in the future.
elif 'arm' in CONFIG['OS_TEST']:
elif CONFIG['CPU_ARCH'] == 'arm':
if CONFIG['OS_ARCH'] != 'Darwin':
if CONFIG['HAVE_ARM_SIMD']:
use_arm_simd_gcc = True

2
gfx/qcms/moz.build
View file

@ -28,7 +28,7 @@ use_altivec = False
if CONFIG['INTEL_ARCHITECTURE']:
use_sse2 = True
if CONFIG['CC_TYPE'] in ('msvc', 'clang-cl'):
if CONFIG['OS_ARCH'] != 'WINNT' or CONFIG['OS_TEST'] != 'x86_64':
if CONFIG['OS_ARCH'] != 'WINNT' or CONFIG['CPU_ARCH'] != 'x86_64':
use_sse1 = True
else:
use_sse1 = True

4
gfx/ycbcr/moz.build
View file

@ -25,7 +25,7 @@ if CONFIG['INTEL_ARCHITECTURE']:
# MSVC doesn't support MMX when targeting AMD64.
if CONFIG['CC_TYPE'] in ('msvc', 'clang-cl'):
if CONFIG['OS_TEST'] != 'x86_64':
if CONFIG['CPU_ARCH'] == 'x86':
SOURCES += [
'yuv_convert_mmx.cpp',
]
@ -34,7 +34,7 @@ if CONFIG['INTEL_ARCHITECTURE']:
SOURCES['yuv_convert_mmx.cpp'].flags += CONFIG['MMX_FLAGS']
if CONFIG['CC_TYPE'] in ('msvc', 'clang-cl'):
if CONFIG['OS_TEST'] == 'x86_64' or CONFIG['CC_TYPE'] == 'clang-cl':
if CONFIG['CPU_ARCH'] == 'x86_64' or CONFIG['CC_TYPE'] == 'clang-cl':
SOURCES += [
'yuv_row_win64.cpp',
]

8
media/libtheora/moz.build
View file

@ -53,15 +53,15 @@ if CONFIG['INTEL_ARCHITECTURE']:
if CONFIG['CC_TYPE'] == 'clang-cl':
# clang-cl can't handle libtheora's inline asm.
pass
elif CONFIG['OS_ARCH'] != 'WINNT' or CONFIG['OS_TEST'] != 'x86_64':
elif CONFIG['OS_ARCH'] != 'WINNT' or CONFIG['CPU_ARCH'] != 'x86_64':
DEFINES['OC_X86_ASM'] = True
if '64' in CONFIG['OS_TEST']:
if CONFIG['CPU_ARCH'] == 'x86_64':
DEFINES['OC_X86_64_ASM'] = True
if CONFIG['CC_TYPE'] in ('msvc', 'clang-cl'):
if CONFIG['CC_TYPE'] == 'clang-cl':
# clang-cl can't handle libtheora's inline asm.
pass
elif '64' not in CONFIG['OS_TEST']:
elif CONFIG['CPU_ARCH'] == 'x86':
SOURCES += [
'lib/x86_vc/mmxfrag.c',
'lib/x86_vc/mmxidct.c',
@ -80,7 +80,7 @@ if CONFIG['INTEL_ARCHITECTURE']:
]
if CONFIG['GNU_AS']:
if 'arm' in CONFIG['OS_TEST']:
if CONFIG['CPU_ARCH'] == 'arm':
SOURCES += [
'lib/arm/armcpu.c',
'lib/arm/armstate.c',

87
xpcom/reflect/xptcall/md/unix/moz.build
View file

@ -9,12 +9,12 @@ if CONFIG['OS_ARCH'] == 'Darwin':
'xptcinvoke_darwin.cpp',
'xptcstubs_darwin.cpp',
]
if CONFIG['OS_TEST'] == 'powerpc':
if CONFIG['CPU_ARCH'] == 'ppc':
SOURCES += [
'!xptcstubs_asm_ppc_darwin.s',
'xptcinvoke_asm_ppc_rhapsody.s',
]
if CONFIG['OS_TEST'] == 'x86_64':
if CONFIG['CPU_ARCH'] == 'x86_64':
SOURCES += [
'xptcinvoke_asm_x86_64_unix.S',
]
@ -28,20 +28,20 @@ if CONFIG['OS_ARCH'] == 'GNU':
if CONFIG['OS_ARCH'] in ('Linux', 'Bitrig', 'DragonFly', 'FreeBSD', 'NetBSD', 'OpenBSD') or \
CONFIG['OS_ARCH'].startswith('GNU_'):
if CONFIG['OS_TEST'] == 'x86_64':
if CONFIG['CPU_ARCH'] == 'x86_64':
SOURCES += [
'xptcinvoke_asm_x86_64_unix.S',
'xptcinvoke_x86_64_unix.cpp',
'xptcstubs_x86_64_linux.cpp',
]
elif '86' in CONFIG['OS_TEST']:
elif CONFIG['CPU_ARCH'] == 'x86':
SOURCES += [
'xptcinvoke_gcc_x86_unix.cpp',
'xptcstubs_gcc_x86_unix.cpp'
]
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):
if 'ia64' in CONFIG['OS_TEST']:
if CONFIG['CPU_ARCH'] == 'ia64':
SOURCES += [
'xptcinvoke_asm_ipf64.s',
'xptcinvoke_ipf64.cpp',
@ -50,7 +50,7 @@ if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):
]
if CONFIG['OS_ARCH'] == 'SunOS' and CONFIG['INTEL_ARCHITECTURE']:
if CONFIG['OS_TEST'] == 'x86_64':
if CONFIG['CPU_ARCH'] == 'x86_64':
if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
SOURCES += [
'xptcinvoke_asm_x86_64_unix.S',
@ -84,7 +84,7 @@ if CONFIG['OS_ARCH'] == 'SunOS' and CONFIG['INTEL_ARCHITECTURE']:
'xptcstubs_x86_solaris.cpp'
]
if CONFIG['OS_TEST'] == 'alpha':
if CONFIG['CPU_ARCH'] == 'Alpha':
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD', 'NetBSD'):
SOURCES += [
'xptcinvoke_linux_alpha.cpp',
@ -96,7 +96,7 @@ if CONFIG['OS_TEST'] == 'alpha':
'xptcstubs_alpha_openbsd.cpp',
]
if CONFIG['CPU_ARCH'] == 'arm' or CONFIG['OS_TEST'] == 'sa110':
if CONFIG['CPU_ARCH'] == 'arm':
if CONFIG['OS_ARCH'] == 'Linux':
SOURCES += [
'xptcinvoke_arm.cpp',
@ -117,7 +117,7 @@ if CONFIG['CPU_ARCH'] == 'arm' and CONFIG['OS_ARCH'] in ('Bitrig', 'OpenBSD'):
if CONFIG['OS_ARCH'] == 'HP-UX':
if CONFIG['CC'] != 'gcc':
if CONFIG['OS_TEST'] == 'ia64':
if CONFIG['CPU_ARCH'] == 'ia64':
SOURCES += [
'xptcinvoke_asm_ipf32.s',
'xptcinvoke_ipf32.cpp',
@ -133,7 +133,7 @@ if CONFIG['OS_ARCH'] == 'HP-UX':
]
if CONFIG['OS_ARCH'] == 'Linux':
if CONFIG['OS_TEST'] in ('hppa', 'hppa2.0', 'hppa1.1'):
if CONFIG['CPU_ARCH'] == 'hppa':
if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
SOURCES += [
'xptcinvoke_asm_parisc_linux.s',
@ -144,42 +144,28 @@ if CONFIG['OS_ARCH'] == 'Linux':
elif CONFIG['COMPILE_ENVIRONMENT']:
error('Unknown C++ compiler, xptcall assembly will probably be incorrect.')
if CONFIG['OS_ARCH'] == 'NetBSD':
if CONFIG['OS_TEST'] in ('amiga', 'atari', 'hp300', 'mac68k', 'mvme68k',
'next68k', 'sun3', 'sun3x', 'x68k'):
SOURCES += [
'xptcinvoke_netbsd_m68k.cpp',
'xptcstubs_netbsd_m68k.cpp'
]
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD', 'NetBSD', 'OpenBSD'):
if CONFIG['OS_TEST'] == 'aarch64':
if CONFIG['CPU_ARCH'] == 'aarch64':
SOURCES += [
'xptcinvoke_aarch64.cpp',
'xptcinvoke_asm_aarch64.s',
'xptcstubs_aarch64.cpp',
'xptcstubs_asm_aarch64.s',
]
if CONFIG['OS_TEST'] == 'm68k':
if CONFIG['CPU_ARCH'] == 'mips64':
SOURCES += [
'xptcinvoke_linux_m68k.cpp',
'xptcstubs_linux_m68k.cpp',
'xptcinvoke_asm_mips64.S',
'xptcinvoke_mips64.cpp',
'xptcstubs_asm_mips64.S',
'xptcstubs_mips64.cpp',
]
if CONFIG['CPU_ARCH'] == 'mips32':
SOURCES += [
'xptcinvoke_asm_mips.S',
'xptcinvoke_mips.cpp',
'xptcstubs_asm_mips.S',
'xptcstubs_mips.cpp',
]
if 'mips' in CONFIG['OS_TEST']:
if 'mips64' in CONFIG['OS_TEST']:
SOURCES += [
'xptcinvoke_asm_mips64.S',
'xptcinvoke_mips64.cpp',
'xptcstubs_asm_mips64.S',
'xptcstubs_mips64.cpp',
]
else:
SOURCES += [
'xptcinvoke_asm_mips.S',
'xptcinvoke_mips.cpp',
'xptcstubs_asm_mips.S',
'xptcstubs_mips.cpp',
]
if CONFIG['OS_ARCH'] == 'AIX':
if CONFIG['HAVE_64BIT_BUILD']:
@ -204,7 +190,7 @@ if CONFIG['OS_ARCH'] == 'AIX':
'xptcinvoke_asm_ppc_aix.s',
]
if CONFIG['OS_TEST'] == 'powerpc':
if CONFIG['CPU_ARCH'] == 'ppc':
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):
SOURCES += [
'xptcinvoke_asm_ppc_linux.S',
@ -213,7 +199,7 @@ if CONFIG['OS_TEST'] == 'powerpc':
'xptcstubs_ppc_linux.cpp',
]
if CONFIG['OS_TEST'] in ('powerpc64', 'powerpc64le'):
if CONFIG['CPU_ARCH'] == 'ppc64':
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):
SOURCES += [
'xptcinvoke_asm_ppc64_linux.S',
@ -222,16 +208,7 @@ if CONFIG['OS_TEST'] in ('powerpc64', 'powerpc64le'):
'xptcstubs_ppc64_linux.cpp',
]
if CONFIG['OS_TEST'] in ('macppc', 'bebox', 'ofppc', 'prep', 'amigappc'):
if CONFIG['OS_ARCH'] == 'NetBSD':
SOURCES += [
'xptcinvoke_asm_ppc_netbsd.s',
'xptcinvoke_ppc_netbsd.cpp',
'xptcstubs_asm_ppc_netbsd.s',
'xptcstubs_ppc_netbsd.cpp',
]
if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['OS_TEST'] == 'powerpc':
if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['CPU_ARCH'] == 'ppc':
SOURCES += [
'xptcinvoke_asm_ppc_openbsd.S',
'xptcinvoke_ppc_openbsd.cpp',
@ -239,7 +216,7 @@ if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['OS_TEST'] == 'powerpc':
'xptcstubs_ppc_openbsd.cpp',
]
if CONFIG['OS_ARCH'] == 'Linux' and CONFIG['OS_TEST'] == 'sparc':
if CONFIG['OS_ARCH'] == 'Linux' and CONFIG['CPU_ARCH'] == 'sparc':
SOURCES += [
'xptcinvoke_asm_sparc_linux_GCC3.s',
'xptcinvoke_sparc_solaris.cpp',
@ -247,7 +224,7 @@ if CONFIG['OS_ARCH'] == 'Linux' and CONFIG['OS_TEST'] == 'sparc':
'xptcstubs_sparc_solaris.cpp',
]
if CONFIG['OS_ARCH'] == 'NetBSD' and CONFIG['OS_TEST'] == 'sparc':
if CONFIG['OS_ARCH'] == 'NetBSD' and CONFIG['CPU_ARCH'] == 'sparc':
SOURCES += [
'xptcinvoke_asm_sparc_netbsd.s',
'xptcinvoke_sparc_netbsd.cpp',
@ -255,7 +232,7 @@ if CONFIG['OS_ARCH'] == 'NetBSD' and CONFIG['OS_TEST'] == 'sparc':
'xptcstubs_sparc_netbsd.cpp',
]
if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['OS_TEST'] == 'sparc':
if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['CPU_ARCH'] == 'sparc':
SOURCES += [
'xptcinvoke_asm_sparc_openbsd.s',
'xptcinvoke_sparc_openbsd.cpp',
@ -263,7 +240,7 @@ if CONFIG['OS_ARCH'] == 'OpenBSD' and CONFIG['OS_TEST'] == 'sparc':
'xptcstubs_sparc_openbsd.cpp',
]
if CONFIG['OS_ARCH'] in ('OpenBSD', 'FreeBSD', 'Linux') and CONFIG['OS_TEST'] == 'sparc64':
if CONFIG['OS_ARCH'] in ('OpenBSD', 'FreeBSD', 'Linux') and CONFIG['CPU_ARCH'] == 'sparc64':
SOURCES += [
'xptcinvoke_asm_sparc64_openbsd.s',
'xptcinvoke_sparc64_openbsd.cpp',
@ -301,7 +278,7 @@ if CONFIG['OS_ARCH'] == 'SunOS' and not CONFIG['INTEL_ARCHITECTURE']:
]
if CONFIG['OS_ARCH'] == 'Linux':
if CONFIG['OS_TEST'] == 's390':
if CONFIG['CPU_ARCH'] == 's390':
SOURCES += [
'xptcinvoke_linux_s390.cpp',
'xptcstubs_linux_s390.cpp',
@ -312,7 +289,7 @@ if CONFIG['OS_ARCH'] == 'Linux':
'-fomit-frame-pointer',
'-mbackchain',
]
elif CONFIG['OS_TEST'] == 's390x':
elif CONFIG['CPU_ARCH'] == 's390x':
SOURCES += [
'xptcinvoke_linux_s390x.cpp',
'xptcstubs_linux_s390x.cpp',

95
xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc_netbsd.s
View file

@ -1,95 +0,0 @@
# -*- Mode: Asm -*-
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
.set r0,0; .set sp,1; .set RTOC,2; .set r3,3; .set r4,4
.set r5,5; .set r6,6; .set r7,7; .set r8,8; .set r9,9
.set r10,10; .set r11,11; .set r12,12; .set r13,13; .set r14,14
.set r15,15; .set r16,16; .set r17,17; .set r18,18; .set r19,19
.set r20,20; .set r21,21; .set r22,22; .set r23,23; .set r24,24
.set r25,25; .set r26,26; .set r27,27; .set r28,28; .set r29,29
.set r30,30; .set r31,31
.set f0,0; .set f1,1; .set f2,2; .set f3,3; .set f4,4
.set f5,5; .set f6,6; .set f7,7; .set f8,8; .set f9,9
.set f10,10; .set f11,11; .set f12,12; .set f13,13; .set f14,14
.set f15,15; .set f16,16; .set f17,17; .set f18,18; .set f19,19
.set f20,20; .set f21,21; .set f22,22; .set f23,23; .set f24,24
.set f25,25; .set f26,26; .set f27,27; .set f28,28; .set f29,29
.set f30,30; .set f31,31
.section ".text"
.align 2
.globl XPTC_InvokeByIndex
.type XPTC_InvokeByIndex,@function
#
# XPTC_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
# uint32_t paramCount, nsXPTCVariant* params)
#
XPTC_InvokeByIndex:
stwu sp,-32(sp) # setup standard stack frame
mflr r0 # save LR
stw r3,8(sp) # r3 <= that
stw r4,12(sp) # r4 <= methodIndex
stw r30,16(sp)
stw r31,20(sp)
stw r0,36(sp) # store LR backchain
mr r31,sp
rlwinm r10,r5,3,0,27 # r10 = (ParamCount * 2 * 4) & ~0x0f
addi r0,r10,96 # reserve stack for GPR and FPR register save area r0 = r10 + 96
lwz r9,0(sp) # r9 = backchain
neg r0,r0
stwux r9,sp,r0 # reserve stack sapce and save SP backchain
addi r3,sp,8 # r3 <= args
mr r4,r5 # r4 <= paramCount
mr r5,r6 # r5 <= params
add r6,r3,r10 # r6 <= gpregs ( == args + r10 )
mr r30,r6 # store in r30 for use later...
addi r7,r6,32 # r7 <= fpregs ( == gpregs + 32 )
bl invoke_copy_to_stack@local # (args, paramCount, params, gpregs, fpregs)
lfd f1,32(r30) # load FP registers with method parameters
lfd f2,40(r30)
lfd f3,48(r30)
lfd f4,56(r30)
lfd f5,64(r30)
lfd f6,72(r30)
lfd f7,80(r30)
lfd f8,88(r30)
lwz r3,8(r31) # r3 <= that
lwz r4,12(r31) # r4 <= methodIndex
lwz r5,0(r3) # r5 <= vtable ( == *that )
slwi r4,r4,3 # convert to offset ( *= 8 )
addi r4,r4,8 # skip first two vtable entries
add r4,r4,r5
lhz r0,0(r4) # virtual base offset
extsh r0,r0
add r3,r3,r0
lwz r0,4(r4) # r0 <= methodpointer ( == vtable + offset )
lwz r4,4(r30) # load GP regs with method parameters
lwz r5,8(r30)
lwz r6,12(r30)
lwz r7,16(r30)
lwz r8,20(r30)
lwz r9,24(r30)
lwz r10,28(r30)
mtlr r0 # copy methodpointer to LR
blrl # call method
lwz r30,16(r31) # restore r30 & r31
lwz r31,20(r31)
lwz r11,0(sp) # clean up the stack
lwz r0,4(r11)
mtlr r0
mr sp,r11
blr

130
xpcom/reflect/xptcall/md/unix/xptcinvoke_linux_m68k.cpp
View file

@ -1,130 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* Platform specific code to invoke XPCOM methods on native objects */
#include "xptcprivate.h"
// Remember that these 'words' are 32bit DWORDS
extern "C" {
static uint32_t
invoke_count_words(uint32_t paramCount, nsXPTCVariant* s)
{
uint32_t result = 0;
for(uint32_t 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;
}
void
invoke_copy_to_stack(uint32_t* d, uint32_t paramCount, nsXPTCVariant* s)
{
for(uint32_t i = 0; i < paramCount; i++, d++, s++)
{
if(s->IsPtrData())
{
*((void**)d) = s->ptr;
continue;
}
switch(s->type)
{
// 8 and 16 bit types should be promoted to 32 bits when copying
// onto the stack.
case nsXPTType::T_I8 : *((uint32_t*)d) = s->val.i8; break;
case nsXPTType::T_I16 : *((uint32_t*)d) = s->val.i16; break;
case nsXPTType::T_I32 : *((int32_t*) d) = s->val.i32; break;
case nsXPTType::T_I64 : *((int64_t*) d) = s->val.i64; d++; break;
case nsXPTType::T_U8 : *((uint32_t*)d) = s->val.u8; break;
case nsXPTType::T_U16 : *((uint32_t*)d) = s->val.u16; break;
case nsXPTType::T_U32 : *((uint32_t*)d) = s->val.u32; break;
case nsXPTType::T_U64 : *((uint64_t*)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 : *((uint32_t*)d) = s->val.b; break;
case nsXPTType::T_CHAR : *((uint32_t*)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;
}
}
}
}
EXPORT_XPCOM_API(nsresult)
NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
uint32_t paramCount, nsXPTCVariant* params)
{
uint32_t result, n;
n = invoke_count_words(paramCount, params) * 4;
__asm__ __volatile__(
"subl %5, %%sp\n\t" /* make room for params */
"movel %4, %%sp@-\n\t"
"movel %3, %%sp@-\n\t"
"pea %%sp@(8)\n\t"
"jbsr invoke_copy_to_stack\n\t" /* copy params */
"addw #12, %%sp\n\t"
"movel %1, %%sp@-\n\t"
"movel %1@, %%a0\n\t"
"movel %%a0@(%2:l:4), %%a0\n\t"
"jbsr %%a0@\n\t" /* safe to not cleanup sp */
"lea %%sp@(4,%5:l), %%sp\n\t"
"movel %%d0, %0"
: "=d" (result) /* %0 */
: "a" (that), /* %1 */
"d" (methodIndex), /* %2 */
"g" (paramCount), /* %3 */
"g" (params), /* %4 */
"d" (n) /* %5 */
: "a0", "a1", "d0", "d1", "memory"
);
return result;
}

143
xpcom/reflect/xptcall/md/unix/xptcinvoke_netbsd_m68k.cpp
View file

@ -1,143 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* Platform specific code to invoke XPCOM methods on native objects */
#include "xptcprivate.h"
// Remember that these 'words' are 32bit DWORDS
#if !defined(__NetBSD__) || !defined(__m68k__)
#error This code is for NetBSD/m68k only
#endif
extern "C" {
static uint32_t
invoke_count_words(uint32_t paramCount, nsXPTCVariant* s)
{
uint32_t result = 0;
for(uint32_t 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(uint32_t* d, uint32_t paramCount, nsXPTCVariant* s)
{
for(uint32_t i = 0; i < paramCount; i++, d++, s++)
{
if(s->IsPtrData())
{
*((void**)d) = s->ptr;
continue;
}
switch(s->type)
{
// 8 and 16 bit types should be promoted to 32 bits when copying
// onto the stack.
case nsXPTType::T_I8 : *((uint32_t*)d) = s->val.i8; break;
case nsXPTType::T_I16 : *((uint32_t*)d) = s->val.i16; break;
case nsXPTType::T_I32 : *((int32_t*) d) = s->val.i32; break;
case nsXPTType::T_I64 : *((int64_t*) d) = s->val.i64; d++; break;
case nsXPTType::T_U8 : *((uint32_t*)d) = s->val.u8; break;
case nsXPTType::T_U16 : *((uint32_t*)d) = s->val.u16; break;
case nsXPTType::T_U32 : *((uint32_t*)d) = s->val.u32; break;
case nsXPTType::T_U64 : *((uint64_t*)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 : *((uint32_t*)d) = s->val.b; break;
case nsXPTType::T_CHAR : *((uint32_t*)d) = s->val.c; break;
// wchar_t is an int (32 bits) on NetBSD
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;
}
}
}
}
XPTC_PUBLIC_API(nsresult)
XPTC_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
uint32_t paramCount, nsXPTCVariant* params)
{
uint32_t result;
__asm__ __volatile__(
"movl %4, sp@-\n\t"
"movl %3, sp@-\n\t"
"jbsr _invoke_count_words\n\t" /* count words */
"addql #8, sp\n\t"
"lsll #2, d0\n\t" /* *= 4 */
"movl sp, a2\n\t" /* save original sp */
"subl d0, sp\n\t" /* make room for params */
"movl sp, a0\n\t"
"movl %4, sp@-\n\t"
"movl %3, sp@-\n\t"
"movl a0, sp@-\n\t"
"jbsr _invoke_copy_to_stack\n\t" /* copy params */
"addl #12, sp\n\t"
"movl %1, a0\n\t"
"movl a0@, a1\n\t"
"movl %2, d0\n\t" /* function index */
"movl a0, d1\n\t"
"movw a1@(8,d0:l:8), a0\n\t"
"addl a0, d1\n\t"
"movl a1@(12,d0:l:8), a1\n\t"
"movl d1, sp@-\n\t"
"jbsr a1@\n\t"
"movl a2, sp\n\t" /* restore original sp */
"movl d0, %0\n\t"
: "=g" (result) /* %0 */
: "g" (that), /* %1 */
"g" (methodIndex), /* %2 */
"g" (paramCount), /* %3 */
"g" (params) /* %4 */
: "a0", "a1", "a2", "d0", "d1", "memory"
);
return result;
}

115
xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc_netbsd.cpp
View file

@ -1,115 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// Platform specific code to invoke XPCOM methods on native objects
// The purpose of XPTC_InvokeByIndex() is to map a platform
// indepenpent call to the platform ABI. To do that,
// XPTC_InvokeByIndex() has to determine the method to call via vtable
// access. The parameters for the method are read from the
// nsXPTCVariant* and prepared for the native ABI. For the Linux/PPC
// ABI this means that the first 8 integral and floating point
// parameters are passed in registers.
#include "xptcprivate.h"
// 8 integral parameters are passed in registers
#define GPR_COUNT 8
// 8 floating point parameters are passed in registers, floats are
// promoted to doubles when passed in registers
#define FPR_COUNT 8
extern "C" uint32_t
invoke_count_words(uint32_t paramCount, nsXPTCVariant* s)
{
return uint32_t(((paramCount * 2) + 3) & ~3);
}
extern "C" void
invoke_copy_to_stack(uint32_t* d,
uint32_t paramCount,
nsXPTCVariant* s,
uint32_t* gpregs,
double* fpregs)
{
uint32_t gpr = 1; // skip one GP reg for 'that'
uint32_t fpr = 0;
uint32_t tempu32;
uint64_t tempu64;
for(uint32_t i = 0; i < paramCount; i++, s++) {
if(s->IsPtrData()) {
if(s->type == nsXPTType::T_JSVAL)
tempu32 = (uint32_t) &(s->ptr);
else
tempu32 = (uint32_t) s->ptr;
} else {
switch(s->type) {
case nsXPTType::T_FLOAT: break;
case nsXPTType::T_DOUBLE: break;
case nsXPTType::T_I8: tempu32 = s->val.i8; break;
case nsXPTType::T_I16: tempu32 = s->val.i16; break;
case nsXPTType::T_I32: tempu32 = s->val.i32; break;
case nsXPTType::T_I64: tempu64 = s->val.i64; break;
case nsXPTType::T_U8: tempu32 = s->val.u8; break;
case nsXPTType::T_U16: tempu32 = s->val.u16; break;
case nsXPTType::T_U32: tempu32 = s->val.u32; break;
case nsXPTType::T_U64: tempu64 = s->val.u64; break;
case nsXPTType::T_BOOL: tempu32 = s->val.b; break;
case nsXPTType::T_CHAR: tempu32 = s->val.c; break;
case nsXPTType::T_WCHAR: tempu32 = s->val.wc; break;
default: tempu32 = (uint32_t) s->val.p; break;
}
}
if (!s->IsPtrData() && s->type == nsXPTType::T_DOUBLE) {
if (fpr < FPR_COUNT)
fpregs[fpr++] = s->val.d;
else {
if ((uint32_t) d & 4) d++; // doubles are 8-byte aligned on stack
*((double*) d) = s->val.d;
d += 2;
if (gpr < GPR_COUNT)
gpr += 2;
}
}
else if (!s->IsPtrData() && s->type == nsXPTType::T_FLOAT) {
if (fpr < FPR_COUNT)
fpregs[fpr++] = s->val.f; // if passed in registers, floats are promoted to doubles
else {
*((float*) d) = s->val.f;
d += 1;
if (gpr < GPR_COUNT)
gpr += 1;
}
}
else if (!s->IsPtrData() && (s->type == nsXPTType::T_I64
|| s->type == nsXPTType::T_U64)) {
if ((gpr + 1) < GPR_COUNT) {
if (gpr & 1) gpr++; // longlongs are aligned in odd/even register pairs, eg. r5/r6
*((uint64_t*) &gpregs[gpr]) = tempu64;
gpr += 2;
}
else {
if ((uint32_t) d & 4) d++; // longlongs are 8-byte aligned on stack
*((uint64_t*) d) = tempu64;
d += 2;
}
}
else {
if (gpr < GPR_COUNT)
gpregs[gpr++] = tempu32;
else
*d++ = tempu32;
}
}
}
extern "C"
XPTC_PUBLIC_API(nsresult)
XPTC_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
uint32_t paramCount, nsXPTCVariant* params);

70
xpcom/reflect/xptcall/md/unix/xptcstubs_asm_ppc_netbsd.s
View file

@ -1,70 +0,0 @@
# -*- Mode: Asm -*-
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
.set r0,0; .set sp,1; .set RTOC,2; .set r3,3; .set r4,4
.set r5,5; .set r6,6; .set r7,7; .set r8,8; .set r9,9
.set r10,10; .set r11,11; .set r12,12; .set r13,13; .set r14,14
.set r15,15; .set r16,16; .set r17,17; .set r18,18; .set r19,19
.set r20,20; .set r21,21; .set r22,22; .set r23,23; .set r24,24
.set r25,25; .set r26,26; .set r27,27; .set r28,28; .set r29,29
.set r30,30; .set r31,31
.set f0,0; .set f1,1; .set f2,2; .set f3,3; .set f4,4
.set f5,5; .set f6,6; .set f7,7; .set f8,8; .set f9,9
.set f10,10; .set f11,11; .set f12,12; .set f13,13; .set f14,14
.set f15,15; .set f16,16; .set f17,17; .set f18,18; .set f19,19
.set f20,20; .set f21,21; .set f22,22; .set f23,23; .set f24,24
.set f25,25; .set f26,26; .set f27,27; .set f28,28; .set f29,29
.set f30,30; .set f31,31
.section ".text"
.align 2
.globl SharedStub
.type SharedStub,@function
SharedStub:
stwu sp,-112(sp) # room for
# linkage (8),
# gprData (32),
# fprData (64),
# stack alignment(8)
mflr r0
stw r0,116(sp) # save LR backchain
stw r4,12(sp) # save GP registers
stw r5,16(sp) # (n.b. that we don't save r3
stw r6,20(sp) # because PrepareAndDispatch() is savvy)
stw r7,24(sp)
stw r8,28(sp)
stw r9,32(sp)
stw r10,36(sp)
stfd f1,40(sp) # save FP registers
stfd f2,48(sp)
stfd f3,56(sp)
stfd f4,64(sp)
stfd f5,72(sp)
stfd f6,80(sp)
stfd f7,88(sp)
stfd f8,96(sp)
# r3 has the 'self' pointer already
mr r4,r11 # r4 <= methodIndex selector, passed
# via r11 in the nsXPTCStubBase::StubXX() call
addi r5,sp,120 # r5 <= pointer to callers args area,
# beyond r3-r10/f1-f8 mapped range
addi r6,sp,8 # r6 <= gprData
addi r7,sp,40 # r7 <= fprData
bl PrepareAndDispatch@local # Go!
lwz r0,116(sp) # restore LR
mtlr r0
la sp,112(sp) # clean up the stack
blr

102
xpcom/reflect/xptcall/md/unix/xptcstubs_linux_m68k.cpp
View file

@ -1,102 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* Implement shared vtbl methods. */
#include "xptcprivate.h"
extern "C" {
nsresult ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
{
#define PARAM_BUFFER_COUNT 16
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
const nsXPTMethodInfo* info;
uint8_t paramCount;
uint8_t i;
NS_ASSERTION(self,"no self");
self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
NS_ASSERTION(info,"no method 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");
const uint8_t indexOfJSContext = info->IndexOfJSContext();
uint32_t* 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 (i == indexOfJSContext)
ap++;
if(param.IsOut() || !type.IsArithmetic())
{
dp->val.p = (void*) *ap;
continue;
}
switch(type)
{
// the 8 and 16 bit types will have been promoted to 32 bits before
// being pushed onto the stack. Since the 68k is big endian, we
// need to skip over the leading high order bytes.
case nsXPTType::T_I8 : dp->val.i8 = *(((int8_t*) ap) + 3); break;
case nsXPTType::T_I16 : dp->val.i16 = *(((int16_t*) ap) + 1); break;
case nsXPTType::T_I32 : dp->val.i32 = *((int32_t*) ap); break;
case nsXPTType::T_I64 : dp->val.i64 = *((int64_t*) ap); ap++; break;
case nsXPTType::T_U8 : dp->val.u8 = *(((uint8_t*) ap) + 3); break;
case nsXPTType::T_U16 : dp->val.u16 = *(((uint16_t*)ap) + 1); break;
case nsXPTType::T_U32 : dp->val.u32 = *((uint32_t*)ap); break;
case nsXPTType::T_U64 : dp->val.u64 = *((uint64_t*)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 = *((uint32_t* ap); break;
case nsXPTType::T_CHAR : dp->val.c = *(((char*) ap) + 3); break;
case nsXPTType::T_WCHAR : dp->val.wc = *((wchar_t*) ap); break;
default:
NS_ERROR("bad type");
break;
}
}
nsresult result = self->mOuter->CallMethod((uint16_t)methodIndex, info,
dispatchParams);
if(dispatchParams != paramBuffer)
delete [] dispatchParams;
return result;
}
}
#define STUB_ENTRY(n) \
nsresult nsXPTCStubBase::Stub##n() \
{ \
void *frame = __builtin_frame_address(0); \
return PrepareAndDispatch(this, n, (uint32_t*)frame + 3); \
}
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"

113
xpcom/reflect/xptcall/md/unix/xptcstubs_netbsd_m68k.cpp
View file

@ -1,113 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* Implement shared vtbl methods. */
#include "xptcprivate.h"
#if !defined(__NetBSD__) || !defined(__m68k__)
#error This code is for NetBSD/m68k only
#endif
extern "C" {
static nsresult ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
{
#define PARAM_BUFFER_COUNT 16
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
const nsXPTInterfaceInfo* iface_info = nullptr;
const nsXPTMethodInfo* info;
uint8_t paramCount;
uint8_t i;
NS_ASSERTION(self,"no self");
self->GetInterfaceInfo(&iface_info);
NS_ASSERTION(iface_info,"no interface info");
iface_info->GetMethodInfo(uint16_t(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");
uint32_t* 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;
}
switch(type)
{
// the 8 and 16 bit types will have been promoted to 32 bits before
// being pushed onto the stack. Since the 68k is big endian, we
// need to skip over the leading high order bytes.
case nsXPTType::T_I8 : dp->val.i8 = *(((int8_t*) ap) + 3); break;
case nsXPTType::T_I16 : dp->val.i16 = *(((int16_t*) ap) + 1); break;
case nsXPTType::T_I32 : dp->val.i32 = *((int32_t*) ap); break;
case nsXPTType::T_I64 : dp->val.i64 = *((int64_t*) ap); ap++; break;
case nsXPTType::T_U8 : dp->val.u8 = *(((uint8_t*) ap) + 3); break;
case nsXPTType::T_U16 : dp->val.u16 = *(((uint16_t*)ap) + 1); break;
case nsXPTType::T_U32 : dp->val.u32 = *((uint32_t*)ap); break;
case nsXPTType::T_U64 : dp->val.u64 = *((uint64_t*)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 = *(((char*) ap) + 3); break;
case nsXPTType::T_CHAR : dp->val.c = *(((char*) ap) + 3); break;
// wchar_t is an int (32 bits) on NetBSD
case nsXPTType::T_WCHAR : dp->val.wc = *((wchar_t*) ap); break;
default:
NS_ERROR("bad type");
break;
}
}
nsresult result = self->CallMethod((uint16_t)methodIndex, info,
dispatchParams);
if(dispatchParams != paramBuffer)
delete [] dispatchParams;
return result;
}
}
#define STUB_ENTRY(n) \
__asm__( \
".global _Stub"#n"__14nsXPTCStubBase\n\t" \
"_Stub"#n"__14nsXPTCStubBase:\n\t" \
"link a6,#0 \n\t" \
"lea a6@(12), a0 \n\t" /* pointer to args */ \
"movl a0, sp@- \n\t" \
"movl #"#n", sp@- \n\t" /* method index */ \
"movl a6@(8), sp@- \n\t" /* this */ \
"jbsr _PrepareAndDispatch \n\t" \
"unlk a6 \n\t" \
"rts \n\t" \
);
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"

183
xpcom/reflect/xptcall/md/unix/xptcstubs_ppc_netbsd.cpp
View file

@ -1,183 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// Implement shared vtbl methods.
#include "xptcprivate.h"
// The Linux/PPC ABI (aka PPC/SYSV ABI) passes the first 8 integral
// parameters and the first 8 floating point parameters in registers
// (r3-r10 and f1-f8), no stack space is allocated for these by the
// caller. The rest of the parameters are passed in the callers stack
// area. The stack pointer has to retain 16-byte alignment, longlongs
// and doubles are aligned on 8-byte boundaries.
#define PARAM_BUFFER_COUNT 16
#define GPR_COUNT 8
#define FPR_COUNT 8
// PrepareAndDispatch() is called by SharedStub() and calls the actual method.
//
// - 'args[]' contains the arguments passed on stack
// - 'gprData[]' contains the arguments passed in integer registers
// - 'fprData[]' 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 ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self,
uint32_t methodIndex,
uint32_t* args,
uint32_t *gprData,
double *fprData)
{
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
const nsXPTInterfaceInfo* iface_info = nullptr;
const nsXPTMethodInfo* info;
uint32_t paramCount;
uint32_t i;
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(uint16_t(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;
uint32_t* ap = args;
uint32_t gpr = 1; // skip one GPR register
uint32_t fpr = 0;
uint32_t tempu32;
uint64_t tempu64;
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 (fpr < FPR_COUNT)
dp->val.d = fprData[fpr++];
else {
if ((uint32_t) ap & 4) ap++; // doubles are 8-byte aligned on stack
dp->val.d = *(double*) ap;
ap += 2;
if (gpr < GPR_COUNT)
gpr += 2;
}
continue;
}
else if (!param.IsOut() && type == nsXPTType::T_FLOAT) {
if (fpr < FPR_COUNT)
dp->val.f = (float) fprData[fpr++]; // in registers floats are passed as doubles
else {
dp->val.f = *(float*) ap;
ap += 1;
if (gpr < GPR_COUNT)
gpr += 1;
}
continue;
}
else if (!param.IsOut() && (type == nsXPTType::T_I64
|| type == nsXPTType::T_U64)) {
if (gpr & 1) gpr++; // longlongs are aligned in odd/even register pairs, eg. r5/r6
if ((gpr + 1) < GPR_COUNT) {
tempu64 = *(uint64_t*) &gprData[gpr];
gpr += 2;
}
else {
if ((uint32_t) ap & 4) ap++; // longlongs are 8-byte aligned on stack
tempu64 = *(uint64_t*) ap;
ap += 2;
}
}
else {
if (gpr < GPR_COUNT)
tempu32 = gprData[gpr++];
else
tempu32 = *ap++;
}
if(param.IsOut() || !type.IsArithmetic()) {
if (type == nsXPTType::T_JSVAL)
dp->val.p = *((void**) tempu32);
else
dp->val.p = (void*) tempu32;
continue;
}
switch(type) {
case nsXPTType::T_I8: dp->val.i8 = (int8_t) tempu32; break;
case nsXPTType::T_I16: dp->val.i16 = (int16_t) tempu32; break;
case nsXPTType::T_I32: dp->val.i32 = (int32_t) tempu32; break;
case nsXPTType::T_I64: dp->val.i64 = (int64_t) tempu64; break;
case nsXPTType::T_U8: dp->val.u8 = (uint8_t) tempu32; break;
case nsXPTType::T_U16: dp->val.u16 = (uint16_t) tempu32; break;
case nsXPTType::T_U32: dp->val.u32 = (uint32_t) tempu32; break;
case nsXPTType::T_U64: dp->val.u64 = (uint64_t) tempu64; break;
case nsXPTType::T_BOOL: dp->val.b = (bool) tempu32; break;
case nsXPTType::T_CHAR: dp->val.c = (char) tempu32; break;
case nsXPTType::T_WCHAR: dp->val.wc = (wchar_t) tempu32; break;
default:
NS_ERROR("bad type");
break;
}
}
nsresult result = self->CallMethod((uint16_t) methodIndex, info,
dispatchParams);
if (dispatchParams != paramBuffer)
delete [] dispatchParams;
return result;
}
// Load r11 with the constant 'n' and branch to SharedStub().
//
// XXX Yes, it's ugly that we're relying on gcc's name-mangling here;
// however, it's quick, dirty, and'll break when the ABI changes on
// us, which is what we want ;-).
#define STUB_ENTRY(n) \
__asm__ ( \
".section \".text\" \n\t" \
".align 2 \n\t" \
".globl Stub"#n"__14nsXPTCStubBase \n\t" \
".type Stub"#n"__14nsXPTCStubBase,@function \n\n" \
\
"Stub"#n"__14nsXPTCStubBase: \n\t" \
"li 11,"#n" \n\t" \
"b SharedStub@local \n" \
);
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"