[Shave]: allow Clang to run the target linker.

[dougk]

Summary

Implement the ShaveToolChain::buildLinker() method instead of calling llvm_unreachable.
Lightly tested, but works ok on a few of the sample applications.

[jyknight]

lib/Driver/Tools.cpp

9110

Perhaps this should be a default plus a command-line argument, instead of an environment variable?

9144

Doesn't seem right to hardcode this particular version. Using a default for ToolsRoot if MV_TOOLS_DIR isn't set sounds okay, but presumably should be done up above before the loop.

9160

"-O9"? That seems weird, and is not actually a thing.

9198

These (oneleon/bothleons) don't seem to do anything different than "rtems", so I'd remove them

9221

Why are these building up explicit paths, instead of adding the proper -L search paths, and then -lc -lssp etc?

[dougk]

lib/Driver/Tools.cpp

9110

How about if '--sysdir' provides the value, falling back to the environment var, and then a fixed default?
There is ample precedent for use of getenv() in some of the other toolchains.

9144

I could see a couple ways around hardcoding a version - if neither --sysroot nor MV_TOOLS_DIR is used, then the path is arbitrary anyway, so doesn't need a versioned subdir. And arguably is sysroot is given, then it could be an already-versioned pathname. Otoh, detecting the version works fine in that case.

For reference, the example sub-Makefile has hardcoded:
MV_TOOLS_VERSION ?= 00.50.62.5
MV_TOOLS_DIR ?= $(HOME)/WORK/Tools/Releases/General

9160

This was cargo-cultism. I've no objection to taking it out, but who's to say that their linker doesn't use it for something, as why else would they bother to put it in the examples?

include/clang/Driver/Options.td

 def i_Group               : OptionGroup<"<i group>">, Group<CompileOnly_Group>;
 def clang_i_Group         : OptionGroup<"<clang i group>">, Group<i_Group>;
 def m_Group               : OptionGroup<"<m group>">, Group<CompileOnly_Group>;
 def m_x86_Features_Group  : OptionGroup<"<m x86 features group>">, Group<m_Group>, Flags<[CoreOption]>;
 def m_hexagon_Features_Group  : OptionGroup<"<m hexagon features group>">, Group<m_Group>;
 def m_arm_Features_Group  : OptionGroup<"<m arm features group>">, Group<m_Group>;
 def m_aarch64_Features_Group  : OptionGroup<"<m aarch64 features group>">, Group<m_Group>;
 def m_ppc_Features_Group  : OptionGroup<"<m ppc features group>">, Group<m_Group>;
+def m_shave_Features_Group  : OptionGroup<"<m shave features group>">, Group<m_Group>;
 def m_libc_Group          : OptionGroup<"<m libc group>">, Group<m_Group>;
 def u_Group               : OptionGroup<"<u group>">;
 
 def pedantic_Group        : OptionGroup<"<pedantic group>">,
   Group<CompileOnly_Group>;
 def reserved_lib_Group   : OptionGroup<"<reserved libs group>">;
 
 // Temporary groups for clang options which we know we don't support,
def mv2 : Flag<["-"], "mv2">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v2"]>;
 def mv3 : Flag<["-"], "mv3">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v3"]>;
 def mv4 : Flag<["-"], "mv4">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v4"]>;
 def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v5"]>;
 
+def mprog_model_EQ : Joined<["-"], "mprog-model=">, Group<m_shave_Features_Group>;
+
 // These are legacy user-facing driver-level option spellings. They are always
 // aliases for options that are spelled using the more common Unix / GNU flag
 // style of double-dash and equals-joined flags.
 def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>;
 def target_legacy_spelling : Separate<["-"], "target">, Alias<target>;
 
 // Special internal option to handle -Xlinker --no-demangle.
 def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">,

lib/Driver/ToolChains.cpp

 
 Tool *SHAVEToolChain::getTool(Action::ActionClass AC) const {
   // SelectTool() must find a tool using the method in the superclass.
   // There's nothing we can do if that fails.
   llvm_unreachable("SHAVEToolChain can't getTool");
 }
 
 Tool *SHAVEToolChain::buildLinker() const {
-  // SHAVEToolChain executables can not be linked except by the vendor tools.
-  llvm_unreachable("SHAVEToolChain can't buildLinker");
+  return new tools::SHAVE::Linker(*this);
 }
 
 Tool *SHAVEToolChain::buildAssembler() const {
   // This one you'd think should be reachable since we expose an
   // assembler to the driver, except not the way it expects.
   llvm_unreachable("SHAVEToolChain can't buildAssembler");
 }

