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 TargetTriple.getOS() == Triple::ChipStar)
96 Env = Kernel;
97 else
98 Env = Unknown;
99
100 // Set the default extensions based on the target triple.
101 if (TargetTriple.getVendor() == Triple::Intel) {
102 Extensions.insert(V: SPIRV::Extension::SPV_INTEL_function_pointers);
103 Extensions.insert(
104 V: SPIRV::Extension::SPV_EXT_relaxed_printf_string_address_space);
105 }
106 if (TargetTriple.getVendor() == Triple::AMD)
107 Extensions = SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple);
108
109 // The order of initialization is important.
110 initAvailableExtensions(AllowedExtIds: Extensions);
111 initAvailableExtInstSets();
112
113 // FIXME: The GlobalRegistry does not belong in the subtarget, see issue
114 // #223774. The DataLayout is a property of the module and in principle
115 // depends on program state. It just happens SPIRV currently doesn't use
116 // target-abi names.
117 GR = std::make_unique<SPIRVGlobalRegistry>(
118 args: DataLayout(TargetTriple.computeDataLayout()));
119 CallLoweringInfo = std::make_unique<SPIRVCallLowering>(args&: TLInfo, args: GR.get());
120 InlineAsmInfo = std::make_unique<SPIRVInlineAsmLowering>(args&: TLInfo);
121 Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this);
122 RegBankInfo = std::make_unique<SPIRVRegisterBankInfo>();
123 InstSelector.reset(p: createSPIRVInstructionSelector(TM, Subtarget: *this, RBI: *RegBankInfo));
124}
125
126SPIRVSubtarget &SPIRVSubtarget::initSubtargetDependencies(StringRef CPU,
127 StringRef FS) {
128 ParseSubtargetFeatures(CPU, /*TuneCPU=*/CPU, FS);
129 return *this;
130}
131
132bool SPIRVSubtarget::canUseExtension(SPIRV::Extension::Extension E) const {
133 return AvailableExtensions.contains(V: E);
134}
135
136bool SPIRVSubtarget::canUseExtInstSet(
137 SPIRV::InstructionSet::InstructionSet E) const {
138 return AvailableExtInstSets.contains(V: E);
139}
140
141SPIRV::InstructionSet::InstructionSet
142SPIRVSubtarget::getPreferredInstructionSet() const {
143 if (isShader())
144 return SPIRV::InstructionSet::GLSL_std_450;
145 else
146 return SPIRV::InstructionSet::OpenCL_std;
147}
148
149bool SPIRVSubtarget::isAtLeastSPIRVVer(VersionTuple VerToCompareTo) const {
150 return isAtLeastVer(Target: SPIRVVersion, VerToCompareTo);
151}
152
153bool SPIRVSubtarget::isAtLeastOpenCLVer(VersionTuple VerToCompareTo) const {
154 if (isShader())
155 return false;
156 return isAtLeastVer(Target: OpenCLVersion, VerToCompareTo);
157}
158
159// If the SPIR-V version is >= 1.4 we can call OpPtrEqual and OpPtrNotEqual.
160// In SPIR-V Translator compatibility mode this feature is not available.
161bool SPIRVSubtarget::canDirectlyComparePointers() const {
162 return !SPVTranslatorCompat && isAtLeastVer(Target: SPIRVVersion, VerToCompareTo: VersionTuple(1, 4));
163}
164
165void SPIRVSubtarget::accountForAMDShaderTrinaryMinmax() {
166 if (canUseExtension(
167 E: SPIRV::Extension::SPV_AMD_shader_trinary_minmax_extension)) {
168 AvailableExtInstSets.insert(
169 V: SPIRV::InstructionSet::SPV_AMD_shader_trinary_minmax);
170 }
171}
172
173// TODO: use command line args for this rather than just defaults.
174// Must have called initAvailableExtensions first.
175void SPIRVSubtarget::initAvailableExtInstSets() {
176 AvailableExtInstSets.clear();
177 if (isShader())
178 AvailableExtInstSets.insert(V: SPIRV::InstructionSet::GLSL_std_450);
179 else
180 AvailableExtInstSets.insert(V: SPIRV::InstructionSet::OpenCL_std);
181
182 // Handle extended instruction sets from extensions.
183 accountForAMDShaderTrinaryMinmax();
184}
185
186void SPIRVSubtarget::setEnv(SPIRVEnvType E) {
187 if (E == Unknown)
188 report_fatal_error(reason: "Unknown environment is not allowed.");
189 if (Env != Unknown && Env != E)
190 report_fatal_error(reason: "Environment is already set to a different value.");
191 if (Env == E)
192 return;
193
194 Env = E;
195
196 // Reinitialize Env-dependent state aka ExtInstSet and legalizer info.
197 initAvailableExtInstSets();
198 Legalizer = std::make_unique<SPIRVLegalizerInfo>(args&: *this);
199}
200
201void SPIRVSubtarget::resolveEnvFromModule(const Module &M) {
202 *GR = SPIRVGlobalRegistry(M.getDataLayout());
203
204 if (Env != Unknown) {
205 assert(!(isKernel() && any_of(M,
206 [](const Function &F) {
207 return F.hasFnAttribute("hlsl.shader");
208 })) &&
209 "Module has hlsl.shader attributes but environment is Kernel");
210 return;
211 }
212
213 bool HasShaderAttr = any_of(
214 Range: M, P: [](const Function &F) { return F.hasFnAttribute(Kind: "hlsl.shader"); });
215
216 if (!HasShaderAttr) {
217 if (auto *MemModel = M.getNamedMetadata(Name: "spirv.MemoryModel")) {
218 if (MemModel->getNumOperands() == 0)
219 report_fatal_error(reason: "Invalid spirv.MemoryModel metadata");
220 auto *MemMD = MemModel->getOperand(i: 0);
221 if (MemMD->getNumOperands() < 2)
222 report_fatal_error(reason: "Invalid spirv.MemoryModel operand");
223 unsigned MemModelVal =
224 mdconst::extract<ConstantInt>(MD: MemMD->getOperand(I: 1))->getZExtValue();
225 switch (MemModelVal) {
226 case SPIRV::MemoryModel::Simple:
227 case SPIRV::MemoryModel::GLSL450:
228 HasShaderAttr = true;
229 break;
230 case SPIRV::MemoryModel::VulkanKHR:
231 HasShaderAttr = true;
232 AvailableExtensions.insert(
233 V: SPIRV::Extension::SPV_KHR_vulkan_memory_model);
234 break;
235 case SPIRV::MemoryModel::OpenCL:
236 break;
237 default:
238 report_fatal_error(
239 reason: "Unknown memory model in spirv.MemoryModel metadata");
240 }
241 }
242 }
243
244 setEnv(HasShaderAttr ? Shader : Kernel);
245}
246
247// Set available extensions after SPIRVSubtarget is created.
248void SPIRVSubtarget::initAvailableExtensions(
249 const ExtensionSet &AllowedExtIds) {
250 AvailableExtensions.clear();
251 const ExtensionSet &ValidExtensions =
252 SPIRVExtensionsParser::getValidExtensions(TT: TargetTriple);
253
254 for (const auto &Ext : AllowedExtIds) {
255 if (ValidExtensions.count(V: Ext))
256 AvailableExtensions.insert(V: Ext);
257 }
258
259 accountForAMDShaderTrinaryMinmax();
260}
261