Index: include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
===================================================================
--- include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
+++ include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
@@ -164,15 +164,16 @@
   LocalJITCompileCallbackManager(JITTargetAddress ErrorHandlerAddress)
       : JITCompileCallbackManager(ErrorHandlerAddress) {
     /// Set up the resolver block.
-    std::error_code EC;
-    ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-        TargetT::ResolverCodeSize, nullptr,
-        sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-    assert(!EC && "Failed to allocate resolver block");
+    std::string Err;
+    ResolverBlock = sys::OwningMemoryBlock(
+        sys::Memory::AllocateRWX(TargetT::ResolverCodeSize, nullptr, &Err));
+    if (!ResolverBlock.base())
+      report_fatal_error("Can't allocate enough memory: " + Err);
 
     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
                                &reenter, this);
 
+    std::error_code EC;
     EC = sys::Memory::protectMappedMemory(ResolverBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
                                               sys::Memory::MF_EXEC);
@@ -191,12 +192,11 @@
   void grow() override {
     assert(this->AvailableTrampolines.empty() && "Growing prematurely?");
 
-    std::error_code EC;
-    auto TrampolineBlock =
-        sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-            sys::Process::getPageSize(), nullptr,
-            sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-    assert(!EC && "Failed to allocate trampoline block");
+    std::string Err;
+    auto TrampolineBlock = sys::OwningMemoryBlock(
+        sys::Memory::AllocateRWX(sys::Process::getPageSize(), nullptr, &Err));
+    if (!TrampolineBlock.base())
+      report_fatal_error("Can't allocate enough memory: " + Err);
 
     unsigned NumTrampolines =
         (sys::Process::getPageSize() - TargetT::PointerSize) /
@@ -211,6 +211,7 @@
           static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(
               TrampolineMem + (I * TargetT::TrampolineSize))));
 
+    std::error_code EC;
     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
                                               sys::Memory::MF_EXEC);
Index: include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
===================================================================
--- include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
+++ include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h
@@ -115,11 +115,10 @@
     }
 
     Error allocate(void *&Addr, size_t Size, uint32_t Align) {
-      std::error_code EC;
-      sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(
-          Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
-      if (EC)
-        return errorCodeToError(EC);
+      std::string Err;
+      sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err);
+      if (!MB.base())
+        report_fatal_error("Can't allocate enough memory: " + Err);
 
       Addr = MB.base();
       assert(Allocs.find(MB.base()) == Allocs.end() && "Duplicate alloc");
@@ -277,12 +276,11 @@
   }
 
   Error handleEmitResolverBlock() {
-    std::error_code EC;
-    ResolverBlock = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-        TargetT::ResolverCodeSize, nullptr,
-        sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-    if (EC)
-      return errorCodeToError(EC);
+    std::string Err;
+    ResolverBlock = sys::OwningMemoryBlock(
+        sys::Memory::AllocateRWX(TargetT::ResolverCodeSize, nullptr, &Err));
+    if (!ResolverBlock.base())
+      report_fatal_error("Can't allocate enough memory: " + Err);
 
     TargetT::writeResolverCode(static_cast<uint8_t *>(ResolverBlock.base()),
                                &reenter, this);
@@ -293,13 +291,11 @@
   }
 
   Expected<std::tuple<JITTargetAddress, uint32_t>> handleEmitTrampolineBlock() {
-    std::error_code EC;
-    auto TrampolineBlock =
-        sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-            sys::Process::getPageSize(), nullptr,
-            sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-    if (EC)
-      return errorCodeToError(EC);
+    std::string Err;
+    auto TrampolineBlock = sys::OwningMemoryBlock(
+        sys::Memory::AllocateRWX(sys::Process::getPageSize(), nullptr, &Err));
+    if (!TrampolineBlock.base())
+      report_fatal_error("Can't allocate enough memory: " + Err);
 
     uint32_t NumTrampolines =
         (sys::Process::getPageSize() - TargetT::PointerSize) /
@@ -309,6 +305,7 @@
     TargetT::writeTrampolines(TrampolineMem, ResolverBlock.base(),
                               NumTrampolines);
 
+    std::error_code EC;
     EC = sys::Memory::protectMappedMemory(TrampolineBlock.getMemoryBlock(),
                                           sys::Memory::MF_READ |
                                               sys::Memory::MF_EXEC);
Index: lib/ExecutionEngine/Orc/OrcABISupport.cpp
===================================================================
--- lib/ExecutionEngine/Orc/OrcABISupport.cpp
+++ lib/ExecutionEngine/Orc/OrcABISupport.cpp
@@ -154,13 +154,11 @@
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
-  std::error_code EC;
-  auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-      2 * NumPages * PageSize, nullptr,
-      sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-
-  if (EC)
-    return errorCodeToError(EC);
+  std::string Err;
+  auto StubsMem = sys::OwningMemoryBlock(
+      sys::Memory::AllocateRWX(2 * NumPages * PageSize, nullptr, &Err));
+  if (!StubsMem.base())
+    report_fatal_error("Can't allocate enough memory: " + Err);
 
   // Create separate MemoryBlocks representing the stubs and pointers.
   sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize);
@@ -236,13 +234,11 @@
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
-  std::error_code EC;
-  auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-      2 * NumPages * PageSize, nullptr,
-      sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-
-  if (EC)
-    return errorCodeToError(EC);
+  std::string Err;
+  auto StubsMem = sys::OwningMemoryBlock(
+      sys::Memory::AllocateRWX(2 * NumPages * PageSize, nullptr, &Err));
+  if (!StubsMem.base())
+    report_fatal_error("Can't allocate enough memory: " + Err);
 
   // Create separate MemoryBlocks representing the stubs and pointers.
   sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize);
@@ -504,13 +500,11 @@
   unsigned NumStubs = (NumPages * PageSize) / StubSize;
 
   // Allocate memory for stubs and pointers in one call.
-  std::error_code EC;
-  auto StubsMem = sys::OwningMemoryBlock(sys::Memory::allocateMappedMemory(
-      2 * NumPages * PageSize, nullptr,
-      sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC));
-
-  if (EC)
-    return errorCodeToError(EC);
+  std::string Err;
+  auto StubsMem = sys::OwningMemoryBlock(
+      sys::Memory::AllocateRWX(2 * NumPages * PageSize, nullptr, &Err));
+  if (!StubsMem.base())
+    report_fatal_error("Can't allocate enough memory: " + Err);
 
   // Create separate MemoryBlocks representing the stubs and pointers.
   sys::MemoryBlock StubsBlock(StubsMem.base(), NumPages * PageSize);
Index: lib/ExecutionEngine/SectionMemoryManager.cpp
===================================================================
--- lib/ExecutionEngine/SectionMemoryManager.cpp
+++ lib/ExecutionEngine/SectionMemoryManager.cpp
@@ -83,16 +83,11 @@
   //
   // FIXME: Initialize the Near member for each memory group to avoid
   // interleaving.
-  std::error_code ec;
-  sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(RequiredSize,
-                                                          &MemGroup.Near,
-                                                          sys::Memory::MF_READ |
-                                                            sys::Memory::MF_WRITE,
-                                                          ec);
-  if (ec) {
-    // FIXME: Add error propagation to the interface.
-    return nullptr;
-  }
+  std::string Err;
+  sys::MemoryBlock MB =
+      sys::Memory::AllocateRWX(RequiredSize, &MemGroup.Near, &Err);
+  if (!MB.base())
+    report_fatal_error("Can't allocate enough memory: " + Err);
 
   // Save this address as the basis for our next request
   MemGroup.Near = MB;