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, bool AtTopLevel)
62     : Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
63       AtTopLevel(AtTopLevel) {}
64 
65 void CudaHostAction::anchor() {}
66 
67 CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,
68                                const ActionList &DeviceActions)
69     : Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}
70 
71 CudaHostAction::~CudaHostAction() {
72   for (auto &DA : DeviceActions)
73     delete DA;
74 }
75 
76 void JobAction::anchor() {}
77 
78 JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,
79                      types::ID Type)
80     : Action(Kind, std::move(Input), Type) {}
81 
82 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
83   : Action(Kind, Inputs, Type) {
84 }
85 
86 void PreprocessJobAction::anchor() {}
87 
88 PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,
89                                          types::ID OutputType)
90     : JobAction(PreprocessJobClass, std::move(Input), OutputType) {}
91 
92 void PrecompileJobAction::anchor() {}
93 
94 PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,
95                                          types::ID OutputType)
96     : JobAction(PrecompileJobClass, std::move(Input), OutputType) {}
97 
98 void AnalyzeJobAction::anchor() {}
99 
100 AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,
101                                    types::ID OutputType)
102     : JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}
103 
104 void MigrateJobAction::anchor() {}
105 
106 MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,
107                                    types::ID OutputType)
108     : JobAction(MigrateJobClass, std::move(Input), OutputType) {}
109 
110 void CompileJobAction::anchor() {}
111 
112 CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,
113                                    types::ID OutputType)
114     : JobAction(CompileJobClass, std::move(Input), OutputType) {}
115 
116 void BackendJobAction::anchor() {}
117 
118 BackendJobAction::BackendJobAction(std::unique_ptr<Action> Input,
119                                    types::ID OutputType)
120     : JobAction(BackendJobClass, std::move(Input), OutputType) {}
121 
122 void AssembleJobAction::anchor() {}
123 
124 AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,
125                                      types::ID OutputType)
126     : JobAction(AssembleJobClass, std::move(Input), OutputType) {}
127 
128 void LinkJobAction::anchor() {}
129 
130 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
131   : JobAction(LinkJobClass, Inputs, Type) {
132 }
133 
134 void LipoJobAction::anchor() {}
135 
136 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
137   : JobAction(LipoJobClass, Inputs, Type) {
138 }
139 
140 void DsymutilJobAction::anchor() {}
141 
142 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
143   : JobAction(DsymutilJobClass, Inputs, Type) {
144 }
145 
146 void VerifyJobAction::anchor() {}
147 
148 VerifyJobAction::VerifyJobAction(ActionClass Kind,
149                                  std::unique_ptr<Action> Input, types::ID Type)
150     : JobAction(Kind, std::move(Input), Type) {
151   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
152          "ActionClass is not a valid VerifyJobAction");
153 }
154 
155 void VerifyDebugInfoJobAction::anchor() {}
156 
157 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
158     std::unique_ptr<Action> Input, types::ID Type)
159     : VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}
160 
161 void VerifyPCHJobAction::anchor() {}
162 
163 VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,
164                                        types::ID Type)
165     : VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}
166