[clang] Add support for SerenityOS

[ADKaster]

Summary

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 <[e-mail]>
Co-authored-by: Andrew Kaster <[e-mail]>
Co-authored-by: Daniel Bertalan <[e-mail]>

Depends on D154395

[MaskRay]

Upstreaming support requires rigid testing, otherwise it's fairly easy for other contributors to break your code while refactoring.
https://maskray.me/blog/2021-08-08-toolchain-testing "I don't know whether a test is needed"

clang/test/Driver has many tests that could have been written in a better way. There are some good ones, e.g. linux-cross.cpp.

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

85

Avoid equals_insensitive. It's only recommended in some places for Windows.

[phosek]

clang/lib/Driver/ToolChains/Serenity.h

38

Have you considered inheriting from Generic_GCC to allow more code reuse?

[ADKaster]

Planning to rebase on top of Generic_ELF per Petr's suggestion.

clang/lib/Driver/ToolChains/Serenity.cpp

85

What is the recommendation for this use case instead? This is the same pattern that is used by the Fuchsia driver. https://github.com/llvm/llvm-project/blob/01e3393b94d194ee99e57f23f9c08160cef94753/clang/lib/Driver/ToolChains/Fuchsia.cpp#L59-L61

though it looks like Fuchsia used that pattern back when it was called equals_lower(). https://github.com/llvm/llvm-project/commit/3e199ecdadf7b546054c5a5820d1678f1e83c821

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

85

I think Fuchsia should not use equals_lower. There is never a case that we'd use something like ld.LLD.

127

OPT_e has the LinkerInput flag and is rendered by AddLinkerInputs. Remove Args.AddAllArgs(CmdArgs, options::OPT_e); to avoid duplicate -e.

130

gcc doesn't recognize -Z. I think it is an early (200x) mistake that some targets render -Z. Drop it.

143

I wonder why you don't use the common addSanitizerRuntimes. ubsan runtime is normally libclang_rt.ubsan_standalone*

195

/usr/local/lib should not be in the default search path.

[ADKaster]

@MaskRay @phosek Daniel and I have updated the patch set, Would you rather I update the phab patch series, or re-upload the set as GitHub PRs?

[brad]

In D154396#4655494, @ADKaster wrote:

@MaskRay @phosek Daniel and I have updated the patch set, Would you rather I update the phab patch series, or re-upload the set as GitHub PRs?

Update the phab patch series.

[ADKaster]

Base on Generic_ELF driver, add tests, add myself as co-author

[ADKaster]

In D154396#4655496, @brad wrote:

In D154396#4655494, @ADKaster wrote:

@MaskRay @phosek Daniel and I have updated the patch set, Would you rather I update the phab patch series, or re-upload the set as GitHub PRs?

Update the phab patch series.

Sounds good, done. Some of the patches didn't need updates, and others needed a rebase. I already abandoned the libcxx patch as the project still needs to figure out the proper way to provision a machine to use as a libcxx buildkite runner (and where to fund it from :) ). We'll resubmit that one on GitHub after these are in and we get that sorted out.

[brad]

Make use of the concat macro with the various header and library paths.
https://github.com/llvm/llvm-project/commit/1d0cc510516d50c459f78896a0375fadb13a2b45

clang/lib/Driver/ToolChains/Serenity.cpp

79

Like the other ToolChains this should have before it..

assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");

108

https://github.com/llvm/llvm-project/commit/894927b491b7c62917ffa7ad665841683095317c

120

https://github.com/llvm/llvm-project/commit/894927b491b7c62917ffa7ad665841683095317c

[brad]

You also have to add Serenity to clang/lib/Lex/InitHeaderSearch.cpp InitHeaderSearch::ShouldAddDefaultIncludePaths().

clang/lib/Driver/ToolChains/Serenity.h

82

This just overrides the default DWARF version anyway.

[ADKaster]

Brad's comments, and clang-format

[brad]

clang/lib/Driver/ToolChains/Serenity.cpp

203

IMO if the library path is removed then the header path should be as well.

[brad]

But the rest LGTM as a start.

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

32

-no-pie is nowadays canonical and GCC does't support -nopie. You can drop -nopie.

77

This is not tested

86

This is untested

212

This is for systems that historically support .ctors/.dtors https://maskray.me/blog/2021-11-07-init-ctors-init-array

If Serenity doesn't, this should be removed.

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

165

crt* files are not tested

clang/test/Driver/serenity.cpp

2 ↗

