--- a/js/xpconnect/loader/AutoMemMap.cpp
+++ b/js/xpconnect/loader/AutoMemMap.cpp
@@ -5,52 +5,92 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AutoMemMap.h"
 #include "ScriptPreloader-inl.h"
 
 #include "mozilla/Unused.h"
 #include "nsIFile.h"
 
+#include <private/pprio.h>
+
 namespace mozilla {
 namespace loader {
 
+using namespace mozilla::ipc;
+
 AutoMemMap::~AutoMemMap()
 {
     if (fileMap) {
         if (addr) {
             Unused << NS_WARN_IF(PR_MemUnmap(addr, size()) != PR_SUCCESS);
             addr = nullptr;
         }
 
         Unused << NS_WARN_IF(PR_CloseFileMap(fileMap) != PR_SUCCESS);
         fileMap = nullptr;
     }
 }
 
+FileDescriptor
+AutoMemMap::cloneFileDescriptor()
+{
+    if (fd.get()) {
+        auto handle = FileDescriptor::PlatformHandleType(PR_FileDesc2NativeHandle(fd.get()));
+        return FileDescriptor(handle);
+    }
+    return FileDescriptor();
+}
+
 Result<Ok, nsresult>
 AutoMemMap::init(nsIFile* file, int flags, int mode, PRFileMapProtect prot)
 {
     MOZ_ASSERT(!fd);
+
+    NS_TRY(file->OpenNSPRFileDesc(flags, mode, &fd.rwget()));
+
+    return initInternal(prot);
+}
+
+Result<Ok, nsresult>
+AutoMemMap::init(const FileDescriptor& file)
+{
+    MOZ_ASSERT(!fd);
+    if (!file.IsValid()) {
+        return Err(NS_ERROR_INVALID_ARG);
+    }
+
+    auto handle = file.ClonePlatformHandle();
+
+    fd = PR_ImportFile(PROsfd(handle.get()));
+    if (!fd) {
+        return Err(NS_ERROR_FAILURE);
+    }
+    Unused << handle.release();
+
+    return initInternal();
+}
+
+Result<Ok, nsresult>
+AutoMemMap::initInternal(PRFileMapProtect prot)
+{
     MOZ_ASSERT(!fileMap);
     MOZ_ASSERT(!addr);
 
-    int64_t fileSize;
-    NS_TRY(file->GetFileSize(&fileSize));
+    PRFileInfo64 fileInfo;
+    NS_TRY(PR_GetOpenFileInfo64(fd.get(), &fileInfo));
 
-    if (fileSize > UINT32_MAX)
+    if (fileInfo.size > UINT32_MAX)
         return Err(NS_ERROR_INVALID_ARG);
 
-    NS_TRY(file->OpenNSPRFileDesc(flags, mode, &fd.rwget()));
-
     fileMap = PR_CreateFileMap(fd, 0, prot);
     if (!fileMap)
         return Err(NS_ERROR_FAILURE);
 
-    size_ = fileSize;
+    size_ = fileInfo.size;
     addr = PR_MemMap(fileMap, 0, size_);
     if (!addr)
         return Err(NS_ERROR_FAILURE);
 
     return Ok();
 }
 
 } // namespace loader

--- a/js/xpconnect/loader/AutoMemMap.h
+++ b/js/xpconnect/loader/AutoMemMap.h
@@ -5,36 +5,42 @@
 
 #ifndef loader_AutoMemMap_h
 #define loader_AutoMemMap_h
 
 #include "mozilla/FileUtils.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/RangedPtr.h"
 #include "mozilla/Result.h"
+#include "mozilla/ipc/FileDescriptor.h"
 #include "nsIMemoryReporter.h"
 
 #include <prio.h>
 
 class nsIFile;
 
 namespace mozilla {
 namespace loader {
 
+using mozilla::ipc::FileDescriptor;
+
 class AutoMemMap
 {
     public:
         AutoMemMap() = default;
 
         ~AutoMemMap();
 
         Result<Ok, nsresult>
         init(nsIFile* file, int flags = PR_RDONLY, int mode = 0,
              PRFileMapProtect prot = PR_PROT_READONLY);
 
+        Result<Ok, nsresult>
+        init(const ipc::FileDescriptor& file);
+
         bool initialized() { return addr; }
 
         uint32_t size() const { MOZ_ASSERT(fd); return size_; }
 
         template<typename T = void>
         const RangedPtr<T> get()
         {
             MOZ_ASSERT(addr);
@@ -45,17 +51,21 @@ class AutoMemMap
         const RangedPtr<T> get() const
         {
             MOZ_ASSERT(addr);
             return { static_cast<T*>(addr), size_ };
         }
 
         size_t nonHeapSizeOfExcludingThis() { return size_; }
 
+        FileDescriptor cloneFileDescriptor();
+
     private:
+        Result<Ok, nsresult> initInternal(PRFileMapProtect prot = PR_PROT_READONLY);
+
         AutoFDClose fd;
         PRFileMap* fileMap = nullptr;
 
         uint32_t size_ = 0;
         void* addr = nullptr;
 
         AutoMemMap(const AutoMemMap&) = delete;
         void operator=(const AutoMemMap&) = delete;