[llvm] Add support for building LLVM on SerenityOS

[ADKaster]

Summary

Adds SerenityOS #ifdefs for platform-specific code.

We stub out wait4, as SerenityOS doesn't support querying a child
process's resource usage information.

POSIX shm is not supported by SerenityOS yet, so disable it in Orc.

Serenity gives each thread a default of 1MiB of stack. Increase the
default stack size for llvm applications when running on SerenityOS.

Depends on D154399

Co-Authored-By: sin-ack <[e-mail]>
Co-Authored-By: Tim Schumacher <[e-mail]>

[ADKaster]

rebase

[ADKaster]

rebase

[brad]

llvm/lib/Support/Unix/Path.inc

193

You will want to add an entry here. If you don't have any such API then at the bare minimum add Serenity next to OpenBSD.

llvm/cmake/modules/HandleLLVMOptions.cmake

if(MSVC)
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:10000000")
 elseif(MINGW OR CYGWIN)
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,16777216")
 
   # Pass -mbig-obj to mingw gas to avoid COFF 2**16 section limit.
   if (NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     append("-Wa,-mbig-obj" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   endif()
+elseif(SERENITYOS)
+  # SerenityOS sets a very low default stack size value, so increase it to 4MB manually.
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,stack-size=4194304")
 endif()
 
 option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
 
 if( MSVC )
 
   # Add definitions that make MSVC much less annoying.
   add_compile_definitions(

llvm/include/llvm/ADT/bit.h

 //===-- llvm/ADT/bit.h - C++20 <bit> ----------------------------*- 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 <cstring>
 #endif
 
 #if defined(_MSC_VER) && !defined(_DEBUG)
 #include <cstdlib>  // for _byteswap_{ushort,ulong,uint64}
 #endif
 
 #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
-    defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__OpenBSD__)
+    defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__OpenBSD__) || \
+    defined(__serenity__)
 #include <endian.h>
 #elif defined(_AIX)
 #include <sys/machine.h>
 #elif defined(__sun)
 /* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
 #include <sys/types.h>
 #define BIG_ENDIAN 4321
 #define LITTLE_ENDIAN 1234

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
 //
 //===----------------------------------------------------------------------===//
 
#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(__ANDROID__)) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !(defined(__ANDROID__) || defined(__serenity__))) \
+    || 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) {

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

 //===---------- ExecutorSharedMemoryMapperService.cpp -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
if (MP == MemProt::Exec)
     return PAGE_EXECUTE;
 
   return PAGE_NOACCESS;
 }
 #endif
 
 Expected<std::pair<ExecutorAddr, std::string>>
 ExecutorSharedMemoryMapperService::reserve(uint64_t Size) {
-#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
+#if (defined(LLVM_ON_UNIX) && !(defined(__ANDROID__) || defined(__serenity__))) \
+    || defined(_WIN32)
 
 #if defined(LLVM_ON_UNIX)
 
   std::string SharedMemoryName;
   {
     std::stringstream SharedMemoryNameStream;
     SharedMemoryNameStream << "/jitlink_" << sys::Process::getProcessId() << '_'
                            << (++SharedMemoryCount);

llvm/lib/Support/Unix/Path.inc

 #include <sys/mount.h>
 #endif
 #define STATVFS statfs
 #define FSTATVFS fstatfs
 #define STATVFS_F_FRSIZE(vfs) static_cast<uint64_t>(vfs.f_bsize)
 #endif
 
 #if defined(__NetBSD__) || defined(__DragonFly__) || defined(__GNU__) ||       \
-    defined(__MVS__)
+    defined(__MVS__) || defined(__serenity__)
 #define STATVFS_F_FLAG(vfs) (vfs).f_flag
 #else
 #define STATVFS_F_FLAG(vfs) (vfs).f_flags
 #endif
 
 using namespace llvm;
 
 namespace llvm {
static char *getprogpath(char ret[PATH_MAX], const char *bin) {
   }
   free(s);
   return nullptr;
 }
 #endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__
 
 /// GetMainExecutable - Return the path to the main executable, given the
 /// value of argv[0] from program startup.
 std::string getMainExecutable(const char *argv0, void *MainAddr) {
 #if defined(__APPLE__)
   // On OS X the executable path is saved to the stack by dyld. Reading it
   // from there is much faster than calling dladdr, especially for large
   // binaries with symbols.
   char exe_path[PATH_MAX];
   uint32_t size = sizeof(exe_path);
   if (_NSGetExecutablePath(exe_path, &size) == 0) {
     char link_path[PATH_MAX];
#elif defined(__Fuchsia__)
   // Fuchsia doesn't yet support remote filesystem mounts.
   return true;
 #elif defined(__EMSCRIPTEN__)
   // Emscripten doesn't currently support remote filesystem mounts.
   return true;
 #elif defined(__HAIKU__)
   // Haiku doesn't expose this information.
   return false;
+#elif defined(__serenity__)
+  // Serenity doesn't yet support remote filesystem mounts.
+  return false;
 #elif defined(__sun)
   // statvfs::f_basetype contains a null-terminated FSType name of the mounted
   // target
   StringRef fstype(Vfs.f_basetype);
   // NFS is the only non-local fstype??
   return !fstype.equals("nfs");
 #elif defined(_AIX)
   // Call mntctl; try more than twice in case of timing issues with a concurrent

llvm/lib/Support/Unix/Program.inc

#endif
   return true;
 }
 
 namespace llvm {
 namespace sys {
 
 #if defined(_AIX)
 static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
-#elif !defined(__Fuchsia__)
+#elif !defined(__Fuchsia__) && !defined(__serenity__)
 using ::wait4;
 #endif
 
 } // namespace sys
 } // namespace llvm
 
 #ifdef _AIX
 #ifndef _ALL_SOURCE
pid_t(llvm::sys::wait4)(pid_t pid, int *status, int options,
 
   // The child has already terminated, so a blocking wait on it is okay in the
   // absence of indiscriminate `wait` calls from the current process (which
   // would cause the call here to fail with ECHILD).
   return ::wait4(pid, status, options & ~WNOHANG, usage);
 }
 #endif
 
+#ifdef __serenity__
+pid_t (llvm::sys::wait4)(pid_t pid, int *status, int options,
+                         struct rusage*) {
+  return ::waitpid(pid, status, options);
+}
+#endif
+
 ProcessInfo llvm::sys::Wait(const ProcessInfo &PI,
                             std::optional<unsigned> SecondsToWait,
                             std::string *ErrMsg,
                             std::optional<ProcessStatistics> *ProcStat,
                             bool Polling) {
   struct sigaction Act, Old;
   assert(PI.Pid && "invalid pid to wait on, process not started?");