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.

Ports/zig/patches/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0001-Support-Add-support-for-building-LLVM-on-SerenityOS.patch

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 <dani@danielbertalan.dev>
+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 <type_traits>
+ 
+ #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
+-    defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
++    defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__serenity__)
+ #include <endian.h>
+ #elif defined(_AIX)
+ #include <sys/machine.h>
+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<unsigned> SecondsToWait,
+                             std::string *ErrMsg,

Ports/zig/patches/0002-Triple-Add-triple-for-SerenityOS.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0002-Triple-Add-triple-for-SerenityOS.patch

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 <dani@danielbertalan.dev>
+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);
+ }
+ 

Ports/zig/patches/0003-Driver-Add-support-for-SerenityOS.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0003-Driver-Add-support-for-SerenityOS.patch

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 <dani@danielbertalan.dev>
+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 <filmroellchen@serenityos.org>
+---
+ 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<AArch64leTargetInfo>(Triple, Opts);
+     case llvm::Triple::OpenBSD:
+       return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
++    case llvm::Triple::Serenity:
++      return new SerenityTargetInfo<AArch64leTargetInfo>(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<RISCV64TargetInfo>(Triple, Opts);
+     case llvm::Triple::Linux:
+       return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
++    case llvm::Triple::Serenity:
++      return new SerenityTargetInfo<RISCV64TargetInfo>(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<X86_32TargetInfo>(Triple, Opts);
++    case llvm::Triple::Serenity:
++      return new SerenityTargetInfo<X86_32TargetInfo>(Triple, Opts);
+     default:
+       return new X86_32TargetInfo(Triple, Opts);
+     }
+@@ -596,6 +602,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
+       return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
+     case llvm::Triple::PS5:
+       return new PS5OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
++    case llvm::Triple::Serenity:
++      return new SerenityTargetInfo<X86_64TargetInfo>(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 <typename Target>
++class LLVM_LIBRARY_VISIBILITY SerenityTargetInfo : public OSTargetInfo<Target> {
++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<Target>(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<toolchains::Fuchsia>(*this, Target, Args);
+       break;
++    case llvm::Triple::Serenity:
++      TC = std::make_unique<toolchains::Serenity>(*this, Target, Args);
++      break;
+     case llvm::Triple::Solaris:
+       TC = std::make_unique<toolchains::Solaris>(*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 <string>
++
++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<Command>(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<int, int, int> 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<StringRef, 3> Parts;
++    VersionText.split(Parts, '.');
++
++    // SerenityOS always builds GCC with <major>.<minor>.<patch> versions
++    if (Parts.size() < 3)
++      continue;
++
++    std::tuple<int, int, int> 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

Ports/zig/patches/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0004-Driver-Default-to-ftls-model-initial-exec-on-Serenit.patch

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 <dani@danielbertalan.dev>
+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))

Ports/zig/patches/0006-cmake-Allow-undefined-symbols-on-SerenityOS.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0007-cmake-Allow-undefined-symbols-on-SerenityOS.patch

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 <dani@danielbertalan.dev>
+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")

Ports/zig/patches/0007-cmake-Support-building-shared-libLLVM-and-libClang-f.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0008-cmake-Support-building-shared-libLLVM-and-libClang-f.patch

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 <dani@danielbertalan.dev>
+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()

Ports/zig/patches/0008-Add-SerenityOS-to-config.guess.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0010-Add-SerenityOS-to-config.guess.patch

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 <timschumi@gmx.de>
+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)

Ports/zig/patches/0009-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0011-llvm-Prevent-the-use-of-POSIX-shm-on-SerenityOS.patch

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 <sin-ack@users.noreply.github.com>
+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<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)
+ 

Ports/zig/patches/0010-cmake-Increase-the-default-stack-size-when-running-o.patch

@@ -1 +0,0 @@
-../../../Toolchain/Patches/llvm/0012-cmake-Increase-the-default-stack-size-when-running-o.patch

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 <timschumi@gmx.de>
+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)