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 PreprocessJobClass: return "preprocessor";
28   case PrecompileJobClass: return "precompiler";
29   case AnalyzeJobClass: return "analyzer";
30   case MigrateJobClass: return "migrator";
31   case CompileJobClass: return "compiler";
32   case AssembleJobClass: return "assembler";
33   case LinkJobClass: return "linker";
34   case LipoJobClass: return "lipo";
35   case DsymutilJobClass: return "dsymutil";
36   case VerifyDebugInfoJobClass: return "verify-debug-info";
37   case VerifyPCHJobClass: return "verify-pch";
38   }
39 
40   llvm_unreachable("invalid class");
41 }
42 
43 void InputAction::anchor() {}
44 
45 InputAction::InputAction(const Arg &_Input, types::ID _Type)
46   : Action(InputClass, _Type), Input(_Input) {
47 }
48 
49 void BindArchAction::anchor() {}
50 
51 BindArchAction::BindArchAction(std::unique_ptr<Action> Input,
52                                const char *_ArchName)
53     : Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}
54 
55 void JobAction::anchor() {}
56 
57 JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,
58                      types::ID Type)
59     : Action(Kind, std::move(Input), Type) {}
60 
61 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
62   : Action(Kind, Inputs, Type) {
63 }
64 
65 void PreprocessJobAction::anchor() {}
66 
67 PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,
68                                          types::ID OutputType)
69     : JobAction(PreprocessJobClass, std::move(Input), OutputType) {}
70 
71 void PrecompileJobAction::anchor() {}
72 
73 PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,
74                                          types::ID OutputType)
75     : JobAction(PrecompileJobClass, std::move(Input), OutputType) {}
76 
77 void AnalyzeJobAction::anchor() {}
78 
79 AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,
80                                    types::ID OutputType)
81     : JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}
82 
83 void MigrateJobAction::anchor() {}
84 
85 MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,
86                                    types::ID OutputType)
87     : JobAction(MigrateJobClass, std::move(Input), OutputType) {}
88 
89 void CompileJobAction::anchor() {}
90 
91 CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,
92                                    types::ID OutputType)
93     : JobAction(CompileJobClass, std::move(Input), OutputType) {}
94 
95 void AssembleJobAction::anchor() {}
96 
97 AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,
98                                      types::ID OutputType)
99     : JobAction(AssembleJobClass, std::move(Input), OutputType) {}
100 
101 void LinkJobAction::anchor() {}
102 
103 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
104   : JobAction(LinkJobClass, Inputs, Type) {
105 }
106 
107 void LipoJobAction::anchor() {}
108 
109 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
110   : JobAction(LipoJobClass, Inputs, Type) {
111 }
112 
113 void DsymutilJobAction::anchor() {}
114 
115 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
116   : JobAction(DsymutilJobClass, Inputs, Type) {
117 }
118 
119 void VerifyJobAction::anchor() {}
120 
121 VerifyJobAction::VerifyJobAction(ActionClass Kind,
122                                  std::unique_ptr<Action> Input, types::ID Type)
123     : JobAction(Kind, std::move(Input), Type) {
124   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
125          "ActionClass is not a valid VerifyJobAction");
126 }
127 
128 VerifyJobAction::VerifyJobAction(ActionClass Kind, ActionList &Inputs,
129                                  types::ID Type)
130     : JobAction(Kind, Inputs, Type) {
131   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
132            "ActionClass is not a valid VerifyJobAction");
133 }
134 
135 void VerifyDebugInfoJobAction::anchor() {}
136 
137 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
138     std::unique_ptr<Action> Input, types::ID Type)
139     : VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}
140 
141 void VerifyPCHJobAction::anchor() {}
142 
143 VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,
144                                        types::ID Type)
145     : VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}
146