From 3bd1305218d990b0c50ce90552414186d2c20297 Mon Sep 17 00:00:00 2001 From: Dan Klishch Date: Sun, 14 Apr 2024 03:32:06 -0400 Subject: [PATCH] Ports/zig: Copy LLVM patches instead of symlinking them LLVM toolchain is about to get updated to 18.1.3, which would desync these patches. --- ...port-for-building-LLVM-on-SerenityOS.patch | 79 ++- ...002-Triple-Add-triple-for-SerenityOS.patch | 57 +- ...03-Driver-Add-support-for-SerenityOS.patch | 597 +++++++++++++++++- ...o-ftls-model-initial-exec-on-Serenit.patch | 33 +- ...llow-undefined-symbols-on-SerenityOS.patch | 26 +- ...ilding-shared-libLLVM-and-libClang-f.patch | 52 +- .../0008-Add-SerenityOS-to-config.guess.patch | 24 +- ...t-the-use-of-POSIX-shm-on-SerenityOS.patch | 39 +- ...he-default-stack-size-when-running-o.patch | 25 +- 9 files changed, 923 insertions(+), 9 deletions(-) mode change 120000 => 100644 Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch mode change 120000 => 100644 Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch mode change 120000 => 100644 Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch mode change 120000 => 100644 Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch mode change 120000 => 100644 Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch mode change 120000 => 100644 Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch mode change 120000 => 100644 Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch mode change 120000 => 100644 Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch mode change 120000 => 100644 Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch diff --git a/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch b/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch deleted file mode 120000 index b9d528427b3..00000000000 --- a/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch \ No newline at end of file diff --git a/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch b/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch new file mode 100644 index 00000000000..cb03543dd52 --- /dev/null +++ b/Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch @@ -0,0 +1,78 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Thu, 14 Apr 2022 09:54:22 +0200 +Subject: [PATCH] [Support] Add support for building LLVM on SerenityOS + +Adds SerenityOS `#ifdef`s for platform-specific code. + +We stub out wait4, as SerenityOS doesn't support querying a child +process's resource usage information. +--- + llvm/include/llvm/Support/SwapByteOrder.h | 2 +- + llvm/lib/Support/Unix/Path.inc | 5 ++++- + llvm/lib/Support/Unix/Program.inc | 9 ++++++++- + 3 files changed, 13 insertions(+), 3 deletions(-) + +diff --git a/llvm/include/llvm/Support/SwapByteOrder.h b/llvm/include/llvm/Support/SwapByteOrder.h +index 9dd08665b..8915f92e8 100644 +--- a/llvm/include/llvm/Support/SwapByteOrder.h ++++ b/llvm/include/llvm/Support/SwapByteOrder.h +@@ -20,7 +20,7 @@ + #include + + #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) || \ +- defined(__Fuchsia__) || defined(__EMSCRIPTEN__) ++ defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__serenity__) + #include + #elif defined(_AIX) + #include +diff --git a/llvm/lib/Support/Unix/Path.inc b/llvm/lib/Support/Unix/Path.inc +index 3efcad4f2..4f83d0e76 100644 +--- a/llvm/lib/Support/Unix/Path.inc ++++ b/llvm/lib/Support/Unix/Path.inc +@@ -112,7 +112,7 @@ typedef uint_t uint; + #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 +@@ -506,6 +506,9 @@ static bool is_local_impl(struct STATVFS &Vfs) { + #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 +diff --git a/llvm/lib/Support/Unix/Program.inc b/llvm/lib/Support/Unix/Program.inc +index 897e22711..23965a1a1 100644 +--- a/llvm/lib/Support/Unix/Program.inc ++++ b/llvm/lib/Support/Unix/Program.inc +@@ -340,7 +340,7 @@ static bool Execute(ProcessInfo &PI, StringRef Program, + namespace llvm { + namespace sys { + +-#ifndef _AIX ++#if !defined(_AIX) && !defined(__serenity__) + using ::wait4; + #else + static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage); +@@ -383,6 +383,13 @@ pid_t(llvm::sys::wait4)(pid_t pid, int *status, int options, + } + #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 SecondsToWait, + std::string *ErrMsg, diff --git a/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch b/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch deleted file mode 120000 index bf126fa344f..00000000000 --- a/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0002-Triple-Add-triple-for-SerenityOS.patch \ No newline at end of file diff --git a/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch b/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch new file mode 100644 index 00000000000..0d8ecd0b049 --- /dev/null +++ b/Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch @@ -0,0 +1,56 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Thu, 14 Apr 2022 09:51:24 +0200 +Subject: [PATCH] [Triple] Add triple for SerenityOS + +--- + llvm/include/llvm/TargetParser/Triple.h | 8 +++++++- + llvm/lib/TargetParser/Triple.cpp | 2 ++ + 2 files changed, 9 insertions(+), 1 deletion(-) + +diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h +index 59513fa2f..951d69010 100644 +--- a/llvm/include/llvm/TargetParser/Triple.h ++++ b/llvm/include/llvm/TargetParser/Triple.h +@@ -223,7 +223,8 @@ public: + WASI, // Experimental WebAssembly OS + Emscripten, + ShaderModel, // DirectX ShaderModel +- LastOSType = ShaderModel ++ Serenity, ++ LastOSType = Serenity + }; + enum EnvironmentType { + UnknownEnvironment, +@@ -670,6 +671,11 @@ public: + return getOS() == Triple::AIX; + } + ++ /// Tests whether the OS is SerenityOS ++ bool isOSSerenity() const { ++ return getOS() == Triple::Serenity; ++ } ++ + /// Tests whether the OS uses the ELF binary format. + bool isOSBinFormatELF() const { + return getObjectFormat() == Triple::ELF; +diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp +index a68035989..1ee9ea3b1 100644 +--- a/llvm/lib/TargetParser/Triple.cpp ++++ b/llvm/lib/TargetParser/Triple.cpp +@@ -237,6 +237,7 @@ StringRef Triple::getOSTypeName(OSType Kind) { + case PS5: return "ps5"; + case RTEMS: return "rtems"; + case Solaris: return "solaris"; ++ case Serenity: return "serenity"; + case TvOS: return "tvos"; + case WASI: return "wasi"; + case WatchOS: return "watchos"; +@@ -596,6 +597,7 @@ static Triple::OSType parseOS(StringRef OSName) { + .StartsWith("wasi", Triple::WASI) + .StartsWith("emscripten", Triple::Emscripten) + .StartsWith("shadermodel", Triple::ShaderModel) ++ .StartsWith("serenity", Triple::Serenity) + .Default(Triple::UnknownOS); + } + diff --git a/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch b/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch deleted file mode 120000 index 1514652360c..00000000000 --- a/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0003-Driver-Add-support-for-SerenityOS.patch \ No newline at end of file diff --git a/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch b/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch new file mode 100644 index 00000000000..d08d1686cee --- /dev/null +++ b/Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch @@ -0,0 +1,596 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Thu, 14 Apr 2022 10:09:50 +0200 +Subject: [PATCH] [Driver] Add support for SerenityOS +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Adds support for the `$arch-pc-serenity` target to the Clang front end. +This makes the compiler look for libraries and headers in the right +places, and enables some security mitigations like stack-smashing +protection and position-independent code by default. + +Co-authored-by: kleines Filmröllchen +--- + clang/lib/Basic/Targets.cpp | 8 + + clang/lib/Basic/Targets/OSTargets.h | 18 ++ + clang/lib/Driver/CMakeLists.txt | 1 + + clang/lib/Driver/Driver.cpp | 4 + + clang/lib/Driver/ToolChain.cpp | 2 + + clang/lib/Driver/ToolChains/Serenity.cpp | 336 +++++++++++++++++++++++ + clang/lib/Driver/ToolChains/Serenity.h | 100 +++++++ + 7 files changed, 469 insertions(+) + create mode 100644 clang/lib/Driver/ToolChains/Serenity.cpp + create mode 100644 clang/lib/Driver/ToolChains/Serenity.h + +diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp +index 8400774db..f82618dc8 100644 +--- a/clang/lib/Basic/Targets.cpp ++++ b/clang/lib/Basic/Targets.cpp +@@ -153,6 +153,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new NetBSDTargetInfo(Triple, Opts); + case llvm::Triple::OpenBSD: + return new OpenBSDTargetInfo(Triple, Opts); ++ case llvm::Triple::Serenity: ++ return new SerenityTargetInfo(Triple, Opts); + case llvm::Triple::Win32: + switch (Triple.getEnvironment()) { + case llvm::Triple::GNU: +@@ -424,6 +426,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new FuchsiaTargetInfo(Triple, Opts); + case llvm::Triple::Linux: + return new LinuxTargetInfo(Triple, Opts); ++ case llvm::Triple::Serenity: ++ return new SerenityTargetInfo(Triple, Opts); + default: + return new RISCV64TargetInfo(Triple, Opts); + } +@@ -542,6 +546,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new MCUX86_32TargetInfo(Triple, Opts); + case llvm::Triple::Hurd: + return new HurdTargetInfo(Triple, Opts); ++ case llvm::Triple::Serenity: ++ return new SerenityTargetInfo(Triple, Opts); + default: + return new X86_32TargetInfo(Triple, Opts); + } +@@ -596,6 +602,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new PS4OSTargetInfo(Triple, Opts); + case llvm::Triple::PS5: + return new PS5OSTargetInfo(Triple, Opts); ++ case llvm::Triple::Serenity: ++ return new SerenityTargetInfo(Triple, Opts); + default: + return new X86_64TargetInfo(Triple, Opts); + } +diff --git a/clang/lib/Basic/Targets/OSTargets.h b/clang/lib/Basic/Targets/OSTargets.h +index fd372cb12..27a3f9797 100644 +--- a/clang/lib/Basic/Targets/OSTargets.h ++++ b/clang/lib/Basic/Targets/OSTargets.h +@@ -1005,6 +1005,24 @@ public: + } + }; + ++// SerenityOS target ++template ++class LLVM_LIBRARY_VISIBILITY SerenityTargetInfo : public OSTargetInfo { ++protected: ++ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, ++ MacroBuilder &Builder) const override { ++ Builder.defineMacro("__serenity__"); ++ DefineStd(Builder, "unix", Opts); ++ Builder.defineMacro("__ELF__"); ++ } ++ ++public: ++ SerenityTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) ++ : OSTargetInfo(Triple, Opts) { ++ this->WIntType = TargetInfo::UnsignedInt; ++ } ++}; ++ + } // namespace targets + } // namespace clang + #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H +diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt +index ba56a9323..4d0ffe88c 100644 +--- a/clang/lib/Driver/CMakeLists.txt ++++ b/clang/lib/Driver/CMakeLists.txt +@@ -78,6 +78,7 @@ add_clang_library(clangDriver + ToolChains/OpenBSD.cpp + ToolChains/PS4CPU.cpp + ToolChains/RISCVToolchain.cpp ++ ToolChains/Serenity.cpp + ToolChains/Solaris.cpp + ToolChains/SPIRV.cpp + ToolChains/TCE.cpp +diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp +index a268f2fa8..df54be3de 100644 +--- a/clang/lib/Driver/Driver.cpp ++++ b/clang/lib/Driver/Driver.cpp +@@ -45,6 +45,7 @@ + #include "ToolChains/PPCLinux.h" + #include "ToolChains/PS4CPU.h" + #include "ToolChains/RISCVToolchain.h" ++#include "ToolChains/Serenity.h" + #include "ToolChains/SPIRV.h" + #include "ToolChains/Solaris.h" + #include "ToolChains/TCE.h" +@@ -6041,6 +6042,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, + case llvm::Triple::Fuchsia: + TC = std::make_unique(*this, Target, Args); + break; ++ case llvm::Triple::Serenity: ++ TC = std::make_unique(*this, Target, Args); ++ break; + case llvm::Triple::Solaris: + TC = std::make_unique(*this, Target, Args); + break; +diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp +index bc70205a6..3d5c856ab 100644 +--- a/clang/lib/Driver/ToolChain.cpp ++++ b/clang/lib/Driver/ToolChain.cpp +@@ -482,6 +482,8 @@ StringRef ToolChain::getOSLibName() const { + return "sunos"; + case llvm::Triple::AIX: + return "aix"; ++ case llvm::Triple::Serenity: ++ return "serenity"; + default: + return getOS(); + } +diff --git a/clang/lib/Driver/ToolChains/Serenity.cpp b/clang/lib/Driver/ToolChains/Serenity.cpp +new file mode 100644 +index 000000000..4fdf45a19 +--- /dev/null ++++ b/clang/lib/Driver/ToolChains/Serenity.cpp +@@ -0,0 +1,340 @@ ++//===---- Serenity.cpp - SerenityOS ToolChain Implementation ----*- 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 "Serenity.h" ++#include "CommonArgs.h" ++#include "clang/Config/config.h" ++#include "clang/Driver/Compilation.h" ++#include "clang/Driver/Driver.h" ++#include "clang/Driver/DriverDiagnostic.h" ++#include "clang/Driver/Options.h" ++#include "clang/Driver/SanitizerArgs.h" ++#include "llvm/Option/ArgList.h" ++#include "llvm/Support/VirtualFileSystem.h" ++#include ++ ++using namespace clang::driver; ++using namespace clang::driver::toolchains; ++using namespace clang; ++using namespace llvm::opt; ++ ++static bool getPIE(const ArgList &Args, const ToolChain &TC) { ++ if (Args.hasArg(options::OPT_static, options::OPT_shared, ++ options::OPT_static_pie)) ++ return false; ++ Arg *Last = Args.getLastArg(options::OPT_pie, options::OPT_no_pie, ++ options::OPT_nopie); ++ return Last ? Last->getOption().matches(options::OPT_pie) : true; ++} ++ ++void tools::serenity::Linker::ConstructJob(Compilation &C, const JobAction &JA, ++ const InputInfo &Output, ++ const InputInfoList &Inputs, ++ const ArgList &Args, ++ const char *LinkingOutput) const { ++ const auto &TC = getToolChain(); ++ const auto &D = TC.getDriver(); ++ const bool IsShared = Args.hasArg(options::OPT_shared); ++ const bool IsStatic = ++ Args.hasArg(options::OPT_static) && !Args.hasArg(options::OPT_static_pie); ++ const bool IsRdynamic = Args.hasArg(options::OPT_rdynamic); ++ const bool IsStaticPIE = Args.hasArg(options::OPT_static_pie); ++ const bool IsPIE = getPIE(Args, TC); ++ ArgStringList CmdArgs; ++ ++ if (!D.SysRoot.empty()) ++ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); ++ ++ if (IsPIE || IsStaticPIE) ++ CmdArgs.push_back("-pie"); ++ ++ if (IsShared) ++ CmdArgs.push_back("-shared"); ++ ++ if (IsStatic || IsStaticPIE) ++ CmdArgs.push_back("-static"); ++ ++ if (IsStaticPIE) { ++ CmdArgs.push_back("--no-dynamic-linker"); ++ CmdArgs.push_back("-z"); ++ CmdArgs.push_back("text"); ++ } ++ ++ if (!IsStatic && !IsStaticPIE) { ++ if (IsRdynamic) ++ CmdArgs.push_back("-export-dynamic"); ++ CmdArgs.push_back("-dynamic-linker"); ++ CmdArgs.push_back("/usr/lib/Loader.so"); ++ } ++ ++ if (!IsStatic || IsStaticPIE) ++ CmdArgs.push_back("--eh-frame-hdr"); ++ ++ if (Output.isFilename()) { ++ CmdArgs.push_back("-o"); ++ CmdArgs.push_back(Output.getFilename()); ++ } ++ ++ const char *Exec = Args.MakeArgString(TC.GetLinkerPath()); ++ auto linkerIs = [Exec](const char* name) { ++ return llvm::sys::path::filename(Exec).equals_insensitive(name) || ++ llvm::sys::path::stem(Exec).equals_insensitive(name); ++ }; ++ ++ if (linkerIs("ld.lld") || linkerIs("ld.mold")) { ++ CmdArgs.push_back("--pack-dyn-relocs=relr"); ++ } else { ++ CmdArgs.push_back("-z"); ++ CmdArgs.push_back("pack-relative-relocs"); ++ } ++ ++ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { ++ CmdArgs.push_back(Args.MakeArgString( ++ TC.GetFilePath((IsShared) ? "crt0_shared.o" : "crt0.o"))); ++ CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crti.o"))); ++ ++ std::string crtbegin_path; ++ if (TC.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT) { ++ std::string crtbegin = ++ TC.getCompilerRT(Args, "crtbegin", ToolChain::FT_Object); ++ if (TC.getVFS().exists(crtbegin)) ++ crtbegin_path = crtbegin; ++ } ++ if (crtbegin_path.empty()) { ++ const char *crtbegin = (IsShared || IsPIE) ? "crtbeginS.o" : "crtbegin.o"; ++ crtbegin_path = TC.GetFilePath(crtbegin); ++ } ++ CmdArgs.push_back(Args.MakeArgString(crtbegin_path)); ++ } ++ ++ Args.AddAllArgs(CmdArgs, options::OPT_L); ++ Args.AddAllArgs(CmdArgs, options::OPT_u); ++ ++ TC.AddFilePathLibArgs(Args, CmdArgs); ++ ++ if (D.isUsingLTO()) { ++ assert(!Inputs.empty() && "Must have at least one input."); ++ addLTOOptions(TC, Args, CmdArgs, Output, Inputs[0], ++ D.getLTOMode() == LTOK_Thin); ++ } ++ ++ Args.AddAllArgs(CmdArgs, options::OPT_T_Group); ++ Args.AddAllArgs(CmdArgs, options::OPT_e); ++ Args.AddAllArgs(CmdArgs, options::OPT_s); ++ Args.AddAllArgs(CmdArgs, options::OPT_t); ++ Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); ++ Args.AddAllArgs(CmdArgs, options::OPT_r); ++ ++ addLinkerCompressDebugSectionsOption(TC, Args, CmdArgs); ++ ++ AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA); ++ ++ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { ++ AddRunTimeLibs(TC, D, CmdArgs, Args); ++ ++ // We supply our own sanitizer runtimes ++ // FIXME: What if we want to use Clang-supplied ones as well? ++ const SanitizerArgs &Sanitize = TC.getSanitizerArgs(Args); ++ if (Sanitize.needsUbsanRt()) ++ CmdArgs.push_back("-lubsan"); ++ } ++ ++ if (D.CCCIsCXX() && TC.ShouldLinkCXXStdlib(Args)) { ++ bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && ++ !Args.hasArg(options::OPT_static); ++ CmdArgs.push_back("--push-state"); ++ CmdArgs.push_back("--as-needed"); ++ if (OnlyLibstdcxxStatic) ++ CmdArgs.push_back("-Bstatic"); ++ TC.AddCXXStdlibLibArgs(Args, CmdArgs); ++ if (OnlyLibstdcxxStatic) ++ CmdArgs.push_back("-Bdynamic"); ++ CmdArgs.push_back("--pop-state"); ++ } ++ ++ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { ++ if (!Args.hasArg(options::OPT_nolibc)) ++ CmdArgs.push_back("-lc"); ++ } ++ ++ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) { ++ std::string crtend_path; ++ if (TC.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT) { ++ std::string crtend = ++ TC.getCompilerRT(Args, "crtend", ToolChain::FT_Object); ++ if (TC.getVFS().exists(crtend)) ++ crtend_path = crtend; ++ } ++ if (crtend_path.empty()) { ++ const char *crtend = (IsShared || IsPIE) ? "crtendS.o" : "crtend.o"; ++ crtend_path = TC.GetFilePath(crtend); ++ } ++ CmdArgs.push_back(Args.MakeArgString(crtend_path)); ++ ++ CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtn.o"))); ++ } ++ ++ Args.AddAllArgs(CmdArgs, options::OPT_T); ++ ++ C.addCommand(std::make_unique(JA, *this, ++ ResponseFileSupport::AtFileCurCP(), ++ Exec, CmdArgs, Inputs, Output)); ++} ++ ++Serenity::Serenity(const Driver &D, const llvm::Triple &Triple, ++ const ArgList &Args) ++ : ToolChain(D, Triple, Args) { ++ getProgramPaths().push_back(getDriver().getInstalledDir()); ++ if (getDriver().getInstalledDir() != getDriver().Dir) ++ getProgramPaths().push_back(getDriver().Dir); ++ getFilePaths().push_back(getDriver().SysRoot + "/usr/local/lib"); ++ getFilePaths().push_back(getDriver().SysRoot + "/usr/lib"); ++} ++ ++Tool *Serenity::buildLinker() const { ++ return new tools::serenity::Linker(*this); ++} ++ ++void Serenity::AddClangSystemIncludeArgs(const ArgList &DriverArgs, ++ ArgStringList &CC1Args) const { ++ const Driver &D = getDriver(); ++ ++ if (DriverArgs.hasArg(options::OPT_nostdinc)) ++ return; ++ ++ if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { ++ addSystemInclude(DriverArgs, CC1Args, D.ResourceDir + "/include"); ++ } ++ ++ if (DriverArgs.hasArg(options::OPT_nostdlibinc)) ++ return; ++ ++ addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include"); ++ addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include"); ++} ++ ++static std::string getLibStdCXXVersion(const Driver &D, StringRef IncludePath) { ++ SmallString<128> Path(IncludePath); ++ llvm::sys::path::append(Path, "c++"); ++ ++ std::error_code EC; ++ std::tuple Newest{0, 0, 0}; ++ std::string Result; ++ ++ for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(Path, EC), LE; ++ !EC && LI != LE; LI = LI.increment(EC)) { ++ StringRef VersionText = llvm::sys::path::filename(LI->path()); ++ ++ // This is libc++ ++ if (VersionText[0] == 'v') ++ continue; ++ ++ llvm::SmallVector Parts; ++ VersionText.split(Parts, '.'); ++ ++ // SerenityOS always builds GCC with .. versions ++ if (Parts.size() < 3) ++ continue; ++ ++ std::tuple Current; ++ if (!llvm::to_integer(Parts[0], std::get<0>(Current))) ++ continue; ++ if (!llvm::to_integer(Parts[1], std::get<1>(Current))) ++ continue; ++ if (!llvm::to_integer(Parts[2], std::get<2>(Current))) ++ continue; ++ ++ if (Current > Newest) { ++ Newest = Current; ++ Result = VersionText.str(); ++ } ++ } ++ return Result; ++} ++ ++void Serenity::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, ++ ArgStringList &CC1Args) const { ++ if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx, ++ options::OPT_nostdlibinc)) ++ return; ++ ++ const auto StdLib = GetCXXStdlibType(DriverArgs); ++ ++ const Driver &D = getDriver(); ++ std::string SysRoot = computeSysRoot(); ++ std::string Target = getTripleString(); ++ ++ auto AddIncludePath = [&](std::string Path) { ++ std::string Version = StdLib == CXXStdlibType::CST_Libstdcxx ++ ? getLibStdCXXVersion(D, Path) ++ : detectLibcxxVersion(Path); ++ if (Version.empty()) ++ return false; ++ ++ std::string TargetDir; ++ if (StdLib == CXXStdlibType::CST_Libstdcxx) { ++ TargetDir = Path + "/c++/" + Version + "/" + Target; ++ } else { ++ TargetDir = Path + "/" + Target + "/c++/" + Version; ++ } ++ ++ if (D.getVFS().exists(TargetDir)) ++ addSystemInclude(DriverArgs, CC1Args, TargetDir); ++ ++ addSystemInclude(DriverArgs, CC1Args, Path + "/c++/" + Version); ++ return true; ++ }; ++ ++ if (AddIncludePath(getDriver().Dir + "/../include")) ++ return; ++ if (AddIncludePath(SysRoot + "/usr/local/include")) ++ return; ++ if (AddIncludePath(SysRoot + "/usr/include")) ++ return; ++} ++ ++void Serenity::addClangTargetOptions( ++ const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, ++ Action::OffloadKind DeviceOffloadKind) const { ++ if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, ++ options::OPT_fno_use_init_array, true)) ++ CC1Args.push_back("-fno-use-init-array"); ++} ++ ++ToolChain::UnwindLibType ++Serenity::GetUnwindLibType(const llvm::opt::ArgList &Args) const { ++ ++ const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ); ++ StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB; ++ ++ if (LibName == "none") { ++ return ToolChain::UNW_None; ++ } else if (LibName == "platform" || LibName == "") { ++ ToolChain::RuntimeLibType RtLibType = GetRuntimeLibType(Args); ++ if (RtLibType == ToolChain::RLT_CompilerRT) { ++ return ToolChain::UNW_CompilerRT; ++ } else if (RtLibType == ToolChain::RLT_Libgcc) ++ return ToolChain::UNW_Libgcc; ++ } else if (LibName == "libunwind") { ++ if (GetRuntimeLibType(Args) == RLT_Libgcc) ++ getDriver().Diag(diag::err_drv_incompatible_unwindlib); ++ return ToolChain::UNW_CompilerRT; ++ } else if (LibName == "libgcc") { ++ return ToolChain::UNW_Libgcc; ++ } ++ ++ if (A) ++ getDriver().Diag(diag::err_drv_invalid_unwindlib_name) ++ << A->getAsString(Args); ++ ++ return ToolChain::UNW_None; ++} ++ ++SanitizerMask Serenity::getSupportedSanitizers() const { ++ return ToolChain::getSupportedSanitizers() | SanitizerKind::KernelAddress; ++} +diff --git a/clang/lib/Driver/ToolChains/Serenity.h b/clang/lib/Driver/ToolChains/Serenity.h +new file mode 100644 +index 000000000..feb31a0d6 +--- /dev/null ++++ b/clang/lib/Driver/ToolChains/Serenity.h +@@ -0,0 +1,102 @@ ++//===---- Serenity.h - SerenityOS ToolChain Implementation ------*- 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 ++// ++//===----------------------------------------------------------------------===// ++ ++#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SERENITY_H ++#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SERENITY_H ++ ++#include "clang/Basic/LangOptions.h" ++#include "clang/Driver/Tool.h" ++#include "clang/Driver/ToolChain.h" ++ ++namespace clang { ++namespace driver { ++namespace tools { ++namespace serenity { ++ ++class LLVM_LIBRARY_VISIBILITY Linker : public Tool { ++public: ++ Linker(const ToolChain &TC) : Tool("serenity::Linker", "linker", TC) {} ++ ++ bool hasIntegratedCPP() const override { return false; } ++ bool isLinkJob() const override { return true; } ++ ++ void ConstructJob(Compilation &C, const JobAction &JA, ++ const InputInfo &Output, const InputInfoList &Inputs, ++ const llvm::opt::ArgList &TCArgs, ++ const char *LinkingOutput) const override; ++}; ++} // end namespace serenity ++} // end namespace tools ++ ++namespace toolchains { ++ ++class LLVM_LIBRARY_VISIBILITY Serenity : public ToolChain { ++public: ++ Serenity(const Driver &D, const llvm::Triple &Triple, ++ const llvm::opt::ArgList &Args); ++ ++ void ++ AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, ++ llvm::opt::ArgStringList &CC1Args) const override; ++ ++ void AddClangCXXStdlibIncludeArgs( ++ const llvm::opt::ArgList &DriverArgs, ++ llvm::opt::ArgStringList &CC1Args) const override; ++ ++ RuntimeLibType GetDefaultRuntimeLibType() const override { ++ return ToolChain::RLT_CompilerRT; ++ } ++ ++ CXXStdlibType GetDefaultCXXStdlibType() const override { ++ return ToolChain::CST_Libcxx; ++ } ++ ++ UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const override; ++ ++ void ++ addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, ++ llvm::opt::ArgStringList &CC1Args, ++ Action::OffloadKind DeviceOffloadKind) const override; ++ ++ const char *getDefaultLinker() const override { return "ld.lld"; } ++ ++ bool HasNativeLLVMSupport() const override { return true; } ++ ++ bool IsIntegratedAssemblerDefault() const override { return true; } ++ ++ bool isPICDefault() const override { return true; } ++ bool isPIEDefault(const llvm::opt::ArgList&) const override { return false; } ++ bool isPICDefaultForced() const override { return false; } ++ ++ SanitizerMask getSupportedSanitizers() const override; ++ ++ bool IsMathErrnoDefault() const override { return false; } ++ ++ UnwindTableLevel ++ getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override { ++ return UnwindTableLevel::Asynchronous; ++ } ++ ++ bool useRelaxRelocations() const override { return true; } ++ ++ LangOptions::StackProtectorMode ++ GetDefaultStackProtectorLevel(bool KernelOrKext) const override { ++ return LangOptions::SSPStrong; ++ } ++ ++ unsigned GetDefaultDwarfVersion() const override { return 5; } ++ ++protected: ++ Tool *buildLinker() const override; ++}; ++ ++} // end namespace toolchains ++} // end namespace driver ++} // end namespace clang ++ ++#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SERENITY_H diff --git a/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch b/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch deleted file mode 120000 index de36d10ec93..00000000000 --- a/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch \ No newline at end of file diff --git a/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch b/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch new file mode 100644 index 00000000000..b79ac975403 --- /dev/null +++ b/Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch @@ -0,0 +1,32 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Thu, 14 Apr 2022 10:12:54 +0200 +Subject: [PATCH] [Driver] Default to -ftls-model=initial-exec on SerenityOS + +This is a hack to make Clang use the initial-exec TLS model instead of +the default local-exec when building code for Serenity. + +This patch should be removed when we implement proper TLS support. +--- + clang/lib/Driver/ToolChains/Clang.cpp | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp +index 77554aa2c..84eebee36 100644 +--- a/clang/lib/Driver/ToolChains/Clang.cpp ++++ b/clang/lib/Driver/ToolChains/Clang.cpp +@@ -6100,7 +6100,13 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, + Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var, + options::OPT_fno_visibility_inlines_hidden_static_local_var); + Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden); +- Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); ++ if (Triple.isOSSerenity()) { ++ StringRef tls_model = ++ Args.getLastArgValue(options::OPT_ftlsmodel_EQ, "initial-exec"); ++ CmdArgs.push_back(Args.MakeArgString("-ftls-model=" + tls_model)); ++ } else { ++ Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); ++ } + + if (Args.hasFlag(options::OPT_fnew_infallible, + options::OPT_fno_new_infallible, false)) diff --git a/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch b/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch deleted file mode 120000 index 910e63886f6..00000000000 --- a/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0007-cmake-Allow-undefined-symbols-on-SerenityOS.patch \ No newline at end of file diff --git a/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch b/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch new file mode 100644 index 00000000000..443cd374446 --- /dev/null +++ b/Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch @@ -0,0 +1,25 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Thu, 14 Apr 2022 10:21:19 +0200 +Subject: [PATCH] [cmake] Allow undefined symbols on SerenityOS + +Allow undefined symbols in LLVM libraries, which is needed because only +stubs are available for SerenityOS libraries when libc++ and libunwind +are built. +--- + llvm/cmake/modules/HandleLLVMOptions.cmake | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/llvm/cmake/modules/HandleLLVMOptions.cmake b/llvm/cmake/modules/HandleLLVMOptions.cmake +index 6119ecdce..59d2c7539 100644 +--- a/llvm/cmake/modules/HandleLLVMOptions.cmake ++++ b/llvm/cmake/modules/HandleLLVMOptions.cmake +@@ -226,7 +226,7 @@ endif() + + # Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO + # build might work on ELF but fail on MachO/COFF. +-if(NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin|FreeBSD|OpenBSD|DragonFly|AIX|OS390" OR ++if(NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin|FreeBSD|OpenBSD|DragonFly|AIX|OS390|SerenityOS" OR + WIN32 OR CYGWIN) AND + NOT LLVM_USE_SANITIZER) + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs") diff --git a/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch b/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch deleted file mode 120000 index e23d2c8d689..00000000000 --- a/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0008-cmake-Support-building-shared-libLLVM-and-libClang-f.patch \ No newline at end of file diff --git a/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch b/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch new file mode 100644 index 00000000000..3a7b70adc81 --- /dev/null +++ b/Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch @@ -0,0 +1,51 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Bertalan +Date: Mon, 18 Apr 2022 22:32:29 +0200 +Subject: [PATCH] [cmake] Support building shared libLLVM and libClang for + SerenityOS + +This patch tells CMake that the --whole-archive linker option should be +used for specifying the archives whose members will constitute these +shared libraries. + +Symbol versioning is disabled, as the SerenityOS loader doesn't support +it, and the ELF sections that store version data would just waste space. +--- + clang/tools/libclang/CMakeLists.txt | 2 +- + llvm/tools/llvm-shlib/CMakeLists.txt | 3 ++- + 2 files changed, 3 insertions(+), 2 deletions(-) + +diff --git a/clang/tools/libclang/CMakeLists.txt b/clang/tools/libclang/CMakeLists.txt +index 4f23065a2..f180d2229 100644 +--- a/clang/tools/libclang/CMakeLists.txt ++++ b/clang/tools/libclang/CMakeLists.txt +@@ -97,7 +97,7 @@ if(MSVC) + set(LLVM_EXPORTED_SYMBOL_FILE) + endif() + +-if (UNIX AND NOT APPLE) ++if (UNIX AND NOT APPLE AND (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "SerenityOS")) + set(LLVM_EXPORTED_SYMBOL_FILE) + set(USE_VERSION_SCRIPT ${LLVM_HAVE_LINK_VERSION_SCRIPT}) + endif() +diff --git a/llvm/tools/llvm-shlib/CMakeLists.txt b/llvm/tools/llvm-shlib/CMakeLists.txt +index 90e290435..f72ca9646 100644 +--- a/llvm/tools/llvm-shlib/CMakeLists.txt ++++ b/llvm/tools/llvm-shlib/CMakeLists.txt +@@ -40,6 +40,7 @@ if(LLVM_BUILD_LLVM_DYLIB) + OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia") + OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "DragonFly") + OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "Android") ++ OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "SerenityOS") + OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")) # FIXME: It should be "GNU ld for elf" + configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/simple_version_script.map.in +@@ -47,7 +48,7 @@ if(LLVM_BUILD_LLVM_DYLIB) + + # GNU ld doesn't resolve symbols in the version script. + set(LIB_NAMES -Wl,--whole-archive ${LIB_NAMES} -Wl,--no-whole-archive) +- if (NOT LLVM_LINKER_IS_SOLARISLD AND NOT MINGW) ++ if (NOT LLVM_LINKER_IS_SOLARISLD AND NOT MINGW AND (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "SerenityOS")) + # Solaris ld does not accept global: *; so there is no way to version *all* global symbols + set(LIB_NAMES -Wl,--version-script,${LLVM_LIBRARY_DIR}/tools/llvm-shlib/simple_version_script.map ${LIB_NAMES}) + endif() diff --git a/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch b/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch deleted file mode 120000 index 8b07a3602f3..00000000000 --- a/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0010-Add-SerenityOS-to-config.guess.patch \ No newline at end of file diff --git a/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch b/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch new file mode 100644 index 00000000000..59685465dc6 --- /dev/null +++ b/Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch @@ -0,0 +1,23 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tim Schumacher +Date: Wed, 10 Nov 2021 03:29:21 +0100 +Subject: [PATCH] Add SerenityOS to config.guess + +--- + llvm/cmake/config.guess | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/llvm/cmake/config.guess b/llvm/cmake/config.guess +index 71abbf939..f48962367 100644 +--- a/llvm/cmake/config.guess ++++ b/llvm/cmake/config.guess +@@ -816,6 +816,9 @@ EOF + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; ++ *:SerenityOS:*:*) ++ echo ${UNAME_MACHINE}-pc-serenity ++ exit ;; + *:Interix*:*) + case ${UNAME_MACHINE} in + x86) diff --git a/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch b/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch deleted file mode 120000 index 7766daa29f1..00000000000 --- a/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0011-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch \ No newline at end of file diff --git a/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch b/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch new file mode 100644 index 00000000000..34f7d39afa8 --- /dev/null +++ b/Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch @@ -0,0 +1,38 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: sin-ack +Date: Sat, 1 Oct 2022 20:05:52 +0000 +Subject: [PATCH] [llvm] Prevent the use of POSIX shm on SerenityOS + +POSIX shm is not supported by SerenityOS yet, so this causes a +compilation error. +--- + llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp | 2 +- + .../Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp b/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp +index b457c7297..5e2907f0c 100644 +--- a/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp ++++ b/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp +@@ -215,7 +215,7 @@ SharedMemoryMapper::Create(ExecutorProcessControl &EPC, SymbolAddrs SAs) { + + 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>( +diff --git a/llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp b/llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp +index 147f915f6..ca773e1ca 100644 +--- a/llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp ++++ b/llvm/lib/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.cpp +@@ -47,7 +47,7 @@ static DWORD getWindowsProtectionFlags(MemProt MP) { + + Expected> + 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) + diff --git a/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch b/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch deleted file mode 120000 index 0d5df5dd227..00000000000 --- a/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch +++ /dev/null @@ -1 +0,0 @@ -../../../Toolchain/Patches/llvm/0012-cmake-Increase-the-default-stack-size-when-running-o.patch \ No newline at end of file diff --git a/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch b/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch new file mode 100644 index 00000000000..23d085f8ba1 --- /dev/null +++ b/Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch @@ -0,0 +1,24 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tim Schumacher +Date: Mon, 10 Apr 2023 12:17:32 +0200 +Subject: [PATCH] cmake: Increase the default stack size when running on + SerenityOS + +--- + llvm/cmake/modules/HandleLLVMOptions.cmake | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/llvm/cmake/modules/HandleLLVMOptions.cmake b/llvm/cmake/modules/HandleLLVMOptions.cmake +index 59d2c7539..7c3b1ff6d 100644 +--- a/llvm/cmake/modules/HandleLLVMOptions.cmake ++++ b/llvm/cmake/modules/HandleLLVMOptions.cmake +@@ -455,6 +455,9 @@ elseif(MINGW) # FIXME: Also cygwin? + 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)