contrib/llvm-project/clang/lib/Driver/Action.cpp

   1 //===- Action.cpp - Abstract compilation steps ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Driver/Action.h"
  10 #include "llvm/Support/ErrorHandling.h"
  11 #include <cassert>
  12 #include <string>
  13
  14 using namespace clang;
  15 using namespace driver;
  16 using namespace llvm::opt;
  17
  18 Action::~Action() = default;
  19
  20 const char *Action::getClassName(ActionClass AC) {
  21   switch (AC) {
  22   case InputClass: return "input";
  23   case BindArchClass: return "bind-arch";
  24   case OffloadClass:
  25     return "offload";
  26   case PreprocessJobClass: return "preprocessor";
  27   case PrecompileJobClass: return "precompiler";
  28   case HeaderModulePrecompileJobClass: return "header-module-precompiler";
  29   case AnalyzeJobClass: return "analyzer";
  30   case MigrateJobClass: return "migrator";
  31   case CompileJobClass: return "compiler";
  32   case BackendJobClass: return "backend";
  33   case AssembleJobClass: return "assembler";
  34   case IfsMergeJobClass: return "interface-stub-merger";
  35   case LinkJobClass: return "linker";
  36   case LipoJobClass: return "lipo";
  37   case DsymutilJobClass: return "dsymutil";
  38   case VerifyDebugInfoJobClass: return "verify-debug-info";
  39   case VerifyPCHJobClass: return "verify-pch";
  40   case OffloadBundlingJobClass:
  41     return "clang-offload-bundler";
  42   case OffloadUnbundlingJobClass:
  43     return "clang-offload-unbundler";
  44   case OffloadWrapperJobClass:
  45     return "clang-offload-wrapper";
  46   }
  47
  48   llvm_unreachable("invalid class");
  49 }
  50
  51 void Action::propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch) {
  52   // Offload action set its own kinds on their dependences.
  53   if (Kind == OffloadClass)
  54     return;
  55   // Unbundling actions use the host kinds.
  56   if (Kind == OffloadUnbundlingJobClass)
  57     return;
  58
  59   assert((OffloadingDeviceKind == OKind || OffloadingDeviceKind == OFK_None) &&
  60          "Setting device kind to a different device??");
  61   assert(!ActiveOffloadKindMask && "Setting a device kind in a host action??");
  62   OffloadingDeviceKind = OKind;
  63   OffloadingArch = OArch;
  64
  65   for (auto *A : Inputs)
  66     A->propagateDeviceOffloadInfo(OffloadingDeviceKind, OArch);
  67 }
  68
  69 void Action::propagateHostOffloadInfo(unsigned OKinds, const char *OArch) {
  70   // Offload action set its own kinds on their dependences.
  71   if (Kind == OffloadClass)
  72     return;
  73
  74   assert(OffloadingDeviceKind == OFK_None &&
  75          "Setting a host kind in a device action.");
  76   ActiveOffloadKindMask |= OKinds;
  77   OffloadingArch = OArch;
  78
  79   for (auto *A : Inputs)
  80     A->propagateHostOffloadInfo(ActiveOffloadKindMask, OArch);
  81 }
  82
  83 void Action::propagateOffloadInfo(const Action *A) {
  84   if (unsigned HK = A->getOffloadingHostActiveKinds())
  85     propagateHostOffloadInfo(HK, A->getOffloadingArch());
  86   else
  87     propagateDeviceOffloadInfo(A->getOffloadingDeviceKind(),
  88                                A->getOffloadingArch());
  89 }
  90
  91 std::string Action::getOffloadingKindPrefix() const {
  92   switch (OffloadingDeviceKind) {
  93   case OFK_None:
  94     break;
  95   case OFK_Host:
  96     llvm_unreachable("Host kind is not an offloading device kind.");
  97     break;
  98   case OFK_Cuda:
  99     return "device-cuda";
 100   case OFK_OpenMP:
 101     return "device-openmp";
 102   case OFK_HIP:
 103     return "device-hip";
 104
 105     // TODO: Add other programming models here.
 106   }
 107
 108   if (!ActiveOffloadKindMask)
 109     return {};
 110
 111   std::string Res("host");
 112   assert(!((ActiveOffloadKindMask & OFK_Cuda) &&
 113            (ActiveOffloadKindMask & OFK_HIP)) &&
 114          "Cannot offload CUDA and HIP at the same time");
 115   if (ActiveOffloadKindMask & OFK_Cuda)
 116     Res += "-cuda";
 117   if (ActiveOffloadKindMask & OFK_HIP)
 118     Res += "-hip";
 119   if (ActiveOffloadKindMask & OFK_OpenMP)
 120     Res += "-openmp";
 121
 122   // TODO: Add other programming models here.
 123
 124   return Res;
 125 }
 126
 127 /// Return a string that can be used as prefix in order to generate unique files
 128 /// for each offloading kind.
 129 std::string
 130 Action::GetOffloadingFileNamePrefix(OffloadKind Kind,
 131                                     StringRef NormalizedTriple,
 132                                     bool CreatePrefixForHost) {
 133   // Don't generate prefix for host actions unless required.
 134   if (!CreatePrefixForHost && (Kind == OFK_None || Kind == OFK_Host))
 135     return {};
 136
 137   std::string Res("-");
 138   Res += GetOffloadKindName(Kind);
 139   Res += "-";
 140   Res += NormalizedTriple;
 141   return Res;
 142 }
 143
 144 /// Return a string with the offload kind name. If that is not defined, we
 145 /// assume 'host'.
 146 StringRef Action::GetOffloadKindName(OffloadKind Kind) {
 147   switch (Kind) {
 148   case OFK_None:
 149   case OFK_Host:
 150     return "host";
 151   case OFK_Cuda:
 152     return "cuda";
 153   case OFK_OpenMP:
 154     return "openmp";
 155   case OFK_HIP:
 156     return "hip";
 157
 158     // TODO: Add other programming models here.
 159   }
 160
 161   llvm_unreachable("invalid offload kind");
 162 }
 163
 164 void InputAction::anchor() {}
 165
 166 InputAction::InputAction(const Arg &_Input, types::ID _Type)
 167     : Action(InputClass, _Type), Input(_Input) {}
 168
 169 void BindArchAction::anchor() {}
 170
 171 BindArchAction::BindArchAction(Action *Input, StringRef ArchName)
 172     : Action(BindArchClass, Input), ArchName(ArchName) {}
 173
 174 void OffloadAction::anchor() {}
 175
 176 OffloadAction::OffloadAction(const HostDependence &HDep)
 177     : Action(OffloadClass, HDep.getAction()), HostTC(HDep.getToolChain()) {
 178   OffloadingArch = HDep.getBoundArch();
 179   ActiveOffloadKindMask = HDep.getOffloadKinds();
 180   HDep.getAction()->propagateHostOffloadInfo(HDep.getOffloadKinds(),
 181                                              HDep.getBoundArch());
 182 }
 183
 184 OffloadAction::OffloadAction(const DeviceDependences &DDeps, types::ID Ty)
 185     : Action(OffloadClass, DDeps.getActions(), Ty),
 186       DevToolChains(DDeps.getToolChains()) {
 187   auto &OKinds = DDeps.getOffloadKinds();
 188   auto &BArchs = DDeps.getBoundArchs();
 189
 190   // If all inputs agree on the same kind, use it also for this action.
 191   if (llvm::all_of(OKinds, [&](OffloadKind K) { return K == OKinds.front(); }))
 192     OffloadingDeviceKind = OKinds.front();
 193
 194   // If we have a single dependency, inherit the architecture from it.
 195   if (OKinds.size() == 1)
 196     OffloadingArch = BArchs.front();
 197
 198   // Propagate info to the dependencies.
 199   for (unsigned i = 0, e = getInputs().size(); i != e; ++i)
 200     getInputs()[i]->propagateDeviceOffloadInfo(OKinds[i], BArchs[i]);
 201 }
 202
 203 OffloadAction::OffloadAction(const HostDependence &HDep,
 204                              const DeviceDependences &DDeps)
 205     : Action(OffloadClass, HDep.getAction()), HostTC(HDep.getToolChain()),
 206       DevToolChains(DDeps.getToolChains()) {
 207   // We use the kinds of the host dependence for this action.
 208   OffloadingArch = HDep.getBoundArch();
 209   ActiveOffloadKindMask = HDep.getOffloadKinds();
 210   HDep.getAction()->propagateHostOffloadInfo(HDep.getOffloadKinds(),
 211                                              HDep.getBoundArch());
 212
 213   // Add device inputs and propagate info to the device actions. Do work only if
 214   // we have dependencies.
 215   for (unsigned i = 0, e = DDeps.getActions().size(); i != e; ++i)
 216     if (auto *A = DDeps.getActions()[i]) {
 217       getInputs().push_back(A);
 218       A->propagateDeviceOffloadInfo(DDeps.getOffloadKinds()[i],
 219                                     DDeps.getBoundArchs()[i]);
 220     }
 221 }
 222
 223 void OffloadAction::doOnHostDependence(const OffloadActionWorkTy &Work) const {
 224   if (!HostTC)
 225     return;
 226   assert(!getInputs().empty() && "No dependencies for offload action??");
 227   auto *A = getInputs().front();
 228   Work(A, HostTC, A->getOffloadingArch());
 229 }
 230
 231 void OffloadAction::doOnEachDeviceDependence(
 232     const OffloadActionWorkTy &Work) const {
 233   auto I = getInputs().begin();
 234   auto E = getInputs().end();
 235   if (I == E)
 236     return;
 237
 238   // We expect to have the same number of input dependences and device tool
 239   // chains, except if we also have a host dependence. In that case we have one
 240   // more dependence than we have device tool chains.
 241   assert(getInputs().size() == DevToolChains.size() + (HostTC ? 1 : 0) &&
 242          "Sizes of action dependences and toolchains are not consistent!");
 243
 244   // Skip host action
 245   if (HostTC)
 246     ++I;
 247
 248   auto TI = DevToolChains.begin();
 249   for (; I != E; ++I, ++TI)
 250     Work(*I, *TI, (*I)->getOffloadingArch());
 251 }
 252
 253 void OffloadAction::doOnEachDependence(const OffloadActionWorkTy &Work) const {
 254   doOnHostDependence(Work);
 255   doOnEachDeviceDependence(Work);
 256 }
 257
 258 void OffloadAction::doOnEachDependence(bool IsHostDependence,
 259                                        const OffloadActionWorkTy &Work) const {
 260   if (IsHostDependence)
 261     doOnHostDependence(Work);
 262   else
 263     doOnEachDeviceDependence(Work);
 264 }
 265
 266 bool OffloadAction::hasHostDependence() const { return HostTC != nullptr; }
 267
 268 Action *OffloadAction::getHostDependence() const {
 269   assert(hasHostDependence() && "Host dependence does not exist!");
 270   assert(!getInputs().empty() && "No dependencies for offload action??");
 271   return HostTC ? getInputs().front() : nullptr;
 272 }
 273
 274 bool OffloadAction::hasSingleDeviceDependence(
 275     bool DoNotConsiderHostActions) const {
 276   if (DoNotConsiderHostActions)
 277     return getInputs().size() == (HostTC ? 2 : 1);
 278   return !HostTC && getInputs().size() == 1;
 279 }
 280
 281 Action *
 282 OffloadAction::getSingleDeviceDependence(bool DoNotConsiderHostActions) const {
 283   assert(hasSingleDeviceDependence(DoNotConsiderHostActions) &&
 284          "Single device dependence does not exist!");
 285   // The previous assert ensures the number of entries in getInputs() is
 286   // consistent with what we are doing here.
 287   return HostTC ? getInputs()[1] : getInputs().front();
 288 }
 289
 290 void OffloadAction::DeviceDependences::add(Action &A, const ToolChain &TC,
 291                                            const char *BoundArch,
 292                                            OffloadKind OKind) {
 293   DeviceActions.push_back(&A);
 294   DeviceToolChains.push_back(&TC);
 295   DeviceBoundArchs.push_back(BoundArch);
 296   DeviceOffloadKinds.push_back(OKind);
 297 }
 298
 299 OffloadAction::HostDependence::HostDependence(Action &A, const ToolChain &TC,
 300                                               const char *BoundArch,
 301                                               const DeviceDependences &DDeps)
 302     : HostAction(A), HostToolChain(TC), HostBoundArch(BoundArch) {
 303   for (auto K : DDeps.getOffloadKinds())
 304     HostOffloadKinds |= K;
 305 }
 306
 307 void JobAction::anchor() {}
 308
 309 JobAction::JobAction(ActionClass Kind, Action *Input, types::ID Type)
 310     : Action(Kind, Input, Type) {}
 311
 312 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
 313     : Action(Kind, Inputs, Type) {}
 314
 315 void PreprocessJobAction::anchor() {}
 316
 317 PreprocessJobAction::PreprocessJobAction(Action *Input, types::ID OutputType)
 318     : JobAction(PreprocessJobClass, Input, OutputType) {}
 319
 320 void PrecompileJobAction::anchor() {}
 321
 322 PrecompileJobAction::PrecompileJobAction(Action *Input, types::ID OutputType)
 323     : JobAction(PrecompileJobClass, Input, OutputType) {}
 324
 325 PrecompileJobAction::PrecompileJobAction(ActionClass Kind, Action *Input,
 326                                          types::ID OutputType)
 327     : JobAction(Kind, Input, OutputType) {
 328   assert(isa<PrecompileJobAction>((Action*)this) && "invalid action kind");
 329 }
 330
 331 void HeaderModulePrecompileJobAction::anchor() {}
 332
 333 HeaderModulePrecompileJobAction::HeaderModulePrecompileJobAction(
 334     Action *Input, types::ID OutputType, const char *ModuleName)
 335     : PrecompileJobAction(HeaderModulePrecompileJobClass, Input, OutputType),
 336       ModuleName(ModuleName) {}
 337
 338 void AnalyzeJobAction::anchor() {}
 339
 340 AnalyzeJobAction::AnalyzeJobAction(Action *Input, types::ID OutputType)
 341     : JobAction(AnalyzeJobClass, Input, OutputType) {}
 342
 343 void MigrateJobAction::anchor() {}
 344
 345 MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType)
 346     : JobAction(MigrateJobClass, Input, OutputType) {}
 347
 348 void CompileJobAction::anchor() {}
 349
 350 CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType)
 351     : JobAction(CompileJobClass, Input, OutputType) {}
 352
 353 void BackendJobAction::anchor() {}
 354
 355 BackendJobAction::BackendJobAction(Action *Input, types::ID OutputType)
 356     : JobAction(BackendJobClass, Input, OutputType) {}
 357
 358 void AssembleJobAction::anchor() {}
 359
 360 AssembleJobAction::AssembleJobAction(Action *Input, types::ID OutputType)
 361     : JobAction(AssembleJobClass, Input, OutputType) {}
 362
 363 void IfsMergeJobAction::anchor() {}
 364
 365 IfsMergeJobAction::IfsMergeJobAction(ActionList &Inputs, types::ID Type)
 366     : JobAction(IfsMergeJobClass, Inputs, Type) {}
 367
 368 void LinkJobAction::anchor() {}
 369
 370 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
 371     : JobAction(LinkJobClass, Inputs, Type) {}
 372
 373 void LipoJobAction::anchor() {}
 374
 375 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
 376     : JobAction(LipoJobClass, Inputs, Type) {}
 377
 378 void DsymutilJobAction::anchor() {}
 379
 380 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
 381     : JobAction(DsymutilJobClass, Inputs, Type) {}
 382
 383 void VerifyJobAction::anchor() {}
 384
 385 VerifyJobAction::VerifyJobAction(ActionClass Kind, Action *Input,
 386                                  types::ID Type)
 387     : JobAction(Kind, Input, Type) {
 388   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
 389          "ActionClass is not a valid VerifyJobAction");
 390 }
 391
 392 void VerifyDebugInfoJobAction::anchor() {}
 393
 394 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(Action *Input,
 395                                                    types::ID Type)
 396     : VerifyJobAction(VerifyDebugInfoJobClass, Input, Type) {}
 397
 398 void VerifyPCHJobAction::anchor() {}
 399
 400 VerifyPCHJobAction::VerifyPCHJobAction(Action *Input, types::ID Type)
 401     : VerifyJobAction(VerifyPCHJobClass, Input, Type) {}
 402
 403 void OffloadBundlingJobAction::anchor() {}
 404
 405 OffloadBundlingJobAction::OffloadBundlingJobAction(ActionList &Inputs)
 406     : JobAction(OffloadBundlingJobClass, Inputs, Inputs.back()->getType()) {}
 407
 408 void OffloadUnbundlingJobAction::anchor() {}
 409
 410 OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(Action *Input)
 411     : JobAction(OffloadUnbundlingJobClass, Input, Input->getType()) {}
 412
 413 void OffloadWrapperJobAction::anchor() {}
 414
 415 OffloadWrapperJobAction::OffloadWrapperJobAction(ActionList &Inputs,
 416                                                  types::ID Type)
 417   : JobAction(OffloadWrapperJobClass, Inputs, Type) {}