clang  16.0.0git
Action.cpp
Go to the documentation of this file.
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 
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 ExtractAPIJobClass:
29  return "api-extractor";
30  case AnalyzeJobClass: return "analyzer";
31  case MigrateJobClass: return "migrator";
32  case CompileJobClass: return "compiler";
33  case BackendJobClass: return "backend";
34  case AssembleJobClass: return "assembler";
35  case IfsMergeJobClass: return "interface-stub-merger";
36  case LinkJobClass: return "linker";
37  case LipoJobClass: return "lipo";
38  case DsymutilJobClass: return "dsymutil";
39  case VerifyDebugInfoJobClass: return "verify-debug-info";
40  case VerifyPCHJobClass: return "verify-pch";
41  case OffloadBundlingJobClass:
42  return "clang-offload-bundler";
43  case OffloadUnbundlingJobClass:
44  return "clang-offload-unbundler";
45  case OffloadPackagerJobClass:
46  return "clang-offload-packager";
47  case LinkerWrapperJobClass:
48  return "clang-linker-wrapper";
49  case StaticLibJobClass:
50  return "static-lib-linker";
51  }
52 
53  llvm_unreachable("invalid class");
54 }
55 
56 void Action::propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch,
57  const ToolChain *OToolChain) {
58  // Offload action set its own kinds on their dependences.
59  if (Kind == OffloadClass)
60  return;
61  // Unbundling actions use the host kinds.
62  if (Kind == OffloadUnbundlingJobClass)
63  return;
64 
65  assert((OffloadingDeviceKind == OKind || OffloadingDeviceKind == OFK_None) &&
66  "Setting device kind to a different device??");
67  assert(!ActiveOffloadKindMask && "Setting a device kind in a host action??");
68  OffloadingDeviceKind = OKind;
69  OffloadingArch = OArch;
70  OffloadingToolChain = OToolChain;
71 
72  for (auto *A : Inputs)
73  A->propagateDeviceOffloadInfo(OffloadingDeviceKind, OArch, OToolChain);
74 }
75 
76 void Action::propagateHostOffloadInfo(unsigned OKinds, const char *OArch) {
77  // Offload action set its own kinds on their dependences.
78  if (Kind == OffloadClass)
79  return;
80 
81  assert(OffloadingDeviceKind == OFK_None &&
82  "Setting a host kind in a device action.");
83  ActiveOffloadKindMask |= OKinds;
84  OffloadingArch = OArch;
85 
86  for (auto *A : Inputs)
87  A->propagateHostOffloadInfo(ActiveOffloadKindMask, OArch);
88 }
89 
91  if (unsigned HK = A->getOffloadingHostActiveKinds())
92  propagateHostOffloadInfo(HK, A->getOffloadingArch());
93  else
94  propagateDeviceOffloadInfo(A->getOffloadingDeviceKind(),
95  A->getOffloadingArch(),
97 }
98 
100  switch (OffloadingDeviceKind) {
101  case OFK_None:
102  break;
103  case OFK_Host:
104  llvm_unreachable("Host kind is not an offloading device kind.");
105  break;
106  case OFK_Cuda:
107  return "device-cuda";
108  case OFK_OpenMP:
109  return "device-openmp";
110  case OFK_HIP:
111  return "device-hip";
112 
113  // TODO: Add other programming models here.
114  }
115 
116  if (!ActiveOffloadKindMask)
117  return {};
118 
119  std::string Res("host");
120  assert(!((ActiveOffloadKindMask & OFK_Cuda) &&
121  (ActiveOffloadKindMask & OFK_HIP)) &&
122  "Cannot offload CUDA and HIP at the same time");
123  if (ActiveOffloadKindMask & OFK_Cuda)
124  Res += "-cuda";
125  if (ActiveOffloadKindMask & OFK_HIP)
126  Res += "-hip";
127  if (ActiveOffloadKindMask & OFK_OpenMP)
128  Res += "-openmp";
129 
130  // TODO: Add other programming models here.
131 
132  return Res;
133 }
134 
135 /// Return a string that can be used as prefix in order to generate unique files
136 /// for each offloading kind.
139  StringRef NormalizedTriple,
140  bool CreatePrefixForHost) {
141  // Don't generate prefix for host actions unless required.
142  if (!CreatePrefixForHost && (Kind == OFK_None || Kind == OFK_Host))
143  return {};
144 
145  std::string Res("-");
146  Res += GetOffloadKindName(Kind);
147  Res += "-";
148  Res += NormalizedTriple;
149  return Res;
150 }
151 
152 /// Return a string with the offload kind name. If that is not defined, we
153 /// assume 'host'.
155  switch (Kind) {
156  case OFK_None:
157  case OFK_Host:
158  return "host";
159  case OFK_Cuda:
160  return "cuda";
161  case OFK_OpenMP:
162  return "openmp";
163  case OFK_HIP:
164  return "hip";
165 
166  // TODO: Add other programming models here.
167  }
168 
169  llvm_unreachable("invalid offload kind");
170 }
171 
172 void InputAction::anchor() {}
173 
174 InputAction::InputAction(const Arg &_Input, types::ID _Type, StringRef _Id)
175  : Action(InputClass, _Type), Input(_Input), Id(_Id.str()) {}
176 
177 void BindArchAction::anchor() {}
178 
179 BindArchAction::BindArchAction(Action *Input, StringRef ArchName)
180  : Action(BindArchClass, Input), ArchName(ArchName) {}
181 
182 void OffloadAction::anchor() {}
183 
185  : Action(OffloadClass, HDep.getAction()), HostTC(HDep.getToolChain()) {
186  OffloadingArch = HDep.getBoundArch();
189  HDep.getBoundArch());
190 }
191 
193  : Action(OffloadClass, DDeps.getActions(), Ty),
194  DevToolChains(DDeps.getToolChains()) {
195  auto &OKinds = DDeps.getOffloadKinds();
196  auto &BArchs = DDeps.getBoundArchs();
197  auto &OTCs = DDeps.getToolChains();
198 
199  // If all inputs agree on the same kind, use it also for this action.
200  if (llvm::all_equal(OKinds))
201  OffloadingDeviceKind = OKinds.front();
202 
203  // If we have a single dependency, inherit the architecture from it.
204  if (OKinds.size() == 1)
205  OffloadingArch = BArchs.front();
206 
207  // Propagate info to the dependencies.
208  for (unsigned i = 0, e = getInputs().size(); i != e; ++i)
209  getInputs()[i]->propagateDeviceOffloadInfo(OKinds[i], BArchs[i], OTCs[i]);
210 }
211 
213  const DeviceDependences &DDeps)
214  : Action(OffloadClass, HDep.getAction()), HostTC(HDep.getToolChain()),
215  DevToolChains(DDeps.getToolChains()) {
216  // We use the kinds of the host dependence for this action.
217  OffloadingArch = HDep.getBoundArch();
220  HDep.getBoundArch());
221 
222  // Add device inputs and propagate info to the device actions. Do work only if
223  // we have dependencies.
224  for (unsigned i = 0, e = DDeps.getActions().size(); i != e; ++i)
225  if (auto *A = DDeps.getActions()[i]) {
226  getInputs().push_back(A);
227  A->propagateDeviceOffloadInfo(DDeps.getOffloadKinds()[i],
228  DDeps.getBoundArchs()[i],
229  DDeps.getToolChains()[i]);
230  }
231 }
232 
234  if (!HostTC)
235  return;
236  assert(!getInputs().empty() && "No dependencies for offload action??");
237  auto *A = getInputs().front();
238  Work(A, HostTC, A->getOffloadingArch());
239 }
240 
242  const OffloadActionWorkTy &Work) const {
243  auto I = getInputs().begin();
244  auto E = getInputs().end();
245  if (I == E)
246  return;
247 
248  // We expect to have the same number of input dependences and device tool
249  // chains, except if we also have a host dependence. In that case we have one
250  // more dependence than we have device tool chains.
251  assert(getInputs().size() == DevToolChains.size() + (HostTC ? 1 : 0) &&
252  "Sizes of action dependences and toolchains are not consistent!");
253 
254  // Skip host action
255  if (HostTC)
256  ++I;
257 
258  auto TI = DevToolChains.begin();
259  for (; I != E; ++I, ++TI)
260  Work(*I, *TI, (*I)->getOffloadingArch());
261 }
262 
264  doOnHostDependence(Work);
266 }
267 
268 void OffloadAction::doOnEachDependence(bool IsHostDependence,
269  const OffloadActionWorkTy &Work) const {
270  if (IsHostDependence)
271  doOnHostDependence(Work);
272  else
274 }
275 
276 bool OffloadAction::hasHostDependence() const { return HostTC != nullptr; }
277 
279  assert(hasHostDependence() && "Host dependence does not exist!");
280  assert(!getInputs().empty() && "No dependencies for offload action??");
281  return HostTC ? getInputs().front() : nullptr;
282 }
283 
285  bool DoNotConsiderHostActions) const {
286  if (DoNotConsiderHostActions)
287  return getInputs().size() == (HostTC ? 2 : 1);
288  return !HostTC && getInputs().size() == 1;
289 }
290 
291 Action *
292 OffloadAction::getSingleDeviceDependence(bool DoNotConsiderHostActions) const {
293  assert(hasSingleDeviceDependence(DoNotConsiderHostActions) &&
294  "Single device dependence does not exist!");
295  // The previous assert ensures the number of entries in getInputs() is
296  // consistent with what we are doing here.
297  return HostTC ? getInputs()[1] : getInputs().front();
298 }
299 
301  const char *BoundArch,
302  OffloadKind OKind) {
303  DeviceActions.push_back(&A);
304  DeviceToolChains.push_back(&TC);
305  DeviceBoundArchs.push_back(BoundArch);
306  DeviceOffloadKinds.push_back(OKind);
307 }
308 
310  const char *BoundArch,
311  unsigned OffloadKindMask) {
312  DeviceActions.push_back(&A);
313  DeviceToolChains.push_back(&TC);
314  DeviceBoundArchs.push_back(BoundArch);
315 
316  // Add each active offloading kind from a mask.
317  for (OffloadKind OKind : {OFK_OpenMP, OFK_Cuda, OFK_HIP})
318  if (OKind & OffloadKindMask)
319  DeviceOffloadKinds.push_back(OKind);
320 }
321 
323  const char *BoundArch,
324  const DeviceDependences &DDeps)
325  : HostAction(A), HostToolChain(TC), HostBoundArch(BoundArch) {
326  for (auto K : DDeps.getOffloadKinds())
327  HostOffloadKinds |= K;
328 }
329 
330 void JobAction::anchor() {}
331 
333  : Action(Kind, Input, Type) {}
334 
336  : Action(Kind, Inputs, Type) {}
337 
338 void PreprocessJobAction::anchor() {}
339 
341  : JobAction(PreprocessJobClass, Input, OutputType) {}
342 
343 void PrecompileJobAction::anchor() {}
344 
346  : JobAction(PrecompileJobClass, Input, OutputType) {}
347 
349  types::ID OutputType)
350  : JobAction(Kind, Input, OutputType) {
351  assert(isa<PrecompileJobAction>((Action*)this) && "invalid action kind");
352 }
353 
354 void ExtractAPIJobAction::anchor() {}
355 
357  : JobAction(ExtractAPIJobClass, Inputs, OutputType) {}
358 
359 void AnalyzeJobAction::anchor() {}
360 
362  : JobAction(AnalyzeJobClass, Input, OutputType) {}
363 
364 void MigrateJobAction::anchor() {}
365 
367  : JobAction(MigrateJobClass, Input, OutputType) {}
368 
369 void CompileJobAction::anchor() {}
370 
372  : JobAction(CompileJobClass, Input, OutputType) {}
373 
374 void BackendJobAction::anchor() {}
375 
377  : JobAction(BackendJobClass, Input, OutputType) {}
378 
379 void AssembleJobAction::anchor() {}
380 
382  : JobAction(AssembleJobClass, Input, OutputType) {}
383 
384 void IfsMergeJobAction::anchor() {}
385 
387  : JobAction(IfsMergeJobClass, Inputs, Type) {}
388 
389 void LinkJobAction::anchor() {}
390 
392  : JobAction(LinkJobClass, Inputs, Type) {}
393 
394 void LipoJobAction::anchor() {}
395 
397  : JobAction(LipoJobClass, Inputs, Type) {}
398 
399 void DsymutilJobAction::anchor() {}
400 
402  : JobAction(DsymutilJobClass, Inputs, Type) {}
403 
404 void VerifyJobAction::anchor() {}
405 
407  types::ID Type)
408  : JobAction(Kind, Input, Type) {
409  assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
410  "ActionClass is not a valid VerifyJobAction");
411 }
412 
413 void VerifyDebugInfoJobAction::anchor() {}
414 
416  types::ID Type)
417  : VerifyJobAction(VerifyDebugInfoJobClass, Input, Type) {}
418 
419 void VerifyPCHJobAction::anchor() {}
420 
422  : VerifyJobAction(VerifyPCHJobClass, Input, Type) {}
423 
424 void OffloadBundlingJobAction::anchor() {}
425 
427  : JobAction(OffloadBundlingJobClass, Inputs, Inputs.back()->getType()) {}
428 
429 void OffloadUnbundlingJobAction::anchor() {}
430 
432  : JobAction(OffloadUnbundlingJobClass, Input, Input->getType()) {}
433 
434 void OffloadPackagerJobAction::anchor() {}
435 
437  types::ID Type)
438  : JobAction(OffloadPackagerJobClass, Inputs, Type) {}
439 
440 void LinkerWrapperJobAction::anchor() {}
441 
443  types::ID Type)
444  : JobAction(LinkerWrapperJobClass, Inputs, Type) {}
445 
446 void StaticLibJobAction::anchor() {}
447 
449  : JobAction(StaticLibJobClass, Inputs, Type) {}
clang::driver::Action::ActiveOffloadKindMask
unsigned ActiveOffloadKindMask
Offload information.
Definition: Action.h:122
clang::driver::Action::getOffloadingArch
const char * getOffloadingArch() const
Definition: Action.h:210
clang::driver::OffloadAction::HostDependence::getBoundArch
const char * getBoundArch() const
Definition: Action.h:344
clang::driver::Action::getOffloadingToolChain
const ToolChain * getOffloadingToolChain() const
Definition: Action.h:211
clang::driver::Action::size
size_type size() const
Definition: Action.h:152
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::Action::OFK_Cuda
@ OFK_Cuda
Definition: Action.h:93
clang::driver::Action::getInputs
ActionList & getInputs()
Definition: Action.h:149
llvm::SmallVector< Action *, 3 >
clang::driver::Action::ActionClass
ActionClass
Definition: Action.h:55
clang::driver::Action::OffloadingArch
const char * OffloadingArch
The Offloading architecture associated with this action.
Definition: Action.h:128
clang::driver::Action
Action - Represent an abstract compilation step to perform.
Definition: Action.h:47
clang::driver::OffloadAction::OffloadAction
OffloadAction(const HostDependence &HDep)
Definition: Action.cpp:184
clang::driver::OffloadAction::OffloadActionWorkTy
llvm::function_ref< void(Action *, const ToolChain *, const char *)> OffloadActionWorkTy
Definition: Action.h:349
clang::driver::OffloadAction::HostDependence::HostDependence
HostDependence(Action &A, const ToolChain &TC, const char *BoundArch, const unsigned OffloadKinds)
Definition: Action.h:333
clang::driver::Action::propagateDeviceOffloadInfo
void propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch, const ToolChain *OToolChain)
Set the device offload info of this action and propagate it to its dependences.
Definition: Action.cpp:56
clang::driver::Action::OFK_HIP
@ OFK_HIP
Definition: Action.h:95
clang::driver::InputAction::InputAction
InputAction(const llvm::opt::Arg &Input, types::ID Type, StringRef Id=StringRef())
Definition: Action.cpp:174
clang::driver::PrecompileJobAction::PrecompileJobAction
PrecompileJobAction(ActionClass Kind, Action *Input, types::ID OutputType)
Definition: Action.cpp:348
clang::driver::OffloadAction::doOnHostDependence
void doOnHostDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on the host dependence.
Definition: Action.cpp:233
clang::driver::Action::getOffloadingHostActiveKinds
unsigned getOffloadingHostActiveKinds() const
Definition: Action.h:205
clang::driver::Action::~Action
virtual ~Action()
clang::driver::Action::GetOffloadKindName
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
Definition: Action.cpp:154
clang::driver::OffloadAction::doOnEachDependence
void doOnEachDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on each dependence.
Definition: Action.cpp:263
clang::driver::Action::OFK_OpenMP
@ OFK_OpenMP
Definition: Action.h:94
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1565
clang::driver::BindArchAction::BindArchAction
BindArchAction(Action *Input, StringRef ArchName)
Definition: Action.cpp:179
Action.h
clang::driver::OffloadAction::HostDependence::getOffloadKinds
unsigned getOffloadKinds() const
Definition: Action.h:345
clang::driver::VerifyJobAction::VerifyJobAction
VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type)
Definition: Action.cpp:406
clang::driver::OffloadAction::HostDependence
Type used to communicate host actions.
Definition: Action.h:319
clang::driver::CompileJobAction::CompileJobAction
CompileJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:371
clang::driver::IfsMergeJobAction::IfsMergeJobAction
IfsMergeJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:386
clang::driver::LinkJobAction::LinkJobAction
LinkJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:391
Id
int Id
Definition: ASTDiff.cpp:189
llvm::opt
Definition: DiagnosticOptions.h:19
clang::driver::OffloadBundlingJobAction::OffloadBundlingJobAction
OffloadBundlingJobAction(ActionList &Inputs)
Definition: Action.cpp:426
clang::driver::OffloadAction::DeviceDependences::getActions
const ActionList & getActions() const
Get each of the individual arrays.
Definition: Action.h:309
clang::driver::OffloadAction::doOnEachDeviceDependence
void doOnEachDeviceDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on each device dependence.
Definition: Action.cpp:241
clang::driver::OffloadAction::hasHostDependence
bool hasHostDependence() const
Return true if the action has a host dependence.
Definition: Action.cpp:276
clang::driver::Action::OffloadingDeviceKind
OffloadKind OffloadingDeviceKind
Offloading kind of the device.
Definition: Action.h:125
clang::driver::Action::GetOffloadingFileNamePrefix
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, StringRef NormalizedTriple, bool CreatePrefixForHost=false)
Return a string that can be used as prefix in order to generate unique files for each offloading kind...
Definition: Action.cpp:138
clang::driver::AssembleJobAction::AssembleJobAction
AssembleJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:381
clang::driver::Action::getOffloadingKindPrefix
std::string getOffloadingKindPrefix() const
Return a string containing the offload kind of the action.
Definition: Action.cpp:99
clang::driver::OffloadAction::DeviceDependences::add
void add(Action &A, const ToolChain &TC, const char *BoundArch, OffloadKind OKind)
Add an action along with the associated toolchain, bound arch, and offload kind.
Definition: Action.cpp:300
clang::driver::Action::propagateHostOffloadInfo
void propagateHostOffloadInfo(unsigned OKinds, const char *OArch)
Append the host offload info of this action and propagate it to its dependences.
Definition: Action.cpp:76
clang::driver::StaticLibJobAction::StaticLibJobAction
StaticLibJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:448
clang::driver::AnalyzeJobAction::AnalyzeJobAction
AnalyzeJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:361
clang::driver::Action::propagateOffloadInfo
void propagateOffloadInfo(const Action *A)
Set the offload info of this action to be the same as the provided action, and propagate it to its de...
Definition: Action.cpp:90
clang::driver::LinkerWrapperJobAction::LinkerWrapperJobAction
LinkerWrapperJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:442
clang::driver::LipoJobAction::LipoJobAction
LipoJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:396
clang::driver::OffloadAction::DeviceDependences::getToolChains
const ToolChainList & getToolChains() const
Definition: Action.h:310
clang::driver::PreprocessJobAction::PreprocessJobAction
PreprocessJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:340
clang::driver::VerifyJobAction
Definition: Action.h:549
clang::driver::OffloadAction::getSingleDeviceDependence
Action * getSingleDeviceDependence(bool DoNotConsiderHostActions=false) const
Return the single device dependence of this action.
Definition: Action.cpp:292
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
clang::driver::Action::getClassName
const char * getClassName() const
Definition: Action.h:144
clang::driver::JobAction::JobAction
JobAction(ActionClass Kind, Action *Input, types::ID Type)
Definition: Action.cpp:332
clang::driver::Action::getOffloadingDeviceKind
OffloadKind getOffloadingDeviceKind() const
Definition: Action.h:209
clang::driver::OffloadPackagerJobAction::OffloadPackagerJobAction
OffloadPackagerJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:436
clang::driver::types::ID
ID
Definition: Types.h:23
clang::driver::OffloadAction::DeviceDependences::getBoundArchs
const BoundArchList & getBoundArchs() const
Definition: Action.h:311
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::driver::VerifyDebugInfoJobAction::VerifyDebugInfoJobAction
VerifyDebugInfoJobAction(Action *Input, types::ID Type)
Definition: Action.cpp:415
clang::driver::ExtractAPIJobAction::ExtractAPIJobAction
ExtractAPIJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:356
clang::driver::OffloadUnbundlingJobAction::OffloadUnbundlingJobAction
OffloadUnbundlingJobAction(Action *Input)
Definition: Action.cpp:431
clang
Definition: CalledOnceCheck.h:17
clang::driver::Action::VerifyDebugInfoJobClass
@ VerifyDebugInfoJobClass
Definition: Action.h:71
clang::driver::OffloadAction::HostDependence::getAction
Action * getAction() const
Definition: Action.h:342
clang::driver::VerifyPCHJobAction::VerifyPCHJobAction
VerifyPCHJobAction(Action *Input, types::ID Type)
Definition: Action.cpp:421
clang::driver::OffloadAction::hasSingleDeviceDependence
bool hasSingleDeviceDependence(bool DoNotConsiderHostActions=false) const
Return true if the action has a single device dependence.
Definition: Action.cpp:284
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:86
clang::driver::DsymutilJobAction::DsymutilJobAction
DsymutilJobAction(ActionList &Inputs, types::ID Type)
Definition: Action.cpp:401
clang::driver::JobAction
Definition: Action.h:398
clang::driver::MigrateJobAction::MigrateJobAction
MigrateJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:366
clang::driver::BackendJobAction::BackendJobAction
BackendJobAction(Action *Input, types::ID OutputType)
Definition: Action.cpp:376
clang::driver::OffloadAction::DeviceDependences::getOffloadKinds
const OffloadKindList & getOffloadKinds() const
Definition: Action.h:312
clang::driver::OffloadAction::DeviceDependences
Type used to communicate device actions.
Definition: Action.h:273
clang::driver::Action::VerifyPCHJobClass
@ VerifyPCHJobClass
Definition: Action.h:72
clang::driver::OffloadAction::getHostDependence
Action * getHostDependence() const
Return the host dependence of this action.
Definition: Action.cpp:278