[Driver] Support GNU ld on Solaris

[ro]

Summary

This patch is posted just for reference on top of D84029 and D84412.

It's a very first attempt to support GNU ld on Solaris, which is non-trivial given that
both linkers have some options not supported by the other. Currently linker selection
is done at cmake time; it probably needs to be made runtime-selectable.

[MaskRay]

Please find a suitable test file (clang/test/Driver/solaris-*.c) and add some tests there (for example, solaris-ld.c)
The challenge is that CLANG_ENABLE_GLD is not a default configuration, so leaving out tests may be fine.

clang/CMakeLists.txt

281

Mention SOLARIS in the variable name? Users on other OSes don't need to read the description of this variable.

It will also make the abbreviation GLD more legitimate. GLD isn't a well-recognized abbreviation for GNU ld.

clang/lib/Driver/ToolChains/Solaris.cpp

252

The hard-coded version doesn't sound great.

[ro]

In D85309#2198505, @MaskRay wrote:

Please find a suitable test file (clang/test/Driver/solaris-*.c) and add some tests there (for example, solaris-ld.c)
The challenge is that CLANG_ENABLE_GLD is not a default configuration, so leaving out tests may be fine.

On top of that, GNU ld may or may not be installed on a particular Solaris systems. So even if the configuration were dynamic instead of hardcoding GNU ld, one would still have to make the test conditional on its presence on the actual system. Same as the somewhat hacky test in D84029.

That said, I don't consider this patch even remotely ready for inclusion. It was primarily meant to show what I'd been using to test that configuration. It has been useful in pinpointing differences between Solaris ld and GNU ld testresults. However, there are quite a number of unexpected asan failures that need to be investigated first.

I'm also not happy with selecting the linker flavour at build time: maybe this can be made dynamic (e.g. parsing ld -V output) to allow for switching between Solaris ld and GNU ld at runtime.

clang/CMakeLists.txt

281

As I said, I've only done it this way to allow selecting GNU ld at all. This would become moot if linker flavour detection were
implemented at runtime.

clang/lib/Driver/ToolChains/Solaris.cpp

252

Certainly not: this is a site-local path used to hack around a configuration error in the current bundled GNU ld on Solaris.
That one is being fixed as we speak.

[ro]

This is a major revison of the original WIP patch that should be (close to) ready. Major differences are:

• Linker selection is dynamic now: one can switch between Solaris ld and GNU ld at runtime, with the default selectable with -DCLANG_DEFAULT_LINKER.
• Testcases have been adjusted to test both variants in case there are differences.
• The compiler-rt/cmake/config-ix.cmake and llvm/cmake/modules/AddLLVM.cmake changes to restrict the tests to Solaris ld are necessary because GNU accepts unknown -z options, but warns every time they are used, creating a lot of noise. Since there seems to be no way to check for those warnings in llvm_check_compiler_linker_flag or llvm_check_compiler_linker_flag, I restrict the cmake tests to Solaris ld in the first place.
• The changes to clang/test/Driver/hip-link-bundle-archive.hip and flang/test/Driver/linker-flags.f90 are required to handle the -DCLANG_DEFAULT_LINKER=gld case: when this is passed to cmake, the WebAssembly.cpp getLinkerPath returns /usr/bin/gld instead of the expected link.
• compiler-rt/test/asan/TestCases/global-location-nodebug.cpp needs to enforce the Solaris ld, otherwise the test would XPASS with GNU ld which has the -S semantics expected by the test.

Tested on amd64-pc-solaris2.11 and sparcv9-sun-solaris2.11 with both -DCLANG_DEFAULT_LINKER=gld and the default, and x86_64-pc-linux-gnu. No regressions in either case.

[MaskRay]

clang/lib/Driver/ToolChains/CommonArgs.cpp

213

I suppose that this should be in a Solaris specific file to indicate that it's not for other systems.

GNU ld is almost ubiquitous on Linux and is almost always available at /usr/bin/ld (with very few distributions using others linkers by default or providing an option).

Detecting linker to affect driver decisions is we Linux are very wary of. We are nervous even trying to do some stuff only related to lld.

We likely don't want this function to be in CommonArgs to lure other contributors to use.

[ro]

clang/lib/Driver/ToolChains/CommonArgs.cpp

213

I suppose that this should be in a Solaris specific file to indicate that it's not for other systems.

Indeed. I've moved it to Solaris.{h,cpp} now. In fact, initially i'd tried to assert a Solaris target in isLinkerGnuLd, but that cannot work because in some cases the function is called in common code, even though the result is only used on Solaris.

I briefly thought about generalizing both IsLinkerGnuLd and IsLinkerLLD into a common

enum LinkerFlavour getLinkerFlavor();

