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