[AMDGPU] Use the AMDGPUToolChain when targeting C/C++ directly

Summary:
The `getToolChain` pass uses the triple to determine which toolchain to
create. Currently the `amdgcn-amd-amdhsa` triple maps to the
`ROCmToolChain` which uses things expected to be provided by `ROCm`.
This is neded for OpenCL, but directly targeting C++ does not want this
since it's primarily being used for creating GPU runtime code. As far as
I know I'm the only user of this, so this shouldn't change anything.

Unfortunately, there's no good logic for detercting this, so I simply
checked ahead of time if the input is either `foo.cl` or `-x cl foo.c`
to choose between the two. This allows us to use the AMDGPU target
normally, as otherwise it will error without passing `-nogpulib`.

Refactor to use inputlist

delete old

Author: jhuber6

clang/include/clang/Driver/Driver.h

@@ -468,11 +468,11 @@ class Driver {
   /// BuildInputs - Construct the list of inputs and their types from
   /// the given arguments.
   ///
-  /// \param TC - The default host tool chain.
+  /// \param TT - The target triple.
   /// \param Args - The input arguments.
   /// \param Inputs - The list to store the resulting compilation
   /// inputs onto.
-  void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args,
+  void BuildInputs(const llvm::Triple &TT, llvm::opt::DerivedArgList &Args,
                    InputList &Inputs) const;
 
   /// BuildActions - Construct the list of actions to perform for the
@@ -758,7 +758,8 @@ class Driver {
   /// Will cache ToolChains for the life of the driver object, and create them
   /// on-demand.
   const ToolChain &getToolChain(const llvm::opt::ArgList &Args,
-                                const llvm::Triple &Target) const;
+                                const llvm::Triple &Target,
+                                const InputList &Inputs) const;
 
   /// @}
 

clang/include/clang/Driver/ToolChain.h

@@ -422,10 +422,6 @@ class ToolChain {
   /// native LLVM support.
   virtual bool HasNativeLLVMSupport() const;
 
-  /// LookupTypeForExtension - Return the default language type to use for the
-  /// given extension.
-  virtual types::ID LookupTypeForExtension(StringRef Ext) const;
-
   /// IsBlocksDefault - Does this tool chain enable -fblocks by default.
   virtual bool IsBlocksDefault() const { return false; }
 

clang/lib/Driver/Driver.cpp

@@ -982,7 +982,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
 
           TC = DeviceTC.get();
         } else
-          TC = &getToolChain(C.getInputArgs(), TT);
+          TC = &getToolChain(C.getInputArgs(), TT, Inputs);
         C.addOffloadDeviceToolChain(TC, Action::OFK_OpenMP);
         auto It = DerivedArchs.find(TT.getTriple());
         if (It != DerivedArchs.end())
@@ -1484,12 +1484,17 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
   std::unique_ptr<llvm::opt::InputArgList> UArgs =
       std::make_unique<InputArgList>(std::move(Args));
 
+  llvm::Triple TT = computeTargetTriple(*this, TargetTriple, *UArgs);
+
   // Perform the default argument translations.
   DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
 
+  // Construct the list of inputs.
+  InputList Inputs;
+  BuildInputs(TT, *TranslatedArgs, Inputs);
+
   // Owned by the host.
-  const ToolChain &TC = getToolChain(
-      *UArgs, computeTargetTriple(*this, TargetTriple, *UArgs));
+  const ToolChain &TC = getToolChain(*UArgs, TT, Inputs);
 
   // Check if the environment version is valid except wasm case.
   llvm::Triple Triple = TC.getTriple();
@@ -1550,10 +1555,6 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
   if (!HandleImmediateArgs(*C))
     return C;
 
-  // Construct the list of inputs.
-  InputList Inputs;
-  BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
-
   // Populate the tool chains for the offloading devices, if any.
   CreateOffloadingDeviceToolChains(*C, Inputs);
 
@@ -1767,7 +1768,7 @@ void Driver::generateCompilationDiagnostics(
 
   // Construct the list of inputs.
   InputList Inputs;
-  BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
+  BuildInputs(C.getDefaultToolChain().getTriple(), C.getArgs(), Inputs);
 
   for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
     bool IgnoreInput = false;
@@ -2660,8 +2661,24 @@ static types::ID CXXHeaderUnitType(ModuleHeaderMode HM) {
   return types::TY_CXXHUHeader;
 }
 
+static types::ID lookupTypeForExtension(const Driver &D, const llvm::Triple &TT,
+                                        llvm::StringRef Ext) {
+  types::ID Ty = types::lookupTypeForExtension(Ext);
+
+  // Flang always runs the preprocessor and has no notion of "preprocessed
+  // fortran". Here, TY_PP_Fortran is coerced to TY_Fortran to avoid treating
+  // them differently.
+  if (D.IsFlangMode() && Ty == types::TY_PP_Fortran)
+    Ty = types::TY_Fortran;
+
+  // Darwin always preprocesses assembly files (unless -x is used explicitly).
+  if (TT.isOSBinFormatMachO() && Ty == types::TY_PP_Asm)
+    Ty = types::TY_Asm;
+  return Ty;
+}
+
 // Construct a the list of inputs and their types.
-void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
+void Driver::BuildInputs(const llvm::Triple &TT, DerivedArgList &Args,
                          InputList &Inputs) const {
   const llvm::opt::OptTable &Opts = getOpts();
   // Track the current user specified (-x) input. We also explicitly track the
@@ -2739,7 +2756,7 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
           // We use a host hook here because Darwin at least has its own
           // idea of what .s is.
           if (const char *Ext = strrchr(Value, '.'))
-            Ty = TC.LookupTypeForExtension(Ext + 1);
+            Ty = lookupTypeForExtension(*this, TT, Ext + 1);
 
           if (Ty == types::TY_INVALID) {
             if (IsCLMode() && (Args.hasArgNoClaim(options::OPT_E) || CCGenDiagnostics))
@@ -2795,7 +2812,8 @@ void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
           // If emulating cl.exe, make sure that /TC and /TP don't affect input
           // object files.
           const char *Ext = strrchr(Value, '.');
-          if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
+          if (Ext &&
+              lookupTypeForExtension(*this, TT, Ext + 1) == types::TY_Object)
             Ty = types::TY_Object;
         }
         if (Ty == types::TY_INVALID) {
@@ -5613,9 +5631,9 @@ InputInfoList Driver::BuildJobsForActionNoCache(
     StringRef ArchName = BAA->getArchName();
 
     if (!ArchName.empty())
-      TC = &getToolChain(C.getArgs(),
-                         computeTargetTriple(*this, TargetTriple,
-                                             C.getArgs(), ArchName));
+      TC = &getToolChain(
+          C.getArgs(),
+          computeTargetTriple(*this, TargetTriple, C.getArgs(), ArchName), {});
     else
       TC = &C.getDefaultToolChain();
 
@@ -6376,7 +6394,8 @@ std::string Driver::GetClPchPath(Compilation &C, StringRef BaseName) const {
 }
 
 const ToolChain &Driver::getToolChain(const ArgList &Args,
-                                      const llvm::Triple &Target) const {
+                                      const llvm::Triple &Target,
+                                      const InputList &Inputs) const {
 
   auto &TC = ToolChains[Target.str()];
   if (!TC) {
@@ -6444,7 +6463,12 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
       TC = std::make_unique<toolchains::NVPTXToolChain>(*this, Target, Args);
       break;
     case llvm::Triple::AMDHSA:
-      TC = std::make_unique<toolchains::ROCMToolChain>(*this, Target, Args);
+      TC =
+          llvm::any_of(Inputs,
+                       [](auto &Input) { return types::isOpenCL(Input.first); })
+              ? std::make_unique<toolchains::ROCMToolChain>(*this, Target, Args)
+              : std::make_unique<toolchains::AMDGPUToolChain>(*this, Target,
+                                                              Args);
       break;
     case llvm::Triple::AMDPAL:
     case llvm::Triple::Mesa3D:

clang/lib/Driver/ToolChain.cpp

@@ -1035,18 +1035,6 @@ std::string ToolChain::GetStaticLibToolPath() const {
   return GetProgramPath("llvm-ar");
 }
 
-types::ID ToolChain::LookupTypeForExtension(StringRef Ext) const {
-  types::ID id = types::lookupTypeForExtension(Ext);
-
-  // Flang always runs the preprocessor and has no notion of "preprocessed
-  // fortran". Here, TY_PP_Fortran is coerced to TY_Fortran to avoid treating
-  // them differently.
-  if (D.IsFlangMode() && id == types::TY_PP_Fortran)
-    id = types::TY_Fortran;
-
-  return id;
-}
-
 bool ToolChain::HasNativeLLVMSupport() const {
   return false;
 }

clang/lib/Driver/ToolChains/Darwin.cpp

@@ -967,16 +967,6 @@ Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
     : MachO(D, Triple, Args), TargetInitialized(false),
       CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {}
 
-types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
-  types::ID Ty = ToolChain::LookupTypeForExtension(Ext);
-
-  // Darwin always preprocesses assembly files (unless -x is used explicitly).
-  if (Ty == types::TY_PP_Asm)
-    return types::TY_Asm;
-
-  return Ty;
-}
-
 bool MachO::HasNativeLLVMSupport() const { return true; }
 
 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {

clang/lib/Driver/ToolChains/Darwin.h

@@ -234,8 +234,6 @@ class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
   /// @name ToolChain Implementation
   /// {
 
-  types::ID LookupTypeForExtension(StringRef Ext) const override;
-
   bool HasNativeLLVMSupport() const override;
 
   llvm::opt::DerivedArgList *

clang/test/Driver/amdgpu-toolchain.c

@@ -36,3 +36,6 @@
 // RUN: %clang -target amdgcn-amd-amdhsa -march=gfx90a -stdlib -startfiles \
 // RUN:   -nogpulib -nogpuinc -### %s 2>&1 | FileCheck -check-prefix=STARTUP %s
 // STARTUP: ld.lld{{.*}}"-lc" "-lm" "{{.*}}crt1.o"
+
+// RUN: %clang -### --target=amdgcn-amd-amdhsa -mcpu=gfx906 %s 2>&1 | FileCheck -check-prefix=ROCM %s
+// ROCM-NOT: -mlink-builtin-bitcode