(On Diff #557945)

https://github.com/MaskRay/Config/wiki/LLVM#clanglibdriver

The test fails in a
-DCLANG_DEFAULT_RTLIB=compiler-rt -DCLANG_DEFAULT_UNWINDLIB=libunwind -DCLANG_DEFAULT_CXX_STDLIB=libc++ build

35 ↗

(On Diff #557945)

https://github.com/MaskRay/Config/wiki/LLVM#clanglibdriver

The NOT -ltest fails in a
-DCLANG_DEFAULT_RTLIB=compiler-rt -DCLANG_DEFAULT_UNWINDLIB=libunwind -DCLANG_DEFAULT_CXX_STDLIB=libc++ build

[brad]

clang/lib/Driver/ToolChains/Serenity.cpp

148

Add in here..

// Silence warnings when linking C code with a C++ '-stdlib' argument.
Args.ClaimAllArgs(options::OPT_stdlib_EQ);

https://github.com/llvm/llvm-project/commit/760658c118f491985ec00f62f5a261293db67b95

[ADKaster]

clang/lib/Driver/ToolChains/Serenity.cpp

203

Fair. /usr/local is the prefix that all ports in the Ports/ tree are installed into by default (though some end up with files in /opt). We can for sure work a bit harder to make those headers/libs available to ports in our build infrastructure for them rather than putting that logic in the compiler.

212

It's my understanding that we don't currently support .ctors/.dtors, though we did a few years ago. It is a bit confusing to me how those are related to .init/.fini though. We have some stubs here for crti.S and crtn.S https://github.com/SerenityOS/serenity/blob/cf3c8a216be5aa496844aadb43ca05ad5c47bb46/Userland/Libraries/LibC/arch/x86_64/crti.S which end up giving every .so and executable a DT_INIT section, but all the actual global ctors and dtors end up in .init_array/.fini_array.

[ADKaster]

clang/lib/Driver/ToolChains/Serenity.cpp

77

Hm. this also seems like incorrect logic. In my next push I will remove this condition around --eh-frame-hdr to match the other ToolChains.

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

77

https://maskray.me/blog/2020-11-08-stack-unwinding I have some notes on ".eh_frame_hdr and PT_GNU_EH_FRAME".

Clang and GCC usually pass --eh-frame-hdr to ld, with the exception that gcc -static does not pass --eh-frame-hdr. The difference is a historical choice related to __register_frame_info.

[ADKaster]

clang/lib/Driver/ToolChains/Serenity.cpp

77

Ah, this explains where @BertalanD got the original logic from, as we had a gcc port first. It was probably copied from our patched gcc spec files.

[ADKaster]

Add more tests and remove items per comments

More tests for crt*, eh-frame-hdr, stdlib arguments
remove /usr/local/include
remove -fno-use-init-array
claim stdlib= args
remove -nopie

I hope that the new tests are more robust, but I could be missing something

[brad]

clang/lib/Driver/ToolChains/Serenity.cpp

111

https://github.com/llvm/llvm-project/commit/1881832994840baa6e42f908b8822ce4d15ab632

[ADKaster]

test LTO with option fix

[MaskRay]

clang/test/Driver/serenity.cpp

20 ↗

(On Diff #558043)

Prefer -SAME: whenever applicable

ditto below

159 ↗

(On Diff #558043)

TC.GetFilePath("crti.o") returns a path to crti.o if crti.o is found, otherwise a raw crti.o without a patch component. The raw crti.o indicates that clang driver fails to find crti.o in a search path.

I think you need to change --sysroot= to pointer to a directory tree in Inputs/ where crti.o can be found.

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.h

62

Test that the -cc1 line contains "-pic-level" "2" "-pic-is-pie"

69

Test that the -cc1 line contains "-funwind-tables=2"

[MaskRay]

clang/lib/Driver/ToolChains/Serenity.cpp

26

I've simplified Gnu.cpp a bit for handling different link modes. ae623d16d50c9f12de7ae7ac1aa11c9d6857e081

52

See ae623d16d50c9f12de7ae7ac1aa11c9d6857e081

[brad]

https://github.com/llvm/llvm-project/commit/c149ff3d372a70e7d9de838a1ff0357394b8d017
https://github.com/llvm/llvm-project/commit/a8e0acf660639078a7e5341dd6ec82326d3b796b

Might want to add the Flang bits if you plan on using the Flang Fortran compiler.

[brad]

@ADKaster Ping.

clang/lib/Basic/Targets.cpp

case llvm::Triple::Linux:
                                                                      Opts);
       }
     case llvm::Triple::NetBSD:
       return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple,
                                                                      Opts);
     case llvm::Triple::OpenBSD:
       return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple,
                                                                       Opts);
+    case llvm::Triple::Serenity:
+      return std::make_unique<SerenityTargetInfo<AArch64leTargetInfo>>(Triple,
+                                                                       Opts);
     case llvm::Triple::Win32:
       switch (Triple.getEnvironment()) {
       case llvm::Triple::GNU:
         return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts);
       case llvm::Triple::MSVC:
       default: // Assume MSVC for unknown environments
         return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts);
       }
