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> 15 using namespace clang::driver; 16 using namespace llvm::opt; 17 18 Action::~Action() {} 19 20 const 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 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(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. 57 static 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 72 void CudaDeviceAction::anchor() {} 73 74 CudaDeviceAction::CudaDeviceAction(Action *Input, const char *ArchName, 75 bool AtTopLevel) 76 : Action(CudaDeviceClass, Input), GpuArchName(ArchName), 77 AtTopLevel(AtTopLevel) { 78 assert(!GpuArchName || IsValidGpuArchName(GpuArchName)); 79 } 80 81 const char *CudaDeviceAction::getComputeArchName() const { 82 return GpuArchToComputeName(GpuArchName); 83 } 84 85 bool CudaDeviceAction::IsValidGpuArchName(llvm::StringRef ArchName) { 86 return GpuArchToComputeName(ArchName.data()) != nullptr; 87 } 88 89 void CudaHostAction::anchor() {} 90 91 CudaHostAction::CudaHostAction(Action *Input, const ActionList &DeviceActions) 92 : Action(CudaHostClass, Input), DeviceActions(DeviceActions) {} 93 94 void JobAction::anchor() {} 95 96 JobAction::JobAction(ActionClass Kind, Action *Input, types::ID Type) 97 : Action(Kind, Input, Type) {} 98 99 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type) 100 : Action(Kind, Inputs, Type) { 101 } 102 103 void PreprocessJobAction::anchor() {} 104 105 PreprocessJobAction::PreprocessJobAction(Action *Input, types::ID OutputType) 106 : JobAction(PreprocessJobClass, Input, OutputType) {} 107 108 void PrecompileJobAction::anchor() {} 109 110 PrecompileJobAction::PrecompileJobAction(Action *Input, types::ID OutputType) 111 : JobAction(PrecompileJobClass, Input, OutputType) {} 112 113 void AnalyzeJobAction::anchor() {} 114 115 AnalyzeJobAction::AnalyzeJobAction(Action *Input, types::ID OutputType) 116 : JobAction(AnalyzeJobClass, Input, OutputType) {} 117 118 void MigrateJobAction::anchor() {} 119 120 MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType) 121 : JobAction(MigrateJobClass, Input, OutputType) {} 122 123 void CompileJobAction::anchor() {} 124 125 CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType) 126 : JobAction(CompileJobClass, Input, OutputType) {} 127 128 void BackendJobAction::anchor() {} 129 130 BackendJobAction::BackendJobAction(Action *Input, types::ID OutputType) 131 : JobAction(BackendJobClass, Input, OutputType) {} 132 133 void AssembleJobAction::anchor() {} 134 135 AssembleJobAction::AssembleJobAction(Action *Input, types::ID OutputType) 136 : JobAction(AssembleJobClass, Input, OutputType) {} 137 138 void LinkJobAction::anchor() {} 139 140 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type) 141 : JobAction(LinkJobClass, Inputs, Type) { 142 } 143 144 void LipoJobAction::anchor() {} 145 146 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type) 147 : JobAction(LipoJobClass, Inputs, Type) { 148 } 149 150 void DsymutilJobAction::anchor() {} 151 152 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type) 153 : JobAction(DsymutilJobClass, Inputs, Type) { 154 } 155 156 void VerifyJobAction::anchor() {} 157 158 VerifyJobAction::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 165 void VerifyDebugInfoJobAction::anchor() {} 166 167 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(Action *Input, 168 types::ID Type) 169 : VerifyJobAction(VerifyDebugInfoJobClass, Input, Type) {} 170 171 void VerifyPCHJobAction::anchor() {} 172 173 VerifyPCHJobAction::VerifyPCHJobAction(Action *Input, types::ID Type) 174 : VerifyJobAction(VerifyPCHJobClass, Input, Type) {} 175