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
55 enum ActionClass {
56 InputClass = 0,
57 BindArchClass,
58 OffloadClass,
59 PreprocessJobClass,
60 PrecompileJobClass,
61 ExtractAPIJobClass,
62 AnalyzeJobClass,
63 MigrateJobClass,
64 CompileJobClass,
65 BackendJobClass,
66 AssembleJobClass,
67 LinkJobClass,
68 IfsMergeJobClass,
69 LipoJobClass,
70 DsymutilJobClass,
71 VerifyDebugInfoJobClass,
72 VerifyPCHJobClass,
73 OffloadBundlingJobClass,
74 OffloadUnbundlingJobClass,
75 OffloadPackagerJobClass,
76 LinkerWrapperJobClass,
77 StaticLibJobClass,
78 BinaryAnalyzeJobClass,
79
80 JobClassFirst = PreprocessJobClass,
81 JobClassLast = BinaryAnalyzeJobClass
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.
87 enum OffloadKind {
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.
105 types::ID Type;
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.
123 unsigned ActiveOffloadKindMask = 0u;
124
125 /// Offloading kind of the device.
126 OffloadKind OffloadingDeviceKind = OFK_None;
127
128 /// The Offloading architecture associated with this action.
129 const char *OffloadingArch = nullptr;
130
131 /// The Offloading toolchain associated with this device action.
132 const ToolChain *OffloadingToolChain = nullptr;
133
134 Action(ActionClass Kind, types::ID Type) : Action(Kind, ActionList(), Type) {}
135 Action(ActionClass Kind, Action *Input, types::ID Type)
136 : Action(Kind, ActionList({Input}), Type) {}
137 Action(ActionClass Kind, Action *Input)
138 : Action(Kind, ActionList({Input}), Input->getType()) {}
139 Action(ActionClass Kind, const ActionList &Inputs, types::ID Type)
140 : Kind(Kind), Type(Type), Inputs(Inputs) {}
141
142public:
143 virtual ~Action();
144
145 const char *getClassName() const { return Action::getClassName(AC: 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(); }
157 input_range inputs() { return input_range(input_begin(), input_end()); }
158 input_const_iterator input_begin() const { return Inputs.begin(); }
159 input_const_iterator input_end() const { return Inputs.end(); }
160 input_const_range inputs() const {
161 return input_const_range(input_begin(), input_end());
162 }
163
164 /// Mark this action as not legal to collapse.
165 void setCannotBeCollapsedWithNextDependentAction() {
166 CanBeCollapsedWithNextDependentAction = false;
167 }
168
169 /// Return true if this function can be collapsed with others.
170 bool isCollapsingWithNextDependentActionLegal() const {
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
181 GetOffloadingFileNamePrefix(OffloadKind Kind,
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
206 unsigned getOffloadingHostActiveKinds() const {
207 return ActiveOffloadKindMask;
208 }
209
210 OffloadKind getOffloadingDeviceKind() const { return OffloadingDeviceKind; }
211 const char *getOffloadingArch() const { return OffloadingArch; }
212 const ToolChain *getOffloadingToolChain() const {
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:
276 using ToolChainList = SmallVector<const ToolChain *, 3>;
277 using BoundArchList = SmallVector<const char *, 3>;
278 using OffloadKindList = SmallVector<OffloadKind, 3>;
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; }
313 const OffloadKindList &getOffloadKinds() const {
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
349 using OffloadActionWorkTy =
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.
357 DeviceDependences::ToolChainList DevToolChains;
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:
403 JobAction(ActionClass Kind, Action *Input, types::ID Type);
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
413class PreprocessJobAction : public JobAction {
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
424class PrecompileJobAction : public JobAction {
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
438class ExtractAPIJobAction : public JobAction {
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(Elt: Input); }
449};
450
451class AnalyzeJobAction : public JobAction {
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
462class MigrateJobAction : public JobAction {
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
473class CompileJobAction : public JobAction {
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
484class BackendJobAction : public JobAction {
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
495class AssembleJobAction : public JobAction {
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
506class IfsMergeJobAction : public JobAction {
507 void anchor() override;
508
509public:
510 IfsMergeJobAction(ActionList &Inputs, types::ID Type);
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:
521 LinkJobAction(ActionList &Inputs, types::ID Type);
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:
532 LipoJobAction(ActionList &Inputs, types::ID Type);
533
534 static bool classof(const Action *A) {
535 return A->getKind() == LipoJobClass;
536 }
537};
538
539class DsymutilJobAction : public JobAction {
540 void anchor() override;
541
542public:
543 DsymutilJobAction(ActionList &Inputs, types::ID Type);
544
545 static bool classof(const Action *A) {
546 return A->getKind() == DsymutilJobClass;
547 }
548};
549
550class VerifyJobAction : public JobAction {
551 void anchor() override;
552
553public:
554 VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type);
555
556 static bool classof(const Action *A) {
557 return A->getKind() == VerifyDebugInfoJobClass ||
558 A->getKind() == VerifyPCHJobClass;
559 }
560};
561
562class VerifyDebugInfoJobAction : public VerifyJobAction {
563 void anchor() override;
564
565public:
566 VerifyDebugInfoJobAction(Action *Input, types::ID Type);
567
568 static bool classof(const Action *A) {
569 return A->getKind() == VerifyDebugInfoJobClass;
570 }
571};
572
573class VerifyPCHJobAction : public VerifyJobAction {
574 void anchor() override;
575
576public:
577 VerifyPCHJobAction(Action *Input, types::ID Type);
578
579 static bool classof(const Action *A) {
580 return A->getKind() == VerifyPCHJobClass;
581 }
582};
583
584class OffloadBundlingJobAction : public JobAction {
585 void anchor() override;
586
587public:
588 // Offloading bundling doesn't change the type of output.
589 OffloadBundlingJobAction(ActionList &Inputs);
590
591 static bool classof(const Action *A) {
592 return A->getKind() == OffloadBundlingJobClass;
593 }
594};
595
596class OffloadUnbundlingJobAction final : public JobAction {
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.
604 const ToolChain *DependentToolChain = nullptr;
605
606 /// The bound architecture of the dependent action.
607 StringRef DependentBoundArch;
608
609 /// The offload kind of the dependent action.
610 const OffloadKind DependentOffloadKind = OFK_None;
611
612 DependentActionInfo(const ToolChain *DependentToolChain,
613 StringRef DependentBoundArch,
614 const OffloadKind DependentOffloadKind)
615 : DependentToolChain(DependentToolChain),
616 DependentBoundArch(DependentBoundArch),
617 DependentOffloadKind(DependentOffloadKind) {}
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.
627 OffloadUnbundlingJobAction(Action *Input);
628
629 /// Register information about a dependent action.
630 void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch,
631 OffloadKind Kind) {
632 DependentActionInfoArray.push_back(Elt: {TC, BoundArch, Kind});
633 }
634
635 /// Return the information about all depending actions.
636 ArrayRef<DependentActionInfo> getDependentActionsInfo() const {
637 return DependentActionInfoArray;
638 }
639
640 static bool classof(const Action *A) {
641 return A->getKind() == OffloadUnbundlingJobClass;
642 }
643};
644
645class OffloadPackagerJobAction : public JobAction {
646 void anchor() override;
647
648public:
649 OffloadPackagerJobAction(ActionList &Inputs, types::ID Type);
650
651 static bool classof(const Action *A) {
652 return A->getKind() == OffloadPackagerJobClass;
653 }
654};
655
656class LinkerWrapperJobAction : public JobAction {
657 void anchor() override;
658
659public:
660 LinkerWrapperJobAction(ActionList &Inputs, types::ID Type);
661
662 static bool classof(const Action *A) {
663 return A->getKind() == LinkerWrapperJobClass;
664 }
665};
666
667class StaticLibJobAction : public JobAction {
668 void anchor() override;
669
670public:
671 StaticLibJobAction(ActionList &Inputs, types::ID Type);
672
673 static bool classof(const Action *A) {
674 return A->getKind() == StaticLibJobClass;
675 }
676};
677
678class BinaryAnalyzeJobAction : public JobAction {
679 void anchor() override;
680
681public:
682 BinaryAnalyzeJobAction(Action *Input, types::ID Type);
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
693

source code of clang/include/clang/Driver/Action.h