wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-10 02:08:38 +09:00
Code Issues Projects Releases Packages Wiki Activity

Remove AIX 1st party code OS checks, part 1

Browse source 
Issue #186
This commit is contained in:
wolfbeast 2019-03-31 18:43:10 +02:00 • committed by Roy Tam
commit 769e5dad1e
23 changed files with 1 additions and 1226 deletions
Download patch file Download diff file Expand all files Collapse all files

4
accessible/atk/Platform.cpp
View file

@ -60,11 +60,7 @@ struct GnomeAccessibilityModule
};
static GnomeAccessibilityModule sAtkBridge = {
#ifdef AIX
"libatk-bridge.a(libatk-bridge.so.0)", nullptr,
#else
"libatk-bridge.so", nullptr,
#endif
"gnome_accessibility_module_init", nullptr,
"gnome_accessibility_module_shutdown", nullptr
};

9
config/rules.mk
View file

@ -386,15 +386,6 @@ endif
endif
endif
ifeq ($(OS_ARCH),AIX)
ifdef IS_COMPONENT
ifneq ($(HAS_EXTRAEXPORTS),1)
MKSHLIB += -bE:$(MOZILLA_DIR)/build/unix/aix.exp -bnoexpall
MKCSHLIB += -bE:$(MOZILLA_DIR)/build/unix/aix.exp -bnoexpall
endif # HAS_EXTRAEXPORTS
endif # IS_COMPONENT
endif # AIX
#
# Linux: add -Bsymbolic flag for components
#

12
dom/plugins/base/nptypes.h
View file

@ -22,18 +22,6 @@
typedef unsigned int uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
#elif defined(_AIX) || defined(__sun) || defined(__osf__) || defined(IRIX) || defined(HPUX)
/*
* AIX ships an inttypes.h header that defines [u]int32_t,
* but not bool for C.
*/
#include <inttypes.h>
#ifndef __cplusplus
typedef int bool;
#define true 1
#define false 0
#endif
#elif defined(bsdi) || defined(FREEBSD) || defined(OPENBSD)
/*
* BSD/OS, FreeBSD, and OpenBSD ship sys/types.h that define int32_t and

3
dom/plugins/base/nsPluginsDirUnix.cpp
View file

@ -24,9 +24,6 @@
#undef LOCAL_PLUGIN_DLL_SUFFIX
#define LOCAL_PLUGIN_DLL_SUFFIX ".sl"
#define LOCAL_PLUGIN_DLL_ALT_SUFFIX ".so"
#elif defined(_AIX)
#define DEFAULT_X11_PATH "/usr/lib"
#define LOCAL_PLUGIN_DLL_ALT_SUFFIX ".a"
#elif defined(LINUX)
#define DEFAULT_X11_PATH "/usr/X11R6/lib/"
#elif defined(__APPLE__)

10
js/public/LegacyIntTypes.h
View file

@ -31,20 +31,10 @@ typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;
/*
* On AIX 4.3, sys/inttypes.h (which is included by sys/types.h, a very
* common header file) defines the types int8, int16, int32, and int64.
* So we don't define these four types here to avoid conflicts in case
* the code also includes sys/types.h.
*/
#if defined(AIX) && defined(HAVE_SYS_INTTYPES_H)
#include <sys/inttypes.h>
#else
typedef int8_t int8;
typedef int16_t int16;
typedef int32_t int32;
typedef int64_t int64;
#endif /* AIX && HAVE_SYS_INTTYPES_H */
typedef uint8_t JSUint8;
typedef uint16_t JSUint16;

11
js/src/Makefile.in
View file

@ -138,17 +138,6 @@ distclean::
CFLAGS += $(MOZ_ZLIB_CFLAGS)
# Silence warnings on AIX/HP-UX from non-GNU compilers
ifndef GNU_CC
ifeq ($(OS_ARCH),AIX)
# Suppress warnings from xlC
# 1540-1281: offsetof() on null non-POD types
# 1540-1608: anonymous unions using static data members
CFLAGS += -qsuppress=1540-1281 -qsuppress=1540-1608
CXXFLAGS += -qsuppress=1540-1281 -qsuppress=1540-1608
endif
endif
$(LIBRARY_NAME).pc: js.pc
cp $^ $@

15
js/src/jsnativestack.cpp
View file

@ -71,21 +71,6 @@ js::GetNativeStackBaseImpl()
# endif
}
#elif defined(AIX)
#include <ucontext.h>
JS_STATIC_ASSERT(JS_STACK_GROWTH_DIRECTION < 0);
void*
js::GetNativeStackBaseImpl()
{
ucontext_t context;
getcontext(&context);
return static_cast<char*>(context.uc_stack.ss_sp) +
context.uc_stack.ss_size;
}
#elif defined(XP_LINUX) && !defined(ANDROID) && defined(__GLIBC__)
void*
js::GetNativeStackBaseImpl()

4
xpcom/build/nsXPCOMPrivate.h
View file

