|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/Driver/Action.h 214 class InputAction : public Action {
229 class BindArchAction : public Action {
249 class OffloadAction final : public Action {
375 class JobAction : public Action {
Declarations
tools/clang/include/clang/Driver/Job.h 27 class Action;
tools/clang/include/clang/Driver/Util.h 19 class Action;
References
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
tools/clang/include/clang/Driver/Action.h 129 Action(ActionClass Kind, Action *Input, types::ID Type)
131 Action(ActionClass Kind, Action *Input)
139 const char *getClassName() const { return Action::getClassName(getKind()); }
192 void propagateOffloadInfo(const Action *A);
214 class InputAction : public Action {
224 static bool classof(const Action *A) {
229 class BindArchAction : public Action {
237 BindArchAction(Action *Input, StringRef ArchName);
241 static bool classof(const Action *A) {
249 class OffloadAction final : public Action {
282 void add(Action &A, const ToolChain &TC, const char *BoundArch,
298 Action &HostAction;
310 HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
317 HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
319 Action *getAction() const { return &HostAction; }
326 llvm::function_ref<void(Action *, const ToolChain *, const char *)>;
359 Action *getHostDependence() const;
369 Action *
372 static bool classof(const Action *A) { return A->getKind() == OffloadClass; }
375 class JobAction : public Action {
379 JobAction(ActionClass Kind, Action *Input, types::ID Type);
383 static bool classof(const Action *A) {
393 PreprocessJobAction(Action *Input, types::ID OutputType);
395 static bool classof(const Action *A) {
404 PrecompileJobAction(ActionClass Kind, Action *Input, types::ID OutputType);
407 PrecompileJobAction(Action *Input, types::ID OutputType);
409 static bool classof(const Action *A) {
421 HeaderModulePrecompileJobAction(Action *Input, types::ID OutputType,
424 static bool classof(const Action *A) {
428 void addModuleHeaderInput(Action *Input) {
439 AnalyzeJobAction(Action *Input, types::ID OutputType);
441 static bool classof(const Action *A) {
450 MigrateJobAction(Action *Input, types::ID OutputType);
452 static bool classof(const Action *A) {
461 CompileJobAction(Action *Input, types::ID OutputType);
463 static bool classof(const Action *A) {
472 BackendJobAction(Action *Input, types::ID OutputType);
474 static bool classof(const Action *A) {
483 AssembleJobAction(Action *Input, types::ID OutputType);
485 static bool classof(const Action *A) {
496 static bool classof(const Action *A) {
507 static bool classof(const Action *A) {
518 static bool classof(const Action *A) {
529 static bool classof(const Action *A) {
538 VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type);
540 static bool classof(const Action *A) {
550 VerifyDebugInfoJobAction(Action *Input, types::ID Type);
552 static bool classof(const Action *A) {
561 VerifyPCHJobAction(Action *Input, types::ID Type);
563 static bool classof(const Action *A) {
575 static bool classof(const Action *A) {
611 OffloadUnbundlingJobAction(Action *Input);
624 static bool classof(const Action *A) {
635 static bool classof(const Action *A) {
tools/clang/include/clang/Driver/Compilation.h 60 std::multimap<Action::OffloadKind, const ToolChain *>
72 std::vector<std::unique_ptr<Action>> AllActions;
86 Action::OffloadKind DeviceOffloadKind = Action::OFK_None;
86 Action::OffloadKind DeviceOffloadKind = Action::OFK_None;
89 Action::OffloadKind DeviceOffloadKind)
137 unsigned isOffloadingHostKind(Action::OffloadKind Kind) const {
143 const std::multimap<Action::OffloadKind,
174 Action::OffloadKind OffloadKind) {
198 AllActions.push_back(std::unique_ptr<Action>(RawPtr));
228 Action::OffloadKind DeviceOffloadKind);
tools/clang/include/clang/Driver/Driver.h 484 Action *ConstructPhaseAction(
486 Action *Input,
487 Action::OffloadKind TargetDeviceOffloadKind = Action::OFK_None) const;
487 Action::OffloadKind TargetDeviceOffloadKind = Action::OFK_None) const;
493 BuildJobsForAction(Compilation &C, const Action *A, const ToolChain *TC,
496 std::map<std::pair<const Action *, std::string>, InputInfo>
498 Action::OffloadKind TargetDeviceOffloadKind) const;
581 Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
583 std::map<std::pair<const Action *, std::string>, InputInfo>
585 Action::OffloadKind TargetDeviceOffloadKind) const;
tools/clang/include/clang/Driver/Job.h 43 const Action &Source;
89 Command(const Action &Source, const Tool &Creator, const char *Executable,
104 const Action &getSource() const { return Source; }
139 FallbackCommand(const Action &Source_, const Tool &Creator_,
158 ForceSuccessCommand(const Action &Source_, const Tool &Creator_,
tools/clang/include/clang/Driver/ToolChain.h 173 virtual Tool *getTool(Action::ActionClass AC) const;
283 Action::OffloadKind DeviceOffloadKind) const {
tools/clang/include/clang/Driver/Util.h 26 typedef SmallVector<Action*, 3> ActionList;
tools/clang/lib/Driver/Action.cpp 65 for (auto *A : Inputs)
79 for (auto *A : Inputs)
83 void Action::propagateOffloadInfo(const Action *A) {
171 BindArchAction::BindArchAction(Action *Input, StringRef ArchName)
216 if (auto *A = DDeps.getActions()[i]) {
227 auto *A = getInputs().front();
268 Action *OffloadAction::getHostDependence() const {
281 Action *
290 void OffloadAction::DeviceDependences::add(Action &A, const ToolChain &TC,
299 OffloadAction::HostDependence::HostDependence(Action &A, const ToolChain &TC,
309 JobAction::JobAction(ActionClass Kind, Action *Input, types::ID Type)
317 PreprocessJobAction::PreprocessJobAction(Action *Input, types::ID OutputType)
322 PrecompileJobAction::PrecompileJobAction(Action *Input, types::ID OutputType)
325 PrecompileJobAction::PrecompileJobAction(ActionClass Kind, Action *Input,
334 Action *Input, types::ID OutputType, const char *ModuleName)
340 AnalyzeJobAction::AnalyzeJobAction(Action *Input, types::ID OutputType)
345 MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType)
350 CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType)
355 BackendJobAction::BackendJobAction(Action *Input, types::ID OutputType)
360 AssembleJobAction::AssembleJobAction(Action *Input, types::ID OutputType)
385 VerifyJobAction::VerifyJobAction(ActionClass Kind, Action *Input,
394 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(Action *Input,
400 VerifyPCHJobAction::VerifyPCHJobAction(Action *Input, types::ID Type)
410 OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(Action *Input)
tools/clang/lib/Driver/Compilation.cpp 43 std::make_pair(Action::OFK_Host, &DefaultToolChain));
63 Action::OffloadKind DeviceOffloadKind) {
72 if (DeviceOffloadKind == Action::OFK_OpenMP) {
73 const ToolChain *HostTC = getSingleOffloadToolChain<Action::OFK_Host>();
196 static bool ActionFailed(const Action *A,
204 if (A->isOffloading(Action::OFK_Cuda) || A->isOffloading(Action::OFK_HIP))
204 if (A->isOffloading(Action::OFK_Cuda) || A->isOffloading(Action::OFK_HIP))
211 for (const auto *AI : A->inputs())
tools/clang/lib/Driver/Driver.cpp 621 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
624 auto OFK = Action::OFK_Cuda;
637 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
640 auto OFK = Action::OFK_HIP;
700 C.getSingleOffloadToolChain<Action::OFK_Host>();
706 *this, TT, *HostTC, C.getInputArgs(), Action::OFK_OpenMP);
710 C.addOffloadDeviceToolChain(TC, Action::OFK_OpenMP);
1815 static unsigned PrintActions1(const Compilation &C, Action *A,
1816 std::map<Action *, unsigned> &Ids,
1830 os << Action::getClassName(A->getKind()) << ", ";
1867 for (Action *PreRequisite : *AL) {
1906 std::map<Action *, unsigned> Ids;
1907 for (Action *A : C.getActions())
1913 static bool ContainsCompileOrAssembleAction(const Action *A) {
1918 for (const Action *Input : A->inputs())
1961 for (Action* Act : SingleActions) {
2003 Action* LastAction = Actions.back();
2277 Action::OffloadKind AssociatedOffloadKind = Action::OFK_None;
2277 Action::OffloadKind AssociatedOffloadKind = Action::OFK_None;
2299 virtual ActionBuilderReturnCode addDeviceDepences(Action *HostAction) {
2324 Action::OffloadKind getAssociatedOffloadKind() {
2347 Action *CudaFatBinary = nullptr;
2364 ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override {
2471 if (AssociatedOffloadKind == Action::OFK_Cuda &&
2472 !C.hasOffloadToolChain<Action::OFK_Cuda>())
2476 if (AssociatedOffloadKind == Action::OFK_HIP &&
2477 !C.hasOffloadToolChain<Action::OFK_HIP>())
2483 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
2496 AssociatedOffloadKind == Action::OFK_Cuda
2497 ? C.getSingleOffloadToolChain<Action::OFK_Cuda>()
2498 : C.getSingleOffloadToolChain<Action::OFK_HIP>());
2559 : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_Cuda) {
2600 C, Args, Ph, CudaDeviceActions[I], Action::OFK_Cuda);
2613 Action *AssembleAction = CudaDeviceActions[I];
2617 Action *BackendAction = AssembleAction->getInputs()[0];
2623 Action::OFK_Cuda);
2636 Action::OFK_Cuda);
2661 for (Action *&A : CudaDeviceActions)
2676 : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) {
2754 for (auto *A : CudaDeviceActions) {
2766 for (Action *&A : CudaDeviceActions)
2799 : DeviceActionBuilder(C, Args, Inputs, Action::OFK_OpenMP) {}
2818 for (auto *A : OpenMPDeviceActions) {
2830 for (Action *&A : OpenMPDeviceActions)
2836 ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override {
2864 ToolChains[I], /*BoundArch=*/StringRef(), Action::OFK_OpenMP);
2878 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
2879 /*BoundArch=*/nullptr, Action::OFK_OpenMP);
2881 for (Action *&A : OpenMPDeviceActions) {
2884 DDep.add(*A, **TC, /*BoundArch=*/nullptr, Action::OFK_OpenMP);
2902 for (auto *A : OpenMPDeviceActions) {
2904 Dep.add(*A, **TI, /*BoundArch=*/nullptr, Action::OFK_OpenMP);
2923 Action::OFK_OpenMP);
2936 auto OpenMPTCRange = C.getOffloadToolChains<Action::OFK_OpenMP>();
3009 Action *
3010 addDeviceDependencesToHostAction(Action *HostAction, const Arg *InputArg,
3060 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
3068 bool addHostDependenceToDeviceActions(Action *&HostAction,
3085 C.getSingleOffloadToolChain<Action::OFK_Host>(),
3086 /*BoundArch=*/StringRef(), Action::OFK_Host);
3112 if (OffloadKind == Action::OFK_None && CanUseBundler)
3157 Action* makeHostLinkAction() {
3180 Action *processHostLinkAction(Action *HostAction) {
3180 Action *processHostLinkAction(Action *HostAction) {
3209 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
3310 Action *ClangClPch = C.MakeAction<InputAction>(*InputArg, HeaderType);
3403 Action *Current = C.MakeAction<InputAction>(*InputArg, InputType);
3451 Action *NewCurrent = ConstructPhaseAction(C, Args, Phase, Current);
3481 if (Action *Wrapper = OffloadBuilder.makeHostLinkAction())
3483 Action *LA = C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image);
3498 Action *InputAc = C.MakeAction<InputAction>(*A, types::TY_C);
3514 Action *Driver::ConstructPhaseAction(
3515 Compilation &C, const ArgList &Args, phases::ID Phase, Action *Input,
3516 Action::OffloadKind TargetDeviceOffloadKind) const {
3599 if (isUsingLTO() && TargetDeviceOffloadKind == Action::OFK_None) {
3627 for (const Action *A : C.getActions())
3645 std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults;
3646 for (Action *A : C.getActions()) {
3666 /*TargetDeviceOffloadKind*/ Action::OFK_None);
3746 Action *CurAction = *Inputs.begin();
3933 for (Action *A : Inputs) {
3955 IsHostSelector = BaseAction->getOffloadingDeviceKind() == Action::OFK_None;
3973 const Action *CurAction = ActionChain.back().JA;
4017 Action::OffloadKind OffloadKind) {
4024 TriplePlusArch += Action::GetOffloadKindName(OffloadKind);
4029 Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
4031 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
4032 Action::OffloadKind TargetDeviceOffloadKind) const {
4033 std::pair<const Action *, std::string> ActionTC = {
4047 Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
4049 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
4050 Action::OffloadKind TargetDeviceOffloadKind) const {
4054 bool BuildingForOffloadDevice = TargetDeviceOffloadKind != Action::OFK_None;
4060 C.getArgsForToolChain(TC, BoundArch, Action::OFK_None);
4159 for (const auto *OA : CollapsedOffloadActions)
4171 for (const Action *Input : Inputs) {
4228 std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
4237 UI.DependentOffloadKind == Action::OFK_HIP,
4246 if (TargetDeviceOffloadKind == Action::OFK_HIP) {
4247 if (UI.DependentOffloadKind == Action::OFK_Host)
4261 std::pair<const Action *, std::string> ActionTC = {
4271 std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
4467 bool IsHIPNoRDC = JA.getOffloadingDeviceKind() == Action::OFK_HIP &&
tools/clang/lib/Driver/InputInfo.h 41 const Action* Act;
45 static types::ID GetActionType(const Action *A) {
51 InputInfo(const Action *A, const char *_BaseInput)
58 InputInfo(const Action *A, const char *_Filename, const char *_BaseInput)
68 InputInfo(const Action *A, const llvm::opt::Arg *_InputArg,
80 const Action *getAction() const { return Act; }
81 void setAction(const Action *A) { Act = A; }
tools/clang/lib/Driver/Job.cpp 36 Command::Command(const Action &Source, const Tool &Creator,
373 FallbackCommand::FallbackCommand(const Action &Source_, const Tool &Creator_,
415 const Action &Source_, const Tool &Creator_, const char *Executable_,
tools/clang/lib/Driver/ToolChain.cpp 301 Tool *ToolChain::getTool(Action::ActionClass AC) const {
303 case Action::AssembleJobClass:
306 case Action::IfsMergeJobClass:
309 case Action::LinkJobClass:
312 case Action::InputClass:
313 case Action::BindArchClass:
314 case Action::OffloadClass:
315 case Action::LipoJobClass:
316 case Action::DsymutilJobClass:
317 case Action::VerifyDebugInfoJobClass:
320 case Action::CompileJobClass:
321 case Action::PrecompileJobClass:
322 case Action::HeaderModulePrecompileJobClass:
323 case Action::PreprocessJobClass:
324 case Action::AnalyzeJobClass:
325 case Action::MigrateJobClass:
326 case Action::VerifyPCHJobClass:
327 case Action::BackendJobClass:
330 case Action::OffloadBundlingJobClass:
331 case Action::OffloadUnbundlingJobClass:
334 case Action::OffloadWrapperJobClass:
497 Action::ActionClass AC = JA.getKind();
498 if (AC == Action::AssembleJobClass && useIntegratedAs())
tools/clang/lib/Driver/ToolChains/AMDGPU.cpp 72 Action::OffloadKind DeviceOffloadKind) const {
tools/clang/lib/Driver/ToolChains/AMDGPU.h 64 Action::OffloadKind DeviceOffloadKind) const override;
tools/clang/lib/Driver/ToolChains/Clang.cpp 132 if (JA.isHostOffloading(Action::OFK_Cuda))
133 Work(*C.getSingleOffloadToolChain<Action::OFK_Cuda>());
134 else if (JA.isDeviceOffloading(Action::OFK_Cuda))
135 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>());
136 else if (JA.isHostOffloading(Action::OFK_HIP))
137 Work(*C.getSingleOffloadToolChain<Action::OFK_HIP>());
138 else if (JA.isDeviceOffloading(Action::OFK_HIP))
139 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>());
141 if (JA.isHostOffloading(Action::OFK_OpenMP)) {
142 auto TCs = C.getOffloadToolChains<Action::OFK_OpenMP>();
145 } else if (JA.isDeviceOffloading(Action::OFK_OpenMP))
146 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>());
830 static bool ContainsCompileAction(const Action *A) {
1078 if (JA.isOffloading(Action::OFK_Cuda))
1083 if (JA.isDeviceOffloading(Action::OFK_OpenMP) &&
1108 if (YcArg && JA.getKind() >= Action::PrecompileJobClass &&
1109 JA.getKind() <= Action::AssembleJobClass) {
3390 bool IsCuda = JA.isOffloading(Action::OFK_Cuda);
3391 bool IsHIP = JA.isOffloading(Action::OFK_HIP);
3392 bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP);
3467 if (JA.isDeviceOffloading(Action::OFK_Cuda) ||
3468 JA.isDeviceOffloading(Action::OFK_HIP))
3469 NormalizedTriple = C.getSingleOffloadToolChain<Action::OFK_Host>()
3475 (IsCuda ? C.getSingleOffloadToolChain<Action::OFK_Cuda>()
3476 : C.getSingleOffloadToolChain<Action::OFK_HIP>())
3483 C.getSingleOffloadToolChain<Action::OFK_Cuda>());
3498 C.getSingleOffloadToolChain<Action::OFK_Host>()
3629 bool isDeviceOffloadAction = !(JA.isDeviceOffloading(Action::OFK_None) ||
3630 JA.isDeviceOffloading(Action::OFK_Host));
4522 (JA.isDeviceOffloading(Action::OFK_None) ||
4523 JA.isDeviceOffloading(Action::OFK_OpenMP))) {
5145 if (!JA.isDeviceOffloading(Action::OFK_None) &&
5146 !JA.isDeviceOffloading(Action::OFK_Host)) {
5148 F += Action::GetOffloadingFileNamePrefix(JA.getOffloadingDeviceKind(),
5355 if (JA.isHostOffloading(Action::OFK_OpenMP)) {
6121 const Action *SourceAction = &JA;
6122 while (SourceAction->getKind() != Action::InputClass) {
6305 Action::OffloadKind CurKind = Action::OFK_Host;
6305 Action::OffloadKind CurKind = Action::OFK_Host;
6307 const Action *CurDep = JA.getInputs()[I];
6317 Triples += Action::GetOffloadKindName(CurKind);
6320 if (CurKind == Action::OFK_HIP && CurDep->getOffloadingArch()) {
6390 Triples += Action::GetOffloadKindName(Dep.DependentOffloadKind);
6393 if (Dep.DependentOffloadKind == Action::OFK_HIP &&
tools/clang/lib/Driver/ToolChains/CommonArgs.cpp 162 if ((JA.isHostOffloading(Action::OFK_OpenMP) &&
163 IA->isDeviceOffloading(Action::OFK_OpenMP)) ||
164 (JA.isHostOffloading(Action::OFK_HIP) &&
165 IA->isDeviceOffloading(Action::OFK_HIP)))
1271 if (!JA.isHostOffloading(Action::OFK_HIP))
1276 const Action *A = II.getAction();
1278 if (A && isa<LinkJobAction>(A) && A->isDeviceOffloading(Action::OFK_HIP)) {
1306 C.getSingleOffloadToolChain<Action::OFK_HIP>());
tools/clang/lib/Driver/ToolChains/Cuda.cpp 335 if (JA.isDeviceOffloading(Action::OFK_OpenMP)) {
408 if (JA.isOffloading(Action::OFK_OpenMP))
413 else if (JA.isOffloading(Action::OFK_Cuda))
577 const Action::OffloadKind OK)
591 if (!(OK == Action::OFK_OpenMP && Input.getType() == types::TY_Object))
613 if (DeviceOffloadingKind == Action::OFK_Cuda) {
635 if (DeviceOffloadingKind == Action::OFK_OpenMP &&
679 if (DeviceOffloadingKind == Action::OFK_OpenMP) {
762 Action::OffloadKind DeviceOffloadKind) const {
773 if (DeviceOffloadKind == Action::OFK_OpenMP) {
840 if (OK == Action::OFK_OpenMP)
tools/clang/lib/Driver/ToolChains/Cuda.h 137 const Action::OffloadKind OK);
147 Action::OffloadKind DeviceOffloadKind) const override;
195 const Action::OffloadKind OK;
tools/clang/lib/Driver/ToolChains/Darwin.cpp 95 const Action *SourceAction = &JA;
96 while (SourceAction->getKind() != Action::InputClass) {
879 Tool *MachO::getTool(Action::ActionClass AC) const {
881 case Action::LipoJobClass:
885 case Action::DsymutilJobClass:
889 case Action::VerifyDebugInfoJobClass:
2071 Action::OffloadKind) const {
2340 Action::OffloadKind DeviceOffloadKind) const {
tools/clang/lib/Driver/ToolChains/Darwin.h 132 Tool *getTool(Action::ActionClass AC) const override;
215 Action::OffloadKind DeviceOffloadKind) const override;
449 Action::OffloadKind DeviceOffloadKind) const override;
tools/clang/lib/Driver/ToolChains/Gnu.cpp 565 JA.isHostOffloading(Action::OFK_OpenMP),
2513 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2515 case Action::PreprocessJobClass:
2519 case Action::CompileJobClass:
2669 Action::OffloadKind DeviceOffloadKind) const {
2675 if (DeviceOffloadKind == Action::OFK_OpenMP) {
tools/clang/lib/Driver/ToolChains/Gnu.h 296 Action::OffloadKind DeviceOffloadKind) const override;
299 Tool *getTool(Action::ActionClass AC) const override;
tools/clang/lib/Driver/ToolChains/HIP.cpp 206 const auto* A = II.getAction();
360 Action::OffloadKind DeviceOffloadKind) const {
tools/clang/lib/Driver/ToolChains/HIP.h 86 Action::OffloadKind DeviceOffloadKind) const override;
tools/clang/lib/Driver/ToolChains/MSVC.cpp 1485 StringRef BoundArch, Action::OffloadKind) const {
tools/clang/lib/Driver/ToolChains/MSVC.h 73 Action::OffloadKind DeviceOffloadKind) const override;
tools/clang/lib/Driver/ToolChains/MinGW.cpp 405 Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {
407 case Action::PreprocessJobClass:
411 case Action::CompileJobClass:
tools/clang/lib/Driver/ToolChains/MinGW.h 88 Tool *getTool(Action::ActionClass AC) const override;
tools/clang/lib/Driver/ToolChains/Myriad.cpp 35 if (JA.getKind() == Action::PreprocessJobClass) {
66 C.getActions()[0]->getKind() == Action::AssembleJobClass) {
270 case Action::PreprocessJobClass:
271 case Action::CompileJobClass:
275 case Action::AssembleJobClass:
tools/clang/lib/Tooling/CompilationDatabase.cpp 152 void run(const driver::Action *A) {
157 void runImpl(const driver::Action *A, bool Collect) {
160 case driver::Action::CompileJobClass:
164 case driver::Action::InputClass:
176 for (const driver::Action *AI : A->inputs())
313 if (Cmd.getSource().getKind() == driver::Action::AssembleJobClass ||
314 Cmd.getSource().getKind() == driver::Action::BackendJobClass ||
315 Cmd.getSource().getKind() == driver::Action::CompileJobClass) {
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };