Augmented CudaHostAction to carry device-side triple.

[tra]

Summary

Paves the way for the upcoming patch where host-side compilation will need to know device-side triple in order to allow simultaneous parsing of host and device code in the same cuda TU. The triple from the opposite side of compilation will be used to pull in info about target-specific builtins and preprocessor macros.

[echristo]

Commit message could use some more elaborating on why you'll need to know this information. Just a bit as the main commit will have a lot of that information.

Thanks!

-eric

[echristo]

Sounds good. Thanks!

cfe/trunk/include/clang/Driver/Action.h

public:
   static bool classof(const Action *A) {
     return A->getKind() == CudaDeviceClass;
   }
 };
 
 class CudaHostAction : public Action {
   virtual void anchor();
   ActionList DeviceActions;
+  const char *DeviceTriple;
 
 public:
-  CudaHostAction(std::unique_ptr<Action> Input,
-                 const ActionList &DeviceActions);
+  CudaHostAction(std::unique_ptr<Action> Input, const ActionList &DeviceActions,
+                 const char *DeviceTriple);
   ~CudaHostAction() override;
 
   ActionList &getDeviceActions() { return DeviceActions; }
   const ActionList &getDeviceActions() const { return DeviceActions; }
+  const char *getDeviceTriple() const { return DeviceTriple; }
 
   static bool classof(const Action *A) { return A->getKind() == CudaHostClass; }
 };
 
 class JobAction : public Action {
   virtual void anchor();
 protected:
   JobAction(ActionClass Kind, std::unique_ptr<Action> Input, types::ID Type);

cfe/trunk/lib/Driver/Action.cpp

CudaDeviceAction::CudaDeviceAction(std::unique_ptr<Action> Input,
                                    const char *ArchName,
                                    const char *DeviceTriple, bool AtTopLevel)
     : Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
       DeviceTriple(DeviceTriple), AtTopLevel(AtTopLevel) {}
 
 void CudaHostAction::anchor() {}
 
 CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,
-                               const ActionList &DeviceActions)
-    : Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}
+                               const ActionList &DeviceActions,
+                               const char *DeviceTriple)
+    : Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions),
+      DeviceTriple(DeviceTriple) {}
 
 CudaHostAction::~CudaHostAction() {
   for (auto &DA : DeviceActions)
     delete DA;
 }
 
 void JobAction::anchor() {}
 

cfe/trunk/lib/Driver/Driver.cpp

 // only) or device-only compilation, each device action is added to /p
 // Actions and /p Current is released. Otherwise the function creates
 // and returns a new CudaHostAction which wraps /p Current and device
 // side actions.
 static std::unique_ptr<Action>
 buildCudaActions(const Driver &D, const ToolChain &TC, DerivedArgList &Args,
                  const Arg *InputArg, std::unique_ptr<Action> HostAction,
                  ActionList &Actions) {
+  // Figure out which NVPTX triple to use for device-side compilation based on
+  // whether host is 64-bit.
+  const char *DeviceTriple = TC.getTriple().isArch64Bit()
+                                 ? "nvptx64-nvidia-cuda"
+                                 : "nvptx-nvidia-cuda";
   Arg *PartialCompilationArg = Args.getLastArg(options::OPT_cuda_host_only,
                                                options::OPT_cuda_device_only);
   // Host-only compilation case.
   if (PartialCompilationArg &&
       PartialCompilationArg->getOption().matches(options::OPT_cuda_host_only))
     return std::unique_ptr<Action>(
-        new CudaHostAction(std::move(HostAction), {}));
+        new CudaHostAction(std::move(HostAction), {}, DeviceTriple));
 
   // Collect all cuda_gpu_arch parameters, removing duplicates.
   SmallVector<const char *, 4> GpuArchList;
   llvm::StringSet<> GpuArchNames;
   for (Arg *A : Args) {
     if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ)) {
       A->claim();
       if (GpuArchNames.insert(A->getValue()).second)
buildCudaActions(const Driver &D, const ToolChain &TC, DerivedArgList &Args,
   bool PartialCompilation = false;
   for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
     if (CudaDeviceActions[I]->getKind() != Action::BackendJobClass) {
       PartialCompilation = true;
       break;
     }
   }
 
-  // Figure out which NVPTX triple to use for device-side compilation based on
-  // whether host is 64-bit.
-  const char *DeviceTriple = TC.getTriple().isArch64Bit()
-                                 ? "nvptx64-nvidia-cuda"
-                                 : "nvptx-nvidia-cuda";
-
   // Figure out what to do with device actions -- pass them as inputs to the
   // host action or run each of them independently.
   bool DeviceOnlyCompilation = PartialCompilationArg != nullptr;
   if (PartialCompilation || DeviceOnlyCompilation) {
     // In case of partial or device-only compilation results of device actions
     // are not consumed by the host action device actions have to be added to
     // top-level actions list with AtTopLevel=true and run independently.
 
buildCudaActions(const Driver &D, const ToolChain &TC, DerivedArgList &Args,
   ActionList DeviceActions;
   for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
     DeviceActions.push_back(new CudaDeviceAction(
         std::unique_ptr<Action>(CudaDeviceActions[I]), GpuArchList[I],
         DeviceTriple, /* AtTopLevel */ false));
   // Return a new host action that incorporates original host action and all
   // device actions.
   return std::unique_ptr<Action>(
-      new CudaHostAction(std::move(HostAction), DeviceActions));
+      new CudaHostAction(std::move(HostAction), DeviceActions, DeviceTriple));
 }
 
 void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args,
                           const InputList &Inputs, ActionList &Actions) const {
   llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
 
   if (!SuppressMissingInputWarning && Inputs.empty()) {
     Diag(clang::diag::err_drv_no_input_files);