[CUDA] Do not allow using NVPTX target for host compilation.

[tra]

Summary

Driver only knows how to construct NVPTX compilation pipeline for device side only.
Using NVPTX on the host side violates number of assumptions, trips several assertions and is not expected to produce anything useful in any case. It's better to thow an explicit error instead of letting user figure out what caused compilar to crash.

[jlebar]

lib/Driver/ToolChains.cpp

4834 ↗

(On Diff #66405)

IRL we talked about putting an assert() here and bailing out earlier. Does that not work?

My hope was that we could avoid having to put checks everywhere that the -arch flag is non-empty.

Also, if we're going to print an error message saying "you can't use nvptx as the host compiler", it would be nice to do that at some point in the code where we have confidence that someone is actually trying to use nvptx as the host compiler, instead of assuming that, if we get here, that's what happened.

[tra]

lib/Driver/ToolChains.cpp

4834 ↗

(On Diff #66405)

Haven't found a good place for it yet.
Another problem is that Driver::Diag() does not abort the program and we'll continue on and will execute these functions and will trigger asserts if they are there. I'll try changing diagnostics from Error to Fatal. If that stops clang right there, then we can keep asserts in place.

[tra]

Abort pipeline constructions early if we detect that NVPTX is used for host compilation.
Restore assertions for presence of -march flag.

[jlebar]

Restore assertions for presence of -march flag.

We don't need an explicit assertion in TranslateArgs?

lib/Driver/Driver.cpp

1412 ↗

(On Diff #66505)

This is probably worth a comment?

[tra]

In D23042#503869, @jlebar wrote:

Restore assertions for presence of -march flag.

We don't need an explicit assertion in TranslateArgs?

Nope. The action we create for fatbin uses CudaToolChain, but has nullptr BoundArch and there's no way to tell who's the caller of TranslateArgs().

[tra]

Added a comment describing why we deliberately error out on use of NVPTX for host compilation.

cfe/trunk/include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_cuda_bad_gpu_arch : Error<"Unsupported CUDA gpu architecture: %0">;
 def err_drv_no_cuda_installation : Error<
   "cannot find CUDA installation.  Provide its path via --cuda-path, or pass "
   "-nocudainc to build without CUDA includes.">;
 def err_drv_cuda_version_too_low : Error<
   "GPU arch %1 requires CUDA version at least %3, but installation at %0 is %2. "
   "Use --cuda-path to specify a different CUDA install, or pass "
   "--no-cuda-version-check.">;
+def err_drv_cuda_nvptx_host : Error<"unsupported use of NVPTX for host compilation.">;
 def err_drv_invalid_thread_model_for_target : Error<
   "invalid thread model '%0' in '%1' for this target">;
 def err_drv_invalid_linker_name : Error<
   "invalid linker name in argument '%0'">;
 def err_drv_invalid_pgo_instrumentor : Error<
   "invalid PGO instrumentor in argument '%0'">;
 def err_drv_invalid_rtlib_name : Error<
   "invalid runtime library name in argument '%0'">;

cfe/trunk/lib/Driver/Driver.cpp

Arg *PartialCompilationArg = Args.getLastArg(
       options::OPT_cuda_host_only, options::OPT_cuda_device_only,
       options::OPT_cuda_compile_host_device);
   bool CompileHostOnly =
       PartialCompilationArg &&
       PartialCompilationArg->getOption().matches(options::OPT_cuda_host_only);
   bool CompileDeviceOnly =
       PartialCompilationArg &&
       PartialCompilationArg->getOption().matches(options::OPT_cuda_device_only);
+  const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
+  assert(HostTC && "No toolchain for host compilation.");
+  if (HostTC->getTriple().isNVPTX()) {
+    // We do not support targeting NVPTX for host compilation. Throw
+    // an error and abort pipeline construction early so we don't trip
+    // asserts that assume device-side compilation.
+    C.getDriver().Diag(diag::err_drv_cuda_nvptx_host);
+    return nullptr;
+  }
 
   if (CompileHostOnly) {
-    OffloadAction::HostDependence HDep(
-        *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
+    OffloadAction::HostDependence HDep(*HostAction, *HostTC,
                                        /*BoundArch=*/nullptr, Action::OFK_Cuda);
     return C.MakeAction<OffloadAction>(HDep);
   }
 
   // Collect all cuda_gpu_arch parameters, removing duplicates.
   SmallVector<CudaArch, 4> GpuArchList;
   llvm::SmallSet<CudaArch, 4> GpuArchs;
   for (Arg *A : Args) {
     if (!A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
for (auto &A : {AssembleAction, BackendAction}) {
       DeviceActions.push_back(C.MakeAction<OffloadAction>(DDep, A->getType()));
     }
   }
   auto FatbinAction =
       C.MakeAction<LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN);
 
   // Return a new host action that incorporates original host action and all
   // device actions.
-  OffloadAction::HostDependence HDep(
-      *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
+  OffloadAction::HostDependence HDep(*HostAction, *HostTC,
                                      /*BoundArch=*/nullptr, Action::OFK_Cuda);
   OffloadAction::DeviceDependences DDep;
   DDep.add(*FatbinAction, *CudaTC, /*BoundArch=*/nullptr, Action::OFK_Cuda);
   return C.MakeAction<OffloadAction>(HDep, DDep);
 }
 
 void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
                           const InputList &Inputs, ActionList &Actions) const {
   llvm::PrettyStackTraceString CrashInfo("Building compilation actions");

cfe/trunk/test/Driver/cuda-bad-arch.cu

 
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_20 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_52 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 // RUN: %clang -### -target x86_64-linux-gnu -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 
+// We don't allow using NVPTX for host compilation.
+// RUN: %clang -### --cuda-host-only -target nvptx-nvidia-cuda -c %s 2>&1 \
+// RUN: | FileCheck -check-prefix HOST_NVPTX %s
+
 // OK-NOT: error: Unsupported CUDA gpu architecture
+// HOST_NVPTX: error: unsupported use of NVPTX for host compilation.

cfe/trunk/test/Preprocessor/cuda-types.cu

 // RUN: grep 'define __[^ ]*\(TYPE\|MAX\|SIZEOF\|WIDTH\)' %T/x86_64-device-defines | grep -v '__LDBL\|_LONG_DOUBLE' > %T/x86_64-device-defines-filtered
 // RUN: diff %T/x86_64-host-defines-filtered %T/x86_64-device-defines-filtered
 
 // RUN: %clang --cuda-host-only -nocudainc -target powerpc64-unknown-linux-gnu -x cuda -E -dM -o - /dev/null > %T/powerpc64-host-defines
 // RUN: %clang --cuda-device-only -nocudainc -target powerpc64-unknown-linux-gnu -x cuda -E -dM -o - /dev/null > %T/powerpc64-device-defines
 // RUN: grep 'define __[^ ]*\(TYPE\|MAX\|SIZEOF\|WIDTH\)' %T/powerpc64-host-defines   | grep -v '__LDBL\|_LONG_DOUBLE' > %T/powerpc64-host-defines-filtered
 // RUN: grep 'define __[^ ]*\(TYPE\|MAX\|SIZEOF\|WIDTH\)' %T/powerpc64-device-defines | grep -v '__LDBL\|_LONG_DOUBLE' > %T/powerpc64-device-defines-filtered
 // RUN: diff %T/powerpc64-host-defines-filtered %T/powerpc64-device-defines-filtered
-
-// RUN: %clang --cuda-host-only -nocudainc -target nvptx-nvidia-cuda -x cuda -E -dM -o - /dev/null > %T/nvptx-host-defines
-// RUN: %clang --cuda-device-only -nocudainc -target nvptx-nvidia-cuda -x cuda -E -dM -o - /dev/null > %T/nvptx-device-defines
-// RUN: grep 'define __[^ ]*\(TYPE\|MAX\|SIZEOF\|WIDTH\)' %T/nvptx-host-defines   | grep -v '__LDBL\|_LONG_DOUBLE' > %T/nvptx-host-defines-filtered
-// RUN: grep 'define __[^ ]*\(TYPE\|MAX\|SIZEOF\|WIDTH\)' %T/nvptx-device-defines | grep -v '__LDBL\|_LONG_DOUBLE' > %T/nvptx-device-defines-filtered
-// RUN: diff %T/nvptx-host-defines-filtered %T/nvptx-device-defines-filtered

cfe/trunk/unittests/ASTMatchers/ASTMatchersTest.h

if (!Finder.addDynamicMatcher(AMatcher, &VerifyDynamicFound))
     return testing::AssertionFailure() << "Could not add dynamic matcher";
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Finder));
   // Some tests use typeof, which is a gnu extension.  Using an explicit
   // unknown-unknown triple is good for a large speedup, because it lets us
   // avoid constructing a full system triple.
   std::vector<std::string> Args = {
       "-xcuda",  "-fno-ms-extensions",      "--cuda-host-only", "-nocudainc",
-      "-target", "nvptx64-unknown-unknown", CompileArg};
+      "-target", "x86_64-unknown-unknown", CompileArg};
   if (!runToolOnCodeWithArgs(Factory->create(),
                              CudaHeader + Code, Args)) {
     return testing::AssertionFailure() << "Parsing error in \"" << Code << "\"";
   }
   if (Found != DynamicFound) {
     return testing::AssertionFailure() << "Dynamic match result ("
                                        << DynamicFound
                                        << ") does not match static result ("