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: TM.createDataLayout());
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 *GR = SPIRVGlobalRegistry(M.getDataLayout());
197
198 if (Env != Unknown) {
199 assert(!(isKernel() && any_of(M,
200 [](const Function &F) {
201 return F.hasFnAttribute("hlsl.shader");
202 })) &&
203 "Module has hlsl.shader attributes but environment is Kernel");
204 return;
205 }
206
207 bool HasShaderAttr = any_of(
208 Range: M, P: [](const Function &F) { return F.hasFnAttribute(Kind: "hlsl.shader"); });
209
210 if (!HasShaderAttr) {
211 if (auto *MemModel = M.getNamedMetadata(Name: "spirv.MemoryModel")) {
212 if (MemModel->getNumOperands() == 0)
213 report_fatal_error(reason: "Invalid spirv.MemoryModel metadata");
214 auto *MemMD = MemModel->getOperand(i: 0);
215 if (MemMD->getNumOperands() < 2)
216 report_fatal_error(reason: "Invalid spirv.MemoryModel operand");
217 unsigned MemModelVal =
218 mdconst::extract<ConstantInt>(MD: MemMD->getOperand(I: 1))->getZExtValue();
219 switch (MemModelVal) {
220 case SPIRV::MemoryModel::Simple:
221 case SPIRV::MemoryModel::GLSL450:
222 HasShaderAttr = true;
223 break;
224 case SPIRV::MemoryModel::VulkanKHR:
225 HasShaderAttr = true;
226 AvailableExtensions.insert(
227 V: SPIRV::Extension::SPV_KHR_vulkan_memory_model);
228 break;
229 case SPIRV::MemoryModel::OpenCL:
230 break;
231 default:
232 report_fatal_error(
233 reason: "Unknown memory model in spirv.MemoryModel metadata");
234 }
235 }
236 }
237
238 setEnv(HasShaderAttr ? Shader : Kernel);
239}
240
241// Set available extensions after SPIRVSubtarget is created.
242void SPIRVSubtarget::initAvailableExtensions(
243 const ExtensionSet &AllowedExtIds) {
244 AvailableExtensions.clear();
245 const ExtensionSet &ValidExtensions =
246 SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple);
247
248 for (const auto &Ext : AllowedExtIds) {
249 if (ValidExtensions.count(V: Ext))
250 AvailableExtensions.insert(V: Ext);
251 }
252
253 accountForAMDShaderTrinaryMinmax();
254}
255