Action.cpp revision 296417 
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/ADT/StringSwitch.h"
12#include "llvm/Support/ErrorHandling.h"
13#include "llvm/Support/Regex.h"
14#include <cassert>
15using namespace clang::driver;
16using namespace llvm::opt;
17
18Action::~Action() {}
19
20const char *Action::getClassName(ActionClass AC) {
21  switch (AC) {
22  case InputClass: return "input";
23  case BindArchClass: return "bind-arch";
24  case CudaDeviceClass: return "cuda-device";
25  case CudaHostClass: return "cuda-host";
26  case PreprocessJobClass: return "preprocessor";
27  case PrecompileJobClass: return "precompiler";
28  case AnalyzeJobClass: return "analyzer";
29  case MigrateJobClass: return "migrator";
30  case CompileJobClass: return "compiler";
31  case BackendJobClass: return "backend";
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
43void InputAction::anchor() {}
44
45InputAction::InputAction(const Arg &_Input, types::ID _Type)
46  : Action(InputClass, _Type), Input(_Input) {
47}
48
49void BindArchAction::anchor() {}
50
51BindArchAction::BindArchAction(Action *Input, const char *_ArchName)
52    : Action(BindArchClass, Input), ArchName(_ArchName) {}
53
54// Converts CUDA GPU architecture, e.g. "sm_21", to its corresponding virtual
55// compute arch, e.g. "compute_20".  Returns null if the input arch is null or
56// doesn't match an existing arch.
57static const char* GpuArchToComputeName(const char *ArchName) {
58  if (!ArchName)
59    return nullptr;
60  return llvm::StringSwitch<const char *>(ArchName)
61      .Cases("sm_20", "sm_21", "compute_20")
62      .Case("sm_30", "compute_30")
63      .Case("sm_32", "compute_32")
64      .Case("sm_35", "compute_35")
65      .Case("sm_37", "compute_37")
66      .Case("sm_50", "compute_50")
67      .Case("sm_52", "compute_52")
68      .Case("sm_53", "compute_53")
69      .Default(nullptr);
70}
71
72void CudaDeviceAction::anchor() {}
73
74CudaDeviceAction::CudaDeviceAction(Action *Input, const char *ArchName,
75                                   bool AtTopLevel)
76    : Action(CudaDeviceClass, Input), GpuArchName(ArchName),
77      AtTopLevel(AtTopLevel) {
78  assert(IsValidGpuArchName(GpuArchName));
79}
80
81const char *CudaDeviceAction::getComputeArchName() const {
82  return GpuArchToComputeName(GpuArchName);
83}
84
85bool CudaDeviceAction::IsValidGpuArchName(llvm::StringRef ArchName) {
86  return GpuArchToComputeName(ArchName.data()) != nullptr;
87}
88
89void CudaHostAction::anchor() {}
90
91CudaHostAction::CudaHostAction(Action *Input, const ActionList &DeviceActions)
92    : Action(CudaHostClass, Input), DeviceActions(DeviceActions) {}
93
94void JobAction::anchor() {}
95
96JobAction::JobAction(ActionClass Kind, Action *Input, types::ID Type)
97    : Action(Kind, Input, Type) {}
98
99JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
100  : Action(Kind, Inputs, Type) {
101}
102
103void PreprocessJobAction::anchor() {}
104
105PreprocessJobAction::PreprocessJobAction(Action *Input, types::ID OutputType)
106    : JobAction(PreprocessJobClass, Input, OutputType) {}
107
108void PrecompileJobAction::anchor() {}
109
110PrecompileJobAction::PrecompileJobAction(Action *Input, types::ID OutputType)
111    : JobAction(PrecompileJobClass, Input, OutputType) {}
112
113void AnalyzeJobAction::anchor() {}
114
115AnalyzeJobAction::AnalyzeJobAction(Action *Input, types::ID OutputType)
116    : JobAction(AnalyzeJobClass, Input, OutputType) {}
117
118void MigrateJobAction::anchor() {}
119
120MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType)
121    : JobAction(MigrateJobClass, Input, OutputType) {}
122
123void CompileJobAction::anchor() {}
124
125CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType)
126    : JobAction(CompileJobClass, Input, OutputType) {}
127
128void BackendJobAction::anchor() {}
129
130BackendJobAction::BackendJobAction(Action *Input, types::ID OutputType)
131    : JobAction(BackendJobClass, Input, OutputType) {}
132
133void AssembleJobAction::anchor() {}
134
135AssembleJobAction::AssembleJobAction(Action *Input, types::ID OutputType)
136    : JobAction(AssembleJobClass, Input, OutputType) {}
137
138void LinkJobAction::anchor() {}
139
140LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
141  : JobAction(LinkJobClass, Inputs, Type) {
142}
143
144void LipoJobAction::anchor() {}
145
146LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
147  : JobAction(LipoJobClass, Inputs, Type) {
148}
149
150void DsymutilJobAction::anchor() {}
151
152DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
153  : JobAction(DsymutilJobClass, Inputs, Type) {
154}
155
156void VerifyJobAction::anchor() {}
157
158VerifyJobAction::VerifyJobAction(ActionClass Kind, Action *Input,
159                                 types::ID Type)
160    : JobAction(Kind, Input, Type) {
161  assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
162         "ActionClass is not a valid VerifyJobAction");
163}
164
165void VerifyDebugInfoJobAction::anchor() {}
166
167VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(Action *Input,
168                                                   types::ID Type)
169    : VerifyJobAction(VerifyDebugInfoJobClass, Input, Type) {}
170
171void VerifyPCHJobAction::anchor() {}
172
173VerifyPCHJobAction::VerifyPCHJobAction(Action *Input, types::ID Type)
174    : VerifyJobAction(VerifyPCHJobClass, Input, Type) {}
175