File mozjs-support-48bit-va.patch of Package mozjs17

# HG changeset patch
# User Zheng Xu <zheng.xu@linaro.org>
# Date 1464657720 -7200
# Node ID dfaafbaaa2919a033c4c0abdd5830f4ea413bed6
# Parent  499f16ca85ec48d1896a1633730715f32bd62140
Bug 1143022 - Manually mmap on arm64 to ensure high 17 bits are clear. r=ehoogeveen

There might be 48-bit VA on arm64 depending on kernel configuration.
Manually mmap heap memory to align with the assumption made by JS engine.

Index: mozjs17.0.0/js/src/gc/Memory.cpp
===================================================================
--- mozjs17.0.0.orig/js/src/gc/Memory.cpp
+++ mozjs17.0.0/js/src/gc/Memory.cpp
@@ -309,6 +309,53 @@ InitMemorySubsystem()
 #endif
 }
 
+
+#if defined(__aarch64__)
+#define USE_SAFE_MMAP
+#endif
+
+#ifdef USE_SAFE_MMAP
+static void *safe_mmap(size_t length, int prot, int flags, int fd, off_t offset)
+{
+   /*
+    * There might be similar virtual address issue on arm64 which depends on
+    * hardware and kernel configurations. But the work around is slightly
+    * different due to the different mmap behavior.
+    */
+    const uintptr_t start = UINT64_C(0x0000070000000000);
+    const uintptr_t end   = UINT64_C(0x0000800000000000);
+    const uintptr_t step  = ChunkSize;
+   /*
+    * Optimization options if there are too many retries in practice:
+    * 1. Examine /proc/self/maps to find an available address. This file is
+    *    not always available, however. In addition, even if we examine
+    *    /proc/self/maps, we may still need to retry several times due to
+    *    racing with other threads.
+    * 2. Use a global/static variable with lock to track the addresses we have
+    *    allocated or tried.
+    */
+    uintptr_t hint;
+    void* region = MAP_FAILED;
+    for (hint = start; region == MAP_FAILED && hint + length <= end; hint += step) {
+        region = mmap((void*)hint, length, prot, flags, fd, offset);
+        if (region != MAP_FAILED) {
+            if ((uintptr_t(region) + (length - 1)) & 0xffff800000000000) {
+                if (munmap(region, length)) {
+                    MOZ_ASSERT(errno == ENOMEM);
+                }
+                region = MAP_FAILED;
+            }
+        }
+    }
+    return region == MAP_FAILED ? NULL : region;
+}
+#else
+static void *safe_mmap(size_t length, int prot, int flags, int fd, off_t offset)
+{
+    return mmap(NULL, length, prot, flags, fd, offset);
+}
+#endif
+
 void *
 MapAlignedPages(size_t size, size_t alignment)
 {
@@ -322,12 +369,12 @@ MapAlignedPages(size_t size, size_t alig
 
     /* Special case: If we want page alignment, no further work is needed. */
     if (alignment == PageSize) {
-        return mmap(NULL, size, prot, flags, -1, 0);
+        return safe_mmap(size, prot, flags, -1, 0);
     }
 
     /* Overallocate and unmap the region's edges. */
     size_t reqSize = Min(size + 2 * alignment, 2 * size);
-    void *region = mmap(NULL, reqSize, prot, flags, -1, 0);
+    void *region = safe_mmap(reqSize, prot, flags, -1, 0);
     if (region == MAP_FAILED)
         return NULL;