@ -281,10 +281,6 @@ void LogTerm();
#error need_to_define_your_file_path_separator_and_illegal_characters
#endif
#ifdef AIX
#include <sys/param.h>
#endif
#ifndef MAXPATHLEN
#ifdef PATH_MAX
#define MAXPATHLEN PATH_MAX

7
xpcom/io/nsLocalFile.h
View file

@ -91,15 +91,8 @@ nsresultForErrno(int aErr)
case EROFS: /* Read-only file system. */
return NS_ERROR_FILE_READ_ONLY;
#endif
/*
* On AIX 4.3, ENOTEMPTY is defined as EEXIST,
* so there can't be cases for both without
* preprocessing.
*/
#if ENOTEMPTY != EEXIST
case ENOTEMPTY:
return NS_ERROR_FILE_DIR_NOT_EMPTY;
#endif /* ENOTEMPTY != EEXIST */
/* Note that nsIFile.createUnique() returns
NS_ERROR_FILE_TOO_BIG when it cannot create a temporary
file with a unique filename.

5
xpcom/io/nsLocalFileUnix.h
View file

@ -65,11 +65,6 @@
// stat64 and lstat64 are deprecated on OS X. Normal stat and lstat are
// 64-bit by default on OS X 10.6+.
#if defined(HAVE_STAT64) && defined(HAVE_LSTAT64) && !defined(XP_DARWIN)
#if defined (AIX)
#if defined STAT
#undef STAT
#endif
#endif
#define STAT stat64
#define LSTAT lstat64
#define HAVE_STATS64 1

18
xpcom/reflect/xptcall/md/unix/Makefile.in
View file

@ -24,13 +24,6 @@ endif
# PowerPC
######################################################################
#
# AIX/PPC
#
ifeq ($(OS_ARCH),AIX)
# #24617 Building the CPP's (CXX) optimized causes a crash
CXXFLAGS := $(filter-out $(MOZ_OPTIMIZE_FLAGS), $(CXXFLAGS))
endif
include $(topsrcdir)/config/rules.mk
ifeq ($(OS_ARCH),Linux)
@ -43,14 +36,3 @@ ifeq ($(OS_ARCH),Darwin)
xptcstubs_asm_ppc_darwin.s: xptcstubs_asm_ppc_darwin.s.m4 $(DIST)/include/xptcstubsdef.inc Makefile
gm4 $(INCLUDES) $< > $@
endif
ifeq ($(OS_ARCH),AIX)
ifdef HAVE_64BIT_BUILD
xptcstubs_asm_ppc_aix64.s: xptcstubs_asm_ppc_aix64.s.m4 $(DIST)/include/xptcstubsdef.inc Makefile
m4 -DAIX_OBJMODEL=$(AIX_OBJMODEL) $(INCLUDES) -I. $< > $@
else
xptcstubs_asm_ppc_aix.s: xptcstubs_asm_ppc_aix.s.m4 $(DIST)/include/xptcstubsdef.inc Makefile
m4 -DAIX_OBJMODEL=$(AIX_OBJMODEL) $(INCLUDES) -I. $< > $@
endif
endif

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

@ -127,29 +127,6 @@ if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD', 'NetBSD', 'OpenBSD'):
'xptcstubs_mips.cpp',
]
if CONFIG['OS_ARCH'] == 'AIX':
if CONFIG['HAVE_64BIT_BUILD']:
SOURCES += [
'!xptcstubs_asm_ppc_aix64.s',
'xptcinvoke_asm_ppc_aix64.s',
'xptcinvoke_ppc_aix64.cpp',
'xptcstubs_ppc_aix64.cpp',
]
else:
SOURCES += [
'!xptcstubs_asm_ppc_aix.s',
'xptcinvoke_ppc_aix.cpp',
'xptcstubs_ppc_aix.cpp',
]
if CONFIG['AIX_OBJMODEL'] == 'ibm':
SOURCES += [
'xptcinvoke_asm_ppc_ibmobj_aix.s',
]
else:
SOURCES += [
'xptcinvoke_asm_ppc_aix.s',
]
if CONFIG['OS_TEST'] == 'powerpc':
if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):
SOURCES += [

129
xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc_aix.s
View file

@ -1,129 +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/.
.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
.set BO_IF,12
.set CR0_EQ,2
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.NS_InvokeByIndex{TC},"NS_InvokeByIndex"
# .text section
.csect H.10.NO_SYMBOL{PR}
.globl .NS_InvokeByIndex
.globl NS_InvokeByIndex{DS}
.extern .invoke_copy_to_stack
.extern ._ptrgl{PR}
#
# NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
# uint32_t paramCount, nsXPTCVariant* params)
#
.NS_InvokeByIndex:
mflr r0
stw r31,-4(sp)
#
# save off the incoming values in the caller's parameter area
#
stw r3,24(sp) # that
stw r4,28(sp) # methodIndex
stw r5,32(sp) # paramCount
stw r6,36(sp) # params
stw r0,8(sp)
stwu sp,-136(sp) # = 24 for linkage area, 8 * 13 for fprData area, 8 for saved registers
# prepare args for 'invoke_copy_to_stack' call
#
lwz r4,168(sp) # paramCount
lwz r5,172(sp) # params
mr r6,sp # fprData
slwi r3,r4,3 # number of bytes of stack required
# at most 8*paramCount
addi r3,r3,28 # linkage area
mr r31,sp # save original stack top
subfc sp,r3,sp # bump the stack
addi r3,sp,28 # parameter pointer excludes linkage area size + 'this'
bl .invoke_copy_to_stack
nop
lfd f1,0(r31) # Restore floating point registers
lfd f2,8(r31)
lfd f3,16(r31)
lfd f4,24(r31)
lfd f5,32(r31)
lfd f6,40(r31)
lfd f7,48(r31)
lfd f8,56(r31)
lfd f9,64(r31)
lfd f10,72(r31)
lfd f11,80(r31)
lfd f12,88(r31)
lfd f13,96(r31)
lwz r3,160(r31) # that
lwz r4,0(r3) # get vTable from 'that'
lwz r5,164(r31) # methodIndex
slwi r5,r5,3 # methodIndex * 8
addi r5,r5,8 # step over junk at start of vTable !
lwzx r11,r5,r4 # get function pointer
addi r5,r5,4 # We need to manually adjust the 'that' pointer, this is CFRONT based
lwzx r5,r4,r5 # offset = r4(vtable) + r5(methodIndex offset) - 4
add r3,r5,r3 # adjust 'that' r3 = r3 + r5
lwz r4,28(sp)
lwz r5,32(sp)
lwz r6,36(sp)
lwz r7,40(sp)
lwz r8,44(sp)
lwz r9,48(sp)
lwz r10,52(sp)
bl ._ptrgl{PR}
nop
mr sp,r31
lwz r0,144(sp)
addi sp,sp,136
mtlr r0
lwz r31,-4(sp)
blr
# .data section
.toc # 0x00000038
T.18.NS_InvokeByIndex:
.tc H.18.NS_InvokeByIndex{TC},NS_InvokeByIndex{DS}
.csect NS_InvokeByIndex{DS}
.long .NS_InvokeByIndex # "\0\0\0\0"
.long TOC{TC0} # "\0\0\0008"
.long 0x00000000 # "\0\0\0\0"
# End csect NS_InvokeByIndex{DS}
# .bss section

128
xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc_aix64.s
View file

@ -1,128 +0,0 @@
# 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
.set BO_IF,12
.set CR0_EQ,2
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.NS_InvokeByIndex{TC},"NS_InvokeByIndex"
# .text section
.csect H.10.NO_SYMBOL{PR}
.globl .NS_InvokeByIndex
.globl NS_InvokeByIndex{DS}
.extern .invoke_copy_to_stack
.extern ._ptrgl{PR}
#
# NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
# uint32_t paramCount, nsXPTCVariant* params)
#
.NS_InvokeByIndex:
mflr r0
std r31,-8(sp)
#
# save off the incoming values in the caller's parameter area
#
std r3,48(sp) # that
std r4,56(sp) # methodIndex
std r5,64(sp) # paramCount
std r6,72(sp) # params
std r0,16(sp)
stdu sp,-168(sp) # 2*24=48 for linkage area,
# 8*13=104 for fprData area
# 16 for saved registers
# prepare args for 'invoke_copy_to_stack' call
#
ld r4,232(sp) # paramCount (168+8+56)
ld r5,240(sp) # params
mr r6,sp # fprData
sldi r3,r4,3 # number of bytes of stack required
# is at most numParams*8
addi r3,r3,56 # linkage area (48) + this (8)
mr r31,sp # save original stack top
subfc sp,r3,sp # bump the stack
addi r3,sp,56 # parameter pointer excludes linkage area
# size + 'this'
bl .invoke_copy_to_stack
nop
lfd f1,0(r31) # Restore floating point registers
lfd f2,8(r31)
lfd f3,16(r31)
lfd f4,24(r31)
lfd f5,32(r31)
lfd f6,40(r31)
lfd f7,48(r31)
lfd f8,56(r31)
lfd f9,64(r31)
lfd f10,72(r31)
lfd f11,80(r31)
lfd f12,88(r31)
lfd f13,96(r31)
ld r3,216(r31) # that (168+48)
ld r4,0(r3) # get vTable from 'that'
ld r5,224(r31) # methodIndex (168+56)
sldi r5,r5,3 # methodIndex * 8
# No junk at the start of 64bit vtable !!!
ldx r11,r5,r4 # get function pointer (this jumps
# either to the function if no adjustment
# is needed (displacement = 0), or it
# jumps to the thunk code, which will jump
# to the function at the end)
# No adjustment of the that pointer in 64bit mode, this is done
# by the thunk code
ld r4,56(sp)
ld r5,64(sp)
ld r6,72(sp)
ld r7,80(sp)
ld r8,88(sp)
ld r9,96(sp)
ld r10,104(sp)
bl ._ptrgl{PR}
nop
mr sp,r31
ld r0,184(sp) # 168+16
addi sp,sp,168
mtlr r0
ld r31,-8(sp)
blr
# .data section
.toc # 0x00000038
T.18.NS_InvokeByIndex:
.tc H.18.NS_InvokeByIndex{TC},NS_InvokeByIndex{DS}
.csect NS_InvokeByIndex{DS}
.llong .NS_InvokeByIndex # "\0\0\0\0"
.llong TOC{TC0} # "\0\0\0008"
.llong 0x00000000 # "\0\0\0\0"
# End csect NS_InvokeByIndex{DS}
# .bss section

124
xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc_ibmobj_aix.s
View file

@ -1,124 +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/.
.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
.set BO_IF,12
.set CR0_EQ,2
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.NS_InvokeByIndex{TC},"NS_InvokeByIndex"
# .text section
.csect H.10.NO_SYMBOL{PR}
.globl .NS_InvokeByIndex
.globl NS_InvokeByIndex{DS}
.extern .invoke_copy_to_stack
.extern ._ptrgl{PR}
#
# NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
# uint32_t paramCount, nsXPTCVariant* params)
#
.NS_InvokeByIndex:
mflr r0
stw r31,-4(sp)
#
# save off the incoming values in the caller's parameter area
#
stw r3,24(sp) # that
stw r4,28(sp) # methodIndex
stw r5,32(sp) # paramCount
stw r6,36(sp) # params
stw r0,8(sp)
stwu sp,-136(sp) # = 24 for linkage area, 8 * 13 for fprData area, 8 for saved registers
# prepare args for 'invoke_copy_to_stack' call
#
lwz r4,168(sp) # paramCount
lwz r5,172(sp) # params
mr r6,sp # fprData
slwi r3,r4,3 # number of bytes of stack required
# at most 8*paramCount
addi r3,r3,28 # linkage area
mr r31,sp # save original stack top
subfc sp,r3,sp # bump the stack
addi r3,sp,28 # parameter pointer excludes linkage area size + 'this'
bl .invoke_copy_to_stack
nop
lfd f1,0(r31) # Restore floating point registers
lfd f2,8(r31)
lfd f3,16(r31)
lfd f4,24(r31)
lfd f5,32(r31)
lfd f6,40(r31)
lfd f7,48(r31)
lfd f8,56(r31)
lfd f9,64(r31)
lfd f10,72(r31)
lfd f11,80(r31)
lfd f12,88(r31)
lfd f13,96(r31)
lwz r3,160(r31) # that
lwz r4,0(r3) # get vTable from 'that'
lwz r5,164(r31) # methodIndex
slwi r5,r5,2 # methodIndex * 4
lwzx r11,r5,r4 # get function pointer
lwz r4,28(sp)
lwz r5,32(sp)
lwz r6,36(sp)
lwz r7,40(sp)
lwz r8,44(sp)
lwz r9,48(sp)
lwz r10,52(sp)
bl ._ptrgl{PR}
nop
mr sp,r31
lwz r0,144(sp)
addi sp,sp,136
mtlr r0
lwz r31,-4(sp)
blr
# .data section
.toc # 0x00000038
T.18.NS_InvokeByIndex:
.tc H.18.NS_InvokeByIndex{TC},NS_InvokeByIndex{DS}
.csect NS_InvokeByIndex{DS}
.long .NS_InvokeByIndex # "\0\0\0\0"
.long TOC{TC0} # "\0\0\0008"
.long 0x00000000 # "\0\0\0\0"
# End csect NS_InvokeByIndex{DS}
# .bss section

74
xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc_aix.cpp
View file

@ -1,74 +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"
#ifndef AIX
#error "This code is for PowerPC only"
#endif
extern "C" void
invoke_copy_to_stack(uint32_t* d, uint32_t paramCount, nsXPTCVariant* s, double *fprData)
{
/*
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.
*/
uint32_t *l_d = d;
nsXPTCVariant *l_s = s;
uint32_t l_paramCount = paramCount, fpCount = 0;
double *l_fprData = fprData;
typedef struct {
uint32_t hi;
uint32_t lo;
} DU; // have to move 64 bit entities as 32 bit halves since
// stack slots are not guaranteed 16 byte aligned
for(uint32_t i = 0; i < l_paramCount; i++, l_d++, l_s++)
{
if(l_s->IsPtrData())
{
*((void**)l_d) = l_s->ptr;
continue;
}
switch(l_s->type)
{
case nsXPTType::T_I8 : *((int32_t*) l_d) = l_s->val.i8; break;
case nsXPTType::T_I16 : *((int32_t*) l_d) = l_s->val.i16; break;
case nsXPTType::T_I32 : *((int32_t*) l_d) = l_s->val.i32; break;
case nsXPTType::T_I64 :
case nsXPTType::T_U64 :
*((uint32_t*) l_d++) = ((DU *)l_s)->hi;
*((uint32_t*) l_d) = ((DU *)l_s)->lo;
break;
case nsXPTType::T_DOUBLE :
*((uint32_t*) l_d++) = ((DU *)l_s)->hi;
*((uint32_t*) l_d) = ((DU *)l_s)->lo;
if(fpCount < 13)
l_fprData[fpCount++] = l_s->val.d;
break;
case nsXPTType::T_U8 : *((uint32_t*) l_d) = l_s->val.u8; break;
case nsXPTType::T_U16 : *((uint32_t*) l_d) = l_s->val.u16; break;
case nsXPTType::T_U32 : *((uint32_t*) l_d) = l_s->val.u32; break;
case nsXPTType::T_FLOAT :
*((float*) l_d) = l_s->val.f;
if(fpCount < 13)
l_fprData[fpCount++] = l_s->val.f;
break;
case nsXPTType::T_BOOL : *((uint32_t*) l_d) = l_s->val.b; break;
case nsXPTType::T_CHAR : *((uint32_t*) l_d) = l_s->val.c; break;
case nsXPTType::T_WCHAR : *((int32_t*) l_d) = l_s->val.wc; break;
default:
// all the others are plain pointer types
*((void**)l_d) = l_s->val.p;
break;
}
}
}