but doing this for all possible configs seemed like a can of worms I'd rather not open.

GNU ld is almost ubiquitous on Linux and is almost always available at /usr/bin/ld (with very few distributions using others linkers by default or providing an option).

Detecting linker to affect driver decisions is we Linux are very wary of. We are nervous even trying to do some stuff only related to lld.

I saw: that code is only used on Darwin, it seems, and I'd like to avoid touching that.

We likely don't want this function to be in CommonArgs to lure other contributors to use.

Apart from the move to Solaris.h, I've also moved it into the solaris namespace to make things completely obvious.

[ro]

Move isLinkerGnuLd to Solaris.{h,cpp} and into solaris namespace to make it unambigously clear where to use it.

[MaskRay]

clang/test/Driver/hip-link-bundle-archive.hip

59 ↗

(On Diff #554946)

Any idea why -fuse-ld= is now needed?

[ro]

clang/test/Driver/hip-link-bundle-archive.hip

59 ↗

(On Diff #554946)

I've tried to explain it in the change description, but just noticed the filename is wrong:

When LLVM is built with -DCLANG_DEFAULT_LINKER=gld on Solaris, MSVC.cpp visualstudio::Linker::ConstructJob sets Linker to gld. Ultimately, GetProgramPath(Linker) is called, resulting in a search for gld, which exists in /usr/bin/gld on Solaris. With -fuse-ld=, this doesn't happen and the expected link is returned.

[MaskRay]

LGTM.

clang/lib/Driver/ToolChains/Solaris.cpp

49

-fuse-ld=<path> is deprecated by --ld-path=. So just drop this FIXME.

61

clang/CMakeLists.txt

 set(CLANG_DEFAULT_STD_C "" CACHE STRING
   "Default standard to use for C/ObjC code (IDENT from LangStandards.def, empty for platform default)")
 set(CLANG_DEFAULT_STD_CXX "" CACHE STRING
   "Default standard to use for C++/ObjC++ code (IDENT from LangStandards.def, empty for platform default)")
 
 set(CLANG_DEFAULT_LINKER "" CACHE STRING
   "Default linker to use (linker name or absolute path, empty for platform default)")
 
+option(CLANG_ENABLE_GLD "Default to GNU ld." OFF)
+
 set(CLANG_DEFAULT_CXX_STDLIB "" CACHE STRING
   "Default C++ stdlib to use (\"libstdc++\" or \"libc++\", empty for platform default")
 if (NOT(CLANG_DEFAULT_CXX_STDLIB STREQUAL "" OR
         CLANG_DEFAULT_CXX_STDLIB STREQUAL "libstdc++" OR
         CLANG_DEFAULT_CXX_STDLIB STREQUAL "libc++"))
   message(WARNING "Resetting default C++ stdlib to use platform default")
   set(CLANG_DEFAULT_CXX_STDLIB "" CACHE STRING
     "Default C++ stdlib to use (\"libstdc++\" or \"libc++\", empty for platform default" FORCE)

clang/include/clang/Config/config.h.cmake

 /* This generated file is for internal use. Do not include it from headers. */
 
 #ifdef CLANG_CONFIG_H
 #error config.h can only be included once
 #else
 #define CLANG_CONFIG_H
 
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
 /* Default linker to use. */
 #define CLANG_DEFAULT_LINKER "${CLANG_DEFAULT_LINKER}"
 
+/* Default to GNU ld. */
+#cmakedefine01 CLANG_ENABLE_GLD
+
 /* Default C/ObjC standard to use. */
 #cmakedefine CLANG_DEFAULT_STD_C LangStandard::lang_${CLANG_DEFAULT_STD_C}
 
 /* Default C++/ObjC++ standard to use. */
 #cmakedefine CLANG_DEFAULT_STD_CXX LangStandard::lang_${CLANG_DEFAULT_STD_CXX}
 
 /* Default C++ stdlib to use. */
 #define CLANG_DEFAULT_CXX_STDLIB "${CLANG_DEFAULT_CXX_STDLIB}"

clang/lib/Driver/ToolChains/CommonArgs.cpp

for (const auto &II : Inputs) {
     else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
       TC.AddCCKextLibArgs(Args, CmdArgs);
     else if (A.getOption().matches(options::OPT_z)) {
       // Pass -z prefix for gcc linker compatibility.
       A.claim();
       A.render(Args, CmdArgs);
     } else {
       A.renderAsInput(Args, CmdArgs);
     }
   }
 }
 
 void tools::AddTargetFeature(const ArgList &Args,
                              std::vector<StringRef> &Features,
                              OptSpecifier OnOpt, OptSpecifier OffOpt,
                              StringRef FeatureName) {
   if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {

 
 // Tries to use a file with the list of dynamic symbols that need to be exported
 // from the runtime library. Returns true if the file was found.
 static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
                                     ArgStringList &CmdArgs,
                                     StringRef Sanitizer) {
   // Solaris ld defaults to --export-dynamic behaviour but doesn't support
   // the option, so don't try to pass it.
-  if (TC.getTriple().getOS() == llvm::Triple::Solaris)
+  if (TC.getTriple().getOS() == llvm::Triple::Solaris && !CLANG_ENABLE_GLD)
     return true;
   // Myriad is static linking only.  Furthermore, some versions of its
   // linker have the bug where --export-dynamic overrides -static, so
   // don't use --export-dynamic on that platform.
   if (TC.getTriple().getVendor() == llvm::Triple::Myriad)
     return true;
   SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer));
   if (llvm::sys::fs::exists(SanRT + ".syms")) {
     CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
     return true;
   }
   return false;
 }
 
 static const char *getAsNeededOption(const ToolChain &TC, bool as_needed) {
   // While the Solaris 11.2 ld added --as-needed/--no-as-needed as aliases
   // for the native forms -z ignore/-z record, they are missing in Illumos,
   // so always use the native form.
-  if (TC.getTriple().isOSSolaris())
+  // GNU ld doesn't support -z ignore/-z record, so don't use them even on
+  // Solaris.
+  if (TC.getTriple().isOSSolaris() && !CLANG_ENABLE_GLD)
     return as_needed ? "-zignore" : "-zrecord";
   else
     return as_needed ? "--as-needed" : "--no-as-needed";
 }
 
 void tools::linkSanitizerRuntimeDeps(const ToolChain &TC,
                                      ArgStringList &CmdArgs) {
   // Fuchsia never needs these.  Any sanitizer runtimes with system

clang/lib/Driver/ToolChains/Solaris.h

public:
 
   void
   addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
                            llvm::opt::ArgStringList &CC1Args) const override;
 
   SanitizerMask getSupportedSanitizers() const override;
   unsigned GetDefaultDwarfVersion() const override { return 2; }
 