case llvm::Triple::x86:
     case llvm::Triple::RTEMS:
       return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);
     case llvm::Triple::NaCl:
       return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts);
     case llvm::Triple::ELFIAMCU:
       return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);
     case llvm::Triple::Hurd:
       return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);
+    case llvm::Triple::Serenity:
+      return std::make_unique<SerenityTargetInfo<X86_32TargetInfo>>(Triple,
+                                                                    Opts);
     default:
       return std::make_unique<X86_32TargetInfo>(Triple, Opts);
     }
 
   case llvm::Triple::x86_64:
     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
       return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);
 
case llvm::Triple::x86_64:
     case llvm::Triple::Haiku:
       return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts);
     case llvm::Triple::NaCl:
       return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts);
     case llvm::Triple::PS4:
       return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
     case llvm::Triple::PS5:
       return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
+    case llvm::Triple::Serenity:
+      return std::make_unique<SerenityTargetInfo<X86_64TargetInfo>>(Triple,
+                                                                    Opts);
     default:
       return std::make_unique<X86_64TargetInfo>(Triple, Opts);
     }
 
   case llvm::Triple::spir: {
     if (os != llvm::Triple::UnknownOS ||
         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
       return nullptr;

clang/lib/Basic/Targets/OSTargets.h

OHOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
     }
   }
 
   const char *getStaticInitSectionSpecifier() const override {
     return ".text.startup";
   }
 };
 
+// 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

clang/lib/Driver/CMakeLists.txt

add_clang_library(clangDriver
   ToolChains/MSVC.cpp
   ToolChains/Myriad.cpp
   ToolChains/NaCl.cpp
   ToolChains/NetBSD.cpp
   ToolChains/OHOS.cpp
   ToolChains/OpenBSD.cpp
   ToolChains/PS4CPU.cpp
   ToolChains/RISCVToolchain.cpp
+  ToolChains/Serenity.cpp
   ToolChains/Solaris.cpp
   ToolChains/SPIRV.cpp
   ToolChains/TCE.cpp
   ToolChains/VEToolchain.cpp
   ToolChains/WebAssembly.cpp
   ToolChains/XCore.cpp
   ToolChains/PPCLinux.cpp
   ToolChains/PPCFreeBSD.cpp

clang/lib/Driver/Driver.cpp

 #include "ToolChains/NetBSD.h"
 #include "ToolChains/OHOS.h"
 #include "ToolChains/OpenBSD.h"
 #include "ToolChains/PPCFreeBSD.h"
 #include "ToolChains/PPCLinux.h"
 #include "ToolChains/PS4CPU.h"
 #include "ToolChains/RISCVToolchain.h"
 #include "ToolChains/SPIRV.h"
+#include "ToolChains/Serenity.h"
 #include "ToolChains/Solaris.h"
 #include "ToolChains/TCE.h"
 #include "ToolChains/VEToolchain.h"
 #include "ToolChains/WebAssembly.h"
 #include "ToolChains/XCore.h"
 #include "ToolChains/ZOS.h"
 #include "clang/Basic/TargetID.h"
 #include "clang/Basic/Version.h"
case llvm::Triple::ELFIAMCU:
         TC = std::make_unique<toolchains::Linux>(*this, Target, Args);
       break;
     case llvm::Triple::NaCl:
       TC = std::make_unique<toolchains::NaClToolChain>(*this, Target, Args);
       break;
     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;
     case llvm::Triple::CUDA:
       TC = std::make_unique<toolchains::NVPTXToolChain>(*this, Target, Args);
       break;
     case llvm::Triple::AMDHSA:
       TC = std::make_unique<toolchains::ROCMToolChain>(*this, Target, Args);

clang/lib/Driver/ToolChain.cpp

StringRef ToolChain::getOSLibName() const {
   case llvm::Triple::NetBSD:
     return "netbsd";
   case llvm::Triple::OpenBSD:
     return "openbsd";
   case llvm::Triple::Solaris:
     return "sunos";
   case llvm::Triple::AIX:
     return "aix";
+  case llvm::Triple::Serenity:
+    return "serenity";
   default:
     return getOS();
   }
 }
 
 std::string ToolChain::getCompilerRTPath() const {
   SmallString<128> Path(getDriver().ResourceDir);
   if (isBareMetal()) {

clang/lib/Driver/ToolChains/Serenity.h

+//===---- 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; }
+
+  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

clang/lib/Driver/ToolChains/Serenity.cpp

+//===---- 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;
+}