cpet/openbsd-ports
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update to minimo-20071108; testing on zaurus and ok kili@

Browse Source
This commit is contained in:
martynas 2007-11-13 21:24:47 +00:00
parent ab59b433e6
commit 7ea4eb3be9
19 changed files with 28 additions and 2315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
www/minimo/Makefile
View File

@ -1,10 +1,10 @@
# $OpenBSD: Makefile,v 1.41 2007/10/27 23:44:41 ajacoutot Exp $
# $OpenBSD: Makefile,v 1.42 2007/11/13 21:24:47 martynas Exp $
ONLY_FOR_ARCHS= alpha amd64 arm i386 powerpc sparc64
SHARED_ONLY= Yes
COMMENT= small, simple, and powerful web browser for mobile devices
DISTNAME= minimo-20070804
DISTNAME= minimo-20071108
CATEGORIES= www
MASTER_SITES= http://mirrors.protection.cx/~martynas/mozilla/minimo/ \
@ -28,8 +28,9 @@ LIB_DEPENDS= jpeg.>=62::graphics/jpeg \
gdk-x11-2.0.>=600.0,gdk_pixbuf-2.0.>=600.0,gtk-x11-2.0.>=600.0::x11/gtk+2 \
nspr4.>=17,plc4.>=17,plds4.>=17:nspr->=4.6.4p1:devel/nspr \
nss3.>=19,smime3.>=19,softokn3.>=19,ssl3.>=19:nss->=3.11.4p1:security/nss
WANTLIB= X11 Xcursor Xext Xfixes Xft Xi Xinerama Xrandr Xrender \
Xt Xau Xdmcp expat c fontconfig freetype m pthread z \
WANTLIB= X11 Xcomposite Xcursor Xdamage Xext Xfixes Xft Xi Xinerama \
Xrandr Xrender Xt Xau Xdmcp expat c fontconfig freetype m \
pthread z \
atk-1.0.>=1011.0 glib-2.0.>=600.0 gmodule-2.0.>=600.0 \
gobject-2.0.>=600.0 pango-1.0.>=800.0 pangocairo-1.0 \
pangoft2-1.0 cairo glitz stdc++
@ -93,9 +94,6 @@ CONFIGURE_ENV= ${MAKE_ENV} \
MOB= ${WRKSRC}/dist/bin
MOZ= ${PREFIX}/share/minimo
post-extract:
@cp ${FILESDIR}/xptc* ${WRKSRC}/xpcom/reflect/xptcall/src/md/unix/
do-install:
${INSTALL_DATA_DIR} ${MOZ}
${INSTALL_PROGRAM} ${MOB}/minimo ${PREFIX}/bin/

10
www/minimo/distinfo
View File

@ -1,5 +1,5 @@
MD5 (minimo-20070804.tar.gz) = UIlNJlvxbAjaVW2w0AtP7w==
RMD160 (minimo-20070804.tar.gz) = ldJWfjKtUUyiB5xi6zdfkms8vzg=
SHA1 (minimo-20070804.tar.gz) = 8Wy3lMrN0c2/2pR+nltAGz/NzpM=
SHA256 (minimo-20070804.tar.gz) = Fe/yr6ZZX24u+n/4leonTyMKpVa/eymq9YrONLopr2w=
SIZE (minimo-20070804.tar.gz) = 45007312
MD5 (minimo-20071108.tar.gz) = i7nluw9hrM8JWPCuafbTYQ==
RMD160 (minimo-20071108.tar.gz) = /6eiAjios+6QK3QP4ZNOuJhm0fA=
SHA1 (minimo-20071108.tar.gz) = FPZ1usauW6qFk/aJBRsOTRyim78=
SHA256 (minimo-20071108.tar.gz) = BHbkpeAcaDLcZgfqtxMXFtaDPT6ApObY/3e2wj6CVxg=
SIZE (minimo-20071108.tar.gz) = 45039529

216
www/minimo/files/xptcinvoke_arm_openbsd.cpp
View File

@ -1,216 +0,0 @@
/* -*- 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) 1998
* 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"
// Remember that these 'words' are 32bit DWORDS
static PRUint32
invoke_count_words(PRUint32 paramCount, nsXPTCVariant* s)
{
PRUint32 result = 0;
for(PRUint32 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(PRUint32* d, PRUint32 paramCount, nsXPTCVariant* s)
{
for(PRUint32 i = 0; i < paramCount; i++, d++, s++)
{
if(s->IsPtrData())
{
*((void**)d) = s->ptr;
continue;
}
switch(s->type)
{
case nsXPTType::T_I8 : *((PRInt8*) d) = s->val.i8; break;
case nsXPTType::T_I16 : *((PRInt16*) d) = s->val.i16; break;
case nsXPTType::T_I32 : *((PRInt32*) d) = s->val.i32; break;
case nsXPTType::T_I64 : *((PRInt64*) d) = s->val.i64; d++; break;
case nsXPTType::T_U8 : *((PRUint8*) d) = s->val.u8; break;
case nsXPTType::T_U16 : *((PRUint16*)d) = s->val.u16; break;
case nsXPTType::T_U32 : *((PRUint32*)d) = s->val.u32; break;
case nsXPTType::T_U64 : *((PRUint64*)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 : *((PRBool*) d) = s->val.b; break;
case nsXPTType::T_CHAR : *((char*) 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;
}
}
}
extern "C" {
struct my_params_struct {
nsISupports* that;
PRUint32 Index;
PRUint32 Count;
nsXPTCVariant* params;
PRUint32 fn_count;
PRUint32 fn_copy;
};
}
XPTC_PUBLIC_API(nsresult)
XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
PRUint32 paramCount, nsXPTCVariant* params)
{
PRUint32 result;
struct my_params_struct my_params;
my_params.that = that;
my_params.Index = methodIndex;
my_params.Count = paramCount;
my_params.params = params;
my_params.fn_copy = (PRUint32) &invoke_copy_to_stack;
my_params.fn_count = (PRUint32) &invoke_count_words;
/* This is to call a given method of class that.
* The parameters are in params, the number is in paramCount.
* The routine will issue calls to count the number of words
* required for argument passing and to copy the arguments to
* the stack.
* Since APCS passes the first 3 params in r1-r3, we need to
* load the first three words from the stack and correct the stack
* pointer (sp) in the appropriate way. This means:
*
* 1.) more than 3 arguments: load r1-r3, correct sp and remember No.
* of bytes left on the stack in r4
*
* 2.) <= 2 args: load r1-r3 (we won't be causing a stack overflow I hope),
* restore sp as if nothing had happened and set the marker r4 to zero.
*
* Afterwards sp will be restored using the value in r4 (which is not a temporary register
* and will be preserved by the function/method called according to APCS [ARM Procedure
* Calling Standard]).
*
* !!! IMPORTANT !!!
* This routine makes assumptions about the vtable layout of the c++ compiler. It's implemented
* for arm-linux GNU g++ >= 2.8.1 (including egcs and gcc-2.95.[1-3])!
*
*/
__asm__ __volatile__(
"ldr r1, [%1, #12] \n\t" /* prepare to call invoke_count_words */
"ldr ip, [%1, #16] \n\t" /* r0=paramCount, r1=params */
"ldr r0, [%1, #8] \n\t"
"mov lr, pc \n\t" /* call it... */
"mov pc, ip \n\t"
"mov r4, r0, lsl #2 \n\t" /* This is the amount of bytes needed. */
"sub sp, sp, r4 \n\t" /* use stack space for the args... */
"mov r0, sp \n\t" /* prepare a pointer an the stack */
"ldr r1, [%1, #8] \n\t" /* =paramCount */
"ldr r2, [%1, #12] \n\t" /* =params */
"ldr ip, [%1, #20] \n\t" /* =invoke_copy_to_stack */
"mov lr, pc \n\t" /* copy args to the stack like the */
"mov pc, ip \n\t" /* compiler would. */
"ldr r0, [%1] \n\t" /* =that */
"ldr r1, [r0, #0] \n\t" /* get that->vtable offset */
"ldr r2, [%1, #4] \n\t"
"mov r2, r2, lsl #2 \n\t" /* a vtable_entry(x)=8 + (4 bytes * x) */
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */
"ldr ip, [r1, r2] \n\t" /* get method adress from vtable */
#else /* non G++ V3 ABI */
"add r2, r2, #8 \n\t" /* with this compilers */
"ldr ip, [r1, r2] \n\t" /* get method adress from vtable */
#endif
"cmp r4, #12 \n\t" /* more than 3 arguments??? */
"ldmgtia sp!, {r1, r2, r3}\n\t" /* yes: load arguments for r1-r3 */
"subgt r4, r4, #12 \n\t" /* and correct the stack pointer */
"ldmleia sp, {r1, r2, r3}\n\t" /* no: load r1-r3 from stack */
"addle sp, sp, r4 \n\t" /* and restore stack pointer */
"movle r4, #0 \n\t" /* a mark for restoring sp */
"ldr r0, [%1, #0] \n\t" /* get (self) */
"mov lr, pc \n\t" /* call mathod */
"mov pc, ip \n\t"
"add sp, sp, r4 \n\t" /* restore stack pointer */
"mov %0, r0 \n\t" /* the result... */
: "=r" (result)
: "r" (&my_params)
: "r0", "r1", "r2", "r3", "r4", "ip", "lr", "sp"
);
return result;
}

