Hello community,
here is the log from the commit of package mozjs60 for openSUSE:Factory checked in at 2019-10-07 13:41:37
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/mozjs60 (Old)
and /work/SRC/openSUSE:Factory/.mozjs60.new.2352 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "mozjs60"
Mon Oct 7 13:41:37 2019 rev:8 rq:735361 version:60.9.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/mozjs60/mozjs60.changes 2019-06-22 11:04:01.231798116 +0200
+++ /work/SRC/openSUSE:Factory/.mozjs60.new.2352/mozjs60.changes 2019-10-07 13:41:47.304216215 +0200
@@ -1,0 +2,19 @@
+Fri Oct 4 21:26:08 UTC 2019 - Michael Gorse
+
+- Update to version 60.9.0
+- rebased riscv-support.patch
+- Remove source modifications that made some private functions
+ public. Probably not needed anymore, and was introducing a
+ build error
+- Regenerate icudt60b.dat.xz
+- Added some upstream bug fixes included in Debian and Fedora:
+ Always-use-the-equivalent-year-to-determine-the-time-zone.patch
+ emitter.patch
+ emitter_test.patch
+ init_patch.patch
+ enddianness.patch
+ jsproperty-endian.patch
+ Save-x28-before-clobbering-it-in-the-regex-compiler.patch
+ Save-and-restore-non-volatile-x28-on-ARM64-for-generated-unboxed-object-constructor.patch
+
+-------------------------------------------------------------------
Old:
----
firefox-60.4.0esr.source.tar.xz
New:
----
Always-use-the-equivalent-year-to-determine-the-time-zone.patch
Save-and-restore-non-volatile-x28-on-ARM64-for-generated-unboxed-object-constructor.patch
Save-x28-before-clobbering-it-in-the-regex-compiler.patch
emitter.patch
emitter_test.patch
enddianness.patch
firefox-60.9.0esr.source.tar.xz
init_patch.patch
jsproperty-endian.patch
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ mozjs60.spec ++++++
--- /var/tmp/diff_new_pack.b2hx7O/_old 2019-10-07 13:41:55.584193320 +0200
+++ /var/tmp/diff_new_pack.b2hx7O/_new 2019-10-07 13:41:55.616193231 +0200
@@ -19,7 +19,7 @@
%global major 60
Name: mozjs%{major}
-Version: 60.4.0
+Version: 60.9.0
Release: 0
Summary: MozJS, or SpiderMonkey, is Mozilla's JavaScript engine written in C and C++
License: MPL-2.0
@@ -33,6 +33,20 @@
Patch0: mozjs60-fix-armv6-build.patch
Patch1: mozjs60-mozilla-s390-bigendian.patch
Patch2: riscv-support.patch
+Patch3: Always-use-the-equivalent-year-to-determine-the-time-zone.patch
+# Build fixes - https://hg.mozilla.org/mozilla-central/rev/ca36a6c4f8a4a0ddaa033fdbe20836d87...
+Patch4: emitter.patch
+Patch5: emitter_test.patch
+Patch6: init_patch.patch
+# s390x fixes:
+# https://salsa.debian.org/gnome-team/mozjs60/blob/debian/master/debian/patche...
+Patch7: enddianness.patch
+# https://salsa.debian.org/gnome-team/mozjs60/blob/debian/master/debian/patche...
+Patch8: jsproperty-endian.patch
+# aarch64 fixes for -O2
+Patch9: Save-x28-before-clobbering-it-in-the-regex-compiler.patch
+Patch10: Save-and-restore-non-volatile-x28-on-ARM64-for-generated-unboxed-object-constructor.patch
+
BuildRequires: autoconf213
BuildRequires: gcc-c++
BuildRequires: memory-constraints
@@ -84,19 +98,19 @@
%patch1 -p1
%endif
%patch2 -p1
+%patch3 -p1
+%patch4 -p1
+%patch5 -p1
+%patch6 -p1
+%patch7 -p1
+%patch8 -p1
+%patch9 -p1
+%patch10 -p1
# Remove zlib directory to make sure the use of zlib from distro:
rm -rf modules/zlib
cd js/src
-# Make mozjs these functions visible:
-# JS::UTF8CharsToNewTwoByteCharsZ and JS::LossyUTF8CharsToNewTwoByteCharsZ
-sed -i 's|^\(TwoByteCharsZ\)$|JS_PUBLIC_API\(\1\)|g' vm/CharacterEncoding.cpp
-sed -i 's|^extern\ \(TwoByteCharsZ\)$|JS_PUBLIC_API\(\1\)|g' ../public/CharacterEncoding.h
-# Also make visible js::DisableExtraThreads()
-sed -i '/^void$/{$!{N;s/^\(void\)\n\(js\:\:DisableExtraThreads()\)$/JS_PUBLIC_API\(\1\)\n\2/;ty;P;D;:y}}' vm/Runtime.cpp
-sed -i 's|\(void\) \(DisableExtraThreads()\)|JS_PUBLIC_API\(\1\) \2|g' vm/Runtime.h
-
# FIX-ME: This should be removed when bmo#1322212 and bmo#1264836 are resolved:
xz -dk %{SOURCE2}
DATFILE=%{SOURCE2}
++++++ Always-use-the-equivalent-year-to-determine-the-time-zone.patch ++++++
From: =?utf-8?q?Andr=C3=A9_Bargull?=
Date: Wed, 8 Nov 2017 03:23:41 -0800
Subject: Always use the equivalent year to determine the time zone offset and
name
Reviewed-by: Jeff Walden
Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1415202
Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1479687
Origin: upstream
Applied-upstream: 62, commit:https://hg.mozilla.org/mozilla-central/rev/ce9f1466ec78
---
js/src/jsdate.cpp | 11 +++++++----
js/src/vm/Time.cpp | 14 ++++----------
js/src/vm/Time.h | 2 +-
3 files changed, 12 insertions(+), 15 deletions(-)
diff --git a/js/src/jsdate.cpp b/js/src/jsdate.cpp
index 07af3d18c865..ff8fd6c3763c 100644
--- a/js/src/jsdate.cpp
+++ b/js/src/jsdate.cpp
@@ -2353,12 +2353,15 @@ static PRMJTime ToPRMJTime(double localTime, double utcTime) {
static size_t FormatTime(char* buf, int buflen, const char* fmt, double utcTime,
double localTime) {
PRMJTime prtm = ToPRMJTime(localTime, utcTime);
- int eqivalentYear = IsRepresentableAsTime32(utcTime)
- ? prtm.tm_year
- : EquivalentYearForDST(prtm.tm_year);
+ // If an equivalent year was used to compute the date/time components, use
+ // the same equivalent year to determine the time zone name and offset in
+ // PRMJ_FormatTime(...).
+ int timeZoneYear = IsRepresentableAsTime32(utcTime)
+ ? prtm.tm_year
+ : EquivalentYearForDST(prtm.tm_year);
int offsetInSeconds = (int)floor((localTime - utcTime) / msPerSecond);
- return PRMJ_FormatTime(buf, buflen, fmt, &prtm, eqivalentYear,
+ return PRMJ_FormatTime(buf, buflen, fmt, &prtm, timeZoneYear,
offsetInSeconds);
}
diff --git a/js/src/vm/Time.cpp b/js/src/vm/Time.cpp
index f59977f0d0e9..5ee4794b3e83 100644
--- a/js/src/vm/Time.cpp
+++ b/js/src/vm/Time.cpp
@@ -247,7 +247,7 @@ static void PRMJ_InvalidParameterHandler(const wchar_t* expression,
/* Format a time value into a buffer. Same semantics as strftime() */
size_t PRMJ_FormatTime(char* buf, int buflen, const char* fmt,
- const PRMJTime* prtm, int equivalentYear,
+ const PRMJTime* prtm, int timeZoneYear,
int offsetInSeconds) {
size_t result = 0;
#if defined(XP_UNIX) || defined(XP_WIN)
@@ -280,7 +280,8 @@ size_t PRMJ_FormatTime(char* buf, int buflen, const char* fmt,
* Fill out |td| to the time represented by |prtm|, leaving the
* timezone fields zeroed out. localtime_r will then fill in the
* timezone fields for that local time according to the system's
- * timezone parameters.
+ * timezone parameters. Use |timeZoneYear| for the year to ensure the
+ * time zone name matches the time zone offset used by the caller.
*/
struct tm td;
memset(&td, 0, sizeof(td));
@@ -290,19 +291,12 @@ size_t PRMJ_FormatTime(char* buf, int buflen, const char* fmt,
td.tm_mday = prtm->tm_mday;
td.tm_mon = prtm->tm_mon;
td.tm_wday = prtm->tm_wday;
- td.tm_year = prtm->tm_year - 1900;
+ td.tm_year = timeZoneYear - 1900;
td.tm_yday = prtm->tm_yday;
td.tm_isdst = prtm->tm_isdst;
time_t t = mktime(&td);
- // If |prtm| cannot be represented in |time_t| the year is probably
- // out of range, try again with the DST equivalent year.
- if (t == static_cast(-1)) {
- td.tm_year = equivalentYear - 1900;
- t = mktime(&td);
- }
-
// If either mktime or localtime_r failed, fill in the fallback time
// zone offset |offsetInSeconds| and set the time zone identifier to
// the empty string.
diff --git a/js/src/vm/Time.h b/js/src/vm/Time.h
index 3a51d869c922..37b7faeec028 100644
--- a/js/src/vm/Time.h
+++ b/js/src/vm/Time.h
@@ -49,7 +49,7 @@ inline void PRMJ_NowShutdown() {}
/* Format a time value into a buffer. Same semantics as strftime() */
extern size_t PRMJ_FormatTime(char* buf, int buflen, const char* fmt,
- const PRMJTime* tm, int equivalentYear,
+ const PRMJTime* tm, int timeZoneYear,
int offsetInSeconds);
/**
--
2.21.0
++++++ Save-and-restore-non-volatile-x28-on-ARM64-for-generated-unboxed-object-constructor.patch ++++++
# HG changeset patch
# User Lars T Hansen
# Date 1519822672 -3600
# Node ID 800abe66894d6b07b24bccecbf6a65e2261076f6
# Parent 223c97459e96183eb616aed39147207bdb953ba8
Bug 1375074 - Save and restore non-volatile x28 on ARM64 for generated unboxed object constructor. r=sstangl
Origin: upstream
Applied-upstream: 61, commit: https://hg.mozilla.org/mozilla-central/rev/800abe66894d
---
js/src/vm/UnboxedObject.cpp | 30 ++++++++++++++++++++++++++----
1 file changed, 26 insertions(+), 4 deletions(-)
diff --git a/js/src/vm/UnboxedObject.cpp b/js/src/vm/UnboxedObject.cpp
index 35ca20d7405f..1c20a1093d13 100644
--- a/js/src/vm/UnboxedObject.cpp
+++ b/js/src/vm/UnboxedObject.cpp
@@ -86,9 +86,16 @@ static const uintptr_t CLEAR_CONSTRUCTOR_CODE_TOKEN = 0x1;
#endif
#ifdef JS_CODEGEN_ARM64
- // ARM64 communicates stack address via sp, but uses a pseudo-sp for
- // addressing.
- masm.initStackPtr();
+ // ARM64 communicates stack address via sp, but uses a pseudo-sp (PSP) for
+ // addressing. The register we use for PSP may however also be used by
+ // calling code, and it is nonvolatile, so save it. Do this as a special
+ // case first because the generic save/restore code needs the PSP to be
+ // initialized already.
+ MOZ_ASSERT(PseudoStackPointer64.Is(masm.GetStackPointer64()));
+ masm.Str(PseudoStackPointer64, vixl::MemOperand(sp, -16, vixl::PreIndex));
+
+ // Initialize the PSP from the SP.
+ masm.initStackPtr();
#endif
MOZ_ASSERT(propertiesReg.volatile_());
@@ -239,7 +246,22 @@ static const uintptr_t CLEAR_CONSTRUCTOR_CODE_TOKEN = 0x1;
if (ScratchDoubleReg.volatile_()) masm.pop(ScratchDoubleReg);
masm.PopRegsInMask(savedNonVolatileRegisters);
- masm.abiret();
+#ifdef JS_CODEGEN_ARM64
+ // Now restore the value that was in the PSP register on entry, and return.
+
+ // Obtain the correct SP from the PSP.
+ masm.Mov(sp, PseudoStackPointer64);
+
+ // Restore the saved value of the PSP register, this value is whatever the
+ // caller had saved in it, not any actual SP value, and it must not be
+ // overwritten subsequently.
+ masm.Ldr(PseudoStackPointer64, vixl::MemOperand(sp, 16, vixl::PostIndex));
+
+ // Perform a plain Ret(), as abiret() will move SP <- PSP and that is wrong.
+ masm.Ret(vixl::lr);
+#else
+ masm.abiret();
+#endif
masm.bind(&failureStoreOther);
--
2.21.0
++++++ Save-x28-before-clobbering-it-in-the-regex-compiler.patch ++++++
# HG changeset patch
# User Lars T Hansen
# Date 1521449886 -3600
# Node ID 903a79a1efff18fc7cc50db09a3fe5d768adc9a8
# Parent 4d2955a9ca7e30ca4c3af9c214ccc77fb2fe7fb8
Bug 1445907 - Save x28 before clobbering it in the regex compiler. r=sstangl
Origin: upstream
Applied-upstream: 61, commit: https://hg.mozilla.org/mozilla-central/rev/903a79a1efff
---
diff --git a/js/src/irregexp/NativeRegExpMacroAssembler.cpp b/js/src/irregexp/NativeRegExpMacroAssembler.cpp
--- a/js/src/irregexp/NativeRegExpMacroAssembler.cpp
+++ b/js/src/irregexp/NativeRegExpMacroAssembler.cpp
@@ -118,17 +118,25 @@ NativeRegExpMacroAssembler::GenerateCode
Label return_temp0;
// Finalize code - write the entry point code now we know how many
// registers we need.
masm.bind(&entry_label_);
#ifdef JS_CODEGEN_ARM64
- // ARM64 communicates stack address via sp, but uses a pseudo-sp for addressing.
+ // ARM64 communicates stack address via SP, but uses a pseudo-sp (PSP) for
+ // addressing. The register we use for PSP may however also be used by
+ // calling code, and it is nonvolatile, so save it. Do this as a special
+ // case first because the generic save/restore code needs the PSP to be
+ // initialized already.
+ MOZ_ASSERT(PseudoStackPointer64.Is(masm.GetStackPointer64()));
+ masm.Str(PseudoStackPointer64, vixl::MemOperand(sp, -16, vixl::PreIndex));
+
+ // Initialize the PSP from the SP.
masm.initStackPtr();
#endif
// Push non-volatile registers which might be modified by jitcode.
size_t pushedNonVolatileRegisters = 0;
for (GeneralRegisterForwardIterator iter(savedNonVolatileRegisters); iter.more(); ++iter) {
masm.Push(*iter);
pushedNonVolatileRegisters++;
@@ -416,17 +424,32 @@ NativeRegExpMacroAssembler::GenerateCode
masm.pop(temp0);
masm.movePtr(temp0, StackPointer);
#endif
// Restore non-volatile registers which were saved on entry.
for (GeneralRegisterBackwardIterator iter(savedNonVolatileRegisters); iter.more(); ++iter)
masm.Pop(*iter);
+#ifdef JS_CODEGEN_ARM64
+ // Now restore the value that was in the PSP register on entry, and return.
+
+ // Obtain the correct SP from the PSP.
+ masm.Mov(sp, PseudoStackPointer64);
+
+ // Restore the saved value of the PSP register, this value is whatever the
+ // caller had saved in it, not any actual SP value, and it must not be
+ // overwritten subsequently.
+ masm.Ldr(PseudoStackPointer64, vixl::MemOperand(sp, 16, vixl::PostIndex));
+
+ // Perform a plain Ret(), as abiret() will move SP <- PSP and that is wrong.
+ masm.Ret(vixl::lr);
+#else
masm.abiret();
+#endif
// Backtrack code (branch target for conditional backtracks).
if (backtrack_label_.used()) {
masm.bind(&backtrack_label_);
Backtrack();
}
// Backtrack stack overflow code.
diff --git a/js/src/jit-test/tests/regexp/bug1445907.js b/js/src/jit-test/tests/regexp/bug1445907.js
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/regexp/bug1445907.js
@@ -0,0 +1,15 @@
+// On ARM64, we failed to save x28 properly when generating code for the regexp
+// matcher.
+//
+// There's wasm and Debugger code here because the combination forces the use of
+// x28 and exposes the bug when running on the simulator.
+
+if (!wasmIsSupported())
+ quit();
+
+var g = newGlobal('');
+var dbg = new Debugger(g);
+g.eval(`var m = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (func (export "test")))')))`);
+var re = /./;
+dbg.onEnterFrame = function(frame) { re.exec("x") };
+result = g.eval("m.exports.test()");
--
2.21.0
++++++ emitter.patch ++++++
--- a/python/mozbuild/mozbuild/frontend/emitter.py
+++ b/python/mozbuild/mozbuild/frontend/emitter.py
@@ -1127,11 +1127,6 @@
raise SandboxValidationError('Path specified in LOCAL_INCLUDES '
'does not exist: %s (resolved to %s)' % (local_include,
full_path), context)
- if (full_path == context.config.topsrcdir or
- full_path == context.config.topobjdir):
- raise SandboxValidationError('Path specified in LOCAL_INCLUDES '
- 'is not allowed: %s (resolved to %s)' % (local_include,
- full_path), context)
include_obj = LocalInclude(context, local_include)
local_includes.append(include_obj.path.full_path)
yield include_obj
++++++ emitter_test.patch ++++++
--- a/python/mozbuild/mozbuild/test/frontend/test_emitter.py
+++ b/python/mozbuild/mozbuild/test/frontend/test_emitter.py
@@ -999,22 +999,6 @@
self.assertEqual(local_includes, expected)
- def test_local_includes_invalid(self):
- """Test that invalid LOCAL_INCLUDES are properly detected."""
- reader = self.reader('local_includes-invalid/srcdir')
-
- with self.assertRaisesRegexp(
- SandboxValidationError,
- 'Path specified in LOCAL_INCLUDES is not allowed:'):
- objs = self.read_topsrcdir(reader)
-
- reader = self.reader('local_includes-invalid/objdir')
-
- with self.assertRaisesRegexp(
- SandboxValidationError,
- 'Path specified in LOCAL_INCLUDES is not allowed:'):
- objs = self.read_topsrcdir(reader)
-
def test_generated_includes(self):
"""Test that GENERATED_INCLUDES is emitted correctly."""
reader = self.reader('generated_includes')
++++++ enddianness.patch ++++++
From f66d410f3ba767efb91c6b9545d373267cd975f2 Mon Sep 17 00:00:00 2001
From: rpm-build <rpm-build>
Date: Sat, 7 Sep 2019 20:43:40 +0200
Subject: [PATCH] enddianness.patch
Bug 1488552 - Ensure proper running on 64-bit and 32-bit BE platforms.
---
js/src/gc/Marking-inl.h | 16 ++++++++++++++++
js/src/gc/RelocationOverlay.h | 13 ++++++++++++-
js/src/jsfriendapi.h | 8 ++++++++
js/src/vm/StringType.h | 13 +++++++++++++
4 files changed, 49 insertions(+), 1 deletion(-)
diff --git a/js/src/gc/Marking-inl.h b/js/src/gc/Marking-inl.h
index 6d2a4c7..c773c21 100644
--- a/js/src/gc/Marking-inl.h
+++ b/js/src/gc/Marking-inl.h
@@ -82,12 +82,28 @@ inline void RelocationOverlay::forwardTo(Cell* cell) {
MOZ_ASSERT(!isForwarded());
// The location of magic_ is important because it must never be valid to see
// the value Relocated there in a GC thing that has not been moved.
+#if MOZ_LITTLE_ENDIAN || JS_BITS_PER_WORD == 32
+ // On 32-bit, the magic_ aliases with whatever comes after the first
+ // pointer; on little-endian 64-bit, the magic_ aliases with the
+ // 32 most significant bits of the pointer, which are the second half.
static_assert(offsetof(RelocationOverlay, magic_) ==
offsetof(JSObject, group_) + sizeof(uint32_t),
"RelocationOverlay::magic_ is in the wrong location");
static_assert(offsetof(RelocationOverlay, magic_) ==
offsetof(js::Shape, base_) + sizeof(uint32_t),
"RelocationOverlay::magic_ is in the wrong location");
+#elif JS_BITS_PER_WORD == 64
+ // On big-endian 64-bit, the magic_ aliases with the 32 most
+ // significant bits of the pointer, but now that's the first half.
+ static_assert(offsetof(RelocationOverlay, magic_) ==
+ offsetof(JSObject, group_),
+ "RelocationOverlay::magic_ is in the wrong location");
+ static_assert(offsetof(RelocationOverlay, magic_) ==
+ offsetof(js::Shape, base_),
+ "RelocationOverlay::magic_ is in the wrong location");
+#else
+# error "Unknown endianness or word size"
+#endif
static_assert(
offsetof(RelocationOverlay, magic_) == offsetof(JSString, d.u1.length),
"RelocationOverlay::magic_ is in the wrong location");
diff --git a/js/src/gc/RelocationOverlay.h b/js/src/gc/RelocationOverlay.h
index a568843..399a541 100644
--- a/js/src/gc/RelocationOverlay.h
+++ b/js/src/gc/RelocationOverlay.h
@@ -33,14 +33,25 @@ class RelocationOverlay {
/* See comment in js/public/HeapAPI.h. */
static const uint32_t Relocated = js::gc::Relocated;
+#if MOZ_LITTLE_ENDIAN || JS_BITS_PER_WORD == 32
/*
- * Keep the low 32 bits untouched. Use them to distinguish strings from
+ * Keep the first 32 bits untouched. Use them to distinguish strings from
* objects in the nursery.
*/
uint32_t preserve_;
/* Set to Relocated when moved. */
uint32_t magic_;
+#elif JS_BITS_PER_WORD == 64
+ /*
+ * On big-endian, we need to reorder to keep preserve_ lined up with the
+ * low 32 bits of the aligned group_ pointer in JSObject.
+ */
+ uint32_t magic_;
+ uint32_t preserve_;
+#else
+# error "Unknown endianness or word size"
+#endif
/* The location |this| was moved to. */
Cell* newLocation_;
diff --git a/js/src/jsfriendapi.h b/js/src/jsfriendapi.h
index 4b8d18a..70ce0a1 100644
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -9,6 +9,7 @@
#include "mozilla/Atomics.h"
#include "mozilla/Casting.h"
+#include "mozilla/EndianUtils.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/UniquePtr.h"
@@ -609,8 +610,15 @@ struct String {
static const uint32_t LATIN1_CHARS_BIT = JS_BIT(6);
static const uint32_t EXTERNAL_FLAGS = LINEAR_BIT | NON_ATOM_BIT | JS_BIT(5);
static const uint32_t TYPE_FLAGS_MASK = JS_BIT(6) - 1;
+#if MOZ_LITTLE_ENDIAN || JS_BITS_PER_WORD == 32
uint32_t flags;
uint32_t length;
+#elif JS_BITS_PER_WORD == 64
+ uint32_t length;
+ uint32_t flags;
+#else
+# error "Unknown endianness or word size"
+#endif
union {
const JS::Latin1Char* nonInlineCharsLatin1;
const char16_t* nonInlineCharsTwoByte;
diff --git a/js/src/vm/StringType.h b/js/src/vm/StringType.h
index cde3427..c3400db 100644
--- a/js/src/vm/StringType.h
+++ b/js/src/vm/StringType.h
@@ -7,6 +7,7 @@
#ifndef vm_StringType_h
#define vm_StringType_h
+#include "mozilla/EndianUtils.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/PodOperations.h"
#include "mozilla/Range.h"
@@ -168,8 +169,20 @@ class JSString : public js::gc::Cell {
struct Data {
union {
struct {
+#if MOZ_LITTLE_ENDIAN || JS_BITS_PER_WORD == 32
uint32_t flags; /* JSString */
uint32_t length; /* JSString */
+#elif JS_BITS_PER_WORD == 64
+ /*
+ * On big-endian, we need to reorder to keep flags lined up
+ * with the low 32 bits of the aligned group_ pointer in
+ * JSObject.
+ */
+ uint32_t length; /* JSString */
+ uint32_t flags; /* JSString */
+#else
+# error "Unknown endianness or word size"
+#endif
};
uintptr_t flattenData; /* JSRope (temporary while flattening) */
} u1;
--
2.23.0
++++++ firefox-60.4.0esr.source.tar.xz -> firefox-60.9.0esr.source.tar.xz ++++++
/work/SRC/openSUSE:Factory/mozjs60/firefox-60.4.0esr.source.tar.xz /work/SRC/openSUSE:Factory/.mozjs60.new.2352/firefox-60.9.0esr.source.tar.xz differ: char 15, line 1
++++++ icudt60b.dat.xz ++++++
Binary files /var/tmp/diff_new_pack.b2hx7O/_old and /var/tmp/diff_new_pack.b2hx7O/_new differ
++++++ init_patch.patch ++++++
--- a/python/mozbuild/mozbuild/configure/__init__.py
+++ b/python/mozbuild/mozbuild/configure/__init__.py
@@ -421,7 +421,7 @@
# All options should have been removed (handled) by now.
for arg in self._helper:
without_value = arg.split('=', 1)[0]
- raise InvalidOptionError('Unknown option: %s' % without_value)
+ # raise InvalidOptionError('Unknown option: %s' % without_value)
# Run the execution queue
for func, args in self._execution_queue:
++++++ jsproperty-endian.patch ++++++
From a95105b7846c29c5bd3868719621ab3679d9932b Mon Sep 17 00:00:00 2001
From: rpm-build <rpm-build>
Date: Sat, 7 Sep 2019 21:45:58 +0200
Subject: [PATCH] jsproperty-endian.patch
Bug 1543659 - fix JSPropertySpec::ValueWrapper on 64-bit big-endian platforms
Add some padding to make the union's int32 member correspond to the
low-order bits of the string member. This fixes TypedArray tests on
s390x.
---
js/src/jsapi.h | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/js/src/jsapi.h b/js/src/jsapi.h
index 0f11787f6..f1c084f6a 100644
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1581,7 +1581,14 @@ struct JSPropertySpec {
uintptr_t type;
union {
const char* string;
+#if MOZ_BIG_ENDIAN && JS_BITS_PER_WORD == 64
+ struct {
+ uint32_t padding;
+ int32_t int32;
+ };
+#else
int32_t int32;
+#endif
};
};
--
2.23.0
++++++ riscv-support.patch ++++++
--- /var/tmp/diff_new_pack.b2hx7O/_old 2019-10-07 13:41:58.912184117 +0200
+++ /var/tmp/diff_new_pack.b2hx7O/_new 2019-10-07 13:41:58.936184051 +0200
@@ -2,7 +2,7 @@
index 83b8d70..e5f3182 100644
--- a/build/moz.configure/init.configure
+++ b/build/moz.configure/init.configure
-@@ -676,6 +676,9 @@ def split_triplet(triplet, allow_unknown=False):
+@@ -676,6 +676,9 @@ def split_triplet(triplet, allow_unknown
elif cpu == 'sh4':
canonical_cpu = 'sh4'
endianness = 'little'
@@ -16,21 +16,21 @@
index a8970b0..41503c8 100644
--- a/js/src/jit/AtomicOperations.h
+++ b/js/src/jit/AtomicOperations.h
-@@ -387,6 +387,8 @@ AtomicOperations::isLockfreeJS(int32_t size)
- # include "jit/none/AtomicOperations-feeling-lucky.h"
+@@ -393,6 +393,8 @@ inline bool AtomicOperations::isLockfree
+ #include "jit/none/AtomicOperations-feeling-lucky.h"
#elif defined(__s390__) || defined(__s390x__)
- # include "jit/none/AtomicOperations-feeling-lucky.h"
+ #include "jit/none/AtomicOperations-feeling-lucky.h"
+#elif defined(__riscv)
+# include "jit/none/AtomicOperations-feeling-lucky.h"
#else
- # error "No AtomicOperations support provided for this platform"
+ #error "No AtomicOperations support provided for this platform"
#endif
diff --git a/js/src/jit/none/AtomicOperations-feeling-lucky.h b/js/src/jit/none/AtomicOperations-feeling-lucky.h
index da57228..5167e82 100644
--- a/js/src/jit/none/AtomicOperations-feeling-lucky.h
+++ b/js/src/jit/none/AtomicOperations-feeling-lucky.h
-@@ -79,6 +79,14 @@
- # define GNUC_COMPATIBLE
+@@ -80,6 +80,14 @@
+ #define GNUC_COMPATIBLE
#endif
+#ifdef __riscv