63
xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc_aix64.cpp
View file

@ -1,63 +0,0 @@
/* 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"
#ifdef _AIX
extern "C" void
invoke_copy_to_stack(uint64_t* d, uint32_t paramCount, nsXPTCVariant* s, double *fprData)
{
/*
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.
*/
uint64_t *l_d = d;
nsXPTCVariant *l_s = s;
uint32_t l_paramCount = paramCount, fpCount = 0;
double *l_fprData = fprData;
for(uint32_t i = 0; i < l_paramCount; i++, l_d++, l_s++)
{
if(l_s->IsPtrData())
{
*l_d = (uint64_t)l_s->ptr;
continue;
}
switch(l_s->type)
{
case nsXPTType::T_I8: *l_d = (uint64_t)l_s->val.i8; break;
case nsXPTType::T_I16: *l_d = (uint64_t)l_s->val.i16; break;
case nsXPTType::T_I32: *l_d = (uint64_t)l_s->val.i32; break;
case nsXPTType::T_I64: *l_d = (uint64_t)l_s->val.i64; break;
case nsXPTType::T_U8: *l_d = (uint64_t)l_s->val.u8; break;
case nsXPTType::T_U16: *l_d = (uint64_t)l_s->val.u16; break;
case nsXPTType::T_U32: *l_d = (uint64_t)l_s->val.u32; break;
case nsXPTType::T_U64: *l_d = (uint64_t)l_s->val.u64; break;
case nsXPTType::T_BOOL: *l_d = (uint64_t)l_s->val.b; break;
case nsXPTType::T_CHAR: *l_d = (uint64_t)l_s->val.c; break;
case nsXPTType::T_WCHAR: *l_d = (uint64_t)l_s->val.wc; break;
case nsXPTType::T_DOUBLE:
*((double*)l_d) = l_s->val.d;
if(fpCount < 13)
l_fprData[fpCount++] = l_s->val.d;
break;
case nsXPTType::T_FLOAT:
*((float*)l_d) = l_s->val.f;
if(fpCount < 13)
l_fprData[fpCount++] = l_s->val.f;
break;
default:
// all the others are plain pointer types
*l_d = (uint64_t)l_s->val.p;
break;
}
}
}
#endif

