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