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