119
xpcom/reflect/xptcall/md/unix/xptcstubs_asm_ppc_aix.s.m4
View file

@ -1,119 +0,0 @@
# 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
# Define the correct name of the stub function based on the object model
define(STUB_NAME,
ifelse(AIX_OBJMODEL, ibm,
`Stub'$1`__EI14nsXPTCStubBaseFv',
`Stub'$1`__14nsXPTCStubBaseFv'))
define(STUB_ENTRY, `
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.'STUB_NAME($1)`{TC},"'STUB_NAME($1)`"
.csect H.10.NO_SYMBOL{PR}
.globl .'STUB_NAME($1)`
.globl 'STUB_NAME($1)`{DS}
.'STUB_NAME($1)`:
li r12, '$1`
b .SharedStub
nop
.toc
T.18.'STUB_NAME($1)`:
.tc H.18.'STUB_NAME($1)`{TC},'STUB_NAME($1)`{DS}
.csect 'STUB_NAME($1)`{DS}
.long .'STUB_NAME($1)`
.long TOC{TC0}
.long 0x00000000
')
define(SENTINEL_ENTRY, `')
include(xptcstubsdef.inc)
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.SharedStub{TC},"SharedStub"
# .text section
.csect H.10.NO_SYMBOL{PR}
.globl .SharedStub
.globl SharedStub{DS}
.extern .PrepareAndDispatch
.SharedStub:
mflr r0
stw r0,8(sp)
stwu sp,-176(sp) # room for linkage (24), fprData (104), gprData(28)
# outgoing params to PrepareAndDispatch (20)
stw r4,44(sp) # link area (24) + PrepareAndDispatch params (20)
stw r5,48(sp)
stw r6,52(sp)
stw r7,56(sp)
stw r8,60(sp)
stw r9,64(sp)
stw r10,68(sp)
stfd f1,72(sp)
stfd f2,80(sp)
stfd f3,88(sp)
stfd f4,96(sp)
stfd f5,104(sp)
stfd f6,112(sp)
stfd f7,120(sp)
stfd f8,128(sp)
stfd f9,136(sp)
stfd f10,144(sp)
stfd f11,152(sp)
stfd f12,156(sp)
stfd f13,164(sp)
addi r6,sp,44 # gprData
addi r7,sp,72 # fprData
# r3 has the 'self' pointer already
mr r4,r12 # methodIndex selector (it is now LATER)
addi r5,sp,232 # pointer to callers args area, beyond r3-r10
# mapped range
bl .PrepareAndDispatch
nop
lwz r0,184(sp)
addi sp,sp,176
mtlr r0
blr
# .data section
.toc # 0x00000038
T.18.SharedStub:
.tc H.18.SharedStub{TC},SharedStub{DS}
.csect SharedStub{DS}
.long .SharedStub # "\0\0\0\0"
.long TOC{TC0} # "\0\0\0008"
.long 0x00000000 # "\0\0\0\0"
# End csect SharedStub{DS}
# .bss section

97
xpcom/reflect/xptcall/md/unix/xptcstubs_asm_ppc_aix64.s.m4
View file

@ -1,97 +0,0 @@
# 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
# Define the correct name of the stub function based on the object model
define(STUB_NAME,
ifelse(AIX_OBJMODEL, ibm,
`Stub'$1`__EI14nsXPTCStubBaseFv',
`Stub'$1`__14nsXPTCStubBaseFv'))
define(STUB_ENTRY, `
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.'STUB_NAME($1)`{TC},"'STUB_NAME($1)`"
.csect H.10.NO_SYMBOL{PR}
.globl .'STUB_NAME($1)`
.globl 'STUB_NAME($1)`{DS}
.'STUB_NAME($1)`:
li r12, '$1`
b .SharedStub
nop
.toc
T.18.'STUB_NAME($1)`:
.tc H.18.'STUB_NAME($1)`{TC},'STUB_NAME($1)`{DS}
.csect 'STUB_NAME($1)`{DS}
.llong .'STUB_NAME($1)`
.llong TOC{TC0}
.llong 0x00000000
')
define(SENTINEL_ENTRY, `')
include(xptcstubsdef.inc)
.rename H.10.NO_SYMBOL{PR},""
.rename H.18.SharedStub{TC},"SharedStub"
# .text section
.csect H.10.NO_SYMBOL{PR}
.globl .SharedStub
.globl SharedStub{DS}
.extern .PrepareAndDispatch
.SharedStub:
mflr r0
std r0,16(sp)
stdu sp,-248(sp) # room for linkage (24*2), fprData (104), gprData(28*2)
# outgoing params to PrepareAndDispatch (40)
std r4,88(sp) # link area (48) + PrepareAndDispatch params (20)
std r5,96(sp)
std r6,104(sp)
std r7,112(sp)
std r8,120(sp)
std r9,128(sp)
std r10,136(sp)
stfd f1,144(sp)
stfd f2,152(sp)
stfd f3,160(sp)
stfd f4,168(sp)
stfd f5,176(sp)
stfd f6,184(sp)
stfd f7,192(sp)
stfd f8,200(sp)
stfd f9,208(sp)
stfd f10,216(sp)
stfd f11,224(sp)
stfd f12,232(sp)
stfd f13,240(sp)
addi r6,sp,88 # gprData
addi r7,sp,144 # fprData
# r3 has the 'self' pointer already
mr r4,r12 # methodIndex selector (it is now LATER)
addi r5,sp,360 # pointer to callers args area, beyond r3-r10
# mapped range
bl .PrepareAndDispatch
nop
ld r0,264(sp)
addi sp,sp,248
mtlr r0
blr
# .data section
.toc # 0x00000038
T.18.SharedStub:
.tc H.18.SharedStub{TC},SharedStub{DS}
.csect SharedStub{DS}
.llong .SharedStub # "\0\0\0\0"
.llong TOC{TC0} # "\0\0\0008"
.llong 0x00000000 # "\0\0\0\0"
# End csect SharedStub{DS}
# .bss section

185
xpcom/reflect/xptcall/md/unix/xptcstubs_ppc_aix.cpp
View file

@ -1,185 +0,0 @@
/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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"
#include "xptiprivate.h"
#if defined(AIX)
/*
For PPC (AIX & MAC), the first 8 integral and the first 13 f.p. parameters
arrive in a separate chunk of data that has been loaded from the registers.
The args pointer has been set to the start of the parameters BEYOND the ones
arriving in registers
*/
extern "C" nsresult ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args, uint32_t *gprData, double *fprData)
{
typedef struct {
uint32_t hi;
uint32_t lo; // have to move 64 bit entities as 32 bit halves since
} DU; // stack slots are not guaranteed 16 byte aligned
#define PARAM_BUFFER_COUNT 16
#define PARAM_GPR_COUNT 7
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
const nsXPTMethodInfo* info = nullptr;
uint8_t paramCount;
uint8_t i;
nsresult result = NS_ERROR_FAILURE;
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");
uint32_t* ap = args;
uint32_t iCount = 0;
uint32_t fpCount = 0;
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.IsArithmetic())
{
if (iCount < PARAM_GPR_COUNT)
dp->val.p = (void*) gprData[iCount++];
else
dp->val.p = (void*) *ap++;
continue;
}
// else
switch(type)
{
case nsXPTType::T_I8 : if (iCount < PARAM_GPR_COUNT)
dp->val.i8 = (int8_t) gprData[iCount++];
else
dp->val.i8 = (int8_t) *ap++;
break;
case nsXPTType::T_I16 : if (iCount < PARAM_GPR_COUNT)
dp->val.i16 = (int16_t) gprData[iCount++];
else
dp->val.i16 = (int16_t) *ap++;
break;
case nsXPTType::T_I32 : if (iCount < PARAM_GPR_COUNT)
dp->val.i32 = (int32_t) gprData[iCount++];
else
dp->val.i32 = (int32_t) *ap++;
break;
case nsXPTType::T_I64 : if (iCount < PARAM_GPR_COUNT)
((DU *)dp)->hi = (int32_t) gprData[iCount++];
else
((DU *)dp)->hi = (int32_t) *ap++;
if (iCount < PARAM_GPR_COUNT)
((DU *)dp)->lo = (uint32_t) gprData[iCount++];
else
((DU *)dp)->lo = (uint32_t) *ap++;
break;
case nsXPTType::T_U8 : if (iCount < PARAM_GPR_COUNT)
dp->val.u8 = (uint8_t) gprData[iCount++];
else
dp->val.u8 = (uint8_t) *ap++;
break;
case nsXPTType::T_U16 : if (iCount < PARAM_GPR_COUNT)
dp->val.u16 = (uint16_t) gprData[iCount++];
else
dp->val.u16 = (uint16_t) *ap++;
break;
case nsXPTType::T_U32 : if (iCount < PARAM_GPR_COUNT)
dp->val.u32 = (uint32_t) gprData[iCount++];
else
dp->val.u32 = (uint32_t) *ap++;
break;
case nsXPTType::T_U64 : if (iCount < PARAM_GPR_COUNT)
((DU *)dp)->hi = (uint32_t) gprData[iCount++];
else
((DU *)dp)->hi = (uint32_t) *ap++;
if (iCount < PARAM_GPR_COUNT)
((DU *)dp)->lo = (uint32_t) gprData[iCount++];
else
((DU *)dp)->lo = (uint32_t) *ap++;
break;
case nsXPTType::T_FLOAT : if (fpCount < 13) {
dp->val.f = (float) fprData[fpCount++];
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
}
else
dp->val.f = *((float*) ap++);
break;
case nsXPTType::T_DOUBLE : if (fpCount < 13) {
dp->val.d = (double) fprData[fpCount++];
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
}
else {
dp->val.f = *((double*) ap);
ap += 2;
}
break;
case nsXPTType::T_BOOL : if (iCount < PARAM_GPR_COUNT)
dp->val.b = (bool) gprData[iCount++];
else
dp->val.b = (bool) *ap++;
break;
case nsXPTType::T_CHAR : if (iCount < PARAM_GPR_COUNT)
dp->val.c = (char) gprData[iCount++];
else
dp->val.c = (char) *ap++;
break;
case nsXPTType::T_WCHAR : if (iCount < PARAM_GPR_COUNT)
dp->val.wc = (wchar_t) gprData[iCount++];
else
dp->val.wc = (wchar_t) *ap++;
break;
default:
NS_ERROR("bad type");
break;
}
}
result = self->mOuter->CallMethod((uint16_t)methodIndex,info,dispatchParams);
if(dispatchParams != paramBuffer)
delete [] dispatchParams;
return result;
}
#define STUB_ENTRY(n)
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"
#endif /* AIX */

172
xpcom/reflect/xptcall/md/unix/xptcstubs_ppc_aix64.cpp
View file

@ -1,172 +0,0 @@
/* 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"
#include "xptiprivate.h"
#if defined(AIX)
/*
For PPC (AIX & MAC), the first 8 integral and the first 13 f.p. parameters
arrive in a separate chunk of data that has been loaded from the registers.
The args pointer has been set to the start of the parameters BEYOND the ones
arriving in registers
*/
extern "C" nsresult ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self, uint64_t methodIndex, uint64_t* args, uint64_t *gprData, double *fprData)
{
#define PARAM_BUFFER_COUNT 16
#define PARAM_GPR_COUNT 7
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
const nsXPTMethodInfo* info = nullptr;
uint8_t paramCount;
uint8_t i;
nsresult result = NS_ERROR_FAILURE;
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");
uint64_t* ap = args;
uint32_t iCount = 0;
uint32_t fpCount = 0;
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.IsArithmetic())
{
if (iCount < PARAM_GPR_COUNT)
dp->val.p = (void*) gprData[iCount++];
else
dp->val.p = (void*) *ap++;
continue;
}
// else
switch(type)
{
case nsXPTType::T_I8 : if (iCount < PARAM_GPR_COUNT)
dp->val.i8 = (int8_t) gprData[iCount++];
else
dp->val.i8 = (int8_t) *ap++;
break;
case nsXPTType::T_I16 : if (iCount < PARAM_GPR_COUNT)
dp->val.i16 = (int16_t) gprData[iCount++];
else
dp->val.i16 = (int16_t) *ap++;
break;
case nsXPTType::T_I32 : if (iCount < PARAM_GPR_COUNT)
dp->val.i32 = (int32_t) gprData[iCount++];
else
dp->val.i32 = (int32_t) *ap++;
break;
case nsXPTType::T_I64 : if (iCount < PARAM_GPR_COUNT)
dp->val.i64 = (int64_t) gprData[iCount++];
else
dp->val.i64 = (int64_t) *ap++;
break;
case nsXPTType::T_U8 : if (iCount < PARAM_GPR_COUNT)
dp->val.u8 = (uint8_t) gprData[iCount++];
else
dp->val.u8 = (uint8_t) *ap++;
break;
case nsXPTType::T_U16 : if (iCount < PARAM_GPR_COUNT)
dp->val.u16 = (uint16_t) gprData[iCount++];
else
dp->val.u16 = (uint16_t) *ap++;
break;
case nsXPTType::T_U32 : if (iCount < PARAM_GPR_COUNT)
dp->val.u32 = (uint32_t) gprData[iCount++];
else
dp->val.u32 = (uint32_t) *ap++;
break;
case nsXPTType::T_U64 : if (iCount < PARAM_GPR_COUNT)
dp->val.u64 = (uint64_t) gprData[iCount++];
else
dp->val.u64 = (uint64_t) *ap++;
break;
case nsXPTType::T_FLOAT : if (fpCount < 13) {
dp->val.f = (float) fprData[fpCount++];
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
}
else
dp->val.f = *((float*) ap++);
break;
case nsXPTType::T_DOUBLE : if (fpCount < 13) {
dp->val.d = (double) fprData[fpCount++];
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
if (iCount < PARAM_GPR_COUNT)
++iCount;
else
++ap;
}
else {
dp->val.f = *((double*) ap);
ap += 2;
}
break;
case nsXPTType::T_BOOL : if (iCount < PARAM_GPR_COUNT)
dp->val.b = (bool) gprData[iCount++];
else
dp->val.b = (bool) *ap++;
break;
case nsXPTType::T_CHAR : if (iCount < PARAM_GPR_COUNT)
dp->val.c = (char) gprData[iCount++];
else
dp->val.c = (char) *ap++;
break;
case nsXPTType::T_WCHAR : if (iCount < PARAM_GPR_COUNT)
dp->val.wc = (wchar_t) gprData[iCount++];
else
dp->val.wc = (wchar_t) *ap++;
break;
default:
NS_ERROR("bad type");
break;
}
}
result = self->mOuter->CallMethod((uint16_t)methodIndex,info,dispatchParams);
if(dispatchParams != paramBuffer)
delete [] dispatchParams;
return result;
}
#define STUB_ENTRY(n)
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"
#endif /* AIX */

11
xpcom/reflect/xptcall/status.html
View file

@ -239,17 +239,6 @@ a port.
</TD>
</TR>
<TR>
<TD bgcolor="green"><font color="white"><b>Done</b></font></TD>
<TD>AIX PPC</TD>
<TD><img alt="Contributed code!" title="Contributed code!" src="http://tinderbox.mozilla.org/star.gif">
<a href="mailto:jdunn@netscape.com">Jim Dunn &lt;jdunn@netscape.com&gt;</a></TD>
<TD>Philip K. Warren writes: <BR>
We have gone through several releases of AIX without any problems.
</TD>
</TR>
<TR>
<TD bgcolor="green"><font color="white"><b>Done</b></font></TD>
<TD>Irix</TD>

4
xpcom/threads/nsThread.cpp
View file

@ -203,11 +203,9 @@ public:
}
}
// This method needs to be public to support older compilers (xlC_r on AIX).
// It should be called directly as this class type is reference counted.
private:
virtual ~nsThreadStartupEvent() {}
private:
NS_IMETHOD Run() override
{
ReentrantMonitorAutoEnter mon(mMon);