1 //===--- SPIRV.cpp - SPIR-V Tool Implementations ----------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 #include "SPIRV.h" 9 #include "CommonArgs.h" 10 #include "clang/Basic/Version.h" 11 #include "clang/Driver/Compilation.h" 12 #include "clang/Driver/Driver.h" 13 #include "clang/Driver/InputInfo.h" 14 #include "clang/Driver/Options.h" 15 16 using namespace clang::driver; 17 using namespace clang::driver::toolchains; 18 using namespace clang::driver::tools; 19 using namespace llvm::opt; 20 21 void SPIRV::constructTranslateCommand(Compilation &C, const Tool &T, 22 const JobAction &JA, 23 const InputInfo &Output, 24 const InputInfo &Input, 25 const llvm::opt::ArgStringList &Args) { 26 llvm::opt::ArgStringList CmdArgs(Args); 27 CmdArgs.push_back(Input.getFilename()); 28 29 assert(Input.getType() != types::TY_PP_Asm && "Unexpected input type"); 30 31 if (Output.getType() == types::TY_PP_Asm) 32 CmdArgs.push_back("--spirv-tools-dis"); 33 34 CmdArgs.append({"-o", Output.getFilename()}); 35 36 // Try to find "llvm-spirv-<LLVM_VERSION_MAJOR>". Otherwise, fall back to 37 // plain "llvm-spirv". 38 using namespace std::string_literals; 39 auto VersionedTool = "llvm-spirv-"s + std::to_string(LLVM_VERSION_MAJOR); 40 std::string ExeCand = T.getToolChain().GetProgramPath(VersionedTool.c_str()); 41 if (!llvm::sys::fs::can_execute(ExeCand)) 42 ExeCand = T.getToolChain().GetProgramPath("llvm-spirv"); 43 44 const char *Exec = C.getArgs().MakeArgString(ExeCand); 45 C.addCommand(std::make_unique<Command>(JA, T, ResponseFileSupport::None(), 46 Exec, CmdArgs, Input, Output)); 47 } 48 49 void SPIRV::constructAssembleCommand(Compilation &C, const Tool &T, 50 const JobAction &JA, 51 const InputInfo &Output, 52 const InputInfo &Input, 53 const llvm::opt::ArgStringList &Args) { 54 llvm::opt::ArgStringList CmdArgs(Args); 55 CmdArgs.push_back(Input.getFilename()); 56 57 assert(Input.getType() == types::TY_PP_Asm && "Unexpected input type"); 58 59 CmdArgs.append({"-o", Output.getFilename()}); 60 61 // Try to find "spirv-as-<LLVM_VERSION_MAJOR>". Otherwise, fall back to 62 // plain "spirv-as". 63 using namespace std::string_literals; 64 auto VersionedTool = "spirv-as-"s + std::to_string(LLVM_VERSION_MAJOR); 65 std::string ExeCand = T.getToolChain().GetProgramPath(VersionedTool.c_str()); 66 if (!llvm::sys::fs::can_execute(ExeCand)) 67 ExeCand = T.getToolChain().GetProgramPath("spirv-as"); 68 69 const char *Exec = C.getArgs().MakeArgString(ExeCand); 70 C.addCommand(std::make_unique<Command>(JA, T, ResponseFileSupport::None(), 71 Exec, CmdArgs, Input, Output)); 72 } 73 74 void SPIRV::Translator::ConstructJob(Compilation &C, const JobAction &JA, 75 const InputInfo &Output, 76 const InputInfoList &Inputs, 77 const ArgList &Args, 78 const char *LinkingOutput) const { 79 claimNoWarnArgs(Args); 80 if (Inputs.size() != 1) 81 llvm_unreachable("Invalid number of input files."); 82 constructTranslateCommand(C, *this, JA, Output, Inputs[0], {}); 83 } 84 85 void SPIRV::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 86 const InputInfo &Output, 87 const InputInfoList &Inputs, 88 const ArgList &Args, 89 const char *AssembleOutput) const { 90 claimNoWarnArgs(Args); 91 if (Inputs.size() != 1) 92 llvm_unreachable("Invalid number of input files."); 93 constructAssembleCommand(C, *this, JA, Output, Inputs[0], {}); 94 } 95 96 clang::driver::Tool *SPIRVToolChain::getTranslator() const { 97 if (!Translator) 98 Translator = std::make_unique<SPIRV::Translator>(*this); 99 return Translator.get(); 100 } 101 102 clang::driver::Tool *SPIRVToolChain::getAssembler() const { 103 if (!Assembler) 104 Assembler = std::make_unique<SPIRV::Assembler>(*this); 105 return Assembler.get(); 106 } 107 108 clang::driver::Tool *SPIRVToolChain::SelectTool(const JobAction &JA) const { 109 Action::ActionClass AC = JA.getKind(); 110 return SPIRVToolChain::getTool(AC); 111 } 112 113 clang::driver::Tool *SPIRVToolChain::getTool(Action::ActionClass AC) const { 114 switch (AC) { 115 default: 116 break; 117 case Action::BackendJobClass: 118 return SPIRVToolChain::getTranslator(); 119 case Action::AssembleJobClass: 120 return SPIRVToolChain::getAssembler(); 121 } 122 return ToolChain::getTool(AC); 123 } 124 clang::driver::Tool *SPIRVToolChain::buildLinker() const { 125 return new tools::SPIRV::Linker(*this); 126 } 127 128 void SPIRV::Linker::ConstructJob(Compilation &C, const JobAction &JA, 129 const InputInfo &Output, 130 const InputInfoList &Inputs, 131 const ArgList &Args, 132 const char *LinkingOutput) const { 133 const ToolChain &ToolChain = getToolChain(); 134 std::string Linker = ToolChain.GetProgramPath(getShortName()); 135 ArgStringList CmdArgs; 136 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 137 138 CmdArgs.push_back("-o"); 139 CmdArgs.push_back(Output.getFilename()); 140 141 // Use of --sycl-link will call the clang-sycl-linker instead of 142 // the default linker (spirv-link). 143 if (Args.hasArg(options::OPT_sycl_link)) 144 Linker = ToolChain.GetProgramPath("clang-sycl-linker"); 145 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), 146 Args.MakeArgString(Linker), CmdArgs, 147 Inputs, Output)); 148 } 149 150 SPIRVToolChain::SPIRVToolChain(const Driver &D, const llvm::Triple &Triple, 151 const ArgList &Args) 152 : ToolChain(D, Triple, Args) { 153 // TODO: Revisit need/use of --sycl-link option once SYCL toolchain is 154 // available and SYCL linking support is moved there. 155 NativeLLVMSupport = Args.hasArg(options::OPT_sycl_link); 156 } 157 158 bool SPIRVToolChain::HasNativeLLVMSupport() const { return NativeLLVMSupport; } 159