pool/firefox-esr
SHA256
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Mozilla Firefox 68.2.0esr

Browse Source 
- removed obsolete patches
    mozilla-bmo1573381.patch
    mozilla-bmo1512162.patch
    mozilla-bmo1585099.patch

OBS-URL: https://build.opensuse.org/package/show/mozilla:Factory/firefox-esr?expand=0&rev=5
This commit is contained in:
Wolfgang Rosenauer 2019-10-21 13:36:41 +00:00 committed by Git OBS Bridge
parent 1c69eeca85
commit 69085a7729
14 changed files with 44 additions and 4698 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compare-locales.tar.xz
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:892b06ef50e2a0f3db6ecefacd620186362913304b932ecb16c888a0243c497c
size 28536
oid sha256:738b0d2cbce77f9f79edc902826da8184fe82ecfbe6c6136b8bb77132bb965db
size 28500

3
firefox-68.1.0esr.source.tar.xz
View File

@ -1,3 +0,0 @@
version https://git-lfs.github.com/spec/v1
oid sha256:f56f5fa5a4744be0b9acf259cb991254d708a50b9a0a12d1d846ffa5a6c409ac
size 312155752

16
firefox-68.1.0esr.source.tar.xz.asc
View File

@ -1,16 +0,0 @@
-----BEGIN PGP SIGNATURE-----
iQIzBAABCgAdFiEECXsxMHeuYqAvhNpN8aZmj7t9Vy4FAl1kD6oACgkQ8aZmj7t9
Vy7zgw//daumocgMPaRkjqsbwsa2PkgdNGv1Doyx3ryKUvAVI0FQYJC2RW5/y++W
Fv92d8ib4Mh8nsmykR4L7jAN+ovdF3mzY0EyoRpC41aWaC0Uw9lLnDVk9s/U46Y3
8IPKEzfNVS4vKETIYviArOLU8AXa/3GT9PtVLZ+VhzMOqe4qnYJTW93s06y0VXUE
r7Bzfe+dwUxLzVtc3d5HfuOmiKYRRjhI1U+Tx8p+DVY7gXhES4r/BmT/bbvNYpdh
i0HzWRH53J7//wiV18WKPxX1UqTYIVMwEhHZZ9+MA11LN2HTLKPmNL/wnh+zx6Wg
arVJQYIIdH7CvNt0/ewJmsFgUmU9inSUd/zJ+7Absq3eDDBwYvsiNNexW+cpgDIe
axWgtQBkp0m73gZ8wzcYO7lI4KhbfraWwBiSubIrZRSuJAbyowKVees/hRtFFeI2
Uhzefr+Cn9RS6vGm7DKme36c6VOZGP7kRO8u+sNrxu4NeOakoG4J7pwFbCnLAVO2
vT0a4xScznXQ9inqrYRdnUiUQv2PLOLCC8uullaPvyd99LPmhbgYaVrii/8S4Ozo
zU95mzbBUbvMPg3OrLNbcszRHeLV9EK0if/+GGr6fSVNrEmShqsFpbceSsbrGg0+
tOWi7PM4iHhlzaFt2TVLV4+xfQWoH7kBW2qNA0dmGjYP1poh1WE=
=Q1b3
-----END PGP SIGNATURE-----

3
firefox-68.2.0esr.source.tar.xz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:85f1c2eaf68ebedcbc0b78a342f6d16ef0865dedd426a1bba94b75c85f716f38
size 312103756

16
firefox-68.2.0esr.source.tar.xz.asc Normal file
View File

