upstream version as of 20190907 (mainly for this patch https://bugzilla.mozilla.org/show_bug.cgi?id=1560700)

--- build/moz.configure/rust.configure	2019-08-27 03:31:51.000000000 +0200

+++ build/moz.configure/rust.configure	2019-09-07 17:17:45.964128000 +0200

@@ -41,7 +41,6 @@ def unwrap_rustup(prog, name):

     # "+stable" file. We'll examine the error output to try and distinguish

     # between failing rustup and failing rustc.

     @depends(prog, dependable(name))

-    @imports('subprocess')

     @imports(_from='__builtin__', _import='open')

     @imports('os')

     def unwrap(prog, name):

@@ -96,6 +95,7 @@ def rustc_info(rustc):

         version=Version(info.get('release', '0')),

         commit=info.get('commit-hash', 'unknown'),

         host=info['host'],

+        llvm_version=Version(info.get('LLVM version', '0')),

     )

 set_config('RUSTC_VERSION', depends(rustc_info)(lambda info: str(info.version)))

@@ -138,11 +138,10 @@ def rust_compiler(rustc_info, cargo_info, build_projec

         or by directly running the installer from https://rustup.rs/

         '''))

     if build_project == 'tools/crashreporter':

-        rustc_min_version = Version('1.22.0')

-        cargo_min_version = Version('0.23.0')

+        rustc_min_version = Version('1.31.0')

     else:

         rustc_min_version = Version('1.35.0')

-        cargo_min_version = rustc_min_version

+    cargo_min_version = rustc_min_version

     version = rustc_info.version

     if version < rustc_min_version:

@@ -185,41 +184,34 @@ def rust_compiler(rustc_info, cargo_info, build_projec

 @depends(rustc, when=rust_compiler)

+@imports(_from='__builtin__', _import='ValueError')

 def rust_supported_targets(rustc):

     out = check_cmd_output(rustc, '--print', 'target-list').splitlines()

-    # The os in the triplets used by rust may match the same OSes, in which

-    # case we need to check the raw_os instead.

-    per_os = {}

-    ambiguous = set()

-    per_raw_os = {}

+    data = {}

     for t in out:

-        t = split_triplet(t, allow_unknown=True)

-        endianness = t.endianness

-        if t.cpu.startswith('thumb') and endianness not in ('big', 'little'):

-            endianness = 'little'

-        key = (t.cpu, endianness, t.os)

-        if key in per_os:

-            previous = per_os[key]

-            per_raw_os[(previous.cpu, previous.endianness,

-                        previous.raw_os)] = previous

-            del per_os[key]

-            ambiguous.add(key)

-        if key in ambiguous:

-            raw_os = t.raw_os

-            # split_triplet will return a raw_os of 'androideabi' for

-            # rust targets in the form cpu-linux-androideabi, but what

-            # we get from the build system is linux-androideabi, so

-            # normalize.

-            if raw_os == 'androideabi':

-                raw_os = 'linux-androideabi'

-            per_raw_os[(t.cpu, endianness, raw_os)] = t

-        else:

-            per_os[key] = t

-    return namespace(per_os=per_os, per_raw_os=per_raw_os)

+        try:

+            info = split_triplet(t)

+        except ValueError:

+            if t.startswith('thumb'):

+                cpu, rest = t.split('-', 1)

+                retry = '-'.join(('arm', rest))

+            elif t.endswith('-windows-msvc'):

+                retry = t[:-len('windows-msvc')] + 'mingw32'

+            elif t.endswith('-windows-gnu'):

+                retry = t[:-len('windows-gnu')] + 'mingw32'

+            else:

+                continue

+            try:

+                info = split_triplet(retry)

+            except ValueError:

+                continue

+        key = (info.cpu, info.endianness, info.os)

+        data.setdefault(key, []).append(namespace(rust_target=t, target=info))

+    return data

 @template

-def rust_triple_alias(host_or_target):

+def rust_triple_alias(host_or_target, host_or_target_c_compiler):

     """Template defining the alias used for rustc's --target flag.

     `host_or_target` is either `host` or `target` (the @depends functions

     from init.configure).

@@ -228,11 +220,10 @@ def rust_triple_alias(host_or_target):

     host_or_target_str = {host: 'host', target: 'target'}[host_or_target]

-    @depends(rustc, host_or_target, c_compiler, rust_supported_targets,

-             arm_target, when=rust_compiler)

+    @depends(rustc, host_or_target, host_or_target_c_compiler,

+             rust_supported_targets, arm_target, when=rust_compiler)

     @checking('for rust %s triplet' % host_or_target_str)

     @imports('os')

-    @imports('subprocess')

     @imports(_from='mozbuild.configure.util', _import='LineIO')

     @imports(_from='mozbuild.shellutil', _import='quote')

     @imports(_from='tempfile', _import='mkstemp')

@@ -248,41 +239,104 @@ def rust_triple_alias(host_or_target):

         # munging to get the correct option to rustc.

         # We correlate the autoconf-derived targets with the list of targets

         # rustc gives us with --print target-list.

-        if host_or_target.kernel == 'WINNT':

-            if compiler_info.type in ('gcc', 'clang'):

-                host_or_target_os = 'windows-gnu'

-            else:

-                host_or_target_os = 'windows-msvc'

-            host_or_target_raw_os = host_or_target_os

-        else:

-            host_or_target_os = host_or_target.os

-            host_or_target_raw_os = host_or_target.raw_os

+        candidates = rust_supported_targets.get(

+            (host_or_target.cpu, host_or_target.endianness, host_or_target.os), [])

-        if host_or_target.cpu == 'arm' and arm_target.arm_arch == 7 and \

-                arm_target.fpu == 'neon' and arm_target.thumb2:

-            host_or_target_cpus = ('thumbv7neon', host_or_target.cpu)

-        else:

-            host_or_target_cpus = (host_or_target.cpu,)

+        def find_candidate(candidates):

+            if len(candidates) == 1:

+                return candidates[0].rust_target

+            elif not candidates:

+                return None

-        for host_or_target_cpu in host_or_target_cpus:

-            rustc_target = rust_supported_targets.per_os.get(

-                (host_or_target_cpu, host_or_target.endianness, host_or_target_os))

-            if rustc_target:

-                break

+            # We have multiple candidates. There are two cases where we can try to

+            # narrow further down using extra information from the build system.

+            # - For windows targets, correlate with the C compiler type

+            if host_or_target.kernel == 'WINNT':

+                if compiler_info.type in ('gcc', 'clang'):

+                    suffix = 'windows-gnu'

+                else:

+                    suffix = 'windows-msvc'

+                narrowed = [c for c in candidates if c.rust_target.endswith('-{}'.format(suffix))]

+                if len(narrowed) == 1:

+                    return narrowed[0].rust_target

+                elif narrowed:

+                    candidates = narrowed

-            rustc_target = rust_supported_targets.per_raw_os.get(

-                (host_or_target_cpu, host_or_target.endianness,

-                 host_or_target_raw_os))

-            if rustc_target:

-                break

+            # - For arm targets, correlate with arm_target

+            #   we could be more thorough with the supported rust targets, but they

+            #   don't support OSes that are supported to build Gecko anyways.

+            #   Also, sadly, the only interface to check the rust target cpu features

+            #   is --print target-spec-json, and it's unstable, so we have to rely on

+            #   our own knowledge of what each arm target means.

+            if host_or_target.cpu == 'arm' and host_or_target.endianness == 'little':

+                prefixes = []

+                if arm_target.arm_arch >= 7:

+                    if arm_target.thumb2 and arm_target.fpu == 'neon':

+                        prefixes.append('thumbv7neon')

+                    if arm_target.thumb2:

+                        prefixes.append('thumbv7a')

+                    prefixes.append('armv7')

+                if arm_target.arm_arch >= 6:

+                    prefixes.append('armv6')

+                    if host_or_target.os != 'Android':

+                        # arm-* rust targets are armv6... except arm-linux-androideabi

+                        prefixes.append('arm')

+                if arm_target.arm_arch >= 5:

+                    prefixes.append('armv5te')

+                    if host_or_target.os == 'Android':

+                        # arm-* rust targets are armv6... except arm-linux-androideabi

+                        prefixes.append('arm')

+                if arm_target.arm_arch >= 4:

+                    prefixes.append('armv4t')

+                # rust freebsd targets are the only ones that don't have a 'hf' suffix

+                # for hard-float. Technically, that means if the float abi ever is not

+                # hard-float, this will pick a wrong target, but since rust only

+                # supports hard-float, let's assume that means freebsd only support

+                # hard-float.

+                if arm_target.float_abi == 'hard' and host_or_target.os != 'FreeBSD':

+                    suffix = 'hf'

+                else:

+                    suffix = ''

+                for p in prefixes:

+                    for c in candidates:

+                        if c.rust_target.startswith('{}-'.format(p)) and \

+                                c.rust_target.endswith(suffix):

+                            return c.rust_target

+            # See if we can narrow down on the exact alias

+            narrowed = [c for c in candidates if c.target.alias == host_or_target.alias]

+            if len(narrowed) == 1:

+                return narrowed[0].rust_target

+            elif narrowed:

+                candidates = narrowed

+

+            # See if we can narrow down with the raw OS

+            narrowed = [c for c in candidates if c.target.raw_os == host_or_target.raw_os]

+            if len(narrowed) == 1:

+                return narrowed[0].rust_target

+            elif narrowed:

+                candidates = narrowed

+

+            # See if we can narrow down with the raw OS and raw CPU

+            narrowed = [

+                c for c in candidates

+                if c.target.raw_os == host_or_target.raw_os and

+                   c.target.raw_cpu == host_or_target.raw_cpu

+            ]

+            if len(narrowed) == 1:

+                return narrowed[0].rust_target

+

+            return None

+

+        rustc_target = find_candidate(candidates)

+

         if rustc_target is None:

             die("Don't know how to translate {} for rustc".format(

                 host_or_target.alias))

         # Check to see whether our rustc has a reasonably functional stdlib

         # for our chosen target.

-        target_arg = '--target=' + rustc_target.alias

+        target_arg = '--target=' + rustc_target

         in_fd, in_path = mkstemp(prefix='conftest', suffix='.rs')

         out_fd, out_path = mkstemp(prefix='conftest', suffix='.rlib')

         os.close(out_fd)

@@ -310,7 +364,7 @@ def rust_triple_alias(host_or_target):

                 a rust std library for that target installed. Try:

                   rustup target add {}

-                '''.format(host_or_target.alias, rustc, rustc_target.alias)))

