Make it buildable on sparc64

5 files changed, 295 insertions, 3 deletions

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 <atomic>.  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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++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<typename T>
++inline T
++js::jit::AtomicOperations::loadSafeWhenRacy(T* addr)
++{
++    return *addr;               // FIXME (1208663): not yet safe
++}
++
++template<typename T>
++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<typename T>
++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<size_t nbytes>
++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<size_t nbytes>
++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 <typename T, typename S> void branchPrivatePtr(Condition, T, S, Label*) { MOZ_CRASH(); }
+     template <typename T, typename S> void decBranchPtr(Condition, T, S, Label*) { MOZ_CRASH(); }
+     template <typename T, typename S> void branchTest64(Condition, T, T, S, Label*) { MOZ_CRASH(); }
++    template <typename T, typename S> void branch64(Condition, T, S, Label*) { MOZ_CRASH(); }
++    template <typename T, typename S> void branch64(Condition, T, T, S, Label*) { MOZ_CRASH(); }
+     template <typename T, typename S> void mov(T, S) { MOZ_CRASH(); }
+     template <typename T, typename S> void movq(T, S) { MOZ_CRASH(); }
+     template <typename T, typename S> void movePtr(T, S) { MOZ_CRASH(); }