116
www/minimo/files/xptcinvoke_asm_ppc_openbsd.s
View File

@ -1,116 +0,0 @@
# -*- Mode: Asm -*-
#
# The contents of this file are subject to the Netscape 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/NPL/
#
# 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 Netscape are
# Copyright (C) 1999 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
# Franz.Sirl-kernel@lauterbach.com (Franz Sirl)
# beard@netscape.com (Patrick Beard)
# waterson@netscape.com (Chris Waterson)
#
.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, PRUint32 methodIndex,
# PRUint32 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 space 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 )
#if 0
#if !((__GNUC__ == 3 && __GNUC_MINOR__ < 2) || __GXX_ABI_VERSION >= 100) # G++ pre-V3 ABI
addi r4,r4,2 # skip first two vtable entries
#endif
#endif
subi r4,r4,2 # skip first two vtable entries
slwi r4,r4,2 # convert to offset ( *= 4 )
lwzx r0,r5,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

104
www/minimo/files/xptcinvoke_asm_sparc64_openbsd.s
View File

@ -1,104 +0,0 @@
/* -*- Mode: asm; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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 Netscape are
* Copyright (C) 2001 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
* Stuart Parmenter <pavlov@netscape.com>
* Chris Seawood <cls@seawood.org>
*/
/*
Platform specific code to invoke XPCOM methods on native objects
for sparcv9 Solaris.
See the SPARC Compliance Definition (SCD) Chapter 3
for more information about what is going on here, including
the use of BIAS (0x7ff).
The SCD is available from http://www.sparc.com/.
*/
.global XPTC_InvokeByIndex
.type XPTC_InvokeByIndex, #function
/*
XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
PRUint32 paramCount, nsXPTCVariant* params);
*/
XPTC_InvokeByIndex:
save %sp,-(128 + 64),%sp ! room for the register window and
! struct pointer, rounded up to 0 % 64
sll %i2,4,%l0 ! assume the worst case
! paramCount * 2 * 8 bytes
cmp %l0, 0 ! are there any args? If not,
be .invoke ! no need to copy args to stack
nop
sub %sp,%l0,%sp ! create the additional stack space
add %sp,0x7ff+136,%o0 ! step past the register window, the
! struct result pointer and the 'this' slot
mov %i2,%o1 ! paramCount
call invoke_copy_to_stack
mov %i3,%o2 ! params
!
! load arguments from stack into the outgoing registers
! BIAS is 0x7ff (2047)
!
! load the %o1..5 64bit (extended word) output registers registers
ldx [%sp + 0x7ff + 136],%o1 ! %i1
ldx [%sp + 0x7ff + 144],%o2 ! %i2
ldx [%sp + 0x7ff + 152],%o3 ! %i3
ldx [%sp + 0x7ff + 160],%o4 ! %i4
ldx [%sp + 0x7ff + 168],%o5 ! %i5
! load the even number double registers starting with %d2
ldd [%sp + 0x7ff + 136],%f2
ldd [%sp + 0x7ff + 144],%f4
ldd [%sp + 0x7ff + 152],%f6
ldd [%sp + 0x7ff + 160],%f8
ldd [%sp + 0x7ff + 168],%f10
ldd [%sp + 0x7ff + 176],%f12
ldd [%sp + 0x7ff + 184],%f14
ldd [%sp + 0x7ff + 192],%f16
ldd [%sp + 0x7ff + 200],%f18
ldd [%sp + 0x7ff + 208],%f20
ldd [%sp + 0x7ff + 216],%f22
ldd [%sp + 0x7ff + 224],%f24
ldd [%sp + 0x7ff + 232],%f26
ldd [%sp + 0x7ff + 240],%f28
ldd [%sp + 0x7ff + 248],%f30
!
! calculate the target address from the vtable
!
.invoke:
sll %i1,3,%l0 ! index *= 8
! add %l0,16,%l0 ! there are 2 extra entries in the vTable (16bytes)
ldx [%i0],%l1 ! *that --> address of vtable
ldx [%l0 + %l1],%l0 ! that->vtable[index * 8 + 16] --> address
jmpl %l0,%o7 ! call the routine
mov %i0,%o0 ! move 'this' pointer to out register
mov %o0,%i0 ! propagate return value
ret
restore
.size XPTC_InvokeByIndex, .-XPTC_InvokeByIndex