lib/Driver/Tools.h

public:
 
   bool hasIntegratedCPP() const override { return false; } // not sure.
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
+
+class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
+public:
+  Linker(const ToolChain &TC) : GnuTool("shave::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 SHAVE
 
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif

lib/Driver/Tools.cpp

void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back(
       Args.MakeArgString(std::string("-o:") + Output.getFilename()));
 
   std::string Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
   C.addCommand(
       llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec), CmdArgs));
 }
+
+void tools::SHAVE::Linker::ConstructJob(Compilation &C, const JobAction &JA,
+                                        const InputInfo &Output,
+                                        const InputInfoList &Inputs,
+                                        const ArgList &Args,
+                                        const char *LinkingOutput) const {
+  ArgStringList CmdArgs;
+
+  // Directory structure is:
+  //   <path_to_mdk_root>
+  //       mdk
+  //       tools             <-- $MV_TOOLS_DIR is this
+  //         <version#>
+  //            linux64
+  //            ...
+
+  const char *ToolsRoot = ::getenv("MV_TOOLS_DIR");
+  // The version is numbered 'n.n.n.n' for arbitrary values that are opaque
+  // as far as clang is concerned.
+  std::string ToolsVersion;
+  // The "Host" directory contains both host tools and target libraries
+  // even though target-only stuff is bitwise identical across
+  // the the 3 possible host toolchains {linux32 | linux64 | win32}.
+  std::string ToolsHostDir;
+  // The "Common" directory has target-only stuff in it such as "crt0.o".
+  std::string ToolsCommonDir;
+
+  if (ToolsRoot) {
+    // Detecting which version of the tools are installed is patterned after
+    // GCCInstallationDetector::ScanLibDirForGCCTriple and other places.
+    // It is assumed that multiple versions will not co-exist side-by-side,
+    // or rather if they do, that picking any is ok.
+    SmallString<128> DirNative;
+    std::error_code EC;
+    llvm::sys::path::native(ToolsRoot, DirNative);
+    for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd;
+         Dir != DirEnd && !EC; Dir.increment(EC)) {
+      // Look for a subdirectory of ToolsDir that has within it
+      // a directory named 'common'.
+      SmallString<128> CommonDir(Dir->path());
+      llvm::sys::path::append(CommonDir, "common");
+      if (llvm::sys::fs::exists(CommonDir)) {
+        ToolsCommonDir = CommonDir.str();
+        ToolsVersion = llvm::sys::path::filename(Dir->path());
+        break;
+      }
+    }
+  }
+  if (ToolsCommonDir.empty()) {
+    ToolsRoot = "/usr/local/myriad/tools";
+    ToolsVersion = "00.50.62.5";
+    ToolsCommonDir = "/usr/local/mdk/tools/" + ToolsVersion + "/common";
+  }
+  llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
+  const char *HostSubdir = "linux64";
+  if (HostTriple.isOSWindows())
+    HostSubdir = "win32";
+  else if (HostTriple.getArch() == llvm::Triple::x86)
+    HostSubdir = "linux32";
+  SmallString<128> HostDir(ToolsRoot);
+  llvm::sys::path::append(HostDir, ToolsVersion, HostSubdir);
+
+  SmallString<127> GnuToolsRoot(ToolsHostDir);
+  llvm::sys::path::append(GnuToolsRoot, "sparc-myriad-elf-4.8.2");
+
+  CmdArgs.push_back("-EL"); // Endianness = little
+  CmdArgs.push_back("-O9"); // Optimization
+  CmdArgs.push_back("--gc-sections");
+  CmdArgs.push_back("-warn-common");
+
+  static const char *LibDirs[] = {"lib/gcc/sparc-myriad-elf/4.8.2/le",
+                                  "sparc-myriad-elf/lib/le"};
+  for (const auto &Dir : LibDirs) {
+    SmallString<128> FullPath(GnuToolsRoot);
+    llvm::sys::path::append(FullPath, Dir);
+    CmdArgs.push_back("-L");
+    CmdArgs.push_back(Args.MakeArgString(FullPath));
+  }
+
+  SmallString<127> CommonDir(ToolsRoot);
+  llvm::sys::path::append(CommonDir, "../mdk/common");
+
+  SmallString<128> LinkerScriptDir(CommonDir);
+  llvm::sys::path::append(LinkerScriptDir, "scripts/ld/myriad2collection");
+  CmdArgs.push_back("-L");
+  CmdArgs.push_back(Args.MakeArgString(LinkerScriptDir));
+
+  SmallString<128> MainLinkerScript(LinkerScriptDir);
+  llvm::sys::path::append(MainLinkerScript,
+                          "myriad2_default_memory_map_elf.ldscript");
+  CmdArgs.push_back("-T");
+  CmdArgs.push_back(Args.MakeArgString(MainLinkerScript));
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  enum ProgrammingModel { Bare, OneLeon, BothLeons, RTEMS } ProgrammingModel;
+  Arg *Arg = Args.getLastArg(options::OPT_mprog_model_EQ);
+  if (Arg) {
+    std::string Value = Arg->getValue(0);
+    // FIXME: Instead of "Fell off the end of a string-switch"
+    // print something like "unsupported programming model".
+    ProgrammingModel = llvm::StringSwitch<enum ProgrammingModel>(Value)
+                           .Case("bare", Bare)
+                           .Case("oneleon", OneLeon)
+                           .Case("bothleons", BothLeons)
+                           .Case("rtems", RTEMS);
+  }
+
+  if (ProgrammingModel != Bare) {
+    static const char *StartFiles[] = {"crti.o", "crtbegin.o"};
+    for (const auto &File : StartFiles) {
+      SmallString<128> FullPath(GnuToolsRoot);
+      llvm::sys::path::append(FullPath, "lib/gcc/sparc-myriad-elf/4.8.2/le",
+                              File);
+      CmdArgs.push_back(Args.MakeArgString(FullPath));
+    }
+  }
+
+  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
+
+  CmdArgs.push_back("--start-group");
+  if (ProgrammingModel == Bare) {
+    CmdArgs.push_back("-lgcc");
+    CmdArgs.push_back("-lc");
+  } else {
+    static const char *RTEMSStaticLibs[] = {"librtemsbsp.a", "librtemscpu.a"};
+    static const char *CStaticLibs[] = {"libc.a", "libssp.a",
+                                        "libssp_nonshared.a"};
+    static const char *GCCStaticLibs[] = {"libgcc.a"};
+    for (const auto &File : RTEMSStaticLibs) {
+      SmallString<128> FullPath(ToolsCommonDir);
+      llvm::sys::path::append(FullPath, "rtems/prebuilt/lib", File);
+      CmdArgs.push_back(Args.MakeArgString(FullPath));
+    }
+    for (const auto &File : CStaticLibs) {
+      SmallString<128> FullPath(ToolsHostDir);
+      llvm::sys::path::append(
+          FullPath, "sparc-myriad-elf-4.8.2/sparc-myriad-elf/lib/le", File);
+      CmdArgs.push_back(Args.MakeArgString(FullPath));
+    }
+    for (const auto &File : GCCStaticLibs) {
+      SmallString<128> FullPath(GnuToolsRoot);
+      llvm::sys::path::append(FullPath, "lib/gcc/sparc-myriad-elf/4.8.2/le",
+                              File);
+      CmdArgs.push_back(Args.MakeArgString(FullPath));
+    }
+  }
+
+  if (C.getDriver().CCCIsCXX()) {
+    CmdArgs.push_back("-lstdc++");
+    CmdArgs.push_back("-lsupc++");
+  }
+
+  CmdArgs.push_back("--end-group");
+
+  if (ProgrammingModel != Bare) {
+    static const char *EndFiles[] = {"crtend.o", "crtn.o"};
+    for (const auto &File : EndFiles) {
+      SmallString<128> FullPath(GnuToolsRoot);
+      llvm::sys::path::append(FullPath, "lib/gcc/sparc-myriad-elf/4.8.2/le",
+                              File);
+      CmdArgs.push_back(Args.MakeArgString(FullPath));
+    }
+  }
+
+  SmallString<128> LinkerExec(GnuToolsRoot);
+  llvm::sys::path::append(LinkerExec, "bin/sparc-myriad-elf-ld");
+
+  C.addCommand(llvm::make_unique<Command>(
+      JA, *this, Args.MakeArgString(LinkerExec), CmdArgs));
+}

test/Driver/shave-toolchain.cpp

+// RUN: %clangxx %s -### -target shave 2>&1 | FileCheck %s
+// CHECK: moviCompile
+// CHECK: moviAsm
+// CHECK: "-lstdc++" "-lsupc++"