+                '''.format(host_or_target.alias, rustc, rustc_target)))

             check_cmd_output(*cmd, onerror=failed)

             if not os.path.exists(out_path) or os.path.getsize(out_path) == 0:

                 failed()

@@ -319,13 +373,13 @@ def rust_triple_alias(host_or_target):

             os.remove(out_path)

         # This target is usable.

-        return rustc_target.alias

+        return rustc_target

     return rust_target

-rust_target_triple = rust_triple_alias(target)

-rust_host_triple = rust_triple_alias(host)

+rust_target_triple = rust_triple_alias(target, c_compiler)

+rust_host_triple = rust_triple_alias(host, host_c_compiler)

 @depends(host, rust_host_triple, rustc_info.host)

@@ -81,6 +95,16 @@

         uint32_t hwcaps = getauxval(AT_HWCAP);

         if (hwcaps & kHWCAP_CRC32  ) { features |= SkCpu::CRC32; }

         if (hwcaps & kHWCAP_ASIMDHP) { features |= SkCpu::ASIMDHP; }

+        return features;

+    }

+

+#elif defined(SK_CPU_ARM32) && defined(__FreeBSD__)

+

+    static uint32_t read_cpu_features() {

+        uint32_t features = 0;

+#if defined(__ARM_NEON__)

+        features |= SkCpu::NEON;

+#endif

         return features;

     }

--- media/libtheora/lib/arm/armcpu.c.orig	2019-09-05 19:12:29.094444000 +0200

+++ media/libtheora/lib/arm/armcpu.c	2019-09-05 19:19:08.583855000 +0200

@@ -107,6 +107,16 @@ ogg_uint32_t oc_cpu_flags_get(void){

   return flags;

 }

+#elif defined(__FreeBSD__)

+ogg_uint32_t oc_cpu_flags_get(void){

+  ogg_uint32_t  flags;

+  flags = 0;

+#if defined(__ARM_NEON)

+  flags|=OC_CPU_ARM_NEON;

+#endif

+  return flags;

+}

+

 #else

 /*The feature registers which can tell us what the processor supports are

    accessible in priveleged modes only, so we can't have a general user-space

--- media/libtheora/moz.build.orig	2019-09-06 16:51:42.932020000 +0200

+++ media/libtheora/moz.build	2019-09-06 15:22:01.650146000 +0200

@@ -110,4 +110,6 @@ if CONFIG['GNU_AS']:

         if CONFIG['CC_TYPE'] == 'clang':

             ASFLAGS += [

                 '-no-integrated-as',

+                '-Wa,-march=armv7-a',

+                '-Wa,-mfpu=neon',

             ]

--- media/libvpx/libvpx/vpx_ports/arm_cpudetect.c.orig	2019-09-05 18:41:37.364158000 +0200

+++ media/libvpx/libvpx/vpx_ports/arm_cpudetect.c	2019-09-06 16:45:58.616157000 +0200

@@ -147,6 +147,15 @@ int arm_cpu_caps(void) {

   }

   return flags & mask;

 }

+#elif defined(__FreeBSD__) /* end __linux__ */

+

+int arm_cpu_caps(void) {

+  int flags = 0;

+#if HAVE_NEON || HAVE_NEON_ASM

+  flags |= HAS_NEON;

+#endif /* HAVE_NEON || HAVE_NEON_ASM */

+  return flags;

+}

 #else  /* end __linux__ */

 #error \

     "--enable-runtime-cpu-detect selected, but no CPU detection method " \

--- media/libvpx/moz.build.orig	2019-09-05 21:18:38.360185000 +0200

+++ media/libvpx/moz.build	2019-09-06 17:21:26.592064000 +0200

@@ -71,10 +71,10 @@ elif CONFIG['CPU_ARCH'] == 'arm':

         LOCAL_INCLUDES += [

             '%%%s/sources/android/cpufeatures' % CONFIG['ANDROID_NDK'],

         ]

-    if CONFIG['CC_TYPE'] == 'clang':

-        ASFLAGS += [

-            '-no-integrated-as',

-        ]

+#    if CONFIG['CC_TYPE'] == 'clang':

+#        ASFLAGS += [

+#            '-no-integrated-as',

+#        ]

 elif CONFIG['CPU_ARCH'] == 'aarch64' and CONFIG['OS_TARGET'] == 'WINNT':

     EXPORTS.vpx += files['ARM64_EXPORTS']

     SOURCES += files['ARM64_SOURCES']

https://bugzilla.mozilla.org/show_bug.cgi?id=1540142

--- other-licenses/nsis/Contrib/CityHash/cityhash/city.cpp.orig	2019-09-06 19:57:59.310749000 +0200

+++ other-licenses/nsis/Contrib/CityHash/cityhash/city.cpp	2019-09-06 19:54:05.947831000 +0200

@@ -33,7 +33,7 @@

 using namespace std;

-#if __sparc__

+#if __arm__

 #include <string.h>

 static inline uint64 UNALIGNED_LOAD64(const char *p) {

   uint64 val;

--- toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h.orig	2019-09-05 21:10:17.255917000 +0200

+++ toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h	2019-09-05 21:11:46.179632000 +0200

@@ -202,6 +202,8 @@ Atomic64 Release_Load(volatile const Atomic64* ptr);

 #elif defined(__GNUC__)

 #if defined(GOOGLE_PROTOBUF_ARCH_IA32) || defined(GOOGLE_PROTOBUF_ARCH_X64)

 #include <google/protobuf/stubs/atomicops_internals_x86_gcc.h>

+#elif defined(GOOGLE_PROTOBUF_ARCH_ARM) && defined(__FreeBSD__)

+#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>

 #elif defined(GOOGLE_PROTOBUF_ARCH_ARM) && defined(__linux__)

 #if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))

 #include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>

--- xpcom/reflect/xptcall/md/unix/moz.build.orig	2019-09-05 21:06:08.123136000 +0200

+++ xpcom/reflect/xptcall/md/unix/moz.build	2019-09-05 21:06:26.425272000 +0200

@@ -62,7 +62,7 @@ if CONFIG['CPU_ARCH'] == 'Alpha':

         ]

 if CONFIG['CPU_ARCH'] == 'arm':

-    if CONFIG['OS_ARCH'] == 'Linux':

+    if CONFIG['OS_ARCH'] in ('Linux', 'FreeBSD'):

         SOURCES += [

             'xptcinvoke_arm.cpp',

             'xptcstubs_arm.cpp'