Driver: Add AMDGPU toolchain

[• tstellarAMD]

Summary

This is a minimal toolchain, which sets the integrated assembler as default,
and uses lld for linking.

[• tstellarAMD]

Ping.

[dougk]

lib/Driver/ToolChains.h

726

Please use ToolChain instead of _TC as the suffix.
See http://reviews.llvm.org/D10609 (pending) which standardizes on that.

lib/Driver/Tools.cpp

5759

any reason not to insert getToolChain().getTripleString() vs hardcoding 'amdgcn--' ?

[• tstellarAMD]

Here is an updated patch. I have renamed AMDGPU_TC to AMDGPUToolChain and
replaced the hard-coded amdgcn-- triple with getToolChain().getTripleString()

[• tstellarAMD]

Ping.

[mcrosier]

Seems reasonable to me.

lib/Driver/Driver.cpp

case llvm::Triple::Linux:
         TC = new toolchains::Linux(*this, Target, Args);
       break;
     case llvm::Triple::NaCl:
       TC = new toolchains::NaCl_TC(*this, Target, Args);
       break;
     case llvm::Triple::Solaris:
       TC = new toolchains::Solaris(*this, Target, Args);
       break;
+    case llvm::Triple::AMDHSA:
+      TC = new toolchains::AMDGPU_TC(*this, Target, Args);
+      break;
     case llvm::Triple::Win32:
       switch (Target.getEnvironment()) {
       default:
         if (Target.isOSBinFormatELF())
           TC = new toolchains::Generic_ELF(*this, Target, Args);
         else if (Target.isOSBinFormatMachO())
           TC = new toolchains::MachO(*this, Target, Args);
         else

lib/Driver/ToolChains.h

public:
 
   static StringRef GetTargetCPU(const llvm::opt::ArgList &Args);
 
   static const char *GetSmallDataThreshold(const llvm::opt::ArgList &Args);
 
   static bool UsesG0(const char* smallDataThreshold);
 };
 
+class LLVM_LIBRARY_VISIBILITY AMDGPU_TC : public Generic_ELF {
+protected:
+  Tool *buildLinker() const override;
+
+public:
+  AMDGPU_TC(const Driver &D, const llvm::Triple &Triple,
+            const llvm::opt::ArgList &Args);
+  bool IsIntegratedAssemblerDefault() const override { return true; }
+};
+
 class LLVM_LIBRARY_VISIBILITY NaCl_TC : public Generic_ELF {
 public:
   NaCl_TC(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;

lib/Driver/ToolChains.cpp

StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
   case 2:
     return "v2";
   case 1:
     return "v1";
   }
 }
 // End Hexagon
 
+/// AMDGPU Toolchain
+AMDGPU_TC::AMDGPU_TC(const Driver &D, const llvm::Triple &Triple,
+                     const ArgList &Args) : Generic_ELF(D, Triple, Args) { }
+
+Tool *AMDGPU_TC::buildLinker() const {
+  return new tools::amdgpu::Linker(*this);
+}
+// End AMDGPU
+
 /// NaCl Toolchain
 NaCl_TC::NaCl_TC(const Driver &D, const llvm::Triple &Triple,
                  const ArgList &Args)
   : Generic_ELF(D, Triple, Args) {
 
   // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
   // default paths, and must instead only use the paths provided
   // with this toolchain based on architecture.

lib/Driver/Tools.h

virtual void RenderExtraToolArgs(const JobAction &JA,
                                      llvm::opt::ArgStringList &CmdArgs) const;
     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 hexagon.
 
+namespace amdgpu {
+
+class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool {
+public:
+  Linker(const ToolChain &TC) : GnuTool("amdgpu::Linker", "lld", TC) {}
+  bool isLinkJob() const override { return true; }
+  bool hasIntegratedCPP() const override { return false; }
+  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 amdgpu
+
 namespace arm {
   std::string getARMTargetCPU(const llvm::opt::ArgList &Args,
                               const llvm::Triple &Triple);
   const std::string getARMArch(const llvm::opt::ArgList &Args,
                                const llvm::Triple &Triple);
   const char* getARMCPUForMArch(const llvm::opt::ArgList &Args,
                                 const llvm::Triple &Triple);
   const char* getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch);

lib/Driver/Tools.cpp

constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
                            LinkingOutput);
 
   std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
   C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
                                           CmdArgs));
 }
 // Hexagon tools end.
 
+void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
+                                  const InputInfo &Output,
+                                  const InputInfoList &Inputs,
+                                  const ArgList &Args,
+                                  const char *LinkingOutput) const {
+
+  std::string Linker = getToolChain().GetProgramPath(getShortName());
+  ArgStringList CmdArgs;
+  CmdArgs.push_back("-flavor");
+  CmdArgs.push_back("gnu");
+  CmdArgs.push_back("-target");
+  CmdArgs.push_back("amdgcn--");
+  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
+                                          CmdArgs));
+}
+// AMDGPU tools end.
+
 const std::string arm::getARMArch(const ArgList &Args,
                                   const llvm::Triple &Triple) {
   std::string MArch;
   if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     // Otherwise, if we have -march= choose the base CPU for that arch.
     MArch = A->getValue();
   } else {
     // Otherwise, use the Arch from the triple.

test/Driver/amdgpu-toolchain.c

+// RUN: %clang -### -target amdgcn--amdhsa -x assembler -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=AS_LINK %s
+// AS_LINK-LABEL: clang
+// AS_LINK: "-cc1as"
+// AS_LINK-LABEL: lld
+// AS_LINK: "-flavor" "gnu" "-target" "amdgcn--"