184
www/minimo/files/xptcinvoke_openbsd_alpha.cpp
View File

@ -1,184 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape 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/NPL/
*
* 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) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either 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 NPL, 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 NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/* Platform specific code to invoke XPCOM methods on native objects */
/* contributed by Glen Nakamura <glen.nakamura@usa.net> */
#include "xptcprivate.h"
/* Prototype specifies unmangled function name and disables unused warning */
static void
invoke_copy_to_stack(PRUint64* d, PRUint32 paramCount, nsXPTCVariant* s)
__asm__("invoke_copy_to_stack") __attribute__((unused));
static void
invoke_copy_to_stack(PRUint64* d, PRUint32 paramCount, nsXPTCVariant* s)
{
const PRUint8 NUM_ARG_REGS = 6-1; // -1 for "this" pointer
for(PRUint32 i = 0; i < paramCount; i++, d++, s++)
{
if(s->IsPtrData())
{
*d = (PRUint64)s->ptr;
continue;
}
switch(s->type)
{
case nsXPTType::T_I8 : *d = (PRUint64)s->val.i8; break;
case nsXPTType::T_I16 : *d = (PRUint64)s->val.i16; break;
case nsXPTType::T_I32 : *d = (PRUint64)s->val.i32; break;
case nsXPTType::T_I64 : *d = (PRUint64)s->val.i64; break;
case nsXPTType::T_U8 : *d = (PRUint64)s->val.u8; break;
case nsXPTType::T_U16 : *d = (PRUint64)s->val.u16; break;
case nsXPTType::T_U32 : *d = (PRUint64)s->val.u32; break;
case nsXPTType::T_U64 : *d = (PRUint64)s->val.u64; break;
case nsXPTType::T_FLOAT :
if(i < NUM_ARG_REGS)
{
// convert floats to doubles if they are to be passed
// via registers so we can just deal with doubles later
union { PRUint64 u64; double d; } t;
t.d = (double)s->val.f;
*d = t.u64;
}
else
// otherwise copy to stack normally
*d = (PRUint64)s->val.u32;
break;
case nsXPTType::T_DOUBLE : *d = (PRUint64)s->val.u64; break;
case nsXPTType::T_BOOL : *d = (PRUint64)s->val.b; break;
case nsXPTType::T_CHAR : *d = (PRUint64)s->val.c; break;
case nsXPTType::T_WCHAR : *d = (PRUint64)s->val.wc; break;
default:
// all the others are plain pointer types
*d = (PRUint64)s->val.p;
break;
}
}
}
/*
* XPTC_PUBLIC_API(nsresult)
* XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
* PRUint32 paramCount, nsXPTCVariant* params, void* vt)
*/
__asm__(
"#### XPTC_InvokeByIndex ####\n"
".text\n\t"
".align 5\n\t"
".globl XPTC_InvokeByIndex\n\t"
".ent XPTC_InvokeByIndex\n"
"XPTC_InvokeByIndex:\n\t"
".frame $15,32,$26,0\n\t"
".mask 0x4008000,-32\n\t"
"ldgp $29,0($27)\n"
"$XPTC_InvokeByIndex..ng:\n\t"
"subq $30,32,$30\n\t"
"stq $26,0($30)\n\t"
"stq $15,8($30)\n\t"
"bis $30,$30,$15\n\t"
".prologue 1\n\t"
/*
* Allocate enough stack space to hold the greater of 6 or "paramCount"+1
* parameters. (+1 for "this" pointer) Room for at least 6 parameters
* is required for storage of those passed via registers.
*/
"bis $31,5,$2\n\t" /* count = MAX(5, "paramCount") */
"cmplt $2,$18,$1\n\t"
"cmovne $1,$18,$2\n\t"
"s8addq $2,16,$1\n\t" /* room for count+1 params (8 bytes each) */
"bic $1,15,$1\n\t" /* stack space is rounded up to 0 % 16 */
"subq $30,$1,$30\n\t"
"stq $16,0($30)\n\t" /* save "that" (as "this" pointer) */
"stq $17,16($15)\n\t" /* save "methodIndex" */
"addq $30,8,$16\n\t" /* pass stack pointer */
"bis $18,$18,$17\n\t" /* pass "paramCount" */
"bis $19,$19,$18\n\t" /* pass "params" */
"bsr $26,$invoke_copy_to_stack..ng\n\t" /* call invoke_copy_to_stack */
/*
* Copy the first 6 parameters to registers and remove from stack frame.
* Both the integer and floating point registers are set for each parameter
* except the first which is the "this" pointer. (integer only)
* The floating point registers are all set as doubles since the
* invoke_copy_to_stack function should have converted the floats.
*/
"ldq $16,0($30)\n\t" /* integer registers */
"ldq $17,8($30)\n\t"
"ldq $18,16($30)\n\t"
"ldq $19,24($30)\n\t"
"ldq $20,32($30)\n\t"
"ldq $21,40($30)\n\t"
"ldt $f17,8($30)\n\t" /* floating point registers */
"ldt $f18,16($30)\n\t"
"ldt $f19,24($30)\n\t"
"ldt $f20,32($30)\n\t"
"ldt $f21,40($30)\n\t"
"addq $30,48,$30\n\t" /* remove params from stack */
/*
* Call the virtual function with the constructed stack frame.
*/
"bis $16,$16,$1\n\t" /* load "this" */
"ldq $2,16($15)\n\t" /* load "methodIndex" */
"ldq $1,0($1)\n\t" /* load vtable */
#if 0
"s8addq $2,16,$2\n\t" /* vtable index = "methodIndex" * 8 + 16 */
#else
"mulq $2, 8, $2\n\t"
"addq $2, 0, $2\n\t" /* vtable index = "methodIndex" * 16 + 24 */
#endif
"addq $1,$2,$1\n\t"
"ldq $27,0($1)\n\t" /* load address of function */
"jsr $26,($27),0\n\t" /* call virtual function */
"ldgp $29,0($26)\n\t"
"bis $15,$15,$30\n\t"
"ldq $26,0($30)\n\t"
"ldq $15,8($30)\n\t"
"addq $30,32,$30\n\t"
"ret $31,($26),1\n\t"
".end XPTC_InvokeByIndex"
);

174
www/minimo/files/xptcinvoke_openbsd_amd64.cpp
View File

@ -1,174 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
// 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;
}

141
www/minimo/files/xptcinvoke_ppc_openbsd.cpp
View File