-  const char *getDefaultLinker() const override {
-    // clang currently uses Solaris ld-only options.
-    return "/usr/bin/ld";
-  }
+  const char *getDefaultLinker() const override;
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_SOLARIS_H

clang/lib/Driver/ToolChains/Solaris.cpp

for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                          Exec, CmdArgs, Inputs));
 }
 
 void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   // Demangle C++ names in errors
+#if !CLANG_ENABLE_GLD
   CmdArgs.push_back("-C");
+#endif
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
     CmdArgs.push_back("-e");
     CmdArgs.push_back("_start");
   }
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
     CmdArgs.push_back("-dn");
   } else {
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
     }
 
     // libpthread has been folded into libc since Solaris 10, no need to do
     // anything for pthreads. Claim argument to avoid warning.
     Args.ClaimAllArgs(options::OPT_pthread);
     Args.ClaimAllArgs(options::OPT_pthreads);
   }
 
+#if CLANG_ENABLE_GLD
+  // FIXME: Correct comment.
+  // Explicitly set the linker emulation for platforms that might not
+  // be the default emulation for the linker.
+   const toolchains::Solaris &ToolChain =
+      static_cast<const toolchains::Solaris &>(getToolChain());
+  const llvm::Triple::ArchType Arch = ToolChain.getArch();
+
+  switch (Arch) {
+  case llvm::Triple::x86:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf_i386_sol2");
+    break;
+  case llvm::Triple::x86_64:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf_x86_64_sol2");
+    break;
+  case llvm::Triple::sparc:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf32_sparc_sol2");
+    break;
+  case llvm::Triple::sparcv9:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf64_sparc_sol2");
+    break;
+  default:
+    break;
+  }
+#endif
+
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
if (IsX86) {
     Res |= SanitizerKind::PointerSubtract;
   }
   if (IsX86 || IsX86_64)
     Res |= SanitizerKind::Function;
   Res |= SanitizerKind::Vptr;
   return Res;
 }
 
+const char *Solaris::getDefaultLinker() const {
+#if CLANG_ENABLE_GLD
+  // FIXME: Hack around /usr/gnu/bin/ld being configure with --with-sysroot.
+  return "/vol/gcc/bin/gld-2.35";
+  //return "/usr/gnu/bin/ld";
+#else
+  // clang currently uses Solaris ld-only options.
+  return "/usr/bin/ld";
+#endif
+}
+
 Tool *Solaris::buildAssembler() const {
   return new tools::solaris::Assembler(*this);
 }
 
 Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
 
 void Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                         ArgStringList &CC1Args) const {