@ -0,0 +1,16 @@
-----BEGIN PGP SIGNATURE-----
iQIzBAABCgAdFiEECXsxMHeuYqAvhNpN8aZmj7t9Vy4FAl2ncUYACgkQ8aZmj7t9
Vy4E0A/8DpD0vJ0cMz3LSslD5xkj+h3CQ+dX8NJOZnWZ4I03VsTHkbkD7pRfcLuz
e5O7jswbkb9osUxK4FBoNTznQWSkwSbByyd92/c31LDCHhxerzIcJ8K3gsxnb6Mx
Z4PMCYfg2DypUcfktxFP5g9Tlel7ooFS/vZV8ClmaszbBCIo2UrlYDYoozxaqnJ7
fVsuWfFfMtOOer3iIRd362HRxBcr41Bie1xX+VCoKN+zMUjscRun00i61XQAK9UN
vOONywCJrp12Hmk+RCvY7r3e043qj8f1HZ1BWO0dgq5HItlt/xAkX4/w3u2dNVL5
LDNPebACJe73f7PfmwESILxJgR+aN/7K20uOLW5Y/hjgJ0VRQqQFWyqPX45agiea
EvDoykZq73IVz8t1ZNXl3QwaVYxqHYIByeuW/VLQmRrz2iDGNmIn/DwjehpOBzNK
ZRAfreypYvVYQLVKgvRuA2R9A8qj9Tl+XDqdLm76vtSrbOnFHM7SEmKbhSJorLKh
KhF5FN35+55JrV+rAlnyuYiE0uPiETtRuKg4UkkgSvT7z64+svln5St0pw/NWSTx
k7RHrWUQExFkzSKGfvMO9b1b8KT/kQJHHQrnFQOOVd34rSMw4AtpHaZgH+GMu/qn
z7AdhJc+k6eKbQlUDNY3GLfVWo6K2i0wAoBKdnZRzMT/EhMCSXs=
=xq+p
-----END PGP SIGNATURE-----

9
firefox-esr.changes
View File

@ -1,3 +1,12 @@
-------------------------------------------------------------------
Mon Oct 21 13:13:29 UTC 2019 - Wolfgang Rosenauer <wr@rosenauer.org>
- Mozilla Firefox 68.2.0esr
- removed obsolete patches
mozilla-bmo1573381.patch
mozilla-bmo1512162.patch
mozilla-bmo1585099.patch
-------------------------------------------------------------------
Wed Oct 2 21:08:05 UTC 2019 - Wolfgang Rosenauer <wr@rosenauer.org>

14
firefox-esr.spec
View File

@ -26,13 +26,13 @@
# major 69
# mainver %major.99
%define major 68
%define mainver %major.1.0
%define orig_version 68.1.0
%define mainver %major.2.0
%define orig_version 68.2.0
%define orig_suffix esr
%define update_channel esr68
%define branding 1
%define devpkg 0
%define releasedate 20190826132627
%define releasedate 20191016163237
# always build with GCC as SUSE Security Team requires that
%define clang_build 0
@ -193,16 +193,13 @@ Patch12: mozilla-reduce-rust-debuginfo.patch
Patch13: mozilla-ppc-altivec_static_inline.patch
Patch14: mozilla-bmo1005535.patch
Patch15: mozilla-bmo1568145.patch
Patch16: mozilla-bmo1573381.patch
Patch17: mozilla-bmo1504834-part1.patch
Patch18: mozilla-bmo1504834-part2.patch
Patch19: mozilla-bmo1504834-part3.patch
Patch20: mozilla-bmo1511604.patch
Patch21: mozilla-bmo1554971.patch
Patch22: mozilla-nestegg-big-endian.patch
Patch23: mozilla-bmo1512162.patch
Patch24: mozilla-fix-top-level-asm.patch
Patch25: mozilla-bmo1585099.patch
# Firefox/browser
Patch101: firefox-kde.patch
Patch102: firefox-branded-icons.patch
@ -246,6 +243,8 @@ Development files for %{appname} to make packaging of addons easier.
Summary: Common translations for %{appname}
Group: System/Localization
Provides: locale(%{name}:ar;ca;cs;da;de;el;en_GB;es_AR;es_CL;es_ES;fi;fr;hu;it;ja;ko;nb_NO;nl;pl;pt_BR;pt_PT;ru;sv_SE;zh_CN;zh_TW)
# This is there for updates from Firefox before the translations-package was split up into 2 packages
Provides: %{name}-translations
Requires: %{name} = %{version}
Obsoletes: %{name}-translations < %{version}-%{release}
@ -328,16 +327,13 @@ cd $RPM_BUILD_DIR/%{srcname}-%{orig_version}
%patch13 -p1
%patch14 -p1
%patch15 -p1
%patch16 -p1
%patch17 -p1
%patch18 -p1
%patch19 -p1
%patch20 -p1
%patch21 -p1
%patch22 -p1
%patch23 -p1
%patch24 -p1
%patch25 -p1
# Firefox
%patch101 -p1
%patch102 -p1

