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