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 <mgo...@suse.com> + +- 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/ca36a6c4f8a4a0ddaa033fdbe20836d87bbfb873 +Patch4: emitter.patch +Patch5: emitter_test.patch +Patch6: init_patch.patch +# s390x fixes: +# https://salsa.debian.org/gnome-team/mozjs60/blob/debian/master/debian/patches/enddianness.patch +Patch7: enddianness.patch +# https://salsa.debian.org/gnome-team/mozjs60/blob/debian/master/debian/patches/jsproperty-endian.patch +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?= <andrebarg...@googlemail.com> 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<time_t>(-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 <lhan...@mozilla.com> # 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 <lhan...@mozilla.com> # 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