3
l10n-68.1.0esr.tar.xz
View File

@ -1,3 +0,0 @@
version https://git-lfs.github.com/spec/v1
oid sha256:043dc60ede681bba9c691fde2481af55858a106b527fe133803482061c3d81ec
size 49123892

3
l10n-68.2.0esr.tar.xz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:bf1908adee88e669b5db6460c35a2d0dbc9788c596bcb91c6209c15b174e1b8e
size 49148316

502
mozilla-bmo1512162.patch
View File

@ -1,502 +0,0 @@
# HG changeset patch
# Parent d4ba07ab572268a34e98c63792beb2ce6d78e7a1
This patch is upstream
diff -r d4ba07ab5722 js/xpconnect/src/XPCWrappedNative.cpp
--- a/js/xpconnect/src/XPCWrappedNative.cpp Fri Sep 20 07:56:01 2019 +0200
+++ b/js/xpconnect/src/XPCWrappedNative.cpp Fri Sep 20 08:00:19 2019 +0200
@@ -1157,10 +1157,6 @@
return helper.get().Call();
}
-#if (__GNUC__ && __linux__ && __PPC64__ && _LITTLE_ENDIAN)
-// Work around a compiler bug on ppc64le (bug 1512162).
-__attribute__ ((noinline,noclone))
-#endif
bool CallMethodHelper::Call() {
mCallContext.SetRetVal(JS::UndefinedValue());
@@ -1319,10 +1315,6 @@
return true;
}
-#if (__GNUC__ && __linux__ && __PPC64__ && _LITTLE_ENDIAN)
-// Work around a compiler bug on ppc64le (bug 1512162).
-__attribute__ ((noinline,noclone))
-#endif
bool CallMethodHelper::GatherAndConvertResults() {
// now we iterate through the native params to gather and convert results
uint8_t paramCount = mMethodInfo->GetParamCount();
diff -r d4ba07ab5722 xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc64_linux.S
--- a/xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc64_linux.S Fri Sep 20 07:56:01 2019 +0200
+++ b/xpcom/reflect/xptcall/md/unix/xptcinvoke_asm_ppc64_linux.S Fri Sep 20 08:00:19 2019 +0200
@@ -151,10 +151,10 @@
ld r2,STACK_TOC(r1) # Load our own TOC pointer
ld r1,0(r1) # Revert stack frame
ld 0,16(r1) # Reload lr
+ mtlr 0
ld 29,-24(r1) # Restore NVGPRS
ld 30,-16(r1)
ld 31,-8(r1)
- mtlr 0
blr
#if _CALL_ELF == 2
diff -r d4ba07ab5722 xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc64_linux.cpp
--- a/xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc64_linux.cpp Fri Sep 20 07:56:01 2019 +0200
+++ b/xpcom/reflect/xptcall/md/unix/xptcinvoke_ppc64_linux.cpp Fri Sep 20 08:00:19 2019 +0200
@@ -5,93 +5,126 @@
// Platform specific code to invoke XPCOM methods on native objects
+#include "xptcprivate.h"
+
// The purpose of NS_InvokeByIndex() is to map a platform
// independent call to the platform ABI. To do that,
// NS_InvokeByIndex() has to determine the method to call via vtable
// access. The parameters for the method are read from the
// nsXPTCVariant* and prepared for the native ABI.
-
-// The PowerPC64 platform ABI can be found here:
-// http://www.freestandards.org/spec/ELF/ppc64/
+//
+// Prior to POWER8, all 64-bit Power ISA systems used ELF v1 ABI, found
+// here:
+// https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html
// and in particular:
-// http://www.freestandards.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#FUNC-CALL
-
-#include <stdio.h>
-#include "xptcprivate.h"
+// https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html#FUNC-CALL
+// Little-endian ppc64le, however, uses ELF v2 ABI, which is here:
+// http://openpowerfoundation.org/wp-content/uploads/resources/leabi/leabi-20170510.pdf
+// and in particular section 2.2, page 22. However, most big-endian ppc64
+// systems still use ELF v1, so this file should support both.
-// 8 integral parameters are passed in registers, not including 'that'
-#define GPR_COUNT 7
+// 7 integral parameters are passed in registers, not including |this|
+// (i.e., r3-r10, with r3 being |this|).
+const uint32_t GPR_COUNT = 7;
-// 8 floating point parameters are passed in registers, floats are
-// promoted to doubles when passed in registers
-#define FPR_COUNT 13
-
-extern "C" uint32_t
-invoke_count_words(uint32_t paramCount, nsXPTCVariant* s)
-{
- return uint32_t(((paramCount * 2) + 3) & ~3);
-}
+// 13 floating point parameters are passed in registers, either single or
+// double precision (i.e., f1-f13).
+const uint32_t FPR_COUNT = 13;
-extern "C" void
-invoke_copy_to_stack(uint64_t* gpregs,
- double* fpregs,
- uint32_t paramCount,
- nsXPTCVariant* s,
- uint64_t* d)
+// Both ABIs use the same register assignment strategy, as per this
+// example from V1 ABI section 3.2.3 and V2 ABI section 2.2.3.2 [page 43]:
+//
+// typedef struct {
+// int a;
+// double dd;
+// } sparm;
+// sparm s, t;
+// int c, d, e;
+// long double ld;
+// double ff, gg, hh;
+//
+// x = func(c, ff, d, ld, s, gg, t, e, hh);
+//
+// Parameter Register Offset in parameter save area
+// c r3 0-7 (not stored in parameter save area)
+// ff f1 8-15 (not stored)
+// d r5 16-23 (not stored)
+// ld f2,f3 24-39 (not stored)
+// s r8,r9 40-55 (not stored)
+// gg f4 56-63 (not stored)
+// t (none) 64-79 (stored in parameter save area)
+// e (none) 80-87 (stored)
+// hh f5 88-95 (not stored)
+//
+// i.e., each successive FPR usage skips a GPR, but not the other way around.
+
+extern "C" void invoke_copy_to_stack(uint64_t* gpregs, double* fpregs,
+ uint32_t paramCount, nsXPTCVariant* s,
+ uint64_t* d)
{
- uint64_t tempu64;
+ uint32_t nr_gpr = 0u;
+ uint32_t nr_fpr = 0u;
+ uint64_t value = 0u;
- for(uint32_t i = 0; i < paramCount; i++, s++) {
- if(s->IsIndirect())
- tempu64 = (uint64_t) &s->val;
+ for (uint32_t i = 0; i < paramCount; i++, s++) {
+ if (s->IsIndirect())
+ value = (uint64_t) &s->val;
else {
- switch(s->type) {
- case nsXPTType::T_FLOAT: break;
- case nsXPTType::T_DOUBLE: break;
- case nsXPTType::T_I8: tempu64 = s->val.i8; break;
- case nsXPTType::T_I16: tempu64 = s->val.i16; break;
- case nsXPTType::T_I32: tempu64 = s->val.i32; break;
- case nsXPTType::T_I64: tempu64 = s->val.i64; break;
- case nsXPTType::T_U8: tempu64 = s->val.u8; break;
- case nsXPTType::T_U16: tempu64 = s->val.u16; break;
- case nsXPTType::T_U32: tempu64 = s->val.u32; break;
- case nsXPTType::T_U64: tempu64 = s->val.u64; break;
- case nsXPTType::T_BOOL: tempu64 = s->val.b; break;
- case nsXPTType::T_CHAR: tempu64 = s->val.c; break;
- case nsXPTType::T_WCHAR: tempu64 = s->val.wc; break;
- default: tempu64 = (uint64_t) s->val.p; break;
+ switch (s->type) {
+ case nsXPTType::T_FLOAT: break;
+ case nsXPTType::T_DOUBLE: break;
+ case nsXPTType::T_I8: value = s->val.i8; break;
+ case nsXPTType::T_I16: value = s->val.i16; break;
+ case nsXPTType::T_I32: value = s->val.i32; break;
+ case nsXPTType::T_I64: value = s->val.i64; break;
+ case nsXPTType::T_U8: value = s->val.u8; break;
+ case nsXPTType::T_U16: value = s->val.u16; break;
+ case nsXPTType::T_U32: value = s->val.u32; break;
+ case nsXPTType::T_U64: value = s->val.u64; break;
+ case nsXPTType::T_BOOL: value = s->val.b; break;
+ case nsXPTType::T_CHAR: value = s->val.c; break;
+ case nsXPTType::T_WCHAR: value = s->val.wc; break;
+ default: value = (uint64_t) s->val.p; break;
}
}
if (!s->IsIndirect() && s->type == nsXPTType::T_DOUBLE) {
- if (i < FPR_COUNT)
- fpregs[i] = s->val.d;
- else
- *(double *)d = s->val.d;
+ if (nr_fpr < FPR_COUNT) {
+ fpregs[nr_fpr++] = s->val.d;
+ nr_gpr++;
+ } else {
+ *((double *)d) = s->val.d;
+ d++;
+ }
}
else if (!s->IsIndirect() && s->type == nsXPTType::T_FLOAT) {
- if (i < FPR_COUNT) {
- fpregs[i] = s->val.f; // if passed in registers, floats are promoted to doubles
+ if (nr_fpr < FPR_COUNT) {
+ // Single-precision floats are passed in FPRs too.
+ fpregs[nr_fpr++] = s->val.f;
+ nr_gpr++;
} else {
- float *p = (float *)d;
-#ifndef __LITTLE_ENDIAN__
+#ifdef __LITTLE_ENDIAN__
+ *((float *)d) = s->val.f;
+#else
+ // Big endian needs adjustment to point to the least
+ // significant word.
+ float* p = (float*)d;
p++;
+ *p = s->val.f;
#endif
- *p = s->val.f;
+ d++;
}
}
else {
- if (i < GPR_COUNT)
- gpregs[i] = tempu64;
- else
- *d = tempu64;
+ if (nr_gpr < GPR_COUNT) {
+ gpregs[nr_gpr++] = value;
+ } else {
+ *d++ = value;
+ }
}
- if (i >= 7)
- d++;
}
}
EXPORT_XPCOM_API(nsresult)
-NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex,
- uint32_t paramCount, nsXPTCVariant* params);
-
+NS_InvokeByIndex(nsISupports* that, uint32_t methodIndex, uint32_t paramCount,
+ nsXPTCVariant* params);
diff -r d4ba07ab5722 xpcom/reflect/xptcall/md/unix/xptcstubs_ppc64_linux.cpp
--- a/xpcom/reflect/xptcall/md/unix/xptcstubs_ppc64_linux.cpp Fri Sep 20 07:56:01 2019 +0200
+++ b/xpcom/reflect/xptcall/md/unix/xptcstubs_ppc64_linux.cpp Fri Sep 20 08:00:19 2019 +0200
@@ -7,36 +7,64 @@
#include "xptcprivate.h"
-// The Linux/PPC64 ABI passes the first 8 integral
-// parameters and the first 13 floating point parameters in registers
-// (r3-r10 and f1-f13), no stack space is allocated for these by the
-// caller. The rest of the parameters are passed in the caller's stack
-// area. The stack pointer has to retain 16-byte alignment.
+// Prior to POWER8, all 64-bit Power ISA systems used ELF v1 ABI, found
+// here:
+// https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html
+// and in particular:
+// https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html#FUNC-CALL
+// Little-endian ppc64le, however, uses ELF v2 ABI, which is here:
+// http://openpowerfoundation.org/wp-content/uploads/resources/leabi/leabi-20170510.pdf
+// and in particular section 2.2, page 22. However, most big-endian ppc64
+// systems still use ELF v1, so this file should support both.
+//
+// Both ABIs pass the first 8 integral parameters and the first 13 floating
+// point parameters in registers r3-r10 and f1-f13. No stack space is
+// allocated for these by the caller. The rest of the parameters are passed
+// in the caller's stack area. The stack pointer must stay 16-byte aligned.
-// The PowerPC64 platform ABI can be found here:
-// http://www.freestandards.org/spec/ELF/ppc64/
-// and in particular:
-// http://www.freestandards.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#FUNC-CALL
-
-#define PARAM_BUFFER_COUNT 16
-#define GPR_COUNT 7
-#define FPR_COUNT 13
+const uint32_t PARAM_BUFFER_COUNT = 16;
+const uint32_t GPR_COUNT = 7;
+const uint32_t FPR_COUNT = 13;
// PrepareAndDispatch() is called by SharedStub() and calls the actual method.
//
// - 'args[]' contains the arguments passed on stack
-// - 'gprData[]' contains the arguments passed in integer registers
-// - 'fprData[]' contains the arguments passed in floating point registers
+// - 'gpregs[]' contains the arguments passed in integer registers
+// - 'fpregs[]' contains the arguments passed in floating point registers
//
// The parameters are mapped into an array of type 'nsXPTCMiniVariant'
// and then the method gets called.
-#include <stdio.h>
+//
+// Both ABIs use the same register assignment strategy, as per this
+// example from V1 ABI section 3.2.3 and V2 ABI section 2.2.3.2 [page 43]:
+//
+// typedef struct {
+// int a;
+// double dd;
+// } sparm;
+// sparm s, t;
+// int c, d, e;
+// long double ld;
+// double ff, gg, hh;
+//
+// x = func(c, ff, d, ld, s, gg, t, e, hh);
+//
+// Parameter Register Offset in parameter save area
+// c r3 0-7 (not stored in parameter save area)
+// ff f1 8-15 (not stored)
+// d r5 16-23 (not stored)
+// ld f2,f3 24-39 (not stored)
+// s r8,r9 40-55 (not stored)
+// gg f4 56-63 (not stored)
+// t (none) 64-79 (stored in parameter save area)
+// e (none) 80-87 (stored)
+// hh f5 88-95 (not stored)
+//
+// i.e., each successive FPR usage skips a GPR, but not the other way around.
+
extern "C" nsresult ATTRIBUTE_USED
-PrepareAndDispatch(nsXPTCStubBase* self,
- uint64_t methodIndex,
- uint64_t* args,
- uint64_t *gprData,
- double *fprData)
+PrepareAndDispatch(nsXPTCStubBase * self, uint32_t methodIndex,
+ uint64_t * args, uint64_t * gpregs, double *fpregs)
{
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
nsXPTCMiniVariant* dispatchParams = nullptr;
@@ -48,7 +76,7 @@
self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
NS_ASSERTION(info,"no method info");
- if (! info)
+ if (!info)
return NS_ERROR_UNEXPECTED;
paramCount = info->GetParamCount();
@@ -66,9 +94,11 @@
const uint8_t indexOfJSContext = info->IndexOfJSContext();
uint64_t* ap = args;
- uint32_t iCount = 0;
- uint32_t fpCount = 0;
- uint64_t tempu64;
+ // |that| is implicit in the calling convention; we really do start at the
+ // first GPR (as opposed to x86_64).
+ uint32_t nr_gpr = 0;
+ uint32_t nr_fpr = 0;
+ uint64_t value;
for(i = 0; i < paramCount; i++) {
const nsXPTParamInfo& param = info->GetParam(i);
@@ -76,67 +106,67 @@
nsXPTCMiniVariant* dp = &dispatchParams[i];
if (i == indexOfJSContext) {
- if (iCount < GPR_COUNT)
- iCount++;
+ if (nr_gpr < GPR_COUNT)
+ nr_gpr++;
else
ap++;
}
if (!param.IsOut() && type == nsXPTType::T_DOUBLE) {
- if (fpCount < FPR_COUNT) {
- dp->val.d = fprData[fpCount++];
- }
- else
- dp->val.d = *(double*) ap;
- } else if (!param.IsOut() && type == nsXPTType::T_FLOAT) {
- if (fpCount < FPR_COUNT) {
- dp->val.f = (float) fprData[fpCount++]; // in registers floats are passed as doubles
+ if (nr_fpr < FPR_COUNT) {
+ dp->val.d = fpregs[nr_fpr++];
+ nr_gpr++;
+ } else {
+ dp->val.d = *(double*)ap++;
}
- else {
- float *p = (float *)ap;
-#ifndef __LITTLE_ENDIAN__
+ continue;
+ }
+ if (!param.IsOut() && type == nsXPTType::T_FLOAT) {
+ if (nr_fpr < FPR_COUNT) {
+ // Single-precision floats are passed in FPRs too.
+ dp->val.f = (float)fpregs[nr_fpr++];
+ nr_gpr++;
+ } else {
+#ifdef __LITTLE_ENDIAN__
+ dp->val.f = *(float*)ap++;
+#else
+ // Big endian needs adjustment to point to the least
+ // significant word.
+ float* p = (float*)ap;
p++;
-#endif
dp->val.f = *p;
+ ap++;
+#endif
}
- } else { /* integer type or pointer */
- if (iCount < GPR_COUNT)
- tempu64 = gprData[iCount];
- else
- tempu64 = *ap;
+ continue;
+ }
+ if (nr_gpr < GPR_COUNT)
+ value = gpregs[nr_gpr++];
+ else
+ value = *ap++;
- if (param.IsOut() || !type.IsArithmetic())
- dp->val.p = (void*) tempu64;
- else if (type == nsXPTType::T_I8)
- dp->val.i8 = (int8_t) tempu64;
- else if (type == nsXPTType::T_I16)
- dp->val.i16 = (int16_t) tempu64;
- else if (type == nsXPTType::T_I32)
- dp->val.i32 = (int32_t) tempu64;
- else if (type == nsXPTType::T_I64)
- dp->val.i64 = (int64_t) tempu64;
- else if (type == nsXPTType::T_U8)
- dp->val.u8 = (uint8_t) tempu64;
- else if (type == nsXPTType::T_U16)
- dp->val.u16 = (uint16_t) tempu64;
- else if (type == nsXPTType::T_U32)
- dp->val.u32 = (uint32_t) tempu64;
- else if (type == nsXPTType::T_U64)
- dp->val.u64 = (uint64_t) tempu64;
- else if (type == nsXPTType::T_BOOL)
- dp->val.b = (bool) tempu64;
- else if (type == nsXPTType::T_CHAR)
- dp->val.c = (char) tempu64;
- else if (type == nsXPTType::T_WCHAR)
- dp->val.wc = (wchar_t) tempu64;
- else
- NS_ERROR("bad type");
+ if (param.IsOut() || !type.IsArithmetic()) {
+ dp->val.p = (void*) value;
+ continue;
}
- if (iCount < GPR_COUNT)
- iCount++; // gprs are skipped for fp args, so this always needs inc
- else
- ap++;
+ switch (type) {
+ case nsXPTType::T_I8: dp->val.i8 = (int8_t) value; break;
+ case nsXPTType::T_I16: dp->val.i16 = (int16_t) value; break;
+ case nsXPTType::T_I32: dp->val.i32 = (int32_t) value; break;
+ case nsXPTType::T_I64: dp->val.i64 = (int64_t) value; break;
+ case nsXPTType::T_U8: dp->val.u8 = (uint8_t) value; break;
+ case nsXPTType::T_U16: dp->val.u16 = (uint16_t) value; break;
+ case nsXPTType::T_U32: dp->val.u32 = (uint32_t) value; break;
+ case nsXPTType::T_U64: dp->val.u64 = (uint64_t) value; break;
+ case nsXPTType::T_BOOL: dp->val.b = (bool) value; break;
+ case nsXPTType::T_CHAR: dp->val.c = (char) value; break;
+ case nsXPTType::T_WCHAR: dp->val.wc = (wchar_t) value; break;
+
+ default:
+ NS_ERROR("bad type");
+ break;
+ }
}
nsresult result = self->mOuter->CallMethod((uint16_t) methodIndex, info,
@@ -150,23 +180,19 @@
// Load r11 with the constant 'n' and branch to SharedStub().
//
+// As G++3 ABI contains the length of the functionname in the mangled
+// name, it is difficult to get a generic assembler mechanism like
+// in the G++ 2.95 case.
// XXX Yes, it's ugly that we're relying on gcc's name-mangling here;
// however, it's quick, dirty, and'll break when the ABI changes on
// us, which is what we want ;-).
-
-
-// gcc-3 version
-//
-// As G++3 ABI contains the length of the functionname in the mangled
-// name, it is difficult to get a generic assembler mechanism like
-// in the G++ 2.95 case.
// Create names would be like:
// _ZN14nsXPTCStubBase5Stub1Ev
// _ZN14nsXPTCStubBase6Stub12Ev
// _ZN14nsXPTCStubBase7Stub123Ev
// _ZN14nsXPTCStubBase8Stub1234Ev
// etc.
-// Use assembler directives to get the names right...
+// Use assembler directives to get the names right.
#if _CALL_ELF == 2
# define STUB_ENTRY(n) \
@@ -252,7 +278,7 @@
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
- NS_ERROR("nsXPTCStubBase::Sentinel called"); \
+ NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}

22
mozilla-bmo1573381.patch
View File

@ -1,22 +0,0 @@
# HG changeset patch
# Parent 45680ce4ca06795cbca1ea5a9ae8a7a11ab95cf1
The code tries to find a codec in a list of codecs. For this it searches for a given prefix.
But the prefix is of type char16_t, which means 2 bytes per character instead of 1, as was compared here.
On big endian this created some false positives, as the order of bytes is different and some characters only
occupy "the first" byte, having the second null'ed out.
Noticed because of gtest: MediaMIMETypes.MediaCodecs
Upstream bugreport: https://bugzilla.mozilla.org/show_bug.cgi?id=1573381
diff -r 45680ce4ca06 -r 381102061fcc dom/media/MediaMIMETypes.cpp
--- a/dom/media/MediaMIMETypes.cpp Mon Aug 05 09:28:53 2019 +0200
+++ b/dom/media/MediaMIMETypes.cpp Tue Aug 13 07:51:27 2019 +0200
@@ -87,7 +87,7 @@
const size_t prefixLength = aCodecPrefix.Length();
for (const auto& myCodec : Range()) {
if (myCodec.Length() >= prefixLength &&
- memcmp(myCodec.Data(), aCodecPrefix.Data(), prefixLength) == 0) {
+ memcmp(myCodec.Data(), aCodecPrefix.Data(), prefixLength * sizeof(char16_t)) == 0) {
return true;
}
}

4133
mozilla-bmo1585099.patch
View File

File diff suppressed because it is too large Load Diff

4
source-stamp.txt
View File

@ -1,2 +1,2 @@
REV=bf6ea738ba073f1a70554799a749235136afc93a
REPO=http://hg.mozilla.org/releases/mozilla-release
REV=ce462a42d4f7aa92e526fab29baea17ab5985841
REPO=http://hg.mozilla.org/releases/mozilla-esr68

10
tar_stamps
View File

@ -1,10 +1,8 @@
PRODUCT="firefox"
CHANNEL="esr68"
VERSION="68.1.0"
VERSION="68.2.0"
VERSION_SUFFIX="esr"
FF_RELEASE_TAG="380fedbb18002297f1b233bd9c09764e59ddaa86"
TB_RELEASE_TAG=""
PREV_VERSION=""
PREV_VERSION_SUFFIX=""
RELEASE_TAG="ce462a42d4f7aa92e526fab29baea17ab5985841"
PREV_VERSION="68.1.0"
PREV_VERSION_SUFFIX="esr"
#SKIP_LOCALES="" # Uncomment to skip l10n and compare-locales-generation