1 //===--- Action.cpp - Abstract compilation steps --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "clang/Driver/Action.h"
11 #include "llvm/Support/ErrorHandling.h"
12 #include <cassert>
13 using namespace clang::driver;
14 using namespace llvm::opt;
15 
16 Action::~Action() {
17   if (OwnsInputs) {
18     for (iterator it = begin(), ie = end(); it != ie; ++it)
19       delete *it;
20   }
21 }
22 
23 const char *Action::getClassName(ActionClass AC) {
24   switch (AC) {
25   case InputClass: return "input";
26   case BindArchClass: return "bind-arch";
27   case CudaDeviceClass: return "cuda-device";
28   case CudaHostClass: return "cuda-host";
29   case PreprocessJobClass: return "preprocessor";
30   case PrecompileJobClass: return "precompiler";
31   case AnalyzeJobClass: return "analyzer";
32   case MigrateJobClass: return "migrator";
33   case CompileJobClass: return "compiler";
34   case BackendJobClass: return "backend";
35   case AssembleJobClass: return "assembler";
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   }
42 
43   llvm_unreachable("invalid class");
44 }
45 
46 void InputAction::anchor() {}
47 
48 InputAction::InputAction(const Arg &_Input, types::ID _Type)
49   : Action(InputClass, _Type), Input(_Input) {
50 }
51 
52 void BindArchAction::anchor() {}
53 
54 BindArchAction::BindArchAction(std::unique_ptr<Action> Input,
55                                const char *_ArchName)
56     : Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}
57 
58 void CudaDeviceAction::anchor() {}
59 
60 CudaDeviceAction::CudaDeviceAction(std::unique_ptr<Action> Input,
61                                    const char *ArchName,
62                                    const char *DeviceTriple, bool AtTopLevel)
63     : Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
64       DeviceTriple(DeviceTriple), AtTopLevel(AtTopLevel) {}
65 
66 void CudaHostAction::anchor() {}
67 
68 CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,
69                                const ActionList &DeviceActions)
70     : Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}
71 
72 CudaHostAction::~CudaHostAction() {
73   for (auto &DA : DeviceActions)
74     delete DA;
75 }
76 
77 void JobAction::anchor() {}
78 
79 JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,
80                      types::ID Type)
81     : Action(Kind, std::move(Input), Type) {}
82 
83 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
84   : Action(Kind, Inputs, Type) {
85 }
86 
87 void PreprocessJobAction::anchor() {}
88 
89 PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,
90                                          types::ID OutputType)
91     : JobAction(PreprocessJobClass, std::move(Input), OutputType) {}
92 
93 void PrecompileJobAction::anchor() {}
94 
95 PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,
96                                          types::ID OutputType)
97     : JobAction(PrecompileJobClass, std::move(Input), OutputType) {}
98 
99 void AnalyzeJobAction::anchor() {}
100 
101 AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,
102                                    types::ID OutputType)
103     : JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}
104 
105 void MigrateJobAction::anchor() {}
106 
107 MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,
108                                    types::ID OutputType)
109     : JobAction(MigrateJobClass, std::move(Input), OutputType) {}
110 
111 void CompileJobAction::anchor() {}
112 
113 CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,
114                                    types::ID OutputType)
115     : JobAction(CompileJobClass, std::move(Input), OutputType) {}
116 
117 void BackendJobAction::anchor() {}
118 
119 BackendJobAction::BackendJobAction(std::unique_ptr<Action> Input,
120                                    types::ID OutputType)
121     : JobAction(BackendJobClass, std::move(Input), OutputType) {}
122 
123 void AssembleJobAction::anchor() {}
124 
125 AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,
126                                      types::ID OutputType)
127     : JobAction(AssembleJobClass, std::move(Input), OutputType) {}
128 
129 void LinkJobAction::anchor() {}
130 
131 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
132   : JobAction(LinkJobClass, Inputs, Type) {
133 }
134 
135 void LipoJobAction::anchor() {}
136 
137 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
138   : JobAction(LipoJobClass, Inputs, Type) {
139 }
140 
141 void DsymutilJobAction::anchor() {}
142 
143 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
144   : JobAction(DsymutilJobClass, Inputs, Type) {
145 }
146 
147 void VerifyJobAction::anchor() {}
148 
149 VerifyJobAction::VerifyJobAction(ActionClass Kind,
150                                  std::unique_ptr<Action> Input, types::ID Type)
151     : JobAction(Kind, std::move(Input), Type) {
152   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
153          "ActionClass is not a valid VerifyJobAction");
154 }
155 
156 void VerifyDebugInfoJobAction::anchor() {}
157 
158 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
159     std::unique_ptr<Action> Input, types::ID Type)
160     : VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}
161 
162 void VerifyPCHJobAction::anchor() {}
163 
164 VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,
165                                        types::ID Type)
166     : VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}
167