1//===-- SPIRVSubtarget.cpp - SPIR-V Subtarget Information ------*- 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//
9// This file implements the SPIR-V specific subclass of TargetSubtargetInfo.
10//
11//===----------------------------------------------------------------------===//
12
13#include "SPIRVSubtarget.h"
14
15#include "MCTargetDesc/SPIRVBaseInfo.h"
16#include "SPIRV.h"
17#include "SPIRVCommandLine.h"
18#include "SPIRVGlobalRegistry.h"
19#include "SPIRVLegalizerInfo.h"
20#include "SPIRVRegisterBankInfo.h"
21#include "SPIRVTargetMachine.h"
22
23#include "llvm/TargetParser/Host.h"
24
25using namespace llvm;
26
27#define DEBUG_TYPE "spirv-subtarget"
28
29#define GET_SUBTARGETINFO_TARGET_DESC
30#define GET_SUBTARGETINFO_CTOR
31#include "SPIRVGenSubtargetInfo.inc"
32
33static cl::opt<bool>
34 SPVTranslatorCompat("translator-compatibility-mode",
35 cl::desc("SPIR-V Translator compatibility mode"),
36 cl::Optional, cl::init(Val: false));
37
38static cl::opt<ExtensionSet, false, SPIRVExtensionsParser>
39 Extensions("spirv-ext",
40 cl::desc("Specify list of enabled SPIR-V extensions"));
41
42// Provides access to the cl::opt<...> `Extensions` variable from outside of the
43// module.
44void SPIRVSubtarget::addExtensionsToClOpt(const ExtensionSet &AllowList) {
45 Extensions.insert(I: AllowList.begin(), E: AllowList.end());
46}
47
48// Compare version numbers, but allow 0 to mean unspecified.
49static bool isAtLeastVer(VersionTuple Target, VersionTuple VerToCompareTo) {
50 return Target.empty() || Target >= VerToCompareTo;
51}
52
53SPIRVSubtarget::SPIRVSubtarget(const Triple &TT, const std::string &CPU,
54 const std::string &FS,
55 const SPIRVTargetMachine &TM)
56 : SPIRVGenSubtargetInfo(TT, CPU, /*TuneCPU=*/CPU, FS),
57 PointerSize(TM.getPointerSizeInBits(/* AS= */ 0)),
58 InstrInfo(initSubtargetDependencies(CPU, FS)), FrameLowering(*this),
59 TLInfo(TM, *this), TargetTriple(TT) {
60 switch (TT.getSubArch()) {
61 case Triple::SPIRVSubArch_v10:
62 SPIRVVersion = VersionTuple(1, 0);
63 break;
64 case Triple::SPIRVSubArch_v11:
65 SPIRVVersion = VersionTuple(1, 1);
66 break;
67 case Triple::SPIRVSubArch_v12:
68 SPIRVVersion = VersionTuple(1, 2);
69 break;
70 case Triple::SPIRVSubArch_v13:
71 SPIRVVersion = VersionTuple(1, 3);
72 break;
73 case Triple::SPIRVSubArch_v14:
74 SPIRVVersion = VersionTuple(1, 4);
75 break;
76 case Triple::SPIRVSubArch_v15:
77 SPIRVVersion = VersionTuple(1, 5);
78 break;
79 case Triple::SPIRVSubArch_v16:
80 SPIRVVersion = VersionTuple(1, 6);
81 break;
82 default:
83 if (TT.getVendor() == Triple::AMD)
84 SPIRVVersion = VersionTuple(1, 6);
85 else
86 SPIRVVersion = VersionTuple(1, 4);
87 }
88 OpenCLVersion = VersionTuple(2, 2);
89
90 // Set the environment based on the target triple.
91 if (TargetTriple.getOS() == Triple::Vulkan)
92 Env = Shader;
93 else if (TargetTriple.getOS() == Triple::OpenCL ||
94 TargetTriple.getVendor() == Triple::AMD)
95 Env = Kernel;
96 else
97 Env = Unknown;
98
99 // Set the default extensions based on the target triple.
100 if (TargetTriple.getVendor() == Triple::Intel) {
101 Extensions.insert(V: SPIRV::Extension::SPV_INTEL_function_pointers);
102 Extensions.insert(
103 V: SPIRV::Extension::SPV_EXT_relaxed_printf_string_address_space);
104 }
105 if (TargetTriple.getVendor() == Triple::AMD)
106 Extensions = SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple);
107
108 // The order of initialization is important.
109 initAvailableExtensions(AllowedExtIds: Extensions);
110 initAvailableExtInstSets();
111
112 GR = std::make_unique<SPIRVGlobalRegistry>(args: PointerSize);
113 CallLoweringInfo = std::make_unique<SPIRVCallLowering>(args&: TLInfo, args: GR.get());
114 InlineAsmInfo = std::make_unique<SPIRVInlineAsmLowering>(args&: TLInfo);
115 Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this);
116 RegBankInfo = std::make_unique<SPIRVRegisterBankInfo>();
117 InstSelector.reset(p: createSPIRVInstructionSelector(TM, Subtarget: *this, RBI: *RegBankInfo));
118}
119
120SPIRVSubtarget &SPIRVSubtarget::initSubtargetDependencies(StringRef CPU,
121 StringRef FS) {
122 ParseSubtargetFeatures(CPU, /*TuneCPU=*/CPU, FS);
123 return *this;
124}
125
126bool SPIRVSubtarget::canUseExtension(SPIRV::Extension::Extension E) const {
127 return AvailableExtensions.contains(V: E);
128}
129
130bool SPIRVSubtarget::canUseExtInstSet(
131 SPIRV::InstructionSet::InstructionSet E) const {
132 return AvailableExtInstSets.contains(V: E);
133}
134
135SPIRV::InstructionSet::InstructionSet
136SPIRVSubtarget::getPreferredInstructionSet() const {
137 if (isShader())
138 return SPIRV::InstructionSet::GLSL_std_450;
139 else
140 return SPIRV::InstructionSet::OpenCL_std;
141}
142
143bool SPIRVSubtarget::isAtLeastSPIRVVer(VersionTuple VerToCompareTo) const {
144 return isAtLeastVer(Target: SPIRVVersion, VerToCompareTo);
145}
146
147bool SPIRVSubtarget::isAtLeastOpenCLVer(VersionTuple VerToCompareTo) const {
148 if (isShader())
149 return false;
150 return isAtLeastVer(Target: OpenCLVersion, VerToCompareTo);
151}
152
153// If the SPIR-V version is >= 1.4 we can call OpPtrEqual and OpPtrNotEqual.
154// In SPIR-V Translator compatibility mode this feature is not available.
155bool SPIRVSubtarget::canDirectlyComparePointers() const {
156 return !SPVTranslatorCompat && isAtLeastVer(Target: SPIRVVersion, VerToCompareTo: VersionTuple(1, 4));
157}
158
159void SPIRVSubtarget::accountForAMDShaderTrinaryMinmax() {
160 if (canUseExtension(
161 E: SPIRV::Extension::SPV_AMD_shader_trinary_minmax_extension)) {
162 AvailableExtInstSets.insert(
163 V: SPIRV::InstructionSet::SPV_AMD_shader_trinary_minmax);
164 }
165}
166
167// TODO: use command line args for this rather than just defaults.
168// Must have called initAvailableExtensions first.
169void SPIRVSubtarget::initAvailableExtInstSets() {
170 AvailableExtInstSets.clear();
171 if (isShader())
172 AvailableExtInstSets.insert(V: SPIRV::InstructionSet::GLSL_std_450);
173 else
174 AvailableExtInstSets.insert(V: SPIRV::InstructionSet::OpenCL_std);
175
176 // Handle extended instruction sets from extensions.
177 accountForAMDShaderTrinaryMinmax();
178}
179
180void SPIRVSubtarget::setEnv(SPIRVEnvType E) {
181 if (E == Unknown)
182 report_fatal_error(reason: "Unknown environment is not allowed.");
183 if (Env != Unknown && Env != E)
184 report_fatal_error(reason: "Environment is already set to a different value.");
185 if (Env == E)
186 return;
187
188 Env = E;
189
190 // Reinitialize Env-dependent state aka ExtInstSet and legalizer info.
191 initAvailableExtInstSets();
192 Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this);
193}
194
195void SPIRVSubtarget::resolveEnvFromModule(const Module &M) {
196 if (Env != Unknown) {
197 assert(!(isKernel() && any_of(M,
198 [](const Function &F) {
199 return F.hasFnAttribute("hlsl.shader");
200 })) &&
201 "Module has hlsl.shader attributes but environment is Kernel");
202 return;
203 }
204
205 bool HasShaderAttr = false;
206 for (const Function &F : M) {
207 if (F.hasFnAttribute(Kind: "hlsl.shader")) {
208 HasShaderAttr = true;
209 break;
210 }
211 }
212
213 if (!HasShaderAttr) {
214 if (auto *MemModel = M.getNamedMetadata(Name: "spirv.MemoryModel")) {
215 if (MemModel->getNumOperands() == 0)
216 report_fatal_error(reason: "Invalid spirv.MemoryModel metadata");
217 auto *MemMD = MemModel->getOperand(i: 0);
218 if (MemMD->getNumOperands() < 2)
219 report_fatal_error(reason: "Invalid spirv.MemoryModel operand");
220 unsigned MemModelVal =
221 mdconst::extract<ConstantInt>(MD: MemMD->getOperand(I: 1))->getZExtValue();
222 switch (MemModelVal) {
223 case SPIRV::MemoryModel::Simple:
224 case SPIRV::MemoryModel::GLSL450:
225 HasShaderAttr = true;
226 break;
227 case SPIRV::MemoryModel::VulkanKHR:
228 HasShaderAttr = true;
229 AvailableExtensions.insert(
230 V: SPIRV::Extension::SPV_KHR_vulkan_memory_model);
231 break;
232 case SPIRV::MemoryModel::OpenCL:
233 break;
234 default:
235 report_fatal_error(
236 reason: "Unknown memory model in spirv.MemoryModel metadata");
237 }
238 }
239 }
240
241 setEnv(HasShaderAttr ? Shader : Kernel);
242}
243
244// Set available extensions after SPIRVSubtarget is created.
245void SPIRVSubtarget::initAvailableExtensions(
246 const ExtensionSet &AllowedExtIds) {
247 AvailableExtensions.clear();
248 const ExtensionSet &ValidExtensions =
249 SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple);
250
251 for (const auto &Ext : AllowedExtIds) {
252 if (ValidExtensions.count(V: Ext))
253 AvailableExtensions.insert(V: Ext);
254 }
255
256 accountForAMDShaderTrinaryMinmax();
257}
258