[Orc] Disable use of shared memory on Android

[argentite]

Summary

shm_open and shm_unlink are not available on Android. This commit
disables SharedMemoryMapper on Android until a better solution is
available.

https://android.googlesource.com/platform/bionic/+/refs/heads/master/docs/status.md
https://github.com/llvm/llvm-project/issues/56812

[sgraenitz]

Not sure about Lang's availability right now. I can sign this off as well if necessary.

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

192

You have to pass a std::error_code here as well. Either try and find a matching standard error code or use llvm::inconvertibleErrorCode().

llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp

63

As mentioned in the mail: SharedMemoryCount should be #ifdefed in the header. Otherwise it's a unused private field and triggers a warning / error (with -Werror).

[sunho]

Would it make sense to make (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32) another macro like LLVM_ORC_SHARED_MAPPER_SUPPORTED? The expression is being repeated a lot.

[argentite]

Something like LLVM_ORC_SHARED_MAPPER_SUPPORTED would be nice and maybe we can even define it from the build system. In any case it should be a follow up patch I guess.

[sunho]

Yup, feel free to move on as this is a hotfix.

[sgraenitz]

Thanks, LGTM. Error in pre-merge checks is unrelated.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.h

#endif
   initializeWrapper(const char *ArgData, size_t ArgSize);
 
   static llvm::orc::shared::CWrapperFunctionResult
   deinitializeWrapper(const char *ArgData, size_t ArgSize);
 
   static llvm::orc::shared::CWrapperFunctionResult
   releaseWrapper(const char *ArgData, size_t ArgSize);
 
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
   std::atomic<int> SharedMemoryCount{0};
+#endif
+
   std::mutex Mutex;
   ReservationMap Reservations;
   AllocationMap Allocations;
 };
 
 } // namespace rt_bootstrap
 } // namespace orc
 } // namespace llvm
 #endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_EXECUTORSHAREDMEMORYMAPPERSERVICE_H

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

 //===- MemoryMapper.cpp - Cross-process memory mapper ------------*- C++ -*-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/MemoryMapper.h"
 
 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
 #include "llvm/Support/WindowsError.h"
 
-#if defined(LLVM_ON_UNIX)
+#if defined(LLVM_ON_UNIX) && !defined(__ANDROID__)
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #elif defined(_WIN32)
 #include <windows.h>
 #endif
 
 namespace llvm {
InProcessMemoryMapper::~InProcessMemoryMapper() {
   release(ReservationAddrs, [&](Error Err) { P.set_value(std::move(Err)); });
   cantFail(F.get());
 }
 
 // SharedMemoryMapper
 
 SharedMemoryMapper::SharedMemoryMapper(ExecutorProcessControl &EPC,
                                        SymbolAddrs SAs, size_t PageSize)
-    : EPC(EPC), SAs(SAs), PageSize(PageSize) {}
+    : EPC(EPC), SAs(SAs), PageSize(PageSize) {
+#if (!defined(LLVM_ON_UNIX) || defined(__ANDROID__)) && !defined(_WIN32)
+  llvm_unreachable("SharedMemoryMapper is not supported on this platform yet");
+#endif
+}
 
 Expected<std::unique_ptr<SharedMemoryMapper>>
 SharedMemoryMapper::Create(ExecutorProcessControl &EPC, SymbolAddrs SAs) {
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
   auto PageSize = sys::Process::getPageSize();
   if (!PageSize)
     return PageSize.takeError();
 
   return std::make_unique<SharedMemoryMapper>(EPC, SAs, *PageSize);
+#else
+  return make_error<StringError>(
+      "SharedMemoryMapper is not supported on this platform yet",
+      inconvertibleErrorCode());
+#endif
 }
 
 void SharedMemoryMapper::reserve(size_t NumBytes,
                                  OnReservedFunction OnReserved) {
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
 
   EPC.callSPSWrapperAsync<
       rt::SPSExecutorSharedMemoryMapperServiceReserveSignature>(
       SAs.Reserve,
       [this, NumBytes, OnReserved = std::move(OnReserved)](
           Error SerializationErr,
           Expected<std::pair<ExecutorAddr, std::string>> Result) mutable {
         if (SerializationErr) {
EPC.callSPSWrapperAsync<
 
         OnDeinitialized(std::move(Result));
       },
       SAs.Instance, Allocations);
 }
 
 void SharedMemoryMapper::release(ArrayRef<ExecutorAddr> Bases,
                                  OnReleasedFunction OnReleased) {
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
   Error Err = Error::success();
 
   {
     std::lock_guard<std::mutex> Lock(Mutex);
 
     for (auto Base : Bases) {
 
 #if defined(LLVM_ON_UNIX)

llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp

 #endif
 
 namespace llvm {
 namespace orc {
 namespace rt_bootstrap {
 
 Expected<std::pair<ExecutorAddr, std::string>>
 ExecutorSharedMemoryMapperService::reserve(uint64_t Size) {
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
 
 #if defined(LLVM_ON_UNIX)
 
   std::string SharedMemoryName;
   {
     std::stringstream SharedMemoryNameStream;
     SharedMemoryNameStream << "/jitlink_" << sys::Process::getProcessId() << '_'
                            << (++SharedMemoryCount);
     SharedMemoryName = SharedMemoryNameStream.str();
   }
 
   int SharedMemoryFile =
       shm_open(SharedMemoryName.c_str(), O_RDWR | O_CREAT | O_EXCL, 0700);
   if (SharedMemoryFile < 0)
     return errorCodeToError(std::error_code(errno, std::generic_category()));
 
#else
   return make_error<StringError>(
       "SharedMemoryMapper is not supported on this platform yet",
       inconvertibleErrorCode());
 #endif
 }
 
 Expected<ExecutorAddr> ExecutorSharedMemoryMapperService::initialize(
     ExecutorAddr Reservation, tpctypes::SharedMemoryFinalizeRequest &FR) {
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
 
   ExecutorAddr MinAddr(~0ULL);
 
   // Contents are already in place
   for (auto &Segment : FR.Segments) {
     if (Segment.Addr < MinAddr)
       MinAddr = Segment.Addr;
 
Error AllErr = Error::success();
     }
   }
 
   return AllErr;
 }
 
 Error ExecutorSharedMemoryMapperService::release(
     const std::vector<ExecutorAddr> &Bases) {
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
   Error Err = Error::success();
 
   for (auto Base : Bases) {
     std::vector<ExecutorAddr> AllocAddrs;
     size_t Size;
 
 #if defined(_WIN32)
     HANDLE SharedMemoryFile;

llvm/unittests/ExecutionEngine/Orc/SharedMemoryMapperTest.cpp

 #include "llvm/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 using namespace llvm::orc::shared;
 using namespace llvm::orc::rt_bootstrap;
 
-#if defined(LLVM_ON_UNIX) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
 
 // A basic function to be used as both initializer/deinitializer
 orc::shared::CWrapperFunctionResult incrementWrapper(const char *ArgData,
                                                      size_t ArgSize) {
   return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
              ArgData, ArgSize,
              [](ExecutorAddr A) -> Error {
                *A.toPtr<int *>() += 1;