clang 19.0.0git
Action.h
Go to the documentation of this file.
1//===- Action.h - Abstract compilation steps --------------------*- C++ -*-===//
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#ifndef LLVM_CLANG_DRIVER_ACTION_H
10#define LLVM_CLANG_DRIVER_ACTION_H
11
12#include "clang/Basic/LLVM.h"
13#include "clang/Driver/Types.h"
14#include "clang/Driver/Util.h"
15#include "llvm/ADT/ArrayRef.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/iterator_range.h"
20#include <string>
21
22namespace llvm {
23namespace opt {
24
25class Arg;
26
27} // namespace opt
28} // namespace llvm
29
30namespace clang {
31namespace driver {
32
33class ToolChain;
34
35/// Action - Represent an abstract compilation step to perform.
36///
37/// An action represents an edge in the compilation graph; typically
38/// it is a job to transform an input using some tool.
39///
40/// The current driver is hard wired to expect actions which produce a
41/// single primary output, at least in terms of controlling the
42/// compilation. Actions can produce auxiliary files, but can only
43/// produce a single output to feed into subsequent actions.
44///
45/// Actions are usually owned by a Compilation, which creates new
46/// actions via MakeAction().
47class Action {
48public:
49 using size_type = ActionList::size_type;
50 using input_iterator = ActionList::iterator;
51 using input_const_iterator = ActionList::const_iterator;
52 using input_range = llvm::iterator_range<input_iterator>;
53 using input_const_range = llvm::iterator_range<input_const_iterator>;
54
79
82 };
83
84 // The offloading kind determines if this action is binded to a particular
85 // programming model. Each entry reserves one bit. We also have a special kind
86 // to designate the host offloading tool chain.
88 OFK_None = 0x00,
89
90 // The host offloading tool chain.
91 OFK_Host = 0x01,
92
93 // The device offloading tool chains - one bit for each programming model.
94 OFK_Cuda = 0x02,
95 OFK_OpenMP = 0x04,
96 OFK_HIP = 0x08,
97 };
98
99 static const char *getClassName(ActionClass AC);
100
101private:
102 ActionClass Kind;
103
104 /// The output type of this action.
106
107 ActionList Inputs;
108
109 /// Flag that is set to true if this action can be collapsed with others
110 /// actions that depend on it. This is true by default and set to false when
111 /// the action is used by two different tool chains, which is enabled by the
112 /// offloading support implementation.
113 bool CanBeCollapsedWithNextDependentAction = true;
114
115protected:
116 ///
117 /// Offload information.
118 ///
119
120 /// The host offloading kind - a combination of kinds encoded in a mask.
121 /// Multiple programming models may be supported simultaneously by the same
122 /// host.
124
125 /// Offloading kind of the device.
127
128 /// The Offloading architecture associated with this action.
129 const char *OffloadingArch = nullptr;
130
131 /// The Offloading toolchain associated with this device action.
133
136 : Action(Kind, ActionList({Input}), Type) {}
138 : Action(Kind, ActionList({Input}), Input->getType()) {}
140 : Kind(Kind), Type(Type), Inputs(Inputs) {}
141
142public:
143 virtual ~Action();
144
145 const char *getClassName() const { return Action::getClassName(getKind()); }
146
147 ActionClass getKind() const { return Kind; }
148 types::ID getType() const { return Type; }
149
150 ActionList &getInputs() { return Inputs; }
151 const ActionList &getInputs() const { return Inputs; }
152
153 size_type size() const { return Inputs.size(); }
154
155 input_iterator input_begin() { return Inputs.begin(); }
156 input_iterator input_end() { return Inputs.end(); }
158 input_const_iterator input_begin() const { return Inputs.begin(); }
159 input_const_iterator input_end() const { return Inputs.end(); }
162 }
163
164 /// Mark this action as not legal to collapse.
166 CanBeCollapsedWithNextDependentAction = false;
167 }
168
169 /// Return true if this function can be collapsed with others.
171 return CanBeCollapsedWithNextDependentAction;
172 }
173
174 /// Return a string containing the offload kind of the action.
175 std::string getOffloadingKindPrefix() const;
176
177 /// Return a string that can be used as prefix in order to generate unique
178 /// files for each offloading kind. By default, no prefix is used for
179 /// non-device kinds, except if \a CreatePrefixForHost is set.
180 static std::string
182 StringRef NormalizedTriple,
183 bool CreatePrefixForHost = false);
184
185 /// Return a string containing a offload kind name.
186 static StringRef GetOffloadKindName(OffloadKind Kind);
187
188 /// Set the device offload info of this action and propagate it to its
189 /// dependences.
190 void propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch,
191 const ToolChain *OToolChain);
192
193 /// Append the host offload info of this action and propagate it to its
194 /// dependences.
195 void propagateHostOffloadInfo(unsigned OKinds, const char *OArch);
196
197 void setHostOffloadInfo(unsigned OKinds, const char *OArch) {
198 ActiveOffloadKindMask |= OKinds;
199 OffloadingArch = OArch;
200 }
201
202 /// Set the offload info of this action to be the same as the provided action,
203 /// and propagate it to its dependences.
204 void propagateOffloadInfo(const Action *A);
205
208 }
209
211 const char *getOffloadingArch() const { return OffloadingArch; }
213 return OffloadingToolChain;
214 }
215
216 /// Check if this action have any offload kinds. Note that host offload kinds
217 /// are only set if the action is a dependence to a host offload action.
218 bool isHostOffloading(unsigned int OKind) const {
219 return ActiveOffloadKindMask & OKind;
220 }
221 bool isDeviceOffloading(OffloadKind OKind) const {
222 return OffloadingDeviceKind == OKind;
223 }
224 bool isOffloading(OffloadKind OKind) const {
225 return isHostOffloading(OKind) || isDeviceOffloading(OKind);
226 }
227};
228
229class InputAction : public Action {
230 const llvm::opt::Arg &Input;
231 std::string Id;
232 virtual void anchor();
233
234public:
235 InputAction(const llvm::opt::Arg &Input, types::ID Type,
236 StringRef Id = StringRef());
237
238 const llvm::opt::Arg &getInputArg() const { return Input; }
239
240 void setId(StringRef _Id) { Id = _Id.str(); }
241 StringRef getId() const { return Id; }
242
243 static bool classof(const Action *A) {
244 return A->getKind() == InputClass;
245 }
246};
247
248class BindArchAction : public Action {
249 virtual void anchor();
250
251 /// The architecture to bind, or 0 if the default architecture
252 /// should be bound.
253 StringRef ArchName;
254
255public:
256 BindArchAction(Action *Input, StringRef ArchName);
257
258 StringRef getArchName() const { return ArchName; }
259
260 static bool classof(const Action *A) {
261 return A->getKind() == BindArchClass;
262 }
263};
264
265/// An offload action combines host or/and device actions according to the
266/// programming model implementation needs and propagates the offloading kind to
267/// its dependences.
268class OffloadAction final : public Action {
269 virtual void anchor();
270
271public:
272 /// Type used to communicate device actions. It associates bound architecture,
273 /// toolchain, and offload kind to each action.
274 class DeviceDependences final {
275 public:
279
280 private:
281 // Lists that keep the information for each dependency. All the lists are
282 // meant to be updated in sync. We are adopting separate lists instead of a
283 // list of structs, because that simplifies forwarding the actions list to
284 // initialize the inputs of the base Action class.
285
286 /// The dependence actions.
287 ActionList DeviceActions;
288
289 /// The offloading toolchains that should be used with the action.
290 ToolChainList DeviceToolChains;
291
292 /// The architectures that should be used with this action.
293 BoundArchList DeviceBoundArchs;
294
295 /// The offload kind of each dependence.
296 OffloadKindList DeviceOffloadKinds;
297
298 public:
299 /// Add an action along with the associated toolchain, bound arch, and
300 /// offload kind.
301 void add(Action &A, const ToolChain &TC, const char *BoundArch,
302 OffloadKind OKind);
303
304 /// Add an action along with the associated toolchain, bound arch, and
305 /// offload kinds.
306 void add(Action &A, const ToolChain &TC, const char *BoundArch,
307 unsigned OffloadKindMask);
308
309 /// Get each of the individual arrays.
310 const ActionList &getActions() const { return DeviceActions; }
311 const ToolChainList &getToolChains() const { return DeviceToolChains; }
312 const BoundArchList &getBoundArchs() const { return DeviceBoundArchs; }
314 return DeviceOffloadKinds;
315 }
316 };
317
318 /// Type used to communicate host actions. It associates bound architecture,
319 /// toolchain, and offload kinds to the host action.
320 class HostDependence final {
321 /// The dependence action.
322 Action &HostAction;
323
324 /// The offloading toolchain that should be used with the action.
325 const ToolChain &HostToolChain;
326
327 /// The architectures that should be used with this action.
328 const char *HostBoundArch = nullptr;
329
330 /// The offload kind of each dependence.
331 unsigned HostOffloadKinds = 0u;
332
333 public:
334 HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
335 const unsigned OffloadKinds)
336 : HostAction(A), HostToolChain(TC), HostBoundArch(BoundArch),
337 HostOffloadKinds(OffloadKinds) {}
338
339 /// Constructor version that obtains the offload kinds from the device
340 /// dependencies.
341 HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
342 const DeviceDependences &DDeps);
343 Action *getAction() const { return &HostAction; }
344 const ToolChain *getToolChain() const { return &HostToolChain; }
345 const char *getBoundArch() const { return HostBoundArch; }
346 unsigned getOffloadKinds() const { return HostOffloadKinds; }
347 };
348
350 llvm::function_ref<void(Action *, const ToolChain *, const char *)>;
351
352private:
353 /// The host offloading toolchain that should be used with the action.
354 const ToolChain *HostTC = nullptr;
355
356 /// The tool chains associated with the list of actions.
358
359public:
360 OffloadAction(const HostDependence &HDep);
361 OffloadAction(const DeviceDependences &DDeps, types::ID Ty);
362 OffloadAction(const HostDependence &HDep, const DeviceDependences &DDeps);
363
364 /// Execute the work specified in \a Work on the host dependence.
365 void doOnHostDependence(const OffloadActionWorkTy &Work) const;
366
367 /// Execute the work specified in \a Work on each device dependence.
368 void doOnEachDeviceDependence(const OffloadActionWorkTy &Work) const;
369
370 /// Execute the work specified in \a Work on each dependence.
371 void doOnEachDependence(const OffloadActionWorkTy &Work) const;
372
373 /// Execute the work specified in \a Work on each host or device dependence if
374 /// \a IsHostDependenceto is true or false, respectively.
375 void doOnEachDependence(bool IsHostDependence,
376 const OffloadActionWorkTy &Work) const;
377
378 /// Return true if the action has a host dependence.
379 bool hasHostDependence() const;
380
381 /// Return the host dependence of this action. This function is only expected
382 /// to be called if the host dependence exists.
383 Action *getHostDependence() const;
384
385 /// Return true if the action has a single device dependence. If \a
386 /// DoNotConsiderHostActions is set, ignore the host dependence, if any, while
387 /// accounting for the number of dependences.
388 bool hasSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
389
390 /// Return the single device dependence of this action. This function is only
391 /// expected to be called if a single device dependence exists. If \a
392 /// DoNotConsiderHostActions is set, a host dependence is allowed.
393 Action *
394 getSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
395
396 static bool classof(const Action *A) { return A->getKind() == OffloadClass; }
397};
398
399class JobAction : public Action {
400 virtual void anchor();
401
402protected:
404 JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type);
405
406public:
407 static bool classof(const Action *A) {
408 return (A->getKind() >= JobClassFirst &&
409 A->getKind() <= JobClassLast);
410 }
411};
412
414 void anchor() override;
415
416public:
417 PreprocessJobAction(Action *Input, types::ID OutputType);
418
419 static bool classof(const Action *A) {
420 return A->getKind() == PreprocessJobClass;
421 }
422};
423
425 void anchor() override;
426
427protected:
428 PrecompileJobAction(ActionClass Kind, Action *Input, types::ID OutputType);
429
430public:
431 PrecompileJobAction(Action *Input, types::ID OutputType);
432
433 static bool classof(const Action *A) {
434 return A->getKind() == PrecompileJobClass;
435 }
436};
437
439 void anchor() override;
440
441public:
442 ExtractAPIJobAction(Action *Input, types::ID OutputType);
443
444 static bool classof(const Action *A) {
445 return A->getKind() == ExtractAPIJobClass;
446 }
447
448 void addHeaderInput(Action *Input) { getInputs().push_back(Input); }
449};
450
452 void anchor() override;
453
454public:
455 AnalyzeJobAction(Action *Input, types::ID OutputType);
456
457 static bool classof(const Action *A) {
458 return A->getKind() == AnalyzeJobClass;
459 }
460};
461
463 void anchor() override;
464
465public:
466 MigrateJobAction(Action *Input, types::ID OutputType);
467
468 static bool classof(const Action *A) {
469 return A->getKind() == MigrateJobClass;
470 }
471};
472
474 void anchor() override;
475
476public:
477 CompileJobAction(Action *Input, types::ID OutputType);
478
479 static bool classof(const Action *A) {
480 return A->getKind() == CompileJobClass;
481 }
482};
483
485 void anchor() override;
486
487public:
488 BackendJobAction(Action *Input, types::ID OutputType);
489
490 static bool classof(const Action *A) {
491 return A->getKind() == BackendJobClass;
492 }
493};
494
496 void anchor() override;
497
498public:
499 AssembleJobAction(Action *Input, types::ID OutputType);
500
501 static bool classof(const Action *A) {
502 return A->getKind() == AssembleJobClass;
503 }
504};
505
507 void anchor() override;
508
509public:
511
512 static bool classof(const Action *A) {
513 return A->getKind() == IfsMergeJobClass;
514 }
515};
516
517class LinkJobAction : public JobAction {
518 void anchor() override;
519
520public:
522
523 static bool classof(const Action *A) {
524 return A->getKind() == LinkJobClass;
525 }
526};
527
528class LipoJobAction : public JobAction {
529 void anchor() override;
530
531public:
533
534 static bool classof(const Action *A) {
535 return A->getKind() == LipoJobClass;
536 }
537};
538
540 void anchor() override;
541
542public:
544
545 static bool classof(const Action *A) {
546 return A->getKind() == DsymutilJobClass;
547 }
548};
549
551 void anchor() override;
552
553public:
555
556 static bool classof(const Action *A) {
557 return A->getKind() == VerifyDebugInfoJobClass ||
559 }
560};
561
563 void anchor() override;
564
565public:
567
568 static bool classof(const Action *A) {
569 return A->getKind() == VerifyDebugInfoJobClass;
570 }
571};
572
574 void anchor() override;
575
576public:
578
579 static bool classof(const Action *A) {
580 return A->getKind() == VerifyPCHJobClass;
581 }
582};
583
585 void anchor() override;
586
587public:
588 // Offloading bundling doesn't change the type of output.
590
591 static bool classof(const Action *A) {
592 return A->getKind() == OffloadBundlingJobClass;
593 }
594};
595
597 void anchor() override;
598
599public:
600 /// Type that provides information about the actions that depend on this
601 /// unbundling action.
602 struct DependentActionInfo final {
603 /// The tool chain of the dependent action.
605
606 /// The bound architecture of the dependent action.
608
609 /// The offload kind of the dependent action.
611
613 StringRef DependentBoundArch,
618 };
619
620private:
621 /// Container that keeps information about each dependence of this unbundling
622 /// action.
623 SmallVector<DependentActionInfo, 6> DependentActionInfoArray;
624
625public:
626 // Offloading unbundling doesn't change the type of output.
628
629 /// Register information about a dependent action.
630 void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch,
631 OffloadKind Kind) {
632 DependentActionInfoArray.push_back({TC, BoundArch, Kind});
633 }
634
635 /// Return the information about all depending actions.
637 return DependentActionInfoArray;
638 }
639
640 static bool classof(const Action *A) {
641 return A->getKind() == OffloadUnbundlingJobClass;
642 }
643};
644
646 void anchor() override;
647
648public:
650
651 static bool classof(const Action *A) {
652 return A->getKind() == OffloadPackagerJobClass;
653 }
654};
655
657 void anchor() override;
658
659public:
661
662 static bool classof(const Action *A) {
663 return A->getKind() == LinkerWrapperJobClass;
664 }
665};
666
668 void anchor() override;
669
670public:
672
673 static bool classof(const Action *A) {
674 return A->getKind() == StaticLibJobClass;
675 }
676};
677
679 void anchor() override;
680
681public:
683
684 static bool classof(const Action *A) {
685 return A->getKind() == BinaryAnalyzeJobClass;
686 }
687};
688
689} // namespace driver
690} // namespace clang
691
692#endif // LLVM_CLANG_DRIVER_ACTION_H
int Id
Definition: ASTDiff.cpp:190
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
The base class of the type hierarchy.
Definition: Type.h:1606
Action - Represent an abstract compilation step to perform.
Definition: Action.h:47
void setHostOffloadInfo(unsigned OKinds, const char *OArch)
Definition: Action.h:197
input_const_iterator input_begin() const
Definition: Action.h:158
OffloadKind OffloadingDeviceKind
Offloading kind of the device.
Definition: Action.h:126
Action(ActionClass Kind, types::ID Type)
Definition: Action.h:134
const char * getOffloadingArch() const
Definition: Action.h:211
size_type size() const
Definition: Action.h:153
bool isCollapsingWithNextDependentActionLegal() const
Return true if this function can be collapsed with others.
Definition: Action.h:170
types::ID getType() const
Definition: Action.h:148
void setCannotBeCollapsedWithNextDependentAction()
Mark this action as not legal to collapse.
Definition: Action.h:165
std::string getOffloadingKindPrefix() const
Return a string containing the offload kind of the action.
Definition: Action.cpp:101
ActionList::size_type size_type
Definition: Action.h:49
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:58
const ToolChain * getOffloadingToolChain() const
Definition: Action.h:212
input_iterator input_end()
Definition: Action.h:156
const ToolChain * OffloadingToolChain
The Offloading toolchain associated with this device action.
Definition: Action.h:132
Action(ActionClass Kind, Action *Input, types::ID Type)
Definition: Action.h:135
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:140
Action(ActionClass Kind, Action *Input)
Definition: Action.h:137
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:92
const ActionList & getInputs() const
Definition: Action.h:151
ActionClass getKind() const
Definition: Action.h:147
ActionList::iterator input_iterator
Definition: Action.h:50
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
Definition: Action.cpp:156
input_const_range inputs() const
Definition: Action.h:160
const char * getClassName() const
Definition: Action.h:145
OffloadKind getOffloadingDeviceKind() const
Definition: Action.h:210
input_const_iterator input_end() const
Definition: Action.h:159
input_iterator input_begin()
Definition: Action.h:155
void propagateHostOffloadInfo(unsigned OKinds, const char *OArch)
Append the host offload info of this action and propagate it to its dependences.
Definition: Action.cpp:78
unsigned ActiveOffloadKindMask
Offload information.
Definition: Action.h:123
input_range inputs()
Definition: Action.h:157
Action(ActionClass Kind, const ActionList &Inputs, types::ID Type)
Definition: Action.h:139
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
Definition: Action.h:218
bool isDeviceOffloading(OffloadKind OKind) const
Definition: Action.h:221
ActionList::const_iterator input_const_iterator
Definition: Action.h:51
const char * OffloadingArch
The Offloading architecture associated with this action.
Definition: Action.h:129
ActionList & getInputs()
Definition: Action.h:150
llvm::iterator_range< input_iterator > input_range
Definition: Action.h:52
llvm::iterator_range< input_const_iterator > input_const_range
Definition: Action.h:53
unsigned getOffloadingHostActiveKinds() const
Definition: Action.h:206
bool isOffloading(OffloadKind OKind) const
Definition: Action.h:224
static bool classof(const Action *A)
Definition: Action.h:457
static bool classof(const Action *A)
Definition: Action.h:501
static bool classof(const Action *A)
Definition: Action.h:490
static bool classof(const Action *A)
Definition: Action.h:684
static bool classof(const Action *A)
Definition: Action.h:260
StringRef getArchName() const
Definition: Action.h:258
static bool classof(const Action *A)
Definition: Action.h:479
static bool classof(const Action *A)
Definition: Action.h:545
static bool classof(const Action *A)
Definition: Action.h:444
void addHeaderInput(Action *Input)
Definition: Action.h:448
static bool classof(const Action *A)
Definition: Action.h:512
void setId(StringRef _Id)
Definition: Action.h:240
const llvm::opt::Arg & getInputArg() const
Definition: Action.h:238
static bool classof(const Action *A)
Definition: Action.h:243
StringRef getId() const
Definition: Action.h:241
static bool classof(const Action *A)
Definition: Action.h:407
static bool classof(const Action *A)
Definition: Action.h:523
static bool classof(const Action *A)
Definition: Action.h:662
static bool classof(const Action *A)
Definition: Action.h:534
static bool classof(const Action *A)
Definition: Action.h:468
Type used to communicate device actions.
Definition: Action.h:274
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:306
const BoundArchList & getBoundArchs() const
Definition: Action.h:312
const OffloadKindList & getOffloadKinds() const
Definition: Action.h:313
const ActionList & getActions() const
Get each of the individual arrays.
Definition: Action.h:310
const ToolChainList & getToolChains() const
Definition: Action.h:311
Type used to communicate host actions.
Definition: Action.h:320
HostDependence(Action &A, const ToolChain &TC, const char *BoundArch, const unsigned OffloadKinds)
Definition: Action.h:334
const ToolChain * getToolChain() const
Definition: Action.h:344
An offload action combines host or/and device actions according to the programming model implementati...
Definition: Action.h:268
void doOnEachDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on each dependence.
Definition: Action.cpp:269
Action * getSingleDeviceDependence(bool DoNotConsiderHostActions=false) const
Return the single device dependence of this action.
Definition: Action.cpp:298
bool hasSingleDeviceDependence(bool DoNotConsiderHostActions=false) const
Return true if the action has a single device dependence.
Definition: Action.cpp:290
Action * getHostDependence() const
Return the host dependence of this action.
Definition: Action.cpp:284
llvm::function_ref< void(Action *, const ToolChain *, const char *)> OffloadActionWorkTy
Definition: Action.h:350
void doOnEachDeviceDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on each device dependence.
Definition: Action.cpp:247
bool hasHostDependence() const
Return true if the action has a host dependence.
Definition: Action.cpp:282
static bool classof(const Action *A)
Definition: Action.h:396
void doOnHostDependence(const OffloadActionWorkTy &Work) const
Execute the work specified in Work on the host dependence.
Definition: Action.cpp:239
static bool classof(const Action *A)
Definition: Action.h:591
static bool classof(const Action *A)
Definition: Action.h:651
static bool classof(const Action *A)
Definition: Action.h:640
void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch, OffloadKind Kind)
Register information about a dependent action.
Definition: Action.h:630
ArrayRef< DependentActionInfo > getDependentActionsInfo() const
Return the information about all depending actions.
Definition: Action.h:636
static bool classof(const Action *A)
Definition: Action.h:433
static bool classof(const Action *A)
Definition: Action.h:419
static bool classof(const Action *A)
Definition: Action.h:673
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:92
static bool classof(const Action *A)
Definition: Action.h:568
static bool classof(const Action *A)
Definition: Action.h:556
static bool classof(const Action *A)
Definition: Action.h:579
The JSON file list parser is used to communicate input to InstallAPI.
YAML serialization mapping.
Definition: Dominators.h:30
Type that provides information about the actions that depend on this unbundling action.
Definition: Action.h:602
const OffloadKind DependentOffloadKind
The offload kind of the dependent action.
Definition: Action.h:610
DependentActionInfo(const ToolChain *DependentToolChain, StringRef DependentBoundArch, const OffloadKind DependentOffloadKind)
Definition: Action.h:612
StringRef DependentBoundArch
The bound architecture of the dependent action.
Definition: Action.h:607
const ToolChain * DependentToolChain
The tool chain of the dependent action.
Definition: Action.h:604