@ -1,141 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape 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/NPL/
*
* 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) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Franz.Sirl-kernel@lauterbach.com (Franz Sirl)
* beard@netscape.com (Patrick Beard)
* waterson@netscape.com (Chris Waterson)
*
* Alternatively, the contents of this file may be used under the terms of
* either 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 NPL, 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 NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// 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 th 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" PRUint32
invoke_count_words(PRUint32 paramCount, nsXPTCVariant* s)
{
return PRUint32(((paramCount * 2) + 3) & ~3);
}
extern "C" void
invoke_copy_to_stack(PRUint32* d,
PRUint32 paramCount,
nsXPTCVariant* s,
PRUint32* gpregs,
double* fpregs)
{
PRUint32 gpr = 1; // skip one GP reg for 'that'
PRUint32 fpr = 0;
PRUint32 tempu32;
PRUint64 tempu64;
for(uint32 i = 0; i < paramCount; i++, s++) {
if(s->IsPtrData())
tempu32 = (PRUint32) 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 = (PRUint32) s->val.p; break;
}
}
if (!s->IsPtrData() && s->type == nsXPTType::T_DOUBLE) {
if (fpr < FPR_COUNT)
fpregs[fpr++] = s->val.d;
else {
if ((PRUint32) d & 4) d++; // doubles are 8-byte aligned on stack
*((double*) d) = s->val.d;
d += 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;
}
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
*((PRUint64*) &gpregs[gpr]) = tempu64;
gpr += 2;
}
else {
if ((PRUint32) d & 4) d++; // longlongs are 8-byte aligned on stack
*((PRUint64*) 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, PRUint32 methodIndex,
PRUint32 paramCount, nsXPTCVariant* params);

87
www/minimo/files/xptcinvoke_sparc64_openbsd.cpp
View File

@ -1,87 +0,0 @@
/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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 Netscape are
* Copyright (C) 2001 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
* Stuart Parmenter <pavlov@netscape.com>
* Chris Seawood <cls@seawood.org>
*/
/* Platform specific code to invoke XPCOM methods on native objects */
#include "xptcprivate.h"
#if !defined(__sparc) && !defined(__sparc__)
#error "This code is for Sparc only"
#endif
extern "C" PRUint64
invoke_copy_to_stack(PRUint64* d, PRUint32 paramCount, nsXPTCVariant* s)
{
/*
We need to copy the parameters for this function to locals and use them
from there since the parameters occupy the same stack space as the stack
we're trying to populate.
*/
PRUint64 *l_d = d;
nsXPTCVariant *l_s = s;
PRUint64 l_paramCount = paramCount;
PRUint64 regCount = 0; // return the number of registers to load from the stack
for(PRUint64 i = 0; i < l_paramCount; i++, l_d++, l_s++)
{
if (regCount < 5) regCount++;
if (l_s->IsPtrData())
{
*l_d = (PRUint64)l_s->ptr;
continue;
}
switch (l_s->type)
{
case nsXPTType::T_I8 : *((PRInt64*)l_d) = l_s->val.i8; break;
case nsXPTType::T_I16 : *((PRInt64*)l_d) = l_s->val.i16; break;
case nsXPTType::T_I32 : *((PRInt64*)l_d) = l_s->val.i32; break;
case nsXPTType::T_I64 : *((PRInt64*)l_d) = l_s->val.i64; break;
case nsXPTType::T_U8 : *((PRUint64*)l_d) = l_s->val.u8; break;
case nsXPTType::T_U16 : *((PRUint64*)l_d) = l_s->val.u16; break;
case nsXPTType::T_U32 : *((PRUint64*)l_d) = l_s->val.u32; break;
case nsXPTType::T_U64 : *((PRUint64*)l_d) = l_s->val.u64; break;
/* in the case of floats, we want to put the bits in to the
64bit space right justified... floats in the paramter array on
sparcv9 use odd numbered registers.. %f1, %f3, so we have to skip
the space that would be occupied by %f0, %f2, etc.
*/
case nsXPTType::T_FLOAT : *(((float*)l_d) + 1) = l_s->val.f; break;
case nsXPTType::T_DOUBLE: *((double*)l_d) = l_s->val.d; break;
case nsXPTType::T_BOOL : *((PRInt64*)l_d) = l_s->val.b; break;
case nsXPTType::T_CHAR : *((PRUint64*)l_d) = l_s->val.c; break;
case nsXPTType::T_WCHAR : *((PRInt64*)l_d) = l_s->val.wc; break;
default:
// all the others are plain pointer types
*((void**)l_d) = l_s->val.p;
break;
}
}
return regCount;
}

240
www/minimo/files/xptcstubs_arm_openbsd.cpp
View File

@ -1,240 +0,0 @@
/* -*- 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):
* Russell King <rmk@arm.linux.org.uk>
*
* 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"
/* Specify explicitly a symbol for this function, don't try to guess the c++ mangled symbol. */
static nsresult PrepareAndDispatch(nsXPTCStubBase* self, uint32 methodIndex, PRUint32* args) asm("_PrepareAndDispatch");
static nsresult
PrepareAndDispatch(nsXPTCStubBase* self, uint32 methodIndex, PRUint32* args)
{
#define PARAM_BUFFER_COUNT 16
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = NULL;
nsIInterfaceInfo* iface_info = NULL;
const nsXPTMethodInfo* info;
PRUint8 paramCount;
PRUint8 i;
nsresult result = NS_ERROR_FAILURE;
NS_ASSERTION(self,"no self");
self->GetInterfaceInfo(&iface_info);
NS_ASSERTION(iface_info,"no interface info");
iface_info->GetMethodInfo(PRUint16(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");
PRUint32* 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;
}
// else
switch(type)
{
case nsXPTType::T_I8 : dp->val.i8 = *((PRInt8*) ap); break;
case nsXPTType::T_I16 : dp->val.i16 = *((PRInt16*) ap); break;
case nsXPTType::T_I32 : dp->val.i32 = *((PRInt32*) ap); break;
case nsXPTType::T_I64 : dp->val.i64 = *((PRInt64*) ap); ap++; break;
case nsXPTType::T_U8 : dp->val.u8 = *((PRUint8*) ap); break;
case nsXPTType::T_U16 : dp->val.u16 = *((PRUint16*)ap); break;
case nsXPTType::T_U32 : dp->val.u32 = *((PRUint32*)ap); break;
case nsXPTType::T_U64 : dp->val.u64 = *((PRUint64*)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 = *((PRBool*) ap); break;
case nsXPTType::T_CHAR : dp->val.c = *((char*) ap); break;
case nsXPTType::T_WCHAR : dp->val.wc = *((wchar_t*) ap); 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;
}
/*
* This is our shared stub.
*
* r0 = Self.
*
* The Rules:
* We pass an (undefined) number of arguments into this function.
* The first 3 C++ arguments are in r1 - r3, the rest are built
* by the calling function on the stack.
*
* We are allowed to corrupt r0 - r3, ip, and lr.
*
* Other Info:
* We pass the stub number in using `ip'.
*
* Implementation:
* - We save r1 to r3 inclusive onto the stack, which will be
* immediately below the caller saved arguments.
* - setup r2 (PrepareAndDispatch's args pointer) to point at
* the base of all these arguments
* - Save LR (for the return address)
* - Set r1 (PrepareAndDispatch's methodindex argument) from ip
* - r0 is passed through (self)
* - Call PrepareAndDispatch
* - When the call returns, we return by loading the PC off the
* stack, and undoing the stack (one instruction)!
*
*/
__asm__ ("\n\
SharedStub: \n\
stmfd sp!, {r1, r2, r3} \n\
mov r2, sp \n\
str lr, [sp, #-4]! \n\
mov r1, ip \n\
bl _PrepareAndDispatch \n\
ldr pc, [sp], #16");
/*
* Create sets of stubs to call the SharedStub.
* We don't touch the stack here, nor any registers, other than IP.
* IP is defined to be corruptable by a called function, so we are
* safe to use it.
*
* This will work with or without optimisation.
*/
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */
/*
* Note : As G++3 ABI contains the length of the functionname in the
* mangled name, it is difficult to get a generic assembler mechanism like
* in the G++ 2.95 case.
* Create names would be like :
* _ZN14nsXPTCStubBase5Stub9Ev
* _ZN14nsXPTCStubBase6Stub13Ev
* _ZN14nsXPTCStubBase7Stub144Ev
* Use the assembler directives to get the names right...
*/
#define STUB_ENTRY(n) \
__asm__( \
".section \".text\"\n" \
" .align 2\n" \
" .iflt ("#n" - 10)\n" \
" .globl _ZN14nsXPTCStubBase5Stub"#n"Ev\n" \
" .type _ZN14nsXPTCStubBase5Stub"#n"Ev,#function\n" \
"_ZN14nsXPTCStubBase5Stub"#n"Ev:\n" \
" .else\n" \
" .iflt ("#n" - 100)\n" \
" .globl _ZN14nsXPTCStubBase6Stub"#n"Ev\n" \
" .type _ZN14nsXPTCStubBase6Stub"#n"Ev,#function\n" \
"_ZN14nsXPTCStubBase6Stub"#n"Ev:\n" \
" .else\n" \
" .iflt ("#n" - 1000)\n" \
" .globl _ZN14nsXPTCStubBase7Stub"#n"Ev\n" \
" .type _ZN14nsXPTCStubBase7Stub"#n"Ev,#function\n" \
"_ZN14nsXPTCStubBase7Stub"#n"Ev:\n" \
" .else\n" \
" .err \"stub number "#n"> 1000 not yet supported\"\n" \
" .endif\n" \
" .endif\n" \
" .endif\n" \
" mov ip, #"#n"\n" \
" b SharedStub\n\t");
#if 0
/*
* This part is left in as comment : this is how the method definition
* should look like.
*/
#define STUB_ENTRY(n) \
nsresult nsXPTCStubBase::Stub##n () \
{ \
__asm__ ( \
" mov ip, #"#n"\n" \
" b SharedStub\n\t"); \
return 0; /* avoid warnings */ \
}
#endif
#else /* G++2.95 ABI */
#define STUB_ENTRY(n) \
__asm__( \
".section \".text\"\n" \
" .align\n" \
" .globl Stub"#n"__14nsXPTCStubBase\n" \
" .type Stub"#n"__14nsXPTCStubBase,#function\n\n" \
"Stub"#n"__14nsXPTCStubBase:\n" \
" mov ip, #"#n"\n" \
" b SharedStub\n\t");
#endif
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"

89
www/minimo/files/xptcstubs_asm_ppc_openbsd.s
View File

@ -1,89 +0,0 @@
# -*- Mode: Asm -*-
#
# The contents of this file are subject to the Netscape 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/NPL/
#
# 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 Netscape are
# Copyright (C) 1999 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
# Franz.Sirl-kernel@lauterbach.com (Franz Sirl)
# beard@netscape.com (Patrick Beard)
# waterson@netscape.com (Chris Waterson)
#
.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

269
www/minimo/files/xptcstubs_openbsd_alpha.cpp
View File

@ -1,269 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape 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/NPL/
*
* 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 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 NPL, 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 NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/* Implement shared vtbl methods. */
/* contributed by Glen Nakamura <glen.nakamura@usa.net> */
#include <sys/types.h>
#include <machine/cpu.h>
#include "xptcprivate.h"
/* Prototype specifies unmangled function name and disables unused warning */
static nsresult
PrepareAndDispatch(nsXPTCStubBase* self, uint32 methodIndex, PRUint64* args)
__asm__("PrepareAndDispatch") __attribute__((unused));
static nsresult
PrepareAndDispatch(nsXPTCStubBase* self, uint32 methodIndex, PRUint64* args)
{
const PRUint8 PARAM_BUFFER_COUNT = 16;
const PRUint8 NUM_ARG_REGS = 6-1; // -1 for "this" pointer
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = NULL;
nsIInterfaceInfo* iface_info = NULL;
const nsXPTMethodInfo* info;
PRUint8 paramCount;
PRUint8 i;
nsresult result = NS_ERROR_FAILURE;
NS_ASSERTION(self,"no self");
self->GetInterfaceInfo(&iface_info);
NS_ASSERTION(iface_info,"no interface info");
iface_info->GetMethodInfo(PRUint16(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");
// args[0] to args[NUM_ARG_REGS] hold floating point register values
PRUint64* ap = args + NUM_ARG_REGS;
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;
}
// else
switch(type)
{
case nsXPTType::T_I8 : dp->val.i8 = (PRInt8) *ap; break;
case nsXPTType::T_I16 : dp->val.i16 = (PRInt16) *ap; break;
case nsXPTType::T_I32 : dp->val.i32 = (PRInt32) *ap; break;
case nsXPTType::T_I64 : dp->val.i64 = (PRInt64) *ap; break;
case nsXPTType::T_U8 : dp->val.u8 = (PRUint8) *ap; break;
case nsXPTType::T_U16 : dp->val.u16 = (PRUint16) *ap; break;
case nsXPTType::T_U32 : dp->val.u32 = (PRUint32) *ap; break;
case nsXPTType::T_U64 : dp->val.u64 = (PRUint64) *ap; break;
case nsXPTType::T_FLOAT :
if(i < NUM_ARG_REGS)
{
// floats passed via registers are stored as doubles
// in the first NUM_ARG_REGS entries in args
dp->val.u64 = (PRUint64) args[i];
dp->val.f = (float) dp->val.d; // convert double to float
}
else
dp->val.u32 = (PRUint32) *ap;
break;
case nsXPTType::T_DOUBLE :
// doubles passed via registers are also stored
// in the first NUM_ARG_REGS entries in args
dp->val.u64 = (i < NUM_ARG_REGS) ? args[i] : *ap;
break;
case nsXPTType::T_BOOL : dp->val.b = (PRBool) *ap; break;
case nsXPTType::T_CHAR : dp->val.c = (char) *ap; break;
case nsXPTType::T_WCHAR : dp->val.wc = (PRUnichar) *ap; 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;
}
/*
* SharedStub()
* Collects arguments and calls PrepareAndDispatch. The "methodIndex" is
* passed to this function via $1 to preserve the argument registers.
*/
__asm__(
"#### SharedStub ####\n"
".text\n\t"
".align 5\n\t"
".ent SharedStub\n"
"SharedStub:\n\t"
".frame $30,96,$26,0\n\t"
".mask 0x4000000,-96\n\t"
"ldgp $29,0($27)\n"
"$SharedStub..ng:\n\t"
"subq $30,96,$30\n\t"
"stq $26,0($30)\n\t"
".prologue 1\n\t"
/*
* Store arguments passed via registers to the stack.
* Floating point registers are stored as doubles and converted
* to floats in PrepareAndDispatch if necessary.
*/
"stt $f17,16($30)\n\t" /* floating point registers */
"stt $f18,24($30)\n\t"
"stt $f19,32($30)\n\t"
"stt $f20,40($30)\n\t"
"stt $f21,48($30)\n\t"
"stq $17,56($30)\n\t" /* integer registers */
"stq $18,64($30)\n\t"
"stq $19,72($30)\n\t"
"stq $20,80($30)\n\t"
"stq $21,88($30)\n\t"
/*
* Call PrepareAndDispatch function.
*/
"bis $1,$1,$17\n\t" /* pass "methodIndex" */
"addq $30,16,$18\n\t" /* pass "args" */
"bsr $26,$PrepareAndDispatch..ng\n\t"
"ldq $26,0($30)\n\t"
"addq $30,96,$30\n\t"
"ret $31,($26),1\n\t"
".end SharedStub"
);
#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */
/*
* nsresult nsXPTCStubBase::Stub##n()
* Sets register $1 to "methodIndex" and jumps to SharedStub.
*/
#define STUB_ENTRY(n) \
__asm__( \
"#### Stub"#n" ####\n" \
".text\n\t" \
".align 5\n\t" \
".globl _ZN14nsXPTCStubBase5Stub"#n"Ev\n\t" \
".ent _ZN14nsXPTCStubBase5Stub"#n"Ev\n" \
"_ZN14nsXPTCStubBase5Stub"#n"Ev:\n\t" \
".frame $30,0,$26,0\n\t" \
"ldgp $29,0($27)\n" \
"$_ZN14nsXPTCStubBase5Stub"#n"Ev..ng:\n\t" \
".prologue 1\n\t" \
"lda $1,"#n"\n\t" \
"br $31,$SharedStub..ng\n\t" \
".end _ZN14nsXPTCStubBase5Stub"#n"Ev" \
); \
__asm__( \
"#### Stub"#n" ####\n" \
".text\n\t" \
".align 5\n\t" \
".globl _ZN14nsXPTCStubBase6Stub"#n"Ev\n\t" \
".ent _ZN14nsXPTCStubBase6Stub"#n"Ev\n" \
"_ZN14nsXPTCStubBase6Stub"#n"Ev:\n\t" \
".frame $30,0,$26,0\n\t" \
"ldgp $29,0($27)\n" \
"$_ZN14nsXPTCStubBase6Stub"#n"Ev..ng:\n\t" \
".prologue 1\n\t" \
"lda $1,"#n"\n\t" \
"br $31,$SharedStub..ng\n\t" \
".end _ZN14nsXPTCStubBase6Stub"#n"Ev" \
); \
__asm__( \
"#### Stub"#n" ####\n" \
".text\n\t" \
".align 5\n\t" \
".globl _ZN14nsXPTCStubBase7Stub"#n"Ev\n\t" \
".ent _ZN14nsXPTCStubBase7Stub"#n"Ev\n" \
"_ZN14nsXPTCStubBase7Stub"#n"Ev:\n\t" \
".frame $30,0,$26,0\n\t" \
"ldgp $29,0($27)\n" \
"$_ZN14nsXPTCStubBase7Stub"#n"Ev..ng:\n\t" \
".prologue 1\n\t" \
"lda $1,"#n"\n\t" \
"br $31,$SharedStub..ng\n\t" \
".end _ZN14nsXPTCStubBase7Stub"#n"Ev" \
);
#else
/*
* nsresult nsXPTCStubBase::Stub##n()
* Sets register $1 to "methodIndex" and jumps to SharedStub.
*/
#define STUB_ENTRY(n) \
nsresult nsXPTCStubBase::Stub##n() \
{ \
nsresult result; \
__asm__ __volatile__( \
"ldah $29,0($27)\n\t" \
"lda $29,0($29)\n\t" \
"lda $1, "#n"\n\t" \
"br $31, $SharedStub..ng\n\t" \
"mov $0, %0\n\t" \
: "=r" (result) \
); \
return result; \
}
#endif
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"

206
www/minimo/files/xptcstubs_openbsd_amd64.cpp
View File

@ -1,206 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
// Implement shared vtbl methods.
#include "xptcprivate.h"
// The Linux/x86-64 ABI passes the first 6 integral 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\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 "can't find a compiler to use"
#endif /* __GNUC__ */

253
www/minimo/files/xptcstubs_ppc_openbsd.cpp
View File

@ -1,253 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape 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/NPL/
*
* 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):
* Franz.Sirl-kernel@lauterbach.com (Franz Sirl)
* beard@netscape.com (Patrick Beard)
* waterson@netscape.com (Chris Waterson)
*
* Alternatively, the contents of this file may be used under the terms of
* either 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 NPL, 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 NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// 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
PrepareAndDispatch(nsXPTCStubBase* self,
PRUint32 methodIndex,
PRUint32* args,
PRUint32 *gprData,
double *fprData)
{
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;
PRUint32* ap = args;
PRUint32 gpr = 1; // skip one GPR register
PRUint32 fpr = 0;
PRUint32 tempu32;
PRUint64 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 ((PRUint32) ap & 4) ap++; // doubles are 8-byte aligned on stack
dp->val.d = *(double*) ap;
ap += 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++;
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 = *(PRUint64*) &gprData[gpr];
gpr += 2;
}
else {
if ((PRUint32) ap & 4) ap++; // longlongs are 8-byte aligned on stack
tempu64 = *(PRUint64*) ap;
ap += 2;
}
}
else {
if (gpr < GPR_COUNT)
tempu32 = gprData[gpr++];
else
tempu32 = *ap++;
}
if(param.IsOut() || !type.IsArithmetic()) {
dp->val.p = (void*) tempu32;
continue;
}
switch(type) {
case nsXPTType::T_I8: dp->val.i8 = (PRInt8) tempu32; break;
case nsXPTType::T_I16: dp->val.i16 = (PRInt16) tempu32; break;
case nsXPTType::T_I32: dp->val.i32 = (PRInt32) tempu32; break;
case nsXPTType::T_I64: dp->val.i64 = (PRInt64) tempu64; break;
case nsXPTType::T_U8: dp->val.u8 = (PRUint8) tempu32; break;
case nsXPTType::T_U16: dp->val.u16 = (PRUint16) tempu32; break;
case nsXPTType::T_U32: dp->val.u32 = (PRUint32) tempu32; break;
case nsXPTType::T_U64: dp->val.u64 = (PRUint64) tempu64; break;
case nsXPTType::T_BOOL: dp->val.b = (PRBool) 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_ASSERTION(0, "bad type");
break;
}
}
result = self->CallMethod((PRUint16) methodIndex, info, dispatchParams);
NS_RELEASE(iface_info);
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 ;-).
#if __GXX_ABI_VERSION < 100
// gcc-2 version
# 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" \
);
#else
// gcc-3 version
//
// As G++3 ABI contains the length of the functionname in the mangled
// name, it is difficult to get a generic assembler mechanism like
// in the G++ 2.95 case.
// Create names would be like:
// _ZN14nsXPTCStubBase5Stub1Ev
// _ZN14nsXPTCStubBase6Stub12Ev
// _ZN14nsXPTCStubBase7Stub123Ev
// _ZN14nsXPTCStubBase8Stub1234Ev
// etc.
// Use assembler directives to get the names right...
# define STUB_ENTRY(n) \
__asm__ ( \
".align 2 \n\t" \
".if "#n" < 10 \n\t" \
".globl _ZN14nsXPTCStubBase5Stub"#n"Ev \n\t" \
".type _ZN14nsXPTCStubBase5Stub"#n"Ev,@function \n\n" \
"_ZN14nsXPTCStubBase5Stub"#n"Ev: \n\t" \
\
".elseif "#n" < 100 \n\t" \
".globl _ZN14nsXPTCStubBase6Stub"#n"Ev \n\t" \
".type _ZN14nsXPTCStubBase6Stub"#n"Ev,@function \n\n" \
"_ZN14nsXPTCStubBase6Stub"#n"Ev: \n\t" \
\
".elseif "#n" < 1000 \n\t" \
".globl _ZN14nsXPTCStubBase7Stub"#n"Ev \n\t" \
".type _ZN14nsXPTCStubBase7Stub"#n"Ev,@function \n\n" \
"_ZN14nsXPTCStubBase7Stub"#n"Ev: \n\t" \
\
".else \n\t" \
".err \"stub number "#n" >= 1000 not yet supported\"\n" \
".endif \n\t" \
\
"li 11,"#n" \n\t" \
"b SharedStub@local \n" \
);
#endif
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"

123
www/minimo/files/xptcstubs_sparc64_openbsd.cpp
View File

@ -1,123 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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 Netscape are
* Copyright (C) 2001 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
* Stuart Parmenter <pavlov@netscape.com>
*/
/* Implement shared vtbl methods. */
#include "xptcprivate.h"
#if defined(sparc) || defined(__sparc__)
extern "C" nsresult
PrepareAndDispatch(nsXPTCStubBase* self, PRUint64 methodIndex, PRUint64* args)
{
#define PARAM_BUFFER_COUNT 16
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = NULL;
nsIInterfaceInfo* iface_info = NULL;
const nsXPTMethodInfo* info;
PRUint8 paramCount;
PRUint8 i;
nsresult result = NS_ERROR_FAILURE;
NS_ASSERTION(self,"no self");
self->GetInterfaceInfo(&iface_info);
NS_ASSERTION(iface_info,"no interface info");
iface_info->GetMethodInfo(PRUint16(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");
PRUint64* 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;
}
// else
switch(type)
{
case nsXPTType::T_BOOL : dp->val.b = *((PRInt64*) ap); break;
case nsXPTType::T_CHAR : dp->val.c = *((PRUint64*) ap); break;
case nsXPTType::T_WCHAR : dp->val.wc = *((PRInt64*) ap); break;
case nsXPTType::T_I8 : dp->val.i8 = *((PRInt64*) ap); break;
case nsXPTType::T_I16 : dp->val.i16 = *((PRInt64*) ap); break;
case nsXPTType::T_I32 : dp->val.i32 = *((PRInt64*) ap); break;
case nsXPTType::T_I64 : dp->val.i64 = *((PRInt64*) ap); break;
case nsXPTType::T_U8 : dp->val.u8 = *((PRUint64*) ap); break;
case nsXPTType::T_U16 : dp->val.u16 = *((PRUint64*)ap); break;
case nsXPTType::T_U32 : dp->val.u32 = *((PRUint64*)ap); break;
case nsXPTType::T_U64 : dp->val.u64 = *((PRUint64*) ap); break;
case nsXPTType::T_FLOAT : dp->val.f = ((float*) ap)[1]; break;
case nsXPTType::T_DOUBLE : dp->val.d = *((double*) ap); 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;
}
extern "C" int SharedStub(int, int*);
#define STUB_ENTRY(n) \
nsresult nsXPTCStubBase::Stub##n() \
{ \
int dummy; /* defeat tail-call optimization */ \
return SharedStub(n, &dummy); \
}
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"
#endif /* sparc || __sparc__ */

10
www/minimo/patches/patch-configure_in
View File

@ -1,7 +1,7 @@
$OpenBSD: patch-configure_in,v 1.7 2007/08/08 17:34:41 martynas Exp $
--- configure.in.orig Wed Jul 25 21:27:50 2007
+++ configure.in Sun Aug 5 15:56:35 2007
@@ -3872,7 +3872,7 @@ _SAVE_LIBS=$LIBS
$OpenBSD: patch-configure_in,v 1.8 2007/11/13 21:24:48 martynas Exp $
--- configure.in.orig Thu Nov 8 15:24:01 2007
+++ configure.in Fri Nov 9 15:23:21 2007
@@ -3878,7 +3878,7 @@ _SAVE_LIBS=$LIBS
CFLAGS="$ZLIB_CFLAGS $CFLAGS"
LDFLAGS="$ZLIB_LIBS -lz $LDFLAGS"
if test -n "${PNG_DIR}" -a "${PNG_DIR}" != "yes"; then
@ -10,7 +10,7 @@ $OpenBSD: patch-configure_in,v 1.7 2007/08/08 17:34:41 martynas Exp $
LDFLAGS="-L${PNG_DIR}/lib $LDFLAGS"
fi
if test -z "$PNG_DIR" -o "$PNG_DIR" = no; then
@@ -3902,7 +3902,7 @@ LDFLAGS=$_SAVE_LDFLAGS
@@ -3908,7 +3908,7 @@ LDFLAGS=$_SAVE_LDFLAGS
LIBS=$_SAVE_LIBS
if test "${PNG_DIR}" -a -d "${PNG_DIR}" -a "$SYSTEM_PNG" = 1; then

16
www/minimo/patches/patch-js_src_jsnum_h
View File

@ -1,12 +1,12 @@
$OpenBSD: patch-js_src_jsnum_h,v 1.1 2007/02/23 18:17:17 robert Exp $
--- js/src/jsnum.h.orig Thu Dec 9 02:32:19 2004
+++ js/src/jsnum.h Fri Feb 23 17:12:12 2007
@@ -60,7 +60,7 @@ JS_BEGIN_EXTERN_C
* are stored in big endian`s way.
$OpenBSD: patch-js_src_jsnum_h,v 1.2 2007/11/13 21:24:48 martynas Exp $
--- js/src/jsnum.h.orig Thu Nov 1 22:52:24 2007
+++ js/src/jsnum.h Fri Nov 9 15:33:55 2007
@@ -61,7 +61,7 @@ JS_BEGIN_EXTERN_C
*/
-#if defined(__arm) || defined(__arm32__) || defined(__arm26__) || defined(__arm__)
+#if (defined(__arm) || defined(__arm32__) || defined(__arm26__) || defined(__arm__)) && !defined(__OpenBSD__) /* Armel ABI */
#if defined(__arm) || defined(__arm32__) || defined(__arm26__) || defined(__arm__)
-#ifndef __QNXNTO__
+#if !defined(__QNXNTO__) && !defined(__OpenBSD__) /* Armel ABI */
#define CPU_IS_ARM
#endif
#endif

10
www/minimo/patches/patch-modules_libpref_src_init_all_js
View File

@ -1,7 +1,7 @@
$OpenBSD: patch-modules_libpref_src_init_all_js,v 1.5 2007/04/01 09:36:15 martynas Exp $
--- modules/libpref/src/init/all.js.orig Fri Jan 5 03:04:33 2007
+++ modules/libpref/src/init/all.js Wed Mar 28 12:08:10 2007
@@ -1932,33 +1932,33 @@ pref("font.name.monospace.ko", "monospace");
$OpenBSD: patch-modules_libpref_src_init_all_js,v 1.6 2007/11/13 21:24:48 martynas Exp $
--- modules/libpref/src/init/all.js.orig Thu Sep 13 22:06:23 2007
+++ modules/libpref/src/init/all.js Fri Nov 9 15:23:22 2007
@@ -1933,33 +1933,33 @@ pref("font.name.monospace.ko", "monospace");
// th
@ -50,7 +50,7 @@ $OpenBSD: patch-modules_libpref_src_init_all_js,v 1.5 2007/04/01 09:36:15 martyn
pref("font.name.serif.zh-CN", "serif");
pref("font.name.sans-serif.zh-CN", "sans-serif");
@@ -2098,7 +2098,7 @@ pref("font.scale.outline.min", 6);
@@ -2099,7 +2099,7 @@ pref("font.scale.outline.min", 6);
// TrueType
pref("font.FreeType2.enable", false);

83
www/minimo/patches/patch-xpcom_reflect_xptcall_src_md_unix_Makefile_in
View File

@ -1,83 +0,0 @@
$OpenBSD: patch-xpcom_reflect_xptcall_src_md_unix_Makefile_in,v 1.5 2007/04/01 09:36:16 martynas Exp $
--- xpcom/reflect/xptcall/src/md/unix/Makefile.in.orig Tue Nov 28 07:29:22 2006
+++ xpcom/reflect/xptcall/src/md/unix/Makefile.in Wed Mar 28 12:08:58 2007
@@ -68,6 +68,12 @@ CPPSRCS := xptcinvoke_unixish_x86.cpp xptcstubs_unixi
endif
endif
#
+# OpenBSD/amd64
+#
+ifeq ($(OS_ARCH)$(OS_TEST),OpenBSDamd64)
+CPPSRCS := xptcinvoke_openbsd_amd64.cpp xptcstubs_openbsd_amd64.cpp
+endif
+#
# New code for Linux, et. al., with gcc
# Migrate other platforms here after testing
#
@@ -129,6 +135,12 @@ CPPSRCS := xptcinvoke_osf1_alpha.cpp xptcstubs_osf1_a
ASFILES := xptcinvoke_asm_osf1_alpha.s xptcstubs_asm_osf1_alpha.s
endif
#
+# OpenBSD/Alpha
+#
+ifeq ($(OS_ARCH)$(OS_TEST),OpenBSDalpha)
+CPPSRCS := xptcinvoke_openbsd_alpha.cpp xptcstubs_openbsd_alpha.cpp
+endif
+#
# Linux/Alpha
#
ifneq (,$(filter Linuxalpha FreeBSDalpha NetBSDalpha,$(OS_ARCH)$(OS_TEST)))
@@ -162,6 +174,17 @@ ifneq (,$(filter arm% sa110,$(OS_TEST)))
CPPSRCS := xptcinvoke_arm_netbsd.cpp xptcstubs_arm_netbsd.cpp
endif
endif
+######################################################################
+#
+# OpenBSD/ARM
+#
+# NOTE: won't work w/o optimizations (-O1, -O2)
+ifeq ($(OS_ARCH),OpenBSD)
+ifneq (,$(filter armish zaurus,$(OS_TEST)))
+CPPSRCS := xptcinvoke_arm_openbsd.cpp xptcstubs_arm_openbsd.cpp
+CXXFLAGS += -O2
+endif
+endif
######################################################################
# HPPA
@@ -278,6 +301,14 @@ ASFILES := xptcinvoke_asm_ppc_netbsd.s xptcstubs_asm_
endif
#
+# OpenBSD/PPC
+#
+ifneq (,$(filter OpenBSDmacppc,$(OS_ARCH)$(OS_TEST)))
+CPPSRCS := xptcinvoke_ppc_openbsd.cpp xptcstubs_ppc_openbsd.cpp
+ASFILES := xptcinvoke_asm_ppc_openbsd.s xptcstubs_asm_ppc_openbsd.s
+endif
+
+#
# Darwin/PPC
#
ifeq ($(OS_ARCH),Darwin)
@@ -349,6 +380,20 @@ endif
endif
endif
+endif
+#
+# OpenBSD/SPARC
+#
+ifeq ($(OS_ARCH)$(OS_TEST),OpenBSDsparc)
+CPPSRCS := xptcinvoke_sparc_netbsd.cpp xptcstubs_sparc_netbsd.cpp
+ASFILES := xptcinvoke_asm_sparc_netbsd.s xptcstubs_asm_sparc_netbsd.s
+endif
+#
+# OpenBSD/SPARC64
+#
+ifeq ($(OS_ARCH)$(OS_TEST),OpenBSDsparc64)
+CPPSRCS := xptcinvoke_sparc64_openbsd.cpp xptcstubs_sparc64_openbsd.cpp
+ASFILES := xptcinvoke_asm_sparc64_openbsd.s xptcstubs_asm_sparcv9_solaris.s
endif
######################################################################