From 0b5c36bc4929cea972f5ed78b902ea298d24e688 Mon Sep 17 00:00:00 2001 From: martin Date: Wed, 4 May 2016 16:22:35 +0000 Subject: Make it buildable on sparc64 --- www/firefox/Makefile | 4 +- www/firefox/distinfo | 5 +- .../patches/patch-js_src_jit_AtomicOperations.h | 15 ++ .../patch-js_src_jit_none_AtomicOperations-sparc.h | 259 +++++++++++++++++++++ .../patch-js_src_jit_none_MacroAssembler-none.h | 15 ++ 5 files changed, 295 insertions(+), 3 deletions(-) create mode 100644 www/firefox/patches/patch-js_src_jit_AtomicOperations.h create mode 100644 www/firefox/patches/patch-js_src_jit_none_AtomicOperations-sparc.h create mode 100644 www/firefox/patches/patch-js_src_jit_none_MacroAssembler-none.h (limited to 'www') diff --git a/www/firefox/Makefile b/www/firefox/Makefile index 3a723eea112..560a3c6158e 100644 --- a/www/firefox/Makefile +++ b/www/firefox/Makefile @@ -1,4 +1,4 @@ -# $NetBSD: Makefile,v 1.251 2016/04/29 23:42:49 ryoon Exp $ +# $NetBSD: Makefile,v 1.252 2016/05/04 16:22:35 martin Exp $ FIREFOX_VER= ${MOZ_BRANCH}${MOZ_BRANCH_MINOR} MOZ_BRANCH= 46.0 @@ -6,7 +6,7 @@ MOZ_BRANCH_MINOR= DISTNAME= firefox-${FIREFOX_VER}.source PKGNAME= firefox-${MOZ_BRANCH}${MOZ_BRANCH_MINOR:S/b/beta/:S/esr//} -PKGREVISION= 1 +PKGREVISION= 2 CATEGORIES= www MASTER_SITES+= ${MASTER_SITE_MOZILLA:=firefox/releases/${FIREFOX_VER}/source/} MASTER_SITES+= ${MASTER_SITE_MOZILLA_ALL:=firefox/releases/${FIREFOX_VER}/source/} diff --git a/www/firefox/distinfo b/www/firefox/distinfo index 0fc23133c6b..9ef99dd6bc4 100644 --- a/www/firefox/distinfo +++ b/www/firefox/distinfo @@ -1,4 +1,4 @@ -$NetBSD: distinfo,v 1.243 2016/04/27 16:22:40 ryoon Exp $ +$NetBSD: distinfo,v 1.244 2016/05/04 16:22:35 martin Exp $ SHA1 (firefox-46.0.source.tar.xz) = 95c5673b4449e8d694c50aea23d8160509d6a85b RMD160 (firefox-46.0.source.tar.xz) = 333ab663beceeed102a90e0c5c3f17610b9895d8 @@ -63,8 +63,11 @@ SHA1 (patch-js__src__vm__SPSProfiler.cpp) = 989ba25e4c5308d21d07baa802decce13609 SHA1 (patch-js_src_ctypes_CTypes.h) = 768a084239f92a424c1c7dc9eaaf9be9456ca9f0 SHA1 (patch-js_src_frontend_ParseMaps.cpp) = c00117d79b78904bc50a1d664a8fc0e4e339bfbc SHA1 (patch-js_src_jit-LIR.cpp) = 6e678d6886724dd346b8ca58ef903bd00dc8f5da +SHA1 (patch-js_src_jit_AtomicOperations.h) = e13cf94a6692495717211eea589ab9c021d7e737 SHA1 (patch-js_src_jit_MIR.cpp) = 32586fb4437b48c62ef3dd8267f4b1796196230b SHA1 (patch-js_src_jit_arm_Architecture-arm.cpp) = d734bea22d803f5f1019fd817cd3993da29a422b +SHA1 (patch-js_src_jit_none_AtomicOperations-sparc.h) = 88d59ed8d16341686c34579008cbd49b3dde3c8d +SHA1 (patch-js_src_jit_none_MacroAssembler-none.h) = 87bfc7a2bb40cd3badd533db02f78542a946534e SHA1 (patch-js_src_jsdate.cpp) = 4e15badd1d9a08462a851aa2a8c47fd1e137626b SHA1 (patch-js_src_jskwgen.cpp) = 34d3b92e13366d4b43ff755ad54f392c116d5c59 SHA1 (patch-js_src_jsmath.cpp) = 7d4993ae91e9b5e6820358165603819aefb586f9 diff --git a/www/firefox/patches/patch-js_src_jit_AtomicOperations.h b/www/firefox/patches/patch-js_src_jit_AtomicOperations.h new file mode 100644 index 00000000000..43dfcbf4b15 --- /dev/null +++ b/www/firefox/patches/patch-js_src_jit_AtomicOperations.h @@ -0,0 +1,15 @@ +$NetBSD: patch-js_src_jit_AtomicOperations.h,v 1.1 2016/05/04 16:22:35 martin Exp $ + +Part of https://bugzilla.mozilla.org/show_bug.cgi?id=1232150 + +--- js/src/jit/AtomicOperations.h.orig 2016-04-22 02:37:26.000000000 +0200 ++++ js/src/jit/AtomicOperations.h 2016-05-02 18:09:00.162942120 +0200 +@@ -316,6 +316,8 @@ AtomicOperations::isLockfree(int32_t siz + || defined(__ppc64le__) || defined(__PPC64LE__) \ + || defined(__ppc__) || defined(__PPC__) + # include "jit/none/AtomicOperations-ppc.h" ++#elif defined(__sparc__) ++# include "jit/none/AtomicOperations-sparc.h" + #elif defined(JS_CODEGEN_NONE) + # include "jit/none/AtomicOperations-none.h" + #elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64) diff --git a/www/firefox/patches/patch-js_src_jit_none_AtomicOperations-sparc.h b/www/firefox/patches/patch-js_src_jit_none_AtomicOperations-sparc.h new file mode 100644 index 00000000000..08b2decaea4 --- /dev/null +++ b/www/firefox/patches/patch-js_src_jit_none_AtomicOperations-sparc.h @@ -0,0 +1,259 @@ +$NetBSD: patch-js_src_jit_none_AtomicOperations-sparc.h,v 1.1 2016/05/04 16:22:35 martin Exp $ + +Part of https://bugzilla.mozilla.org/show_bug.cgi?id=1232150 + + +--- /dev/null 2016-05-02 17:53:05.061148459 +0200 ++++ js/src/jit/none/AtomicOperations-sparc.h 2016-05-02 18:11:03.394211888 +0200 +@@ -0,0 +1,251 @@ ++/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- ++ * vim: set ts=8 sts=4 et sw=4 tw=99: ++ * 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/. */ ++ ++/* For documentation, see jit/AtomicOperations.h */ ++ ++#ifndef jit_sparc_AtomicOperations_sparc_h ++#define jit_sparc_AtomicOperations_sparc_h ++ ++#include "mozilla/Assertions.h" ++#include "mozilla/Types.h" ++ ++#if defined(__clang__) || defined(__GNUC__) ++ ++// The default implementation tactic for gcc/clang is to use the newer ++// __atomic intrinsics added for use in C++11 . Where that ++// isn't available, we use GCC's older __sync functions instead. ++// ++// ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS is kept as a backward ++// compatible option for older compilers: enable this to use GCC's old ++// __sync functions instead of the newer __atomic functions. This ++// will be required for GCC 4.6.x and earlier, and probably for Clang ++// 3.1, should we need to use those versions. ++ ++//#define ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ ++inline bool ++js::jit::AtomicOperations::isLockfree8() ++{ ++# ifndef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ MOZ_ASSERT(__atomic_always_lock_free(sizeof(int8_t), 0)); ++ MOZ_ASSERT(__atomic_always_lock_free(sizeof(int16_t), 0)); ++ MOZ_ASSERT(__atomic_always_lock_free(sizeof(int32_t), 0)); ++# if defined(__LP64__) ++ MOZ_ASSERT(__atomic_always_lock_free(sizeof(int64_t), 0)); ++# endif ++ return true; ++# else ++ return false; ++# endif ++} ++ ++inline void ++js::jit::AtomicOperations::fenceSeqCst() ++{ ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ __sync_synchronize(); ++# else ++ __atomic_thread_fence(__ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::loadSeqCst(T* addr) ++{ ++ MOZ_ASSERT(sizeof(T) < 8 || isLockfree8()); ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ __sync_synchronize(); ++ T v = *addr; ++ __sync_synchronize(); ++# else ++ T v; ++ __atomic_load(addr, &v, __ATOMIC_SEQ_CST); ++# endif ++ return v; ++} ++ ++template ++inline void ++js::jit::AtomicOperations::storeSeqCst(T* addr, T val) ++{ ++ MOZ_ASSERT(sizeof(T) < 8 || isLockfree8()); ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ __sync_synchronize(); ++ *addr = val; ++ __sync_synchronize(); ++# else ++ __atomic_store(addr, &val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::compareExchangeSeqCst(T* addr, T oldval, T newval) ++{ ++ MOZ_ASSERT(sizeof(T) < 8 || isLockfree8()); ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_val_compare_and_swap(addr, oldval, newval); ++# else ++ __atomic_compare_exchange(addr, &oldval, &newval, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); ++ return oldval; ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::fetchAddSeqCst(T* addr, T val) ++{ ++#if !defined( __LP64__) ++ static_assert(sizeof(T) <= 4, "not available for 8-byte values yet"); ++#endif ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_fetch_and_add(addr, val); ++# else ++ return __atomic_fetch_add(addr, val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::fetchSubSeqCst(T* addr, T val) ++{ ++#if !defined( __LP64__) ++ static_assert(sizeof(T) <= 4, "not available for 8-byte values yet"); ++#endif ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_fetch_and_sub(addr, val); ++# else ++ return __atomic_fetch_sub(addr, val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::fetchAndSeqCst(T* addr, T val) ++{ ++#if !defined( __LP64__) ++ static_assert(sizeof(T) <= 4, "not available for 8-byte values yet"); ++#endif ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_fetch_and_and(addr, val); ++# else ++ return __atomic_fetch_and(addr, val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::fetchOrSeqCst(T* addr, T val) ++{ ++#if !defined( __LP64__) ++ static_assert(sizeof(T) <= 4, "not available for 8-byte values yet"); ++#endif ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_fetch_and_or(addr, val); ++# else ++ return __atomic_fetch_or(addr, val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::fetchXorSeqCst(T* addr, T val) ++{ ++#if !defined( __LP64__) ++ static_assert(sizeof(T) <= 4, "not available for 8-byte values yet"); ++#endif ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ return __sync_fetch_and_xor(addr, val); ++# else ++ return __atomic_fetch_xor(addr, val, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++template ++inline T ++js::jit::AtomicOperations::loadSafeWhenRacy(T* addr) ++{ ++ return *addr; // FIXME (1208663): not yet safe ++} ++ ++template ++inline void ++js::jit::AtomicOperations::storeSafeWhenRacy(T* addr, T val) ++{ ++ *addr = val; // FIXME (1208663): not yet safe ++} ++ ++inline void ++js::jit::AtomicOperations::memcpySafeWhenRacy(void* dest, const void* src, size_t nbytes) ++{ ++ ::memcpy(dest, src, nbytes); // FIXME (1208663): not yet safe ++} ++ ++inline void ++js::jit::AtomicOperations::memmoveSafeWhenRacy(void* dest, const void* src, size_t nbytes) ++{ ++ ::memmove(dest, src, nbytes); // FIXME (1208663): not yet safe ++} ++ ++template ++inline T ++js::jit::AtomicOperations::exchangeSeqCst(T* addr, T val) ++{ ++ MOZ_ASSERT(sizeof(T) < 8 || isLockfree8()); ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ T v; ++ __sync_synchronize(); ++ do { ++ v = *addr; ++ } while (__sync_val_compare_and_swap(addr, v, val) != v); ++ return v; ++# else ++ T v; ++ __atomic_exchange(addr, &val, &v, __ATOMIC_SEQ_CST); ++ return v; ++# endif ++} ++ ++template ++inline void ++js::jit::RegionLock::acquire(void* addr) ++{ ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ while (!__sync_bool_compare_and_swap(&spinlock, 0, 1)) ++ ; ++# else ++ uint32_t zero = 0; ++ uint32_t one = 1; ++ while (!__atomic_compare_exchange(&spinlock, &zero, &one, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE)) { ++ zero = 0; ++ continue; ++ } ++# endif ++} ++ ++template ++inline void ++js::jit::RegionLock::release(void* addr) ++{ ++ MOZ_ASSERT(AtomicOperations::loadSeqCst(&spinlock) == 1, "releasing unlocked region lock"); ++# ifdef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ __sync_sub_and_fetch(&spinlock, 1); ++# else ++ uint32_t zero = 0; ++ __atomic_store(&spinlock, &zero, __ATOMIC_SEQ_CST); ++# endif ++} ++ ++# undef ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS ++ ++#elif defined(ENABLE_SHARED_ARRAY_BUFFER) ++ ++# error "Either disable JS shared memory, use GCC or Clang, or add code here" ++ ++#endif ++ ++#endif // jit_sparc_AtomicOperations_sparc_h diff --git a/www/firefox/patches/patch-js_src_jit_none_MacroAssembler-none.h b/www/firefox/patches/patch-js_src_jit_none_MacroAssembler-none.h new file mode 100644 index 00000000000..fc9e7665e12 --- /dev/null +++ b/www/firefox/patches/patch-js_src_jit_none_MacroAssembler-none.h @@ -0,0 +1,15 @@ +$NetBSD: patch-js_src_jit_none_MacroAssembler-none.h,v 1.1 2016/05/04 16:22:35 martin Exp $ + +See https://bugzilla.mozilla.org/show_bug.cgi?id=1266366 + +--- js/src/jit/none/MacroAssembler-none.h.orig 2016-04-22 02:37:27.000000000 +0200 ++++ js/src/jit/none/MacroAssembler-none.h 2016-05-04 18:04:09.836344041 +0200 +@@ -255,6 +255,8 @@ class MacroAssemblerNone : public Assemb + template void branchPrivatePtr(Condition, T, S, Label*) { MOZ_CRASH(); } + template void decBranchPtr(Condition, T, S, Label*) { MOZ_CRASH(); } + template void branchTest64(Condition, T, T, S, Label*) { MOZ_CRASH(); } ++ template void branch64(Condition, T, S, Label*) { MOZ_CRASH(); } ++ template void branch64(Condition, T, T, S, Label*) { MOZ_CRASH(); } + template void mov(T, S) { MOZ_CRASH(); } + template void movq(T, S) { MOZ_CRASH(); } + template void movePtr(T, S) { MOZ_CRASH(); } -- cgit v1.2.3