diff options
| -rw-r--r-- | firefox-aarch64-double-convertsion.patch | 80 | ||||
| -rw-r--r-- | firefox-aarch64-libevent.patch | 115 | ||||
| -rw-r--r-- | firefox-aarch64-xpcom.patch | 517 | ||||
| -rw-r--r-- | firefox.spec | 21 |
4 files changed, 730 insertions, 3 deletions
diff --git a/firefox-aarch64-double-convertsion.patch b/firefox-aarch64-double-convertsion.patch new file mode 100644 index 0000000..06320be --- /dev/null +++ b/firefox-aarch64-double-convertsion.patch @@ -0,0 +1,80 @@ + +# HG changeset patch +# User Marcin Juszkiewicz <mjuszkiewicz@redhat.com> +# Date 1393440196 18000 +# Node ID 6a46f53ad944b44385398822d7bcf7621a785d91 +# Parent 0aa56e2a5f816a30da48701f73d03060ee9692b2 +Bug 962488 - Update double-conversion for proper AArch64 support. r=froydnj + +Fix imported from upstream repository: +https://code.google.com/p/double-conversion/source/detail?r=4e24bb31bcc76d6d218f3056b4c24a109d367561 + +diff --git a/mfbt/double-conversion/fix-aarch64-macro.patch b/mfbt/double-conversion/fix-aarch64-macro.patch +new file mode 100644 +--- /dev/null ++++ b/mfbt/double-conversion/fix-aarch64-macro.patch +@@ -0,0 +1,23 @@ ++Backport from upstream. ++ ++https://code.google.com/p/double-conversion/source/detail?r=4e24bb31bcc76d6d218f3056b4c24a109d367561 ++ ++--- ++ mfbt/double-conversion/utils.h | 2 +- ++ 1 file changed, 1 insertion(+), 1 deletion(-) ++ ++--- a/mfbt/double-conversion/utils.h +++++ b/mfbt/double-conversion/utils.h ++@@ -58,11 +58,11 @@ ++ defined(__mips__) || \ ++ defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \ ++ defined(__sparc__) || defined(__sparc) || defined(__s390__) || \ ++ defined(__SH4__) || defined(__alpha__) || \ ++ defined(_MIPS_ARCH_MIPS32R2) || \ ++- defined(_AARCH64EL_) +++ defined(__AARCH64EL__) ++ #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 ++ #elif defined(_M_IX86) || defined(__i386__) || defined(__i386) ++ #if defined(_WIN32) ++ // Windows uses a 64bit wide floating point stack. ++ #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 +diff --git a/mfbt/double-conversion/update.sh b/mfbt/double-conversion/update.sh +--- a/mfbt/double-conversion/update.sh ++++ b/mfbt/double-conversion/update.sh +@@ -15,9 +15,12 @@ cp $1/src/*.h ./ + + # Source + cp $1/src/*.cc ./ + + patch -p3 < add-mfbt-api-markers.patch + patch -p3 < use-StandardInteger.patch + patch -p3 < use-mozilla-assertions.patch + patch -p3 < use-static_assert.patch +-patch -p3 < ToPrecision-exponential.patch +\ No newline at end of file ++patch -p3 < ToPrecision-exponential.patch ++ ++# Merged upstream, part of 2.0.1 version ++patch -p3 < fix-aarch64-macro.patch +diff --git a/mfbt/double-conversion/utils.h b/mfbt/double-conversion/utils.h +--- a/mfbt/double-conversion/utils.h ++++ b/mfbt/double-conversion/utils.h +@@ -55,17 +55,17 @@ + #if defined(_M_X64) || defined(__x86_64__) || \ + defined(__ARMEL__) || defined(__avr32__) || \ + defined(__hppa__) || defined(__ia64__) || \ + defined(__mips__) || \ + defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \ + defined(__sparc__) || defined(__sparc) || defined(__s390__) || \ + defined(__SH4__) || defined(__alpha__) || \ + defined(_MIPS_ARCH_MIPS32R2) || \ +- defined(_AARCH64EL_) ++ defined(__AARCH64EL__) + #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 + #elif defined(_M_IX86) || defined(__i386__) || defined(__i386) + #if defined(_WIN32) + // Windows uses a 64bit wide floating point stack. + #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 + #else + #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS + #endif // _WIN32 + diff --git a/firefox-aarch64-libevent.patch b/firefox-aarch64-libevent.patch new file mode 100644 index 0000000..6f9d02a --- /dev/null +++ b/firefox-aarch64-libevent.patch @@ -0,0 +1,115 @@ + +# HG changeset patch +# User Marcin Juszkiewicz <mjuszkiewicz@redhat.com> +# Date 1392217668 18000 +# Node ID 4e9b713f435ade266a68a8d7ba08aad65c3fa6c5 +# Parent 282b6e88f9d4c2367a72836f6f9efeab2aadaa58 +Bug 963023 - AArch64 support for libevent. r=froydnj + +diff --git a/ipc/chromium/src/third_party/libevent-use-non-deprecated-syscalls.patch b/ipc/chromium/src/third_party/libevent-use-non-deprecated-syscalls.patch +new file mode 100644 +--- /dev/null ++++ b/ipc/chromium/src/third_party/libevent-use-non-deprecated-syscalls.patch +@@ -0,0 +1,43 @@ ++--- ++ ipc/chromium/src/third_party/libevent/epoll_sub.c | 13 +++++++++++++ ++ 1 file changed, 13 insertions(+) ++ ++--- mozilla-central.orig/ipc/chromium/src/third_party/libevent/epoll_sub.c +++++ mozilla-central/ipc/chromium/src/third_party/libevent/epoll_sub.c ++@@ -29,15 +29,24 @@ ++ #include <sys/param.h> ++ #include <sys/types.h> ++ #include <sys/syscall.h> ++ #include <sys/epoll.h> ++ #include <unistd.h> +++#include <errno.h> ++ ++ int ++ epoll_create(int size) ++ { +++#if !defined(__NR_epoll_create) && defined(__NR_epoll_create1) +++ if (size <= 0) { +++ errno = EINVAL; +++ return -1; +++ } +++ return (syscall(__NR_epoll_create1, 0)); +++#else ++ return (syscall(__NR_epoll_create, size)); +++#endif ++ } ++ ++ int ++ epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) ++ { ++@@ -46,7 +55,11 @@ epoll_ctl(int epfd, int op, int fd, stru ++ } ++ ++ int ++ epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout) ++ { +++#if !defined(__NR_epoll_wait) && defined(__NR_epoll_pwait) +++ return (syscall(__NR_epoll_pwait, epfd, events, maxevents, timeout, NULL, 0)); +++#else ++ return (syscall(__NR_epoll_wait, epfd, events, maxevents, timeout)); +++#endif ++ } +diff --git a/ipc/chromium/src/third_party/libevent/README.mozilla b/ipc/chromium/src/third_party/libevent/README.mozilla +--- a/ipc/chromium/src/third_party/libevent/README.mozilla ++++ b/ipc/chromium/src/third_party/libevent/README.mozilla +@@ -8,8 +8,10 @@ android/event2/event-config.h + + These files are taken from libevent-2.0.21-stable built on the development environment indicated by the first path component. You have to run "./configure" and "make" to get all of the pre-processing done. The file can then be found in "include/event2/". + + 2. This is ugly, prepare yourself. OS X has a weird problem with how the "TAILQ_END(head)" is used, causing a linking error. Just replace all use of the "TAILQ_END(head)" macro with "NULL". + + 3. Apply "add mac-arc4random-buf.patch", which removes some bad OS X compatibility code. This will allow libevent to compile on all supported versions of OS X. + + 4. Apply "openbsd-no-arc4random_addrandom.patch", which fixes the build on OpenBSD (which doesnt provide arc4random_addrandom anymore, see #931354) ++ ++5. Apply "libevent-use-non-deprecated-syscalls.patch", which fixes the build on AArch64 architecture (which does not provide deprecated syscalls) +diff --git a/ipc/chromium/src/third_party/libevent/epoll_sub.c b/ipc/chromium/src/third_party/libevent/epoll_sub.c +--- a/ipc/chromium/src/third_party/libevent/epoll_sub.c ++++ b/ipc/chromium/src/third_party/libevent/epoll_sub.c +@@ -26,27 +26,40 @@ + */ + #include <stdint.h> + + #include <sys/param.h> + #include <sys/types.h> + #include <sys/syscall.h> + #include <sys/epoll.h> + #include <unistd.h> ++#include <errno.h> + + int + epoll_create(int size) + { ++#if !defined(__NR_epoll_create) && defined(__NR_epoll_create1) ++ if (size <= 0) { ++ errno = EINVAL; ++ return -1; ++ } ++ return (syscall(__NR_epoll_create1, 0)); ++#else + return (syscall(__NR_epoll_create, size)); ++#endif + } + + int + epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) + { + + return (syscall(__NR_epoll_ctl, epfd, op, fd, event)); + } + + int + epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout) + { ++#if !defined(__NR_epoll_wait) && defined(__NR_epoll_pwait) ++ return (syscall(__NR_epoll_pwait, epfd, events, maxevents, timeout, NULL, 0)); ++#else + return (syscall(__NR_epoll_wait, epfd, events, maxevents, timeout)); ++#endif + } + diff --git a/firefox-aarch64-xpcom.patch b/firefox-aarch64-xpcom.patch new file mode 100644 index 0000000..5f70003 --- /dev/null +++ b/firefox-aarch64-xpcom.patch @@ -0,0 +1,517 @@ + +# HG changeset patch +# User Marcin Juszkiewicz <mjuszkiewicz@redhat.com> +# Date 1393440196 18000 +# Node ID d56b5c1a557348d4ac14a4d1ea7a5b5d240e3647 +# Parent 6a46f53ad944b44385398822d7bcf7621a785d91 +Bug 963024 - AArch64 support for XPCOM. r=froydnj + +diff --git a/xpcom/reflect/xptcall/src/md/unix/moz.build b/xpcom/reflect/xptcall/src/md/unix/moz.build +--- a/xpcom/reflect/xptcall/src/md/unix/moz.build ++++ b/xpcom/reflect/xptcall/src/md/unix/moz.build +@@ -144,16 +144,23 @@ if CONFIG['OS_ARCH'] == 'NetBSD': + if CONFIG['OS_TEST'] in ('amiga', 'atari', 'hp300', 'mac68k', 'mvme68k', + 'next68k', 'sun3', 'sun3x', 'x68k'): + SOURCES += [ + 'xptcinvoke_netbsd_m68k.cpp', + 'xptcstubs_netbsd_m68k.cpp' + ] + + if CONFIG['OS_ARCH'] == 'Linux': ++ if CONFIG['OS_TEST'] == 'aarch64': ++ SOURCES += [ ++ 'xptcinvoke_aarch64.cpp', ++ 'xptcinvoke_asm_aarch64.s', ++ 'xptcstubs_aarch64.cpp', ++ 'xptcstubs_asm_aarch64.s', ++ ] + if CONFIG['OS_TEST'] == 'm68k': + SOURCES += [ + 'xptcinvoke_linux_m68k.cpp', + 'xptcstubs_linux_m68k.cpp', + ] + if CONFIG['OS_TEST'].find('mips') != -1: + if CONFIG['OS_TEST'].find('mips64') != -1: + SOURCES += [ +diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_aarch64.cpp b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_aarch64.cpp +new file mode 100644 +--- /dev/null ++++ b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_aarch64.cpp +@@ -0,0 +1,136 @@ ++/* -*- 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" ++ ++#if !defined(__aarch64__) ++#error "This code is for Linux AArch64 only." ++#endif ++ ++ ++/* "Procedure Call Standard for the ARM 64-bit Architecture" document, sections ++ * "5.4 Parameter Passing" and "6.1.2 Procedure Calling" contain all the ++ * needed information. ++ * ++ * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042d/IHI0042D_aapcs.pdf ++ */ ++ ++#ifndef __AARCH64EL__ ++#error "Only little endian compatibility was tested" ++#endif ++ ++/* ++ * Allocation of integer function arguments initially to registers r1-r7 ++ * and then to stack. Handling of 'that' argument which goes to register r0 ++ * is handled separately and does not belong here. ++ * ++ * 'ireg_args' - pointer to the current position in the buffer, ++ * corresponding to the register arguments ++ * 'stack_args' - pointer to the current position in the buffer, ++ * corresponding to the arguments on stack ++ * 'end' - pointer to the end of the registers argument ++ * buffer. ++ */ ++static inline void alloc_word(uint64_t* &ireg_args, ++ uint64_t* &stack_args, ++ uint64_t* end, ++ uint64_t data) ++{ ++ if (ireg_args < end) { ++ *ireg_args = data; ++ ireg_args++; ++ } else { ++ *stack_args = data; ++ stack_args++; ++ } ++} ++ ++static inline void alloc_double(double* &freg_args, ++ uint64_t* &stack_args, ++ double* end, ++ double data) ++{ ++ if (freg_args < end) { ++ *freg_args = data; ++ freg_args++; ++ } else { ++ memcpy(stack_args, &data, sizeof(data)); ++ stack_args++; ++ } ++} ++ ++static inline void alloc_float(double* &freg_args, ++ uint64_t* &stack_args, ++ double* end, ++ float data) ++{ ++ if (freg_args < end) { ++ memcpy(freg_args, &data, sizeof(data)); ++ freg_args++; ++ } else { ++ memcpy(stack_args, &data, sizeof(data)); ++ stack_args++; ++ } ++} ++ ++ ++extern "C" void ++invoke_copy_to_stack(uint64_t* stk, uint64_t *end, ++ uint32_t paramCount, nsXPTCVariant* s) ++{ ++ uint64_t *ireg_args = stk; ++ uint64_t *ireg_end = ireg_args + 8; ++ double *freg_args = (double *)ireg_end; ++ double *freg_end = freg_args + 8; ++ uint64_t *stack_args = (uint64_t *)freg_end; ++ ++ // leave room for 'that' argument in x0 ++ ++ireg_args; ++ ++ for (uint32_t i = 0; i < paramCount; i++, s++) { ++ if (s->IsPtrData()) { ++ alloc_word(ireg_args, stack_args, ireg_end, (uint64_t)s->ptr); ++ continue; ++ } ++ // According to the ABI, integral types that are smaller than 8 bytes ++ // are to be passed in 8-byte registers or 8-byte stack slots. ++ switch (s->type) { ++ case nsXPTType::T_FLOAT: ++ alloc_float(freg_args, stack_args, freg_end, s->val.f); ++ break; ++ case nsXPTType::T_DOUBLE: ++ alloc_double(freg_args, stack_args, freg_end, s->val.d); ++ break; ++ case nsXPTType::T_I8: alloc_word(ireg_args, stk, end, s->val.i8); break; ++ case nsXPTType::T_I16: alloc_word(ireg_args, stk, end, s->val.i16); break; ++ case nsXPTType::T_I32: alloc_word(ireg_args, stk, end, s->val.i32); break; ++ case nsXPTType::T_I64: alloc_word(ireg_args, stk, end, s->val.i64); break; ++ case nsXPTType::T_U8: alloc_word(ireg_args, stk, end, s->val.u8); break; ++ case nsXPTType::T_U16: alloc_word(ireg_args, stk, end, s->val.u16); break; ++ case nsXPTType::T_U32: alloc_word(ireg_args, stk, end, s->val.u32); break; ++ case nsXPTType::T_U64: alloc_word(ireg_args, stk, end, s->val.u64); break; ++ case nsXPTType::T_BOOL: alloc_word(ireg_args, stk, end, s->val.b); break; ++ case nsXPTType::T_CHAR: alloc_word(ireg_args, stk, end, s->val.c); break; ++ case nsXPTType::T_WCHAR: alloc_word(ireg_args, stk, end, s->val.wc); break; ++ default: ++ // all the others are plain pointer types ++ alloc_word(ireg_args, stack_args, ireg_end, ++ reinterpret_cast<uint64_t>(s->val.p)); ++ break; ++ } ++ } ++} ++ ++extern "C" nsresult _NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex, ++ uint32_t paramCount, nsXPTCVariant* params); ++ ++EXPORT_XPCOM_API(nsresult) ++NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex, ++ uint32_t paramCount, nsXPTCVariant* params) ++{ ++ return _NS_InvokeByIndex(that, methodIndex, paramCount, params); ++} +diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_aarch64.s b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_aarch64.s +new file mode 100644 +--- /dev/null ++++ b/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_aarch64.s +@@ -0,0 +1,67 @@ ++/* -*- 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/. */ ++ ++ .section ".text" ++ .globl _NS_InvokeByIndex ++ .type _NS_InvokeByIndex,@function ++ ++/* ++ * _NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex, ++ * uint32_t paramCount, nsXPTCVariant* params) ++ */ ++ ++_NS_InvokeByIndex: ++ # set up frame ++ stp x29, x30, [sp,#-32]! ++ mov x29, sp ++ stp x19, x20, [sp,#16] ++ ++ # save methodIndex across function calls ++ mov w20, w1 ++ ++ # end of stack area passed to invoke_copy_to_stack ++ mov x1, sp ++ ++ # assume 8 bytes of stack for each argument with 16-byte alignment ++ add w19, w2, #1 ++ and w19, w19, #0xfffffffe ++ sub sp, sp, w19, uxth #3 ++ ++ # temporary place to store args passed in r0-r7,v0-v7 ++ sub sp, sp, #128 ++ ++ # save 'that' on stack ++ str x0, [sp] ++ ++ # start of stack area passed to invoke_copy_to_stack ++ mov x0, sp ++ bl invoke_copy_to_stack ++ ++ # load arguments passed in r0-r7 ++ ldp x6, x7, [sp, #48] ++ ldp x4, x5, [sp, #32] ++ ldp x2, x3, [sp, #16] ++ ldp x0, x1, [sp],#64 ++ ++ # load arguments passed in v0-v7 ++ ldp d6, d7, [sp, #48] ++ ldp d4, d5, [sp, #32] ++ ldp d2, d3, [sp, #16] ++ ldp d0, d1, [sp],#64 ++ ++ # call the method ++ ldr x16, [x0] ++ add x16, x16, w20, uxth #3 ++ ldr x16, [x16] ++ blr x16 ++ ++ add sp, sp, w19, uxth #3 ++ ldp x19, x20, [sp,#16] ++ ldp x29, x30, [sp],#32 ++ ret ++ ++ .size _NS_InvokeByIndex, . - _NS_InvokeByIndex ++ ++ +diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_aarch64.cpp b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_aarch64.cpp +new file mode 100644 +--- /dev/null ++++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_aarch64.cpp +@@ -0,0 +1,219 @@ ++/* -*- 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/. */ ++ ++#include "xptcprivate.h" ++#include "xptiprivate.h" ++ ++#ifndef __AARCH64EL__ ++#error "Only little endian compatibility was tested" ++#endif ++ ++/* ++ * This is for AArch64 ABI ++ * ++ * When we're called, the "gp" registers are stored in gprData and ++ * the "fp" registers are stored in fprData. Each array has 8 regs ++ * but first reg in gprData is a placeholder for 'self'. ++ */ ++extern "C" nsresult ++PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint64_t* args, ++ uint64_t *gprData, double *fprData) ++{ ++#define PARAM_BUFFER_COUNT 16 ++#define PARAM_GPR_COUNT 8 ++#define PARAM_FPR_COUNT 8 ++ ++ nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT]; ++ nsXPTCMiniVariant* dispatchParams = NULL; ++ const nsXPTMethodInfo* info; ++ nsresult result = NS_ERROR_FAILURE; ++ ++ NS_ASSERTION(self,"no self"); ++ ++ self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info); ++ NS_ASSERTION(info,"no method info"); ++ ++ uint32_t 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 next_gpr = 1; // skip first arg which is 'self' ++ uint32_t next_fpr = 0; ++ for (uint32_t 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 (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.p = (void*)gprData[next_gpr++]; ++ } else { ++ dp->val.p = (void*)*ap++; ++ } ++ continue; ++ } ++ ++ switch (type) { ++ case nsXPTType::T_I8: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.i8 = (int8_t)gprData[next_gpr++]; ++ } else { ++ dp->val.i8 = (int8_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_I16: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.i16 = (int16_t)gprData[next_gpr++]; ++ } else { ++ dp->val.i16 = (int16_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_I32: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.i32 = (int32_t)gprData[next_gpr++]; ++ } else { ++ dp->val.i32 = (int32_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_I64: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.i64 = (int64_t)gprData[next_gpr++]; ++ } else { ++ dp->val.i64 = (int64_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_U8: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.u8 = (uint8_t)gprData[next_gpr++]; ++ } else { ++ dp->val.u8 = (uint8_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_U16: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.u16 = (uint16_t)gprData[next_gpr++]; ++ } else { ++ dp->val.u16 = (uint16_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_U32: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.u32 = (uint32_t)gprData[next_gpr++]; ++ } else { ++ dp->val.u32 = (uint32_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_U64: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.u64 = (uint64_t)gprData[next_gpr++]; ++ } else { ++ dp->val.u64 = (uint64_t)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_FLOAT: ++ if (next_fpr < PARAM_FPR_COUNT) { ++ memcpy(&dp->val.f, &fprData[next_fpr++], sizeof(dp->val.f)); ++ } else { ++ memcpy(&dp->val.f, ap++, sizeof(dp->val.f)); ++ } ++ break; ++ ++ case nsXPTType::T_DOUBLE: ++ if (next_fpr < PARAM_FPR_COUNT) { ++ memcpy(&dp->val.d, &fprData[next_fpr++], sizeof(dp->val.d)); ++ } else { ++ memcpy(&dp->val.d, ap++, sizeof(dp->val.d)); ++ } ++ break; ++ ++ case nsXPTType::T_BOOL: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.b = (bool)gprData[next_gpr++]; ++ } else { ++ dp->val.b = (bool)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_CHAR: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.c = (char)gprData[next_gpr++]; ++ } else { ++ dp->val.c = (char)*ap++; ++ } ++ break; ++ ++ case nsXPTType::T_WCHAR: ++ if (next_gpr < PARAM_GPR_COUNT) { ++ dp->val.wc = (wchar_t)gprData[next_gpr++]; ++ } else { ++ dp->val.wc = (wchar_t)*ap++; ++ } ++ break; ++ ++ default: ++ NS_ASSERTION(0, "bad type"); ++ break; ++ } ++ } ++ ++ result = self->mOuter->CallMethod((uint16_t)methodIndex, info, dispatchParams); ++ ++ if (dispatchParams != paramBuffer) { ++ delete [] dispatchParams; ++ } ++ ++ return result; ++} ++ ++// Load w17 with the constant 'n' and branch to SharedStub(). ++# define STUB_ENTRY(n) \ ++ __asm__ ( \ ++ ".section \".text\" \n\t" \ ++ ".align 2\n\t" \ ++ ".if "#n" < 10 \n\t" \ ++ ".globl _ZN14nsXPTCStubBase5Stub"#n"Ev \n\t" \ ++ ".hidden _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" \ ++ ".hidden _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" \ ++ ".hidden _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" \ ++ "mov w17,#"#n" \n\t" \ ++ "b SharedStub \n" \ ++); ++ ++#define SENTINEL_ENTRY(n) \ ++ nsresult nsXPTCStubBase::Sentinel##n() \ ++{ \ ++ NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \ ++ return NS_ERROR_NOT_IMPLEMENTED; \ ++} ++ ++#include "xptcstubsdef.inc" +diff --git a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_aarch64.s b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_aarch64.s +new file mode 100644 +--- /dev/null ++++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_aarch64.s +@@ -0,0 +1,39 @@ ++# 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 NGPREGS,8 ++ .set NFPREGS,8 ++ ++ .section ".text" ++ .globl SharedStub ++ .hidden SharedStub ++ .type SharedStub,@function ++SharedStub: ++ stp x29, x30, [sp,#-16]! ++ mov x29, sp ++ ++ sub sp, sp, #8*(NGPREGS+NFPREGS) ++ stp x0, x1, [sp, #64+(0*8)] ++ stp x2, x3, [sp, #64+(2*8)] ++ stp x4, x5, [sp, #64+(4*8)] ++ stp x6, x7, [sp, #64+(6*8)] ++ stp d0, d1, [sp, #(0*8)] ++ stp d2, d3, [sp, #(2*8)] ++ stp d4, d5, [sp, #(4*8)] ++ stp d6, d7, [sp, #(6*8)] ++ ++ # methodIndex passed from stub ++ mov w1, w17 ++ ++ add x2, sp, #16+(8*(NGPREGS+NFPREGS)) ++ add x3, sp, #8*NFPREGS ++ add x4, sp, #0 ++ ++ bl PrepareAndDispatch ++ ++ add sp, sp, #8*(NGPREGS+NFPREGS) ++ ldp x29, x30, [sp],#16 ++ ret ++ ++ .size SharedStub, . - SharedStub + diff --git a/firefox.spec b/firefox.spec index 411ecf1..697f75f 100644 --- a/firefox.spec +++ b/firefox.spec @@ -87,7 +87,7 @@ Summary: Mozilla Firefox Web browser Name: firefox Version: 29.0.1 -Release: 2%{?pre_tag}%{?dist} +Release: 3%{?pre_tag}%{?dist} URL: http://www.mozilla.org/projects/firefox/ License: MPLv1.1 or GPLv2+ or LGPLv2+ Group: Applications/Internet @@ -118,6 +118,12 @@ Patch216: firefox-duckduckgo.patch # Upstream patches Patch300: mozilla-ppc64le.patch +# mbo 962488 +Patch301: firefox-aarch64-double-convertsion.patch +# mbo 963023 +Patch302: firefox-aarch64-libevent.patch +# mbo 963024 +Patch303: firefox-aarch64-xpcom.patch %if %{official_branding} # Required by Mozilla Corporation @@ -235,6 +241,9 @@ cd %{tarballdir} %patch300 -p1 -b .ppc64le %endif %endif +%patch301 -p1 -b .aarch64-dbl +%patch302 -p1 -b .aarch64-libevent +%patch303 -p1 -b .aarch64-xpcom %if %{official_branding} # Required by Mozilla Corporation @@ -348,6 +357,9 @@ esac cd %{tarballdir} +# Update the various config.guess to upstream release for aarch64 support +find ./ -name config.guess -exec cp /usr/lib/rpm/config.guess {} ';' + # -fpermissive is needed to build with gcc 4.6+ which has become stricter # # Mozilla builds with -Wall with exception of a few warnings which show up @@ -364,7 +376,7 @@ MOZ_OPT_FLAGS=$(echo "$MOZ_OPT_FLAGS" | %{__sed} -e 's/-O2//') %ifarch s390 MOZ_OPT_FLAGS=$(echo "$MOZ_OPT_FLAGS" | %{__sed} -e 's/-g/-g1/') %endif -%ifarch s390 %{arm} ppc +%ifarch s390 %{arm} ppc aarch64 MOZ_LINK_FLAGS="-Wl,--no-keep-memory -Wl,--reduce-memory-overheads" %endif export CFLAGS=$MOZ_OPT_FLAGS @@ -377,7 +389,7 @@ export LIBDIR='%{_libdir}' MOZ_SMP_FLAGS=-j1 # On x86 architectures, Mozilla can build up to 4 jobs at once in parallel, # however builds tend to fail on other arches when building in parallel. -%ifarch %{ix86} x86_64 ppc ppc64 ppc64le +%ifarch %{ix86} x86_64 ppc ppc64 ppc64le aarch64 [ -z "$RPM_BUILD_NCPUS" ] && \ RPM_BUILD_NCPUS="`/usr/bin/getconf _NPROCESSORS_ONLN`" [ "$RPM_BUILD_NCPUS" -ge 2 ] && MOZ_SMP_FLAGS=-j2 @@ -635,6 +647,9 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || : #--------------------------------------------------------------------- %changelog +* Thu May 15 2014 Peter Robinson <pbrobinson@fedoraproject.org> 29.0.1-4 +- Add upstream patches for aarch64 support + * Thu May 15 2014 Martin Stransky <stransky@redhat.com> - 29.0.1-2 - Fixed rhbz#1098090 - Enable plugin-container for nspluginwrapper |