Action.cpp revision 288943 
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>
13using namespace clang::driver;
14using namespace llvm::opt;
15
16Action::~Action() {
17  if (OwnsInputs) {
18    for (iterator it = begin(), ie = end(); it != ie; ++it)
19      delete *it;
20  }
21}
22
23const 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
46void InputAction::anchor() {}
47
48InputAction::InputAction(const Arg &_Input, types::ID _Type)
49  : Action(InputClass, _Type), Input(_Input) {
50}
51
52void BindArchAction::anchor() {}
53
54BindArchAction::BindArchAction(std::unique_ptr<Action> Input,
55                               const char *_ArchName)
56    : Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}
57
58void CudaDeviceAction::anchor() {}
59
60CudaDeviceAction::CudaDeviceAction(std::unique_ptr<Action> Input,
61                                   const char *ArchName, bool AtTopLevel)
62    : Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
63      AtTopLevel(AtTopLevel) {}
64
65void CudaHostAction::anchor() {}
66
67CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,
68                               const ActionList &_DeviceActions)
69    : Action(CudaHostClass, std::move(Input)), DeviceActions(_DeviceActions) {}
70
71CudaHostAction::~CudaHostAction() {
72  for (iterator it = DeviceActions.begin(), ie = DeviceActions.end(); it != ie;
73       ++it)
74    delete *it;
75}
76
77void JobAction::anchor() {}
78
79JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,
80                     types::ID Type)
81    : Action(Kind, std::move(Input), Type) {}
82
83JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
84  : Action(Kind, Inputs, Type) {
85}
86
87void PreprocessJobAction::anchor() {}
88
89PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,
90                                         types::ID OutputType)
91    : JobAction(PreprocessJobClass, std::move(Input), OutputType) {}
92
93void PrecompileJobAction::anchor() {}
94
95PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,
96                                         types::ID OutputType)
97    : JobAction(PrecompileJobClass, std::move(Input), OutputType) {}
98
99void AnalyzeJobAction::anchor() {}
100
101AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,
102                                   types::ID OutputType)
103    : JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}
104
105void MigrateJobAction::anchor() {}
106
107MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,
108                                   types::ID OutputType)
109    : JobAction(MigrateJobClass, std::move(Input), OutputType) {}
110
111void CompileJobAction::anchor() {}
112
113CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,
114                                   types::ID OutputType)
115    : JobAction(CompileJobClass, std::move(Input), OutputType) {}
116
117void BackendJobAction::anchor() {}
118
119BackendJobAction::BackendJobAction(std::unique_ptr<Action> Input,
120                                   types::ID OutputType)
121    : JobAction(BackendJobClass, std::move(Input), OutputType) {}
122
123void AssembleJobAction::anchor() {}
124
125AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,
126                                     types::ID OutputType)
127    : JobAction(AssembleJobClass, std::move(Input), OutputType) {}
128
129void LinkJobAction::anchor() {}
130
131LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
132  : JobAction(LinkJobClass, Inputs, Type) {
133}
134
135void LipoJobAction::anchor() {}
136
137LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
138  : JobAction(LipoJobClass, Inputs, Type) {
139}
140
141void DsymutilJobAction::anchor() {}
142
143DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
144  : JobAction(DsymutilJobClass, Inputs, Type) {
145}
146
147void VerifyJobAction::anchor() {}
148
149VerifyJobAction::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
156VerifyJobAction::VerifyJobAction(ActionClass Kind, ActionList &Inputs,
157                                 types::ID Type)
158    : JobAction(Kind, Inputs, Type) {
159  assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
160           "ActionClass is not a valid VerifyJobAction");
161}
162
163void VerifyDebugInfoJobAction::anchor() {}
164
165VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
166    std::unique_ptr<Action> Input, types::ID Type)
167    : VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}
168
169void VerifyPCHJobAction::anchor() {}
170
171VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,
172                                       types::ID Type)